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, 2009, 2010, 2011
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. */
25 #include "libiberty.h"
26 #include "filenames.h"
27 #include "safe-ctype.h"
47 #endif /* ENABLE_PLUGINS */
50 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
53 /* Locals variables. */
54 static struct obstack stat_obstack
;
55 static struct obstack map_obstack
;
57 #define obstack_chunk_alloc xmalloc
58 #define obstack_chunk_free free
59 static const char *entry_symbol_default
= "start";
60 static bfd_boolean placed_commons
= FALSE
;
61 static bfd_boolean stripped_excluded_sections
= FALSE
;
62 static lang_output_section_statement_type
*default_common_section
;
63 static bfd_boolean map_option_f
;
64 static bfd_vma print_dot
;
65 static lang_input_statement_type
*first_file
;
66 static const char *current_target
;
67 static lang_statement_list_type statement_list
;
68 static struct bfd_hash_table lang_definedness_table
;
69 static lang_statement_list_type
*stat_save
[10];
70 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
71 static struct unique_sections
*unique_section_list
;
72 static bfd_boolean ldlang_sysrooted_script
= FALSE
;
74 /* Forward declarations. */
75 static void exp_init_os (etree_type
*);
76 static void init_map_userdata (bfd
*, asection
*, void *);
77 static lang_input_statement_type
*lookup_name (const char *);
78 static struct bfd_hash_entry
*lang_definedness_newfunc
79 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
80 static void insert_undefined (const char *);
81 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
82 static void print_statement (lang_statement_union_type
*,
83 lang_output_section_statement_type
*);
84 static void print_statement_list (lang_statement_union_type
*,
85 lang_output_section_statement_type
*);
86 static void print_statements (void);
87 static void print_input_section (asection
*, bfd_boolean
);
88 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
89 static void lang_record_phdrs (void);
90 static void lang_do_version_exports_section (void);
91 static void lang_finalize_version_expr_head
92 (struct bfd_elf_version_expr_head
*);
94 /* Exported variables. */
95 const char *output_target
;
96 lang_output_section_statement_type
*abs_output_section
;
97 lang_statement_list_type lang_output_section_statement
;
98 lang_statement_list_type
*stat_ptr
= &statement_list
;
99 lang_statement_list_type file_chain
= { NULL
, NULL
};
100 lang_statement_list_type input_file_chain
;
101 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
102 const char *entry_section
= ".text";
103 bfd_boolean entry_from_cmdline
;
104 bfd_boolean undef_from_cmdline
;
105 bfd_boolean lang_has_input_file
= FALSE
;
106 bfd_boolean had_output_filename
= FALSE
;
107 bfd_boolean lang_float_flag
= FALSE
;
108 bfd_boolean delete_output_file_on_failure
= FALSE
;
109 struct lang_phdr
*lang_phdr_list
;
110 struct lang_nocrossrefs
*nocrossref_list
;
111 bfd_boolean missing_file
= FALSE
;
113 /* Functions that traverse the linker script and might evaluate
114 DEFINED() need to increment this. */
115 int lang_statement_iteration
= 0;
117 etree_type
*base
; /* Relocation base - or null */
119 /* Return TRUE if the PATTERN argument is a wildcard pattern.
120 Although backslashes are treated specially if a pattern contains
121 wildcards, we do not consider the mere presence of a backslash to
122 be enough to cause the pattern to be treated as a wildcard.
123 That lets us handle DOS filenames more naturally. */
124 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
126 #define new_stat(x, y) \
127 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
129 #define outside_section_address(q) \
130 ((q)->output_offset + (q)->output_section->vma)
132 #define outside_symbol_address(q) \
133 ((q)->value + outside_section_address (q->section))
135 #define SECTION_NAME_MAP_LENGTH (16)
138 stat_alloc (size_t size
)
140 return obstack_alloc (&stat_obstack
, size
);
144 name_match (const char *pattern
, const char *name
)
146 if (wildcardp (pattern
))
147 return fnmatch (pattern
, name
, 0);
148 return strcmp (pattern
, name
);
151 /* If PATTERN is of the form archive:file, return a pointer to the
152 separator. If not, return NULL. */
155 archive_path (const char *pattern
)
159 if (link_info
.path_separator
== 0)
162 p
= strchr (pattern
, link_info
.path_separator
);
163 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
164 if (p
== NULL
|| link_info
.path_separator
!= ':')
167 /* Assume a match on the second char is part of drive specifier,
168 as in "c:\silly.dos". */
169 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
170 p
= strchr (p
+ 1, link_info
.path_separator
);
175 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
176 return whether F matches FILE_SPEC. */
179 input_statement_is_archive_path (const char *file_spec
, char *sep
,
180 lang_input_statement_type
*f
)
182 bfd_boolean match
= FALSE
;
185 || name_match (sep
+ 1, f
->filename
) == 0)
186 && ((sep
!= file_spec
)
187 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
191 if (sep
!= file_spec
)
193 const char *aname
= f
->the_bfd
->my_archive
->filename
;
195 match
= name_match (file_spec
, aname
) == 0;
196 *sep
= link_info
.path_separator
;
203 unique_section_p (const asection
*sec
,
204 const lang_output_section_statement_type
*os
)
206 struct unique_sections
*unam
;
209 if (link_info
.relocatable
210 && sec
->owner
!= NULL
211 && bfd_is_group_section (sec
->owner
, sec
))
213 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
216 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
217 if (name_match (unam
->name
, secnam
) == 0)
223 /* Generic traversal routines for finding matching sections. */
225 /* Try processing a section against a wildcard. This just calls
226 the callback unless the filename exclusion list is present
227 and excludes the file. It's hardly ever present so this
228 function is very fast. */
231 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
232 lang_input_statement_type
*file
,
234 struct wildcard_list
*sec
,
238 struct name_list
*list_tmp
;
240 /* Don't process sections from files which were excluded. */
241 for (list_tmp
= sec
->spec
.exclude_name_list
;
243 list_tmp
= list_tmp
->next
)
245 char *p
= archive_path (list_tmp
->name
);
249 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
253 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
256 /* FIXME: Perhaps remove the following at some stage? Matching
257 unadorned archives like this was never documented and has
258 been superceded by the archive:path syntax. */
259 else if (file
->the_bfd
!= NULL
260 && file
->the_bfd
->my_archive
!= NULL
261 && name_match (list_tmp
->name
,
262 file
->the_bfd
->my_archive
->filename
) == 0)
266 (*callback
) (ptr
, sec
, s
, file
, data
);
269 /* Lowest common denominator routine that can handle everything correctly,
273 walk_wild_section_general (lang_wild_statement_type
*ptr
,
274 lang_input_statement_type
*file
,
279 struct wildcard_list
*sec
;
281 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
283 sec
= ptr
->section_list
;
285 (*callback
) (ptr
, sec
, s
, file
, data
);
289 bfd_boolean skip
= FALSE
;
291 if (sec
->spec
.name
!= NULL
)
293 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
295 skip
= name_match (sec
->spec
.name
, sname
) != 0;
299 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
306 /* Routines to find a single section given its name. If there's more
307 than one section with that name, we report that. */
311 asection
*found_section
;
312 bfd_boolean multiple_sections_found
;
313 } section_iterator_callback_data
;
316 section_iterator_callback (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
318 section_iterator_callback_data
*d
= (section_iterator_callback_data
*) data
;
320 if (d
->found_section
!= NULL
)
322 d
->multiple_sections_found
= TRUE
;
326 d
->found_section
= s
;
331 find_section (lang_input_statement_type
*file
,
332 struct wildcard_list
*sec
,
333 bfd_boolean
*multiple_sections_found
)
335 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
337 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
338 section_iterator_callback
, &cb_data
);
339 *multiple_sections_found
= cb_data
.multiple_sections_found
;
340 return cb_data
.found_section
;
343 /* Code for handling simple wildcards without going through fnmatch,
344 which can be expensive because of charset translations etc. */
346 /* A simple wild is a literal string followed by a single '*',
347 where the literal part is at least 4 characters long. */
350 is_simple_wild (const char *name
)
352 size_t len
= strcspn (name
, "*?[");
353 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
357 match_simple_wild (const char *pattern
, const char *name
)
359 /* The first four characters of the pattern are guaranteed valid
360 non-wildcard characters. So we can go faster. */
361 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
362 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
367 while (*pattern
!= '*')
368 if (*name
++ != *pattern
++)
374 /* Return the numerical value of the init_priority attribute from
375 section name NAME. */
378 get_init_priority (const char *name
)
381 unsigned long init_priority
;
383 /* GCC uses the following section names for the init_priority
384 attribute with numerical values 101 and 65535 inclusive. A
385 lower value means a higher priority.
387 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the
388 decimal numerical value of the init_priority attribute.
389 The order of execution in .init_array is forward and
390 .fini_array is backward.
391 2: .ctors.NNNN/.ctors.NNNN: Where NNNN is 65535 minus the
392 decimal numerical value of the init_priority attribute.
393 The order of execution in .ctors is backward and .dtors
396 if (strncmp (name
, ".init_array.", 12) == 0
397 || strncmp (name
, ".fini_array.", 12) == 0)
399 init_priority
= strtoul (name
+ 12, &end
, 10);
400 return *end
? 0 : init_priority
;
402 else if (strncmp (name
, ".ctors.", 7) == 0
403 || strncmp (name
, ".dtors.", 7) == 0)
405 init_priority
= strtoul (name
+ 7, &end
, 10);
406 return *end
? 0 : 65535 - init_priority
;
412 /* Compare sections ASEC and BSEC according to SORT. */
415 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
418 unsigned long ainit_priority
, binit_priority
;
425 case by_init_priority
:
427 = get_init_priority (bfd_get_section_name (asec
->owner
, asec
));
429 = get_init_priority (bfd_get_section_name (bsec
->owner
, bsec
));
430 if (ainit_priority
== 0 || binit_priority
== 0)
432 ret
= ainit_priority
- binit_priority
;
438 case by_alignment_name
:
439 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
440 - bfd_section_alignment (asec
->owner
, asec
));
447 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
448 bfd_get_section_name (bsec
->owner
, bsec
));
451 case by_name_alignment
:
452 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
453 bfd_get_section_name (bsec
->owner
, bsec
));
459 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
460 - bfd_section_alignment (asec
->owner
, asec
));
467 /* Build a Binary Search Tree to sort sections, unlike insertion sort
468 used in wild_sort(). BST is considerably faster if the number of
469 of sections are large. */
471 static lang_section_bst_type
**
472 wild_sort_fast (lang_wild_statement_type
*wild
,
473 struct wildcard_list
*sec
,
474 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
477 lang_section_bst_type
**tree
;
480 if (!wild
->filenames_sorted
481 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
483 /* Append at the right end of tree. */
485 tree
= &((*tree
)->right
);
491 /* Find the correct node to append this section. */
492 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
493 tree
= &((*tree
)->left
);
495 tree
= &((*tree
)->right
);
501 /* Use wild_sort_fast to build a BST to sort sections. */
504 output_section_callback_fast (lang_wild_statement_type
*ptr
,
505 struct wildcard_list
*sec
,
507 lang_input_statement_type
*file
,
510 lang_section_bst_type
*node
;
511 lang_section_bst_type
**tree
;
512 lang_output_section_statement_type
*os
;
514 os
= (lang_output_section_statement_type
*) output
;
516 if (unique_section_p (section
, os
))
519 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
522 node
->section
= section
;
524 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
529 /* Convert a sorted sections' BST back to list form. */
532 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
533 lang_section_bst_type
*tree
,
537 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
539 lang_add_section (&ptr
->children
, tree
->section
,
540 (lang_output_section_statement_type
*) output
);
543 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
548 /* Specialized, optimized routines for handling different kinds of
552 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
553 lang_input_statement_type
*file
,
557 /* We can just do a hash lookup for the section with the right name.
558 But if that lookup discovers more than one section with the name
559 (should be rare), we fall back to the general algorithm because
560 we would otherwise have to sort the sections to make sure they
561 get processed in the bfd's order. */
562 bfd_boolean multiple_sections_found
;
563 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
564 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
566 if (multiple_sections_found
)
567 walk_wild_section_general (ptr
, file
, callback
, data
);
569 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
573 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
574 lang_input_statement_type
*file
,
579 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
581 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
583 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
584 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
587 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
592 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
593 lang_input_statement_type
*file
,
598 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
599 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
600 bfd_boolean multiple_sections_found
;
601 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
603 if (multiple_sections_found
)
605 walk_wild_section_general (ptr
, file
, callback
, data
);
609 /* Note that if the section was not found, s0 is NULL and
610 we'll simply never succeed the s == s0 test below. */
611 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
613 /* Recall that in this code path, a section cannot satisfy more
614 than one spec, so if s == s0 then it cannot match
617 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
620 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
621 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
624 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
631 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
632 lang_input_statement_type
*file
,
637 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
638 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
639 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
640 bfd_boolean multiple_sections_found
;
641 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
643 if (multiple_sections_found
)
645 walk_wild_section_general (ptr
, file
, callback
, data
);
649 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
652 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
655 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
656 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
659 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
662 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
664 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
672 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
673 lang_input_statement_type
*file
,
678 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
679 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
680 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
681 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
682 bfd_boolean multiple_sections_found
;
683 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
685 if (multiple_sections_found
)
687 walk_wild_section_general (ptr
, file
, callback
, data
);
691 s1
= find_section (file
, sec1
, &multiple_sections_found
);
692 if (multiple_sections_found
)
694 walk_wild_section_general (ptr
, file
, callback
, data
);
698 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
701 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
704 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
707 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
708 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
712 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
716 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
718 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
726 walk_wild_section (lang_wild_statement_type
*ptr
,
727 lang_input_statement_type
*file
,
731 if (file
->just_syms_flag
)
734 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
737 /* Returns TRUE when name1 is a wildcard spec that might match
738 something name2 can match. We're conservative: we return FALSE
739 only if the prefixes of name1 and name2 are different up to the
740 first wildcard character. */
743 wild_spec_can_overlap (const char *name1
, const char *name2
)
745 size_t prefix1_len
= strcspn (name1
, "?*[");
746 size_t prefix2_len
= strcspn (name2
, "?*[");
747 size_t min_prefix_len
;
749 /* Note that if there is no wildcard character, then we treat the
750 terminating 0 as part of the prefix. Thus ".text" won't match
751 ".text." or ".text.*", for example. */
752 if (name1
[prefix1_len
] == '\0')
754 if (name2
[prefix2_len
] == '\0')
757 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
759 return memcmp (name1
, name2
, min_prefix_len
) == 0;
762 /* Select specialized code to handle various kinds of wildcard
766 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
769 int wild_name_count
= 0;
770 struct wildcard_list
*sec
;
774 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
775 ptr
->handler_data
[0] = NULL
;
776 ptr
->handler_data
[1] = NULL
;
777 ptr
->handler_data
[2] = NULL
;
778 ptr
->handler_data
[3] = NULL
;
781 /* Count how many wildcard_specs there are, and how many of those
782 actually use wildcards in the name. Also, bail out if any of the
783 wildcard names are NULL. (Can this actually happen?
784 walk_wild_section used to test for it.) And bail out if any
785 of the wildcards are more complex than a simple string
786 ending in a single '*'. */
787 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
790 if (sec
->spec
.name
== NULL
)
792 if (wildcardp (sec
->spec
.name
))
795 if (!is_simple_wild (sec
->spec
.name
))
800 /* The zero-spec case would be easy to optimize but it doesn't
801 happen in practice. Likewise, more than 4 specs doesn't
802 happen in practice. */
803 if (sec_count
== 0 || sec_count
> 4)
806 /* Check that no two specs can match the same section. */
807 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
809 struct wildcard_list
*sec2
;
810 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
812 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
817 signature
= (sec_count
<< 8) + wild_name_count
;
821 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
824 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
827 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
830 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
833 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
839 /* Now fill the data array with pointers to the specs, first the
840 specs with non-wildcard names, then the specs with wildcard
841 names. It's OK to process the specs in different order from the
842 given order, because we've already determined that no section
843 will match more than one spec. */
845 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
846 if (!wildcardp (sec
->spec
.name
))
847 ptr
->handler_data
[data_counter
++] = sec
;
848 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
849 if (wildcardp (sec
->spec
.name
))
850 ptr
->handler_data
[data_counter
++] = sec
;
853 /* Handle a wild statement for a single file F. */
856 walk_wild_file (lang_wild_statement_type
*s
,
857 lang_input_statement_type
*f
,
861 if (f
->the_bfd
== NULL
862 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
863 walk_wild_section (s
, f
, callback
, data
);
868 /* This is an archive file. We must map each member of the
869 archive separately. */
870 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
871 while (member
!= NULL
)
873 /* When lookup_name is called, it will call the add_symbols
874 entry point for the archive. For each element of the
875 archive which is included, BFD will call ldlang_add_file,
876 which will set the usrdata field of the member to the
877 lang_input_statement. */
878 if (member
->usrdata
!= NULL
)
880 walk_wild_section (s
,
881 (lang_input_statement_type
*) member
->usrdata
,
885 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
891 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
893 const char *file_spec
= s
->filename
;
896 if (file_spec
== NULL
)
898 /* Perform the iteration over all files in the list. */
899 LANG_FOR_EACH_INPUT_STATEMENT (f
)
901 walk_wild_file (s
, f
, callback
, data
);
904 else if ((p
= archive_path (file_spec
)) != NULL
)
906 LANG_FOR_EACH_INPUT_STATEMENT (f
)
908 if (input_statement_is_archive_path (file_spec
, p
, f
))
909 walk_wild_file (s
, f
, callback
, data
);
912 else if (wildcardp (file_spec
))
914 LANG_FOR_EACH_INPUT_STATEMENT (f
)
916 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
917 walk_wild_file (s
, f
, callback
, data
);
922 lang_input_statement_type
*f
;
924 /* Perform the iteration over a single file. */
925 f
= lookup_name (file_spec
);
927 walk_wild_file (s
, f
, callback
, data
);
931 /* lang_for_each_statement walks the parse tree and calls the provided
932 function for each node, except those inside output section statements
933 with constraint set to -1. */
936 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
937 lang_statement_union_type
*s
)
939 for (; s
!= NULL
; s
= s
->header
.next
)
943 switch (s
->header
.type
)
945 case lang_constructors_statement_enum
:
946 lang_for_each_statement_worker (func
, constructor_list
.head
);
948 case lang_output_section_statement_enum
:
949 if (s
->output_section_statement
.constraint
!= -1)
950 lang_for_each_statement_worker
951 (func
, s
->output_section_statement
.children
.head
);
953 case lang_wild_statement_enum
:
954 lang_for_each_statement_worker (func
,
955 s
->wild_statement
.children
.head
);
957 case lang_group_statement_enum
:
958 lang_for_each_statement_worker (func
,
959 s
->group_statement
.children
.head
);
961 case lang_data_statement_enum
:
962 case lang_reloc_statement_enum
:
963 case lang_object_symbols_statement_enum
:
964 case lang_output_statement_enum
:
965 case lang_target_statement_enum
:
966 case lang_input_section_enum
:
967 case lang_input_statement_enum
:
968 case lang_assignment_statement_enum
:
969 case lang_padding_statement_enum
:
970 case lang_address_statement_enum
:
971 case lang_fill_statement_enum
:
972 case lang_insert_statement_enum
:
982 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
984 lang_for_each_statement_worker (func
, statement_list
.head
);
987 /*----------------------------------------------------------------------*/
990 lang_list_init (lang_statement_list_type
*list
)
993 list
->tail
= &list
->head
;
997 push_stat_ptr (lang_statement_list_type
*new_ptr
)
999 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1001 *stat_save_ptr
++ = stat_ptr
;
1008 if (stat_save_ptr
<= stat_save
)
1010 stat_ptr
= *--stat_save_ptr
;
1013 /* Build a new statement node for the parse tree. */
1015 static lang_statement_union_type
*
1016 new_statement (enum statement_enum type
,
1018 lang_statement_list_type
*list
)
1020 lang_statement_union_type
*new_stmt
;
1022 new_stmt
= (lang_statement_union_type
*) stat_alloc (size
);
1023 new_stmt
->header
.type
= type
;
1024 new_stmt
->header
.next
= NULL
;
1025 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1029 /* Build a new input file node for the language. There are several
1030 ways in which we treat an input file, eg, we only look at symbols,
1031 or prefix it with a -l etc.
1033 We can be supplied with requests for input files more than once;
1034 they may, for example be split over several lines like foo.o(.text)
1035 foo.o(.data) etc, so when asked for a file we check that we haven't
1036 got it already so we don't duplicate the bfd. */
1038 static lang_input_statement_type
*
1039 new_afile (const char *name
,
1040 lang_input_file_enum_type file_type
,
1042 bfd_boolean add_to_list
)
1044 lang_input_statement_type
*p
;
1047 p
= (lang_input_statement_type
*) new_stat (lang_input_statement
, stat_ptr
);
1050 p
= (lang_input_statement_type
*)
1051 stat_alloc (sizeof (lang_input_statement_type
));
1052 p
->header
.type
= lang_input_statement_enum
;
1053 p
->header
.next
= NULL
;
1056 lang_has_input_file
= TRUE
;
1058 p
->sysrooted
= FALSE
;
1060 if (file_type
== lang_input_file_is_l_enum
1061 && name
[0] == ':' && name
[1] != '\0')
1063 file_type
= lang_input_file_is_search_file_enum
;
1069 case lang_input_file_is_symbols_only_enum
:
1071 p
->maybe_archive
= FALSE
;
1073 p
->local_sym_name
= name
;
1074 p
->just_syms_flag
= TRUE
;
1075 p
->search_dirs_flag
= FALSE
;
1077 case lang_input_file_is_fake_enum
:
1079 p
->maybe_archive
= FALSE
;
1081 p
->local_sym_name
= name
;
1082 p
->just_syms_flag
= FALSE
;
1083 p
->search_dirs_flag
= FALSE
;
1085 case lang_input_file_is_l_enum
:
1086 p
->maybe_archive
= TRUE
;
1089 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1090 p
->just_syms_flag
= FALSE
;
1091 p
->search_dirs_flag
= TRUE
;
1093 case lang_input_file_is_marker_enum
:
1095 p
->maybe_archive
= FALSE
;
1097 p
->local_sym_name
= name
;
1098 p
->just_syms_flag
= FALSE
;
1099 p
->search_dirs_flag
= TRUE
;
1101 case lang_input_file_is_search_file_enum
:
1102 p
->sysrooted
= ldlang_sysrooted_script
;
1104 p
->maybe_archive
= FALSE
;
1106 p
->local_sym_name
= name
;
1107 p
->just_syms_flag
= FALSE
;
1108 p
->search_dirs_flag
= TRUE
;
1110 case lang_input_file_is_file_enum
:
1112 p
->maybe_archive
= FALSE
;
1114 p
->local_sym_name
= name
;
1115 p
->just_syms_flag
= FALSE
;
1116 p
->search_dirs_flag
= FALSE
;
1122 p
->next_real_file
= NULL
;
1124 p
->dynamic
= config
.dynamic_link
;
1125 p
->add_DT_NEEDED_for_dynamic
= add_DT_NEEDED_for_dynamic
;
1126 p
->add_DT_NEEDED_for_regular
= add_DT_NEEDED_for_regular
;
1127 p
->whole_archive
= whole_archive
;
1129 p
->missing_file
= FALSE
;
1130 #ifdef ENABLE_PLUGINS
1132 p
->claim_archive
= FALSE
;
1133 #endif /* ENABLE_PLUGINS */
1135 lang_statement_append (&input_file_chain
,
1136 (lang_statement_union_type
*) p
,
1137 &p
->next_real_file
);
1141 lang_input_statement_type
*
1142 lang_add_input_file (const char *name
,
1143 lang_input_file_enum_type file_type
,
1146 return new_afile (name
, file_type
, target
, TRUE
);
1149 struct out_section_hash_entry
1151 struct bfd_hash_entry root
;
1152 lang_statement_union_type s
;
1155 /* The hash table. */
1157 static struct bfd_hash_table output_section_statement_table
;
1159 /* Support routines for the hash table used by lang_output_section_find,
1160 initialize the table, fill in an entry and remove the table. */
1162 static struct bfd_hash_entry
*
1163 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1164 struct bfd_hash_table
*table
,
1167 lang_output_section_statement_type
**nextp
;
1168 struct out_section_hash_entry
*ret
;
1172 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1178 entry
= bfd_hash_newfunc (entry
, table
, string
);
1182 ret
= (struct out_section_hash_entry
*) entry
;
1183 memset (&ret
->s
, 0, sizeof (ret
->s
));
1184 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1185 ret
->s
.output_section_statement
.subsection_alignment
= -1;
1186 ret
->s
.output_section_statement
.section_alignment
= -1;
1187 ret
->s
.output_section_statement
.block_value
= 1;
1188 lang_list_init (&ret
->s
.output_section_statement
.children
);
1189 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1191 /* For every output section statement added to the list, except the
1192 first one, lang_output_section_statement.tail points to the "next"
1193 field of the last element of the list. */
1194 if (lang_output_section_statement
.head
!= NULL
)
1195 ret
->s
.output_section_statement
.prev
1196 = ((lang_output_section_statement_type
*)
1197 ((char *) lang_output_section_statement
.tail
1198 - offsetof (lang_output_section_statement_type
, next
)));
1200 /* GCC's strict aliasing rules prevent us from just casting the
1201 address, so we store the pointer in a variable and cast that
1203 nextp
= &ret
->s
.output_section_statement
.next
;
1204 lang_statement_append (&lang_output_section_statement
,
1206 (lang_statement_union_type
**) nextp
);
1211 output_section_statement_table_init (void)
1213 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1214 output_section_statement_newfunc
,
1215 sizeof (struct out_section_hash_entry
),
1217 einfo (_("%P%F: can not create hash table: %E\n"));
1221 output_section_statement_table_free (void)
1223 bfd_hash_table_free (&output_section_statement_table
);
1226 /* Build enough state so that the parser can build its tree. */
1231 obstack_begin (&stat_obstack
, 1000);
1233 stat_ptr
= &statement_list
;
1235 output_section_statement_table_init ();
1237 lang_list_init (stat_ptr
);
1239 lang_list_init (&input_file_chain
);
1240 lang_list_init (&lang_output_section_statement
);
1241 lang_list_init (&file_chain
);
1242 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1244 abs_output_section
=
1245 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1247 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1249 /* The value "3" is ad-hoc, somewhat related to the expected number of
1250 DEFINED expressions in a linker script. For most default linker
1251 scripts, there are none. Why a hash table then? Well, it's somewhat
1252 simpler to re-use working machinery than using a linked list in terms
1253 of code-complexity here in ld, besides the initialization which just
1254 looks like other code here. */
1255 if (!bfd_hash_table_init_n (&lang_definedness_table
,
1256 lang_definedness_newfunc
,
1257 sizeof (struct lang_definedness_hash_entry
),
1259 einfo (_("%P%F: can not create hash table: %E\n"));
1265 output_section_statement_table_free ();
1268 /*----------------------------------------------------------------------
1269 A region is an area of memory declared with the
1270 MEMORY { name:org=exp, len=exp ... }
1273 We maintain a list of all the regions here.
1275 If no regions are specified in the script, then the default is used
1276 which is created when looked up to be the entire data space.
1278 If create is true we are creating a region inside a MEMORY block.
1279 In this case it is probably an error to create a region that has
1280 already been created. If we are not inside a MEMORY block it is
1281 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1282 and so we issue a warning.
1284 Each region has at least one name. The first name is either
1285 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1286 alias names to an existing region within a script with
1287 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1290 static lang_memory_region_type
*lang_memory_region_list
;
1291 static lang_memory_region_type
**lang_memory_region_list_tail
1292 = &lang_memory_region_list
;
1294 lang_memory_region_type
*
1295 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1297 lang_memory_region_name
*n
;
1298 lang_memory_region_type
*r
;
1299 lang_memory_region_type
*new_region
;
1301 /* NAME is NULL for LMA memspecs if no region was specified. */
1305 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1306 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1307 if (strcmp (n
->name
, name
) == 0)
1310 einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
1315 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1316 einfo (_("%P:%S: warning: memory region `%s' not declared\n"), name
);
1318 new_region
= (lang_memory_region_type
*)
1319 stat_alloc (sizeof (lang_memory_region_type
));
1321 new_region
->name_list
.name
= xstrdup (name
);
1322 new_region
->name_list
.next
= NULL
;
1323 new_region
->next
= NULL
;
1324 new_region
->origin
= 0;
1325 new_region
->length
= ~(bfd_size_type
) 0;
1326 new_region
->current
= 0;
1327 new_region
->last_os
= NULL
;
1328 new_region
->flags
= 0;
1329 new_region
->not_flags
= 0;
1330 new_region
->had_full_message
= FALSE
;
1332 *lang_memory_region_list_tail
= new_region
;
1333 lang_memory_region_list_tail
= &new_region
->next
;
1339 lang_memory_region_alias (const char * alias
, const char * region_name
)
1341 lang_memory_region_name
* n
;
1342 lang_memory_region_type
* r
;
1343 lang_memory_region_type
* region
;
1345 /* The default region must be unique. This ensures that it is not necessary
1346 to iterate through the name list if someone wants the check if a region is
1347 the default memory region. */
1348 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1349 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1350 einfo (_("%F%P:%S: error: alias for default memory region\n"));
1352 /* Look for the target region and check if the alias is not already
1355 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1356 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1358 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1360 if (strcmp (n
->name
, alias
) == 0)
1361 einfo (_("%F%P:%S: error: redefinition of memory region "
1366 /* Check if the target region exists. */
1368 einfo (_("%F%P:%S: error: memory region `%s' "
1369 "for alias `%s' does not exist\n"),
1373 /* Add alias to region name list. */
1374 n
= (lang_memory_region_name
*) stat_alloc (sizeof (lang_memory_region_name
));
1375 n
->name
= xstrdup (alias
);
1376 n
->next
= region
->name_list
.next
;
1377 region
->name_list
.next
= n
;
1380 static lang_memory_region_type
*
1381 lang_memory_default (asection
* section
)
1383 lang_memory_region_type
*p
;
1385 flagword sec_flags
= section
->flags
;
1387 /* Override SEC_DATA to mean a writable section. */
1388 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1389 sec_flags
|= SEC_DATA
;
1391 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1393 if ((p
->flags
& sec_flags
) != 0
1394 && (p
->not_flags
& sec_flags
) == 0)
1399 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1402 /* Find or create an output_section_statement with the given NAME.
1403 If CONSTRAINT is non-zero match one with that constraint, otherwise
1404 match any non-negative constraint. If CREATE, always make a
1405 new output_section_statement for SPECIAL CONSTRAINT. */
1407 lang_output_section_statement_type
*
1408 lang_output_section_statement_lookup (const char *name
,
1412 struct out_section_hash_entry
*entry
;
1414 entry
= ((struct out_section_hash_entry
*)
1415 bfd_hash_lookup (&output_section_statement_table
, name
,
1420 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1424 if (entry
->s
.output_section_statement
.name
!= NULL
)
1426 /* We have a section of this name, but it might not have the correct
1428 struct out_section_hash_entry
*last_ent
;
1430 name
= entry
->s
.output_section_statement
.name
;
1431 if (create
&& constraint
== SPECIAL
)
1432 /* Not traversing to the end reverses the order of the second
1433 and subsequent SPECIAL sections in the hash table chain,
1434 but that shouldn't matter. */
1439 if (constraint
== entry
->s
.output_section_statement
.constraint
1441 && entry
->s
.output_section_statement
.constraint
>= 0))
1442 return &entry
->s
.output_section_statement
;
1444 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1446 while (entry
!= NULL
1447 && name
== entry
->s
.output_section_statement
.name
);
1453 = ((struct out_section_hash_entry
*)
1454 output_section_statement_newfunc (NULL
,
1455 &output_section_statement_table
,
1459 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1462 entry
->root
= last_ent
->root
;
1463 last_ent
->root
.next
= &entry
->root
;
1466 entry
->s
.output_section_statement
.name
= name
;
1467 entry
->s
.output_section_statement
.constraint
= constraint
;
1468 return &entry
->s
.output_section_statement
;
1471 /* Find the next output_section_statement with the same name as OS.
1472 If CONSTRAINT is non-zero, find one with that constraint otherwise
1473 match any non-negative constraint. */
1475 lang_output_section_statement_type
*
1476 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1479 /* All output_section_statements are actually part of a
1480 struct out_section_hash_entry. */
1481 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1483 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1484 const char *name
= os
->name
;
1486 ASSERT (name
== entry
->root
.string
);
1489 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1491 || name
!= entry
->s
.output_section_statement
.name
)
1494 while (constraint
!= entry
->s
.output_section_statement
.constraint
1496 || entry
->s
.output_section_statement
.constraint
< 0));
1498 return &entry
->s
.output_section_statement
;
1501 /* A variant of lang_output_section_find used by place_orphan.
1502 Returns the output statement that should precede a new output
1503 statement for SEC. If an exact match is found on certain flags,
1506 lang_output_section_statement_type
*
1507 lang_output_section_find_by_flags (const asection
*sec
,
1508 lang_output_section_statement_type
**exact
,
1509 lang_match_sec_type_func match_type
)
1511 lang_output_section_statement_type
*first
, *look
, *found
;
1514 /* We know the first statement on this list is *ABS*. May as well
1516 first
= &lang_output_section_statement
.head
->output_section_statement
;
1517 first
= first
->next
;
1519 /* First try for an exact match. */
1521 for (look
= first
; look
; look
= look
->next
)
1523 flags
= look
->flags
;
1524 if (look
->bfd_section
!= NULL
)
1526 flags
= look
->bfd_section
->flags
;
1527 if (match_type
&& !match_type (link_info
.output_bfd
,
1532 flags
^= sec
->flags
;
1533 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1534 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1544 if ((sec
->flags
& SEC_CODE
) != 0
1545 && (sec
->flags
& SEC_ALLOC
) != 0)
1547 /* Try for a rw code section. */
1548 for (look
= first
; look
; look
= look
->next
)
1550 flags
= look
->flags
;
1551 if (look
->bfd_section
!= NULL
)
1553 flags
= look
->bfd_section
->flags
;
1554 if (match_type
&& !match_type (link_info
.output_bfd
,
1559 flags
^= sec
->flags
;
1560 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1561 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1565 else if ((sec
->flags
& (SEC_READONLY
| SEC_THREAD_LOCAL
)) != 0
1566 && (sec
->flags
& SEC_ALLOC
) != 0)
1568 /* .rodata can go after .text, .sdata2 after .rodata. */
1569 for (look
= first
; look
; look
= look
->next
)
1571 flags
= look
->flags
;
1572 if (look
->bfd_section
!= NULL
)
1574 flags
= look
->bfd_section
->flags
;
1575 if (match_type
&& !match_type (link_info
.output_bfd
,
1580 flags
^= sec
->flags
;
1581 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1582 | SEC_READONLY
| SEC_SMALL_DATA
))
1583 || (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1585 && !(look
->flags
& SEC_SMALL_DATA
))
1586 || (!(flags
& (SEC_THREAD_LOCAL
| SEC_ALLOC
))
1587 && (look
->flags
& SEC_THREAD_LOCAL
)
1588 && (!(flags
& SEC_LOAD
)
1589 || (look
->flags
& SEC_LOAD
))))
1593 else if ((sec
->flags
& SEC_SMALL_DATA
) != 0
1594 && (sec
->flags
& SEC_ALLOC
) != 0)
1596 /* .sdata goes after .data, .sbss after .sdata. */
1597 for (look
= first
; look
; look
= look
->next
)
1599 flags
= look
->flags
;
1600 if (look
->bfd_section
!= NULL
)
1602 flags
= look
->bfd_section
->flags
;
1603 if (match_type
&& !match_type (link_info
.output_bfd
,
1608 flags
^= sec
->flags
;
1609 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1610 | SEC_THREAD_LOCAL
))
1611 || ((look
->flags
& SEC_SMALL_DATA
)
1612 && !(sec
->flags
& SEC_HAS_CONTENTS
)))
1616 else if ((sec
->flags
& SEC_HAS_CONTENTS
) != 0
1617 && (sec
->flags
& SEC_ALLOC
) != 0)
1619 /* .data goes after .rodata. */
1620 for (look
= first
; look
; look
= look
->next
)
1622 flags
= look
->flags
;
1623 if (look
->bfd_section
!= NULL
)
1625 flags
= look
->bfd_section
->flags
;
1626 if (match_type
&& !match_type (link_info
.output_bfd
,
1631 flags
^= sec
->flags
;
1632 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1633 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1637 else if ((sec
->flags
& SEC_ALLOC
) != 0)
1639 /* .bss goes after any other alloc section. */
1640 for (look
= first
; look
; look
= look
->next
)
1642 flags
= look
->flags
;
1643 if (look
->bfd_section
!= NULL
)
1645 flags
= look
->bfd_section
->flags
;
1646 if (match_type
&& !match_type (link_info
.output_bfd
,
1651 flags
^= sec
->flags
;
1652 if (!(flags
& SEC_ALLOC
))
1658 /* non-alloc go last. */
1659 for (look
= first
; look
; look
= look
->next
)
1661 flags
= look
->flags
;
1662 if (look
->bfd_section
!= NULL
)
1663 flags
= look
->bfd_section
->flags
;
1664 flags
^= sec
->flags
;
1665 if (!(flags
& SEC_DEBUGGING
))
1671 if (found
|| !match_type
)
1674 return lang_output_section_find_by_flags (sec
, NULL
, NULL
);
1677 /* Find the last output section before given output statement.
1678 Used by place_orphan. */
1681 output_prev_sec_find (lang_output_section_statement_type
*os
)
1683 lang_output_section_statement_type
*lookup
;
1685 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1687 if (lookup
->constraint
< 0)
1690 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1691 return lookup
->bfd_section
;
1697 /* Look for a suitable place for a new output section statement. The
1698 idea is to skip over anything that might be inside a SECTIONS {}
1699 statement in a script, before we find another output section
1700 statement. Assignments to "dot" before an output section statement
1701 are assumed to belong to it, except in two cases; The first
1702 assignment to dot, and assignments before non-alloc sections.
1703 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1704 similar assignments that set the initial address, or we might
1705 insert non-alloc note sections among assignments setting end of
1708 static lang_statement_union_type
**
1709 insert_os_after (lang_output_section_statement_type
*after
)
1711 lang_statement_union_type
**where
;
1712 lang_statement_union_type
**assign
= NULL
;
1713 bfd_boolean ignore_first
;
1716 = after
== &lang_output_section_statement
.head
->output_section_statement
;
1718 for (where
= &after
->header
.next
;
1720 where
= &(*where
)->header
.next
)
1722 switch ((*where
)->header
.type
)
1724 case lang_assignment_statement_enum
:
1727 lang_assignment_statement_type
*ass
;
1729 ass
= &(*where
)->assignment_statement
;
1730 if (ass
->exp
->type
.node_class
!= etree_assert
1731 && ass
->exp
->assign
.dst
[0] == '.'
1732 && ass
->exp
->assign
.dst
[1] == 0
1736 ignore_first
= FALSE
;
1738 case lang_wild_statement_enum
:
1739 case lang_input_section_enum
:
1740 case lang_object_symbols_statement_enum
:
1741 case lang_fill_statement_enum
:
1742 case lang_data_statement_enum
:
1743 case lang_reloc_statement_enum
:
1744 case lang_padding_statement_enum
:
1745 case lang_constructors_statement_enum
:
1748 case lang_output_section_statement_enum
:
1751 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1754 || s
->map_head
.s
== NULL
1755 || (s
->flags
& SEC_ALLOC
) != 0)
1759 case lang_input_statement_enum
:
1760 case lang_address_statement_enum
:
1761 case lang_target_statement_enum
:
1762 case lang_output_statement_enum
:
1763 case lang_group_statement_enum
:
1764 case lang_insert_statement_enum
:
1773 lang_output_section_statement_type
*
1774 lang_insert_orphan (asection
*s
,
1775 const char *secname
,
1777 lang_output_section_statement_type
*after
,
1778 struct orphan_save
*place
,
1779 etree_type
*address
,
1780 lang_statement_list_type
*add_child
)
1782 lang_statement_list_type add
;
1784 lang_output_section_statement_type
*os
;
1785 lang_output_section_statement_type
**os_tail
;
1787 /* If we have found an appropriate place for the output section
1788 statements for this orphan, add them to our own private list,
1789 inserting them later into the global statement list. */
1792 lang_list_init (&add
);
1793 push_stat_ptr (&add
);
1796 if (link_info
.relocatable
|| (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1797 address
= exp_intop (0);
1799 os_tail
= ((lang_output_section_statement_type
**)
1800 lang_output_section_statement
.tail
);
1801 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1802 NULL
, NULL
, NULL
, constraint
);
1805 if (config
.build_constructors
&& *os_tail
== os
)
1807 /* If the name of the section is representable in C, then create
1808 symbols to mark the start and the end of the section. */
1809 for (ps
= secname
; *ps
!= '\0'; ps
++)
1810 if (! ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
1815 etree_type
*e_align
;
1817 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__start_" + 1);
1818 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1819 sprintf (symname
+ (symname
[0] != 0), "__start_%s", secname
);
1820 e_align
= exp_unop (ALIGN_K
,
1821 exp_intop ((bfd_vma
) 1 << s
->alignment_power
));
1822 lang_add_assignment (exp_assign (".", e_align
));
1823 lang_add_assignment (exp_provide (symname
,
1825 exp_nameop (NAME
, ".")),
1830 if (add_child
== NULL
)
1831 add_child
= &os
->children
;
1832 lang_add_section (add_child
, s
, os
);
1834 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1836 const char *region
= (after
->region
1837 ? after
->region
->name_list
.name
1838 : DEFAULT_MEMORY_REGION
);
1839 const char *lma_region
= (after
->lma_region
1840 ? after
->lma_region
->name_list
.name
1842 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1846 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1849 if (ps
!= NULL
&& *ps
== '\0')
1853 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__stop_" + 1);
1854 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1855 sprintf (symname
+ (symname
[0] != 0), "__stop_%s", secname
);
1856 lang_add_assignment (exp_provide (symname
,
1857 exp_nameop (NAME
, "."),
1861 /* Restore the global list pointer. */
1865 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1867 asection
*snew
, *as
;
1869 snew
= os
->bfd_section
;
1871 /* Shuffle the bfd section list to make the output file look
1872 neater. This is really only cosmetic. */
1873 if (place
->section
== NULL
1874 && after
!= (&lang_output_section_statement
.head
1875 ->output_section_statement
))
1877 asection
*bfd_section
= after
->bfd_section
;
1879 /* If the output statement hasn't been used to place any input
1880 sections (and thus doesn't have an output bfd_section),
1881 look for the closest prior output statement having an
1883 if (bfd_section
== NULL
)
1884 bfd_section
= output_prev_sec_find (after
);
1886 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1887 place
->section
= &bfd_section
->next
;
1890 if (place
->section
== NULL
)
1891 place
->section
= &link_info
.output_bfd
->sections
;
1893 as
= *place
->section
;
1897 /* Put the section at the end of the list. */
1899 /* Unlink the section. */
1900 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1902 /* Now tack it back on in the right place. */
1903 bfd_section_list_append (link_info
.output_bfd
, snew
);
1905 else if (as
!= snew
&& as
->prev
!= snew
)
1907 /* Unlink the section. */
1908 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1910 /* Now tack it back on in the right place. */
1911 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
1914 /* Save the end of this list. Further ophans of this type will
1915 follow the one we've just added. */
1916 place
->section
= &snew
->next
;
1918 /* The following is non-cosmetic. We try to put the output
1919 statements in some sort of reasonable order here, because they
1920 determine the final load addresses of the orphan sections.
1921 In addition, placing output statements in the wrong order may
1922 require extra segments. For instance, given a typical
1923 situation of all read-only sections placed in one segment and
1924 following that a segment containing all the read-write
1925 sections, we wouldn't want to place an orphan read/write
1926 section before or amongst the read-only ones. */
1927 if (add
.head
!= NULL
)
1929 lang_output_section_statement_type
*newly_added_os
;
1931 if (place
->stmt
== NULL
)
1933 lang_statement_union_type
**where
= insert_os_after (after
);
1938 place
->os_tail
= &after
->next
;
1942 /* Put it after the last orphan statement we added. */
1943 *add
.tail
= *place
->stmt
;
1944 *place
->stmt
= add
.head
;
1947 /* Fix the global list pointer if we happened to tack our
1948 new list at the tail. */
1949 if (*stat_ptr
->tail
== add
.head
)
1950 stat_ptr
->tail
= add
.tail
;
1952 /* Save the end of this list. */
1953 place
->stmt
= add
.tail
;
1955 /* Do the same for the list of output section statements. */
1956 newly_added_os
= *os_tail
;
1958 newly_added_os
->prev
= (lang_output_section_statement_type
*)
1959 ((char *) place
->os_tail
1960 - offsetof (lang_output_section_statement_type
, next
));
1961 newly_added_os
->next
= *place
->os_tail
;
1962 if (newly_added_os
->next
!= NULL
)
1963 newly_added_os
->next
->prev
= newly_added_os
;
1964 *place
->os_tail
= newly_added_os
;
1965 place
->os_tail
= &newly_added_os
->next
;
1967 /* Fixing the global list pointer here is a little different.
1968 We added to the list in lang_enter_output_section_statement,
1969 trimmed off the new output_section_statment above when
1970 assigning *os_tail = NULL, but possibly added it back in
1971 the same place when assigning *place->os_tail. */
1972 if (*os_tail
== NULL
)
1973 lang_output_section_statement
.tail
1974 = (lang_statement_union_type
**) os_tail
;
1981 lang_map_flags (flagword flag
)
1983 if (flag
& SEC_ALLOC
)
1986 if (flag
& SEC_CODE
)
1989 if (flag
& SEC_READONLY
)
1992 if (flag
& SEC_DATA
)
1995 if (flag
& SEC_LOAD
)
2002 lang_memory_region_type
*m
;
2003 bfd_boolean dis_header_printed
= FALSE
;
2006 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2010 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2011 || file
->just_syms_flag
)
2014 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2015 if ((s
->output_section
== NULL
2016 || s
->output_section
->owner
!= link_info
.output_bfd
)
2017 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2019 if (! dis_header_printed
)
2021 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2022 dis_header_printed
= TRUE
;
2025 print_input_section (s
, TRUE
);
2029 minfo (_("\nMemory Configuration\n\n"));
2030 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2031 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2033 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2038 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2040 sprintf_vma (buf
, m
->origin
);
2041 minfo ("0x%s ", buf
);
2049 minfo ("0x%V", m
->length
);
2050 if (m
->flags
|| m
->not_flags
)
2058 lang_map_flags (m
->flags
);
2064 lang_map_flags (m
->not_flags
);
2071 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2073 if (! link_info
.reduce_memory_overheads
)
2075 obstack_begin (&map_obstack
, 1000);
2076 for (p
= link_info
.input_bfds
; p
!= (bfd
*) NULL
; p
= p
->link_next
)
2077 bfd_map_over_sections (p
, init_map_userdata
, 0);
2078 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2080 lang_statement_iteration
++;
2081 print_statements ();
2085 init_map_userdata (bfd
*abfd ATTRIBUTE_UNUSED
,
2087 void *data ATTRIBUTE_UNUSED
)
2089 fat_section_userdata_type
*new_data
2090 = ((fat_section_userdata_type
*) (stat_alloc
2091 (sizeof (fat_section_userdata_type
))));
2093 ASSERT (get_userdata (sec
) == NULL
);
2094 get_userdata (sec
) = new_data
;
2095 new_data
->map_symbol_def_tail
= &new_data
->map_symbol_def_head
;
2096 new_data
->map_symbol_def_count
= 0;
2100 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2101 void *info ATTRIBUTE_UNUSED
)
2103 if (hash_entry
->type
== bfd_link_hash_defined
2104 || hash_entry
->type
== bfd_link_hash_defweak
)
2106 struct fat_user_section_struct
*ud
;
2107 struct map_symbol_def
*def
;
2109 ud
= (struct fat_user_section_struct
*)
2110 get_userdata (hash_entry
->u
.def
.section
);
2113 /* ??? What do we have to do to initialize this beforehand? */
2114 /* The first time we get here is bfd_abs_section... */
2115 init_map_userdata (0, hash_entry
->u
.def
.section
, 0);
2116 ud
= (struct fat_user_section_struct
*)
2117 get_userdata (hash_entry
->u
.def
.section
);
2119 else if (!ud
->map_symbol_def_tail
)
2120 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2122 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2123 def
->entry
= hash_entry
;
2124 *(ud
->map_symbol_def_tail
) = def
;
2125 ud
->map_symbol_def_tail
= &def
->next
;
2126 ud
->map_symbol_def_count
++;
2131 /* Initialize an output section. */
2134 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2136 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2137 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2139 if (s
->constraint
!= SPECIAL
)
2140 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2141 if (s
->bfd_section
== NULL
)
2142 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2144 if (s
->bfd_section
== NULL
)
2146 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2147 link_info
.output_bfd
->xvec
->name
, s
->name
);
2149 s
->bfd_section
->output_section
= s
->bfd_section
;
2150 s
->bfd_section
->output_offset
= 0;
2152 if (!link_info
.reduce_memory_overheads
)
2154 fat_section_userdata_type
*new_userdata
= (fat_section_userdata_type
*)
2155 stat_alloc (sizeof (fat_section_userdata_type
));
2156 memset (new_userdata
, 0, sizeof (fat_section_userdata_type
));
2157 get_userdata (s
->bfd_section
) = new_userdata
;
2160 /* If there is a base address, make sure that any sections it might
2161 mention are initialized. */
2162 if (s
->addr_tree
!= NULL
)
2163 exp_init_os (s
->addr_tree
);
2165 if (s
->load_base
!= NULL
)
2166 exp_init_os (s
->load_base
);
2168 /* If supplied an alignment, set it. */
2169 if (s
->section_alignment
!= -1)
2170 s
->bfd_section
->alignment_power
= s
->section_alignment
;
2173 /* Make sure that all output sections mentioned in an expression are
2177 exp_init_os (etree_type
*exp
)
2179 switch (exp
->type
.node_class
)
2183 exp_init_os (exp
->assign
.src
);
2187 exp_init_os (exp
->binary
.lhs
);
2188 exp_init_os (exp
->binary
.rhs
);
2192 exp_init_os (exp
->trinary
.cond
);
2193 exp_init_os (exp
->trinary
.lhs
);
2194 exp_init_os (exp
->trinary
.rhs
);
2198 exp_init_os (exp
->assert_s
.child
);
2202 exp_init_os (exp
->unary
.child
);
2206 switch (exp
->type
.node_code
)
2212 lang_output_section_statement_type
*os
;
2214 os
= lang_output_section_find (exp
->name
.name
);
2215 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2227 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2229 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2231 /* If we are only reading symbols from this object, then we want to
2232 discard all sections. */
2233 if (entry
->just_syms_flag
)
2235 bfd_link_just_syms (abfd
, sec
, &link_info
);
2239 if (!(abfd
->flags
& DYNAMIC
))
2240 bfd_section_already_linked (abfd
, sec
, &link_info
);
2243 /* The wild routines.
2245 These expand statements like *(.text) and foo.o to a list of
2246 explicit actions, like foo.o(.text), bar.o(.text) and
2247 foo.o(.text, .data). */
2249 /* Add SECTION to the output section OUTPUT. Do this by creating a
2250 lang_input_section statement which is placed at PTR. FILE is the
2251 input file which holds SECTION. */
2254 lang_add_section (lang_statement_list_type
*ptr
,
2256 lang_output_section_statement_type
*output
)
2258 flagword flags
= section
->flags
;
2259 bfd_boolean discard
;
2260 lang_input_section_type
*new_section
;
2262 /* Discard sections marked with SEC_EXCLUDE. */
2263 discard
= (flags
& SEC_EXCLUDE
) != 0;
2265 /* Discard input sections which are assigned to a section named
2266 DISCARD_SECTION_NAME. */
2267 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2270 /* Discard debugging sections if we are stripping debugging
2272 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2273 && (flags
& SEC_DEBUGGING
) != 0)
2278 if (section
->output_section
== NULL
)
2280 /* This prevents future calls from assigning this section. */
2281 section
->output_section
= bfd_abs_section_ptr
;
2286 if (section
->output_section
!= NULL
)
2289 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2290 to an output section, because we want to be able to include a
2291 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2292 section (I don't know why we want to do this, but we do).
2293 build_link_order in ldwrite.c handles this case by turning
2294 the embedded SEC_NEVER_LOAD section into a fill. */
2295 flags
&= ~ SEC_NEVER_LOAD
;
2297 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2298 already been processed. One reason to do this is that on pe
2299 format targets, .text$foo sections go into .text and it's odd
2300 to see .text with SEC_LINK_ONCE set. */
2302 if (!link_info
.relocatable
)
2303 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2305 switch (output
->sectype
)
2307 case normal_section
:
2308 case overlay_section
:
2310 case noalloc_section
:
2311 flags
&= ~SEC_ALLOC
;
2313 case noload_section
:
2315 flags
|= SEC_NEVER_LOAD
;
2316 /* Unfortunately GNU ld has managed to evolve two different
2317 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2318 alloc, no contents section. All others get a noload, noalloc
2320 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2321 flags
&= ~SEC_HAS_CONTENTS
;
2323 flags
&= ~SEC_ALLOC
;
2327 if (output
->bfd_section
== NULL
)
2328 init_os (output
, flags
);
2330 /* If SEC_READONLY is not set in the input section, then clear
2331 it from the output section. */
2332 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2334 if (output
->bfd_section
->linker_has_input
)
2336 /* Only set SEC_READONLY flag on the first input section. */
2337 flags
&= ~ SEC_READONLY
;
2339 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2340 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2341 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2342 || ((flags
& SEC_MERGE
) != 0
2343 && output
->bfd_section
->entsize
!= section
->entsize
))
2345 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2346 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2349 output
->bfd_section
->flags
|= flags
;
2351 if (!output
->bfd_section
->linker_has_input
)
2353 output
->bfd_section
->linker_has_input
= 1;
2354 /* This must happen after flags have been updated. The output
2355 section may have been created before we saw its first input
2356 section, eg. for a data statement. */
2357 bfd_init_private_section_data (section
->owner
, section
,
2358 link_info
.output_bfd
,
2359 output
->bfd_section
,
2361 if ((flags
& SEC_MERGE
) != 0)
2362 output
->bfd_section
->entsize
= section
->entsize
;
2365 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2366 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2368 /* FIXME: This value should really be obtained from the bfd... */
2369 output
->block_value
= 128;
2372 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2373 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2375 section
->output_section
= output
->bfd_section
;
2377 if (!link_info
.relocatable
2378 && !stripped_excluded_sections
)
2380 asection
*s
= output
->bfd_section
->map_tail
.s
;
2381 output
->bfd_section
->map_tail
.s
= section
;
2382 section
->map_head
.s
= NULL
;
2383 section
->map_tail
.s
= s
;
2385 s
->map_head
.s
= section
;
2387 output
->bfd_section
->map_head
.s
= section
;
2390 /* Add a section reference to the list. */
2391 new_section
= new_stat (lang_input_section
, ptr
);
2392 new_section
->section
= section
;
2395 /* Handle wildcard sorting. This returns the lang_input_section which
2396 should follow the one we are going to create for SECTION and FILE,
2397 based on the sorting requirements of WILD. It returns NULL if the
2398 new section should just go at the end of the current list. */
2400 static lang_statement_union_type
*
2401 wild_sort (lang_wild_statement_type
*wild
,
2402 struct wildcard_list
*sec
,
2403 lang_input_statement_type
*file
,
2406 lang_statement_union_type
*l
;
2408 if (!wild
->filenames_sorted
2409 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2412 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2414 lang_input_section_type
*ls
;
2416 if (l
->header
.type
!= lang_input_section_enum
)
2418 ls
= &l
->input_section
;
2420 /* Sorting by filename takes precedence over sorting by section
2423 if (wild
->filenames_sorted
)
2425 const char *fn
, *ln
;
2429 /* The PE support for the .idata section as generated by
2430 dlltool assumes that files will be sorted by the name of
2431 the archive and then the name of the file within the
2434 if (file
->the_bfd
!= NULL
2435 && bfd_my_archive (file
->the_bfd
) != NULL
)
2437 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
2442 fn
= file
->filename
;
2446 if (bfd_my_archive (ls
->section
->owner
) != NULL
)
2448 ln
= bfd_get_filename (bfd_my_archive (ls
->section
->owner
));
2453 ln
= ls
->section
->owner
->filename
;
2457 i
= filename_cmp (fn
, ln
);
2466 fn
= file
->filename
;
2468 ln
= ls
->section
->owner
->filename
;
2470 i
= filename_cmp (fn
, ln
);
2478 /* Here either the files are not sorted by name, or we are
2479 looking at the sections for this file. */
2481 if (sec
!= NULL
&& sec
->spec
.sorted
!= none
)
2482 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2489 /* Expand a wild statement for a particular FILE. SECTION may be
2490 NULL, in which case it is a wild card. */
2493 output_section_callback (lang_wild_statement_type
*ptr
,
2494 struct wildcard_list
*sec
,
2496 lang_input_statement_type
*file
,
2499 lang_statement_union_type
*before
;
2500 lang_output_section_statement_type
*os
;
2502 os
= (lang_output_section_statement_type
*) output
;
2504 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2505 if (unique_section_p (section
, os
))
2508 before
= wild_sort (ptr
, sec
, file
, section
);
2510 /* Here BEFORE points to the lang_input_section which
2511 should follow the one we are about to add. If BEFORE
2512 is NULL, then the section should just go at the end
2513 of the current list. */
2516 lang_add_section (&ptr
->children
, section
, os
);
2519 lang_statement_list_type list
;
2520 lang_statement_union_type
**pp
;
2522 lang_list_init (&list
);
2523 lang_add_section (&list
, section
, os
);
2525 /* If we are discarding the section, LIST.HEAD will
2527 if (list
.head
!= NULL
)
2529 ASSERT (list
.head
->header
.next
== NULL
);
2531 for (pp
= &ptr
->children
.head
;
2533 pp
= &(*pp
)->header
.next
)
2534 ASSERT (*pp
!= NULL
);
2536 list
.head
->header
.next
= *pp
;
2542 /* Check if all sections in a wild statement for a particular FILE
2546 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2547 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2549 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2552 lang_output_section_statement_type
*os
;
2554 os
= (lang_output_section_statement_type
*) output
;
2556 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2557 if (unique_section_p (section
, os
))
2560 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2561 os
->all_input_readonly
= FALSE
;
2564 /* This is passed a file name which must have been seen already and
2565 added to the statement tree. We will see if it has been opened
2566 already and had its symbols read. If not then we'll read it. */
2568 static lang_input_statement_type
*
2569 lookup_name (const char *name
)
2571 lang_input_statement_type
*search
;
2573 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2575 search
= (lang_input_statement_type
*) search
->next_real_file
)
2577 /* Use the local_sym_name as the name of the file that has
2578 already been loaded as filename might have been transformed
2579 via the search directory lookup mechanism. */
2580 const char *filename
= search
->local_sym_name
;
2582 if (filename
!= NULL
2583 && filename_cmp (filename
, name
) == 0)
2588 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2589 default_target
, FALSE
);
2591 /* If we have already added this file, or this file is not real
2592 don't add this file. */
2593 if (search
->loaded
|| !search
->real
)
2596 if (! load_symbols (search
, NULL
))
2602 /* Save LIST as a list of libraries whose symbols should not be exported. */
2607 struct excluded_lib
*next
;
2609 static struct excluded_lib
*excluded_libs
;
2612 add_excluded_libs (const char *list
)
2614 const char *p
= list
, *end
;
2618 struct excluded_lib
*entry
;
2619 end
= strpbrk (p
, ",:");
2621 end
= p
+ strlen (p
);
2622 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2623 entry
->next
= excluded_libs
;
2624 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2625 memcpy (entry
->name
, p
, end
- p
);
2626 entry
->name
[end
- p
] = '\0';
2627 excluded_libs
= entry
;
2635 check_excluded_libs (bfd
*abfd
)
2637 struct excluded_lib
*lib
= excluded_libs
;
2641 int len
= strlen (lib
->name
);
2642 const char *filename
= lbasename (abfd
->filename
);
2644 if (strcmp (lib
->name
, "ALL") == 0)
2646 abfd
->no_export
= TRUE
;
2650 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2651 && (filename
[len
] == '\0'
2652 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2653 && filename
[len
+ 2] == '\0')))
2655 abfd
->no_export
= TRUE
;
2663 /* Get the symbols for an input file. */
2666 load_symbols (lang_input_statement_type
*entry
,
2667 lang_statement_list_type
*place
)
2674 ldfile_open_file (entry
);
2676 /* Do not process further if the file was missing. */
2677 if (entry
->missing_file
)
2680 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
2681 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2684 bfd_boolean save_ldlang_sysrooted_script
;
2685 bfd_boolean save_add_DT_NEEDED_for_regular
;
2686 bfd_boolean save_add_DT_NEEDED_for_dynamic
;
2687 bfd_boolean save_whole_archive
;
2689 err
= bfd_get_error ();
2691 /* See if the emulation has some special knowledge. */
2692 if (ldemul_unrecognized_file (entry
))
2695 if (err
== bfd_error_file_ambiguously_recognized
)
2699 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
2700 einfo (_("%B: matching formats:"), entry
->the_bfd
);
2701 for (p
= matching
; *p
!= NULL
; p
++)
2705 else if (err
!= bfd_error_file_not_recognized
2707 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
2709 bfd_close (entry
->the_bfd
);
2710 entry
->the_bfd
= NULL
;
2712 /* Try to interpret the file as a linker script. */
2713 ldfile_open_command_file (entry
->filename
);
2715 push_stat_ptr (place
);
2716 save_ldlang_sysrooted_script
= ldlang_sysrooted_script
;
2717 ldlang_sysrooted_script
= entry
->sysrooted
;
2718 save_add_DT_NEEDED_for_regular
= add_DT_NEEDED_for_regular
;
2719 add_DT_NEEDED_for_regular
= entry
->add_DT_NEEDED_for_regular
;
2720 save_add_DT_NEEDED_for_dynamic
= add_DT_NEEDED_for_dynamic
;
2721 add_DT_NEEDED_for_dynamic
= entry
->add_DT_NEEDED_for_dynamic
;
2722 save_whole_archive
= whole_archive
;
2723 whole_archive
= entry
->whole_archive
;
2725 ldfile_assumed_script
= TRUE
;
2726 parser_input
= input_script
;
2727 /* We want to use the same -Bdynamic/-Bstatic as the one for
2729 config
.dynamic_link
= entry
->dynamic
;
2731 ldfile_assumed_script
= FALSE
;
2733 ldlang_sysrooted_script
= save_ldlang_sysrooted_script
;
2734 add_DT_NEEDED_for_regular
= save_add_DT_NEEDED_for_regular
;
2735 add_DT_NEEDED_for_dynamic
= save_add_DT_NEEDED_for_dynamic
;
2736 whole_archive
= save_whole_archive
;
2742 if (ldemul_recognized_file (entry
))
2745 /* We don't call ldlang_add_file for an archive. Instead, the
2746 add_symbols entry point will call ldlang_add_file, via the
2747 add_archive_element callback, for each element of the archive
2749 switch (bfd_get_format (entry
->the_bfd
))
2755 ldlang_add_file (entry
);
2756 if (trace_files
|| trace_file_tries
)
2757 info_msg ("%I\n", entry
);
2761 check_excluded_libs (entry
->the_bfd
);
2763 if (entry
->whole_archive
)
2766 bfd_boolean loaded
= TRUE
;
2771 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
2776 if (! bfd_check_format (member
, bfd_object
))
2778 einfo (_("%F%B: member %B in archive is not an object\n"),
2779 entry
->the_bfd
, member
);
2784 if (!(*link_info
.callbacks
2785 ->add_archive_element
) (&link_info
, member
,
2786 "--whole-archive", &subsbfd
))
2789 /* Potentially, the add_archive_element hook may have set a
2790 substitute BFD for us. */
2791 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
2793 einfo (_("%F%B: could not read symbols: %E\n"), member
);
2798 entry
->loaded
= loaded
;
2804 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
2805 entry
->loaded
= TRUE
;
2807 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
2809 return entry
->loaded
;
2812 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2813 may be NULL, indicating that it is a wildcard. Separate
2814 lang_input_section statements are created for each part of the
2815 expansion; they are added after the wild statement S. OUTPUT is
2816 the output section. */
2819 wild (lang_wild_statement_type
*s
,
2820 const char *target ATTRIBUTE_UNUSED
,
2821 lang_output_section_statement_type
*output
)
2823 struct wildcard_list
*sec
;
2825 if (s
->handler_data
[0]
2826 && s
->handler_data
[0]->spec
.sorted
== by_name
2827 && !s
->filenames_sorted
)
2829 lang_section_bst_type
*tree
;
2831 walk_wild (s
, output_section_callback_fast
, output
);
2836 output_section_callback_tree_to_list (s
, tree
, output
);
2841 walk_wild (s
, output_section_callback
, output
);
2843 if (default_common_section
== NULL
)
2844 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
2845 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
2847 /* Remember the section that common is going to in case we
2848 later get something which doesn't know where to put it. */
2849 default_common_section
= output
;
2854 /* Return TRUE iff target is the sought target. */
2857 get_target (const bfd_target
*target
, void *data
)
2859 const char *sought
= (const char *) data
;
2861 return strcmp (target
->name
, sought
) == 0;
2864 /* Like strcpy() but convert to lower case as well. */
2867 stricpy (char *dest
, char *src
)
2871 while ((c
= *src
++) != 0)
2872 *dest
++ = TOLOWER (c
);
2877 /* Remove the first occurrence of needle (if any) in haystack
2881 strcut (char *haystack
, char *needle
)
2883 haystack
= strstr (haystack
, needle
);
2889 for (src
= haystack
+ strlen (needle
); *src
;)
2890 *haystack
++ = *src
++;
2896 /* Compare two target format name strings.
2897 Return a value indicating how "similar" they are. */
2900 name_compare (char *first
, char *second
)
2906 copy1
= (char *) xmalloc (strlen (first
) + 1);
2907 copy2
= (char *) xmalloc (strlen (second
) + 1);
2909 /* Convert the names to lower case. */
2910 stricpy (copy1
, first
);
2911 stricpy (copy2
, second
);
2913 /* Remove size and endian strings from the name. */
2914 strcut (copy1
, "big");
2915 strcut (copy1
, "little");
2916 strcut (copy2
, "big");
2917 strcut (copy2
, "little");
2919 /* Return a value based on how many characters match,
2920 starting from the beginning. If both strings are
2921 the same then return 10 * their length. */
2922 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
2923 if (copy1
[result
] == 0)
2935 /* Set by closest_target_match() below. */
2936 static const bfd_target
*winner
;
2938 /* Scan all the valid bfd targets looking for one that has the endianness
2939 requirement that was specified on the command line, and is the nearest
2940 match to the original output target. */
2943 closest_target_match (const bfd_target
*target
, void *data
)
2945 const bfd_target
*original
= (const bfd_target
*) data
;
2947 if (command_line
.endian
== ENDIAN_BIG
2948 && target
->byteorder
!= BFD_ENDIAN_BIG
)
2951 if (command_line
.endian
== ENDIAN_LITTLE
2952 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
2955 /* Must be the same flavour. */
2956 if (target
->flavour
!= original
->flavour
)
2959 /* Ignore generic big and little endian elf vectors. */
2960 if (strcmp (target
->name
, "elf32-big") == 0
2961 || strcmp (target
->name
, "elf64-big") == 0
2962 || strcmp (target
->name
, "elf32-little") == 0
2963 || strcmp (target
->name
, "elf64-little") == 0)
2966 /* If we have not found a potential winner yet, then record this one. */
2973 /* Oh dear, we now have two potential candidates for a successful match.
2974 Compare their names and choose the better one. */
2975 if (name_compare (target
->name
, original
->name
)
2976 > name_compare (winner
->name
, original
->name
))
2979 /* Keep on searching until wqe have checked them all. */
2983 /* Return the BFD target format of the first input file. */
2986 get_first_input_target (void)
2988 char *target
= NULL
;
2990 LANG_FOR_EACH_INPUT_STATEMENT (s
)
2992 if (s
->header
.type
== lang_input_statement_enum
2995 ldfile_open_file (s
);
2997 if (s
->the_bfd
!= NULL
2998 && bfd_check_format (s
->the_bfd
, bfd_object
))
3000 target
= bfd_get_target (s
->the_bfd
);
3012 lang_get_output_target (void)
3016 /* Has the user told us which output format to use? */
3017 if (output_target
!= NULL
)
3018 return output_target
;
3020 /* No - has the current target been set to something other than
3022 if (current_target
!= default_target
)
3023 return current_target
;
3025 /* No - can we determine the format of the first input file? */
3026 target
= get_first_input_target ();
3030 /* Failed - use the default output target. */
3031 return default_target
;
3034 /* Open the output file. */
3037 open_output (const char *name
)
3039 output_target
= lang_get_output_target ();
3041 /* Has the user requested a particular endianness on the command
3043 if (command_line
.endian
!= ENDIAN_UNSET
)
3045 const bfd_target
*target
;
3046 enum bfd_endian desired_endian
;
3048 /* Get the chosen target. */
3049 target
= bfd_search_for_target (get_target
, (void *) output_target
);
3051 /* If the target is not supported, we cannot do anything. */
3054 if (command_line
.endian
== ENDIAN_BIG
)
3055 desired_endian
= BFD_ENDIAN_BIG
;
3057 desired_endian
= BFD_ENDIAN_LITTLE
;
3059 /* See if the target has the wrong endianness. This should
3060 not happen if the linker script has provided big and
3061 little endian alternatives, but some scrips don't do
3063 if (target
->byteorder
!= desired_endian
)
3065 /* If it does, then see if the target provides
3066 an alternative with the correct endianness. */
3067 if (target
->alternative_target
!= NULL
3068 && (target
->alternative_target
->byteorder
== desired_endian
))
3069 output_target
= target
->alternative_target
->name
;
3072 /* Try to find a target as similar as possible to
3073 the default target, but which has the desired
3074 endian characteristic. */
3075 bfd_search_for_target (closest_target_match
,
3078 /* Oh dear - we could not find any targets that
3079 satisfy our requirements. */
3081 einfo (_("%P: warning: could not find any targets"
3082 " that match endianness requirement\n"));
3084 output_target
= winner
->name
;
3090 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3092 if (link_info
.output_bfd
== NULL
)
3094 if (bfd_get_error () == bfd_error_invalid_target
)
3095 einfo (_("%P%F: target %s not found\n"), output_target
);
3097 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
3100 delete_output_file_on_failure
= TRUE
;
3102 if (! bfd_set_format (link_info
.output_bfd
, bfd_object
))
3103 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
3104 if (! bfd_set_arch_mach (link_info
.output_bfd
,
3105 ldfile_output_architecture
,
3106 ldfile_output_machine
))
3107 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
3109 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3110 if (link_info
.hash
== NULL
)
3111 einfo (_("%P%F: can not create hash table: %E\n"));
3113 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3117 ldlang_open_output (lang_statement_union_type
*statement
)
3119 switch (statement
->header
.type
)
3121 case lang_output_statement_enum
:
3122 ASSERT (link_info
.output_bfd
== NULL
);
3123 open_output (statement
->output_statement
.name
);
3124 ldemul_set_output_arch ();
3125 if (config
.magic_demand_paged
&& !link_info
.relocatable
)
3126 link_info
.output_bfd
->flags
|= D_PAGED
;
3128 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3129 if (config
.text_read_only
)
3130 link_info
.output_bfd
->flags
|= WP_TEXT
;
3132 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3133 if (link_info
.traditional_format
)
3134 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3136 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3139 case lang_target_statement_enum
:
3140 current_target
= statement
->target_statement
.target
;
3147 /* Convert between addresses in bytes and sizes in octets.
3148 For currently supported targets, octets_per_byte is always a power
3149 of two, so we can use shifts. */
3150 #define TO_ADDR(X) ((X) >> opb_shift)
3151 #define TO_SIZE(X) ((X) << opb_shift)
3153 /* Support the above. */
3154 static unsigned int opb_shift
= 0;
3159 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3160 ldfile_output_machine
);
3163 while ((x
& 1) == 0)
3171 /* Open all the input files. */
3175 OPEN_BFD_NORMAL
= 0,
3179 #ifdef ENABLE_PLUGINS
3180 static lang_input_statement_type
*plugin_insert
= NULL
;
3184 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3186 for (; s
!= NULL
; s
= s
->header
.next
)
3188 switch (s
->header
.type
)
3190 case lang_constructors_statement_enum
:
3191 open_input_bfds (constructor_list
.head
, mode
);
3193 case lang_output_section_statement_enum
:
3194 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3196 case lang_wild_statement_enum
:
3197 /* Maybe we should load the file's symbols. */
3198 if ((mode
& OPEN_BFD_RESCAN
) == 0
3199 && s
->wild_statement
.filename
3200 && !wildcardp (s
->wild_statement
.filename
)
3201 && !archive_path (s
->wild_statement
.filename
))
3202 lookup_name (s
->wild_statement
.filename
);
3203 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3205 case lang_group_statement_enum
:
3207 struct bfd_link_hash_entry
*undefs
;
3209 /* We must continually search the entries in the group
3210 until no new symbols are added to the list of undefined
3215 undefs
= link_info
.hash
->undefs_tail
;
3216 open_input_bfds (s
->group_statement
.children
.head
,
3217 mode
| OPEN_BFD_FORCE
);
3219 while (undefs
!= link_info
.hash
->undefs_tail
);
3222 case lang_target_statement_enum
:
3223 current_target
= s
->target_statement
.target
;
3225 case lang_input_statement_enum
:
3226 if (s
->input_statement
.real
)
3228 lang_statement_union_type
**os_tail
;
3229 lang_statement_list_type add
;
3231 s
->input_statement
.target
= current_target
;
3233 /* If we are being called from within a group, and this
3234 is an archive which has already been searched, then
3235 force it to be researched unless the whole archive
3236 has been loaded already. Do the same for a rescan. */
3237 if (mode
!= OPEN_BFD_NORMAL
3238 #ifdef ENABLE_PLUGINS
3239 && ((mode
& OPEN_BFD_RESCAN
) == 0
3240 || plugin_insert
== NULL
)
3242 && !s
->input_statement
.whole_archive
3243 && s
->input_statement
.loaded
3244 && bfd_check_format (s
->input_statement
.the_bfd
,
3246 s
->input_statement
.loaded
= FALSE
;
3248 os_tail
= lang_output_section_statement
.tail
;
3249 lang_list_init (&add
);
3251 if (! load_symbols (&s
->input_statement
, &add
))
3252 config
.make_executable
= FALSE
;
3254 if (add
.head
!= NULL
)
3256 /* If this was a script with output sections then
3257 tack any added statements on to the end of the
3258 list. This avoids having to reorder the output
3259 section statement list. Very likely the user
3260 forgot -T, and whatever we do here will not meet
3261 naive user expectations. */
3262 if (os_tail
!= lang_output_section_statement
.tail
)
3264 einfo (_("%P: warning: %s contains output sections;"
3265 " did you forget -T?\n"),
3266 s
->input_statement
.filename
);
3267 *stat_ptr
->tail
= add
.head
;
3268 stat_ptr
->tail
= add
.tail
;
3272 *add
.tail
= s
->header
.next
;
3273 s
->header
.next
= add
.head
;
3277 #ifdef ENABLE_PLUGINS
3278 /* If we have found the point at which a plugin added new
3279 files, clear plugin_insert to enable archive rescan. */
3280 if (&s
->input_statement
== plugin_insert
)
3281 plugin_insert
= NULL
;
3284 case lang_assignment_statement_enum
:
3285 if (s
->assignment_statement
.exp
->assign
.hidden
)
3286 /* This is from a --defsym on the command line. */
3287 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3294 /* Exit if any of the files were missing. */
3299 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
3302 lang_track_definedness (const char *name
)
3304 if (bfd_hash_lookup (&lang_definedness_table
, name
, TRUE
, FALSE
) == NULL
)
3305 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
3308 /* New-function for the definedness hash table. */
3310 static struct bfd_hash_entry
*
3311 lang_definedness_newfunc (struct bfd_hash_entry
*entry
,
3312 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
3313 const char *name ATTRIBUTE_UNUSED
)
3315 struct lang_definedness_hash_entry
*ret
3316 = (struct lang_definedness_hash_entry
*) entry
;
3319 ret
= (struct lang_definedness_hash_entry
*)
3320 bfd_hash_allocate (table
, sizeof (struct lang_definedness_hash_entry
));
3323 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
3325 ret
->iteration
= -1;
3329 /* Return the iteration when the definition of NAME was last updated. A
3330 value of -1 means that the symbol is not defined in the linker script
3331 or the command line, but may be defined in the linker symbol table. */
3334 lang_symbol_definition_iteration (const char *name
)
3336 struct lang_definedness_hash_entry
*defentry
3337 = (struct lang_definedness_hash_entry
*)
3338 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
3340 /* We've already created this one on the presence of DEFINED in the
3341 script, so it can't be NULL unless something is borked elsewhere in
3343 if (defentry
== NULL
)
3346 return defentry
->iteration
;
3349 /* Update the definedness state of NAME. */
3352 lang_update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
3354 struct lang_definedness_hash_entry
*defentry
3355 = (struct lang_definedness_hash_entry
*)
3356 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
3358 /* We don't keep track of symbols not tested with DEFINED. */
3359 if (defentry
== NULL
)
3362 /* If the symbol was already defined, and not from an earlier statement
3363 iteration, don't update the definedness iteration, because that'd
3364 make the symbol seem defined in the linker script at this point, and
3365 it wasn't; it was defined in some object. If we do anyway, DEFINED
3366 would start to yield false before this point and the construct "sym =
3367 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3369 if (h
->type
!= bfd_link_hash_undefined
3370 && h
->type
!= bfd_link_hash_common
3371 && h
->type
!= bfd_link_hash_new
3372 && defentry
->iteration
== -1)
3375 defentry
->iteration
= lang_statement_iteration
;
3378 /* Add the supplied name to the symbol table as an undefined reference.
3379 This is a two step process as the symbol table doesn't even exist at
3380 the time the ld command line is processed. First we put the name
3381 on a list, then, once the output file has been opened, transfer the
3382 name to the symbol table. */
3384 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3386 #define ldlang_undef_chain_list_head entry_symbol.next
3389 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3391 ldlang_undef_chain_list_type
*new_undef
;
3393 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3394 new_undef
= (ldlang_undef_chain_list_type
*) stat_alloc (sizeof (*new_undef
));
3395 new_undef
->next
= ldlang_undef_chain_list_head
;
3396 ldlang_undef_chain_list_head
= new_undef
;
3398 new_undef
->name
= xstrdup (name
);
3400 if (link_info
.output_bfd
!= NULL
)
3401 insert_undefined (new_undef
->name
);
3404 /* Insert NAME as undefined in the symbol table. */
3407 insert_undefined (const char *name
)
3409 struct bfd_link_hash_entry
*h
;
3411 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3413 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3414 if (h
->type
== bfd_link_hash_new
)
3416 h
->type
= bfd_link_hash_undefined
;
3417 h
->u
.undef
.abfd
= NULL
;
3418 bfd_link_add_undef (link_info
.hash
, h
);
3422 /* Run through the list of undefineds created above and place them
3423 into the linker hash table as undefined symbols belonging to the
3427 lang_place_undefineds (void)
3429 ldlang_undef_chain_list_type
*ptr
;
3431 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3432 insert_undefined (ptr
->name
);
3435 /* Check for all readonly or some readwrite sections. */
3438 check_input_sections
3439 (lang_statement_union_type
*s
,
3440 lang_output_section_statement_type
*output_section_statement
)
3442 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3444 switch (s
->header
.type
)
3446 case lang_wild_statement_enum
:
3447 walk_wild (&s
->wild_statement
, check_section_callback
,
3448 output_section_statement
);
3449 if (! output_section_statement
->all_input_readonly
)
3452 case lang_constructors_statement_enum
:
3453 check_input_sections (constructor_list
.head
,
3454 output_section_statement
);
3455 if (! output_section_statement
->all_input_readonly
)
3458 case lang_group_statement_enum
:
3459 check_input_sections (s
->group_statement
.children
.head
,
3460 output_section_statement
);
3461 if (! output_section_statement
->all_input_readonly
)
3470 /* Update wildcard statements if needed. */
3473 update_wild_statements (lang_statement_union_type
*s
)
3475 struct wildcard_list
*sec
;
3477 switch (sort_section
)
3487 for (; s
!= NULL
; s
= s
->header
.next
)
3489 switch (s
->header
.type
)
3494 case lang_wild_statement_enum
:
3495 sec
= s
->wild_statement
.section_list
;
3496 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3499 switch (sec
->spec
.sorted
)
3502 sec
->spec
.sorted
= sort_section
;
3505 if (sort_section
== by_alignment
)
3506 sec
->spec
.sorted
= by_name_alignment
;
3509 if (sort_section
== by_name
)
3510 sec
->spec
.sorted
= by_alignment_name
;
3518 case lang_constructors_statement_enum
:
3519 update_wild_statements (constructor_list
.head
);
3522 case lang_output_section_statement_enum
:
3523 update_wild_statements
3524 (s
->output_section_statement
.children
.head
);
3527 case lang_group_statement_enum
:
3528 update_wild_statements (s
->group_statement
.children
.head
);
3536 /* Open input files and attach to output sections. */
3539 map_input_to_output_sections
3540 (lang_statement_union_type
*s
, const char *target
,
3541 lang_output_section_statement_type
*os
)
3543 for (; s
!= NULL
; s
= s
->header
.next
)
3545 lang_output_section_statement_type
*tos
;
3548 switch (s
->header
.type
)
3550 case lang_wild_statement_enum
:
3551 wild (&s
->wild_statement
, target
, os
);
3553 case lang_constructors_statement_enum
:
3554 map_input_to_output_sections (constructor_list
.head
,
3558 case lang_output_section_statement_enum
:
3559 tos
= &s
->output_section_statement
;
3560 if (tos
->constraint
!= 0)
3562 if (tos
->constraint
!= ONLY_IF_RW
3563 && tos
->constraint
!= ONLY_IF_RO
)
3565 tos
->all_input_readonly
= TRUE
;
3566 check_input_sections (tos
->children
.head
, tos
);
3567 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3569 tos
->constraint
= -1;
3573 map_input_to_output_sections (tos
->children
.head
,
3577 case lang_output_statement_enum
:
3579 case lang_target_statement_enum
:
3580 target
= s
->target_statement
.target
;
3582 case lang_group_statement_enum
:
3583 map_input_to_output_sections (s
->group_statement
.children
.head
,
3587 case lang_data_statement_enum
:
3588 /* Make sure that any sections mentioned in the expression
3590 exp_init_os (s
->data_statement
.exp
);
3591 /* The output section gets CONTENTS, ALLOC and LOAD, but
3592 these may be overridden by the script. */
3593 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3594 switch (os
->sectype
)
3596 case normal_section
:
3597 case overlay_section
:
3599 case noalloc_section
:
3600 flags
= SEC_HAS_CONTENTS
;
3602 case noload_section
:
3603 if (bfd_get_flavour (link_info
.output_bfd
)
3604 == bfd_target_elf_flavour
)
3605 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3607 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3610 if (os
->bfd_section
== NULL
)
3611 init_os (os
, flags
);
3613 os
->bfd_section
->flags
|= flags
;
3615 case lang_input_section_enum
:
3617 case lang_fill_statement_enum
:
3618 case lang_object_symbols_statement_enum
:
3619 case lang_reloc_statement_enum
:
3620 case lang_padding_statement_enum
:
3621 case lang_input_statement_enum
:
3622 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3625 case lang_assignment_statement_enum
:
3626 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3629 /* Make sure that any sections mentioned in the assignment
3631 exp_init_os (s
->assignment_statement
.exp
);
3633 case lang_address_statement_enum
:
3634 /* Mark the specified section with the supplied address.
3635 If this section was actually a segment marker, then the
3636 directive is ignored if the linker script explicitly
3637 processed the segment marker. Originally, the linker
3638 treated segment directives (like -Ttext on the
3639 command-line) as section directives. We honor the
3640 section directive semantics for backwards compatibilty;
3641 linker scripts that do not specifically check for
3642 SEGMENT_START automatically get the old semantics. */
3643 if (!s
->address_statement
.segment
3644 || !s
->address_statement
.segment
->used
)
3646 const char *name
= s
->address_statement
.section_name
;
3648 /* Create the output section statement here so that
3649 orphans with a set address will be placed after other
3650 script sections. If we let the orphan placement code
3651 place them in amongst other sections then the address
3652 will affect following script sections, which is
3653 likely to surprise naive users. */
3654 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3655 tos
->addr_tree
= s
->address_statement
.address
;
3656 if (tos
->bfd_section
== NULL
)
3660 case lang_insert_statement_enum
:
3666 /* An insert statement snips out all the linker statements from the
3667 start of the list and places them after the output section
3668 statement specified by the insert. This operation is complicated
3669 by the fact that we keep a doubly linked list of output section
3670 statements as well as the singly linked list of all statements. */
3673 process_insert_statements (void)
3675 lang_statement_union_type
**s
;
3676 lang_output_section_statement_type
*first_os
= NULL
;
3677 lang_output_section_statement_type
*last_os
= NULL
;
3678 lang_output_section_statement_type
*os
;
3680 /* "start of list" is actually the statement immediately after
3681 the special abs_section output statement, so that it isn't
3683 s
= &lang_output_section_statement
.head
;
3684 while (*(s
= &(*s
)->header
.next
) != NULL
)
3686 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3688 /* Keep pointers to the first and last output section
3689 statement in the sequence we may be about to move. */
3690 os
= &(*s
)->output_section_statement
;
3692 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3695 /* Set constraint negative so that lang_output_section_find
3696 won't match this output section statement. At this
3697 stage in linking constraint has values in the range
3698 [-1, ONLY_IN_RW]. */
3699 last_os
->constraint
= -2 - last_os
->constraint
;
3700 if (first_os
== NULL
)
3703 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3705 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3706 lang_output_section_statement_type
*where
;
3707 lang_statement_union_type
**ptr
;
3708 lang_statement_union_type
*first
;
3710 where
= lang_output_section_find (i
->where
);
3711 if (where
!= NULL
&& i
->is_before
)
3714 where
= where
->prev
;
3715 while (where
!= NULL
&& where
->constraint
< 0);
3719 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
3723 /* Deal with reordering the output section statement list. */
3724 if (last_os
!= NULL
)
3726 asection
*first_sec
, *last_sec
;
3727 struct lang_output_section_statement_struct
**next
;
3729 /* Snip out the output sections we are moving. */
3730 first_os
->prev
->next
= last_os
->next
;
3731 if (last_os
->next
== NULL
)
3733 next
= &first_os
->prev
->next
;
3734 lang_output_section_statement
.tail
3735 = (lang_statement_union_type
**) next
;
3738 last_os
->next
->prev
= first_os
->prev
;
3739 /* Add them in at the new position. */
3740 last_os
->next
= where
->next
;
3741 if (where
->next
== NULL
)
3743 next
= &last_os
->next
;
3744 lang_output_section_statement
.tail
3745 = (lang_statement_union_type
**) next
;
3748 where
->next
->prev
= last_os
;
3749 first_os
->prev
= where
;
3750 where
->next
= first_os
;
3752 /* Move the bfd sections in the same way. */
3755 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3757 os
->constraint
= -2 - os
->constraint
;
3758 if (os
->bfd_section
!= NULL
3759 && os
->bfd_section
->owner
!= NULL
)
3761 last_sec
= os
->bfd_section
;
3762 if (first_sec
== NULL
)
3763 first_sec
= last_sec
;
3768 if (last_sec
!= NULL
)
3770 asection
*sec
= where
->bfd_section
;
3772 sec
= output_prev_sec_find (where
);
3774 /* The place we want to insert must come after the
3775 sections we are moving. So if we find no
3776 section or if the section is the same as our
3777 last section, then no move is needed. */
3778 if (sec
!= NULL
&& sec
!= last_sec
)
3780 /* Trim them off. */
3781 if (first_sec
->prev
!= NULL
)
3782 first_sec
->prev
->next
= last_sec
->next
;
3784 link_info
.output_bfd
->sections
= last_sec
->next
;
3785 if (last_sec
->next
!= NULL
)
3786 last_sec
->next
->prev
= first_sec
->prev
;
3788 link_info
.output_bfd
->section_last
= first_sec
->prev
;
3790 last_sec
->next
= sec
->next
;
3791 if (sec
->next
!= NULL
)
3792 sec
->next
->prev
= last_sec
;
3794 link_info
.output_bfd
->section_last
= last_sec
;
3795 first_sec
->prev
= sec
;
3796 sec
->next
= first_sec
;
3804 ptr
= insert_os_after (where
);
3805 /* Snip everything after the abs_section output statement we
3806 know is at the start of the list, up to and including
3807 the insert statement we are currently processing. */
3808 first
= lang_output_section_statement
.head
->header
.next
;
3809 lang_output_section_statement
.head
->header
.next
= (*s
)->header
.next
;
3810 /* Add them back where they belong. */
3813 statement_list
.tail
= s
;
3815 s
= &lang_output_section_statement
.head
;
3819 /* Undo constraint twiddling. */
3820 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3822 os
->constraint
= -2 - os
->constraint
;
3828 /* An output section might have been removed after its statement was
3829 added. For example, ldemul_before_allocation can remove dynamic
3830 sections if they turn out to be not needed. Clean them up here. */
3833 strip_excluded_output_sections (void)
3835 lang_output_section_statement_type
*os
;
3837 /* Run lang_size_sections (if not already done). */
3838 if (expld
.phase
!= lang_mark_phase_enum
)
3840 expld
.phase
= lang_mark_phase_enum
;
3841 expld
.dataseg
.phase
= exp_dataseg_none
;
3842 one_lang_size_sections_pass (NULL
, FALSE
);
3843 lang_reset_memory_regions ();
3846 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3850 asection
*output_section
;
3851 bfd_boolean exclude
;
3853 if (os
->constraint
< 0)
3856 output_section
= os
->bfd_section
;
3857 if (output_section
== NULL
)
3860 exclude
= (output_section
->rawsize
== 0
3861 && (output_section
->flags
& SEC_KEEP
) == 0
3862 && !bfd_section_removed_from_list (link_info
.output_bfd
,
3865 /* Some sections have not yet been sized, notably .gnu.version,
3866 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3867 input sections, so don't drop output sections that have such
3868 input sections unless they are also marked SEC_EXCLUDE. */
3869 if (exclude
&& output_section
->map_head
.s
!= NULL
)
3873 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
3874 if ((s
->flags
& SEC_LINKER_CREATED
) != 0
3875 && (s
->flags
& SEC_EXCLUDE
) == 0)
3882 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3883 output_section
->map_head
.link_order
= NULL
;
3884 output_section
->map_tail
.link_order
= NULL
;
3888 /* We don't set bfd_section to NULL since bfd_section of the
3889 removed output section statement may still be used. */
3890 if (!os
->section_relative_symbol
3891 && !os
->update_dot_tree
)
3893 output_section
->flags
|= SEC_EXCLUDE
;
3894 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
3895 link_info
.output_bfd
->section_count
--;
3899 /* Stop future calls to lang_add_section from messing with map_head
3900 and map_tail link_order fields. */
3901 stripped_excluded_sections
= TRUE
;
3905 print_output_section_statement
3906 (lang_output_section_statement_type
*output_section_statement
)
3908 asection
*section
= output_section_statement
->bfd_section
;
3911 if (output_section_statement
!= abs_output_section
)
3913 minfo ("\n%s", output_section_statement
->name
);
3915 if (section
!= NULL
)
3917 print_dot
= section
->vma
;
3919 len
= strlen (output_section_statement
->name
);
3920 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3925 while (len
< SECTION_NAME_MAP_LENGTH
)
3931 minfo ("0x%V %W", section
->vma
, section
->size
);
3933 if (section
->vma
!= section
->lma
)
3934 minfo (_(" load address 0x%V"), section
->lma
);
3936 if (output_section_statement
->update_dot_tree
!= NULL
)
3937 exp_fold_tree (output_section_statement
->update_dot_tree
,
3938 bfd_abs_section_ptr
, &print_dot
);
3944 print_statement_list (output_section_statement
->children
.head
,
3945 output_section_statement
);
3948 /* Scan for the use of the destination in the right hand side
3949 of an expression. In such cases we will not compute the
3950 correct expression, since the value of DST that is used on
3951 the right hand side will be its final value, not its value
3952 just before this expression is evaluated. */
3955 scan_for_self_assignment (const char * dst
, etree_type
* rhs
)
3957 if (rhs
== NULL
|| dst
== NULL
)
3960 switch (rhs
->type
.node_class
)
3963 return (scan_for_self_assignment (dst
, rhs
->binary
.lhs
)
3964 || scan_for_self_assignment (dst
, rhs
->binary
.rhs
));
3967 return (scan_for_self_assignment (dst
, rhs
->trinary
.lhs
)
3968 || scan_for_self_assignment (dst
, rhs
->trinary
.rhs
));
3971 case etree_provided
:
3973 if (strcmp (dst
, rhs
->assign
.dst
) == 0)
3975 return scan_for_self_assignment (dst
, rhs
->assign
.src
);
3978 return scan_for_self_assignment (dst
, rhs
->unary
.child
);
3982 return strcmp (dst
, rhs
->value
.str
) == 0;
3987 return strcmp (dst
, rhs
->name
.name
) == 0;
3999 print_assignment (lang_assignment_statement_type
*assignment
,
4000 lang_output_section_statement_type
*output_section
)
4004 bfd_boolean computation_is_valid
= TRUE
;
4008 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4011 if (assignment
->exp
->type
.node_class
== etree_assert
)
4014 tree
= assignment
->exp
->assert_s
.child
;
4015 computation_is_valid
= TRUE
;
4019 const char *dst
= assignment
->exp
->assign
.dst
;
4021 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4022 tree
= assignment
->exp
->assign
.src
;
4023 computation_is_valid
= is_dot
|| !scan_for_self_assignment (dst
, tree
);
4026 osec
= output_section
->bfd_section
;
4028 osec
= bfd_abs_section_ptr
;
4029 exp_fold_tree (tree
, osec
, &print_dot
);
4030 if (expld
.result
.valid_p
)
4034 if (computation_is_valid
)
4036 value
= expld
.result
.value
;
4038 if (expld
.result
.section
!= NULL
)
4039 value
+= expld
.result
.section
->vma
;
4041 minfo ("0x%V", value
);
4047 struct bfd_link_hash_entry
*h
;
4049 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4050 FALSE
, FALSE
, TRUE
);
4053 value
= h
->u
.def
.value
;
4054 value
+= h
->u
.def
.section
->output_section
->vma
;
4055 value
+= h
->u
.def
.section
->output_offset
;
4057 minfo ("[0x%V]", value
);
4060 minfo ("[unresolved]");
4072 exp_print_tree (assignment
->exp
);
4077 print_input_statement (lang_input_statement_type
*statm
)
4079 if (statm
->filename
!= NULL
4080 && (statm
->the_bfd
== NULL
4081 || (statm
->the_bfd
->flags
& BFD_LINKER_CREATED
) == 0))
4082 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4085 /* Print all symbols defined in a particular section. This is called
4086 via bfd_link_hash_traverse, or by print_all_symbols. */
4089 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4091 asection
*sec
= (asection
*) ptr
;
4093 if ((hash_entry
->type
== bfd_link_hash_defined
4094 || hash_entry
->type
== bfd_link_hash_defweak
)
4095 && sec
== hash_entry
->u
.def
.section
)
4099 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4102 (hash_entry
->u
.def
.value
4103 + hash_entry
->u
.def
.section
->output_offset
4104 + hash_entry
->u
.def
.section
->output_section
->vma
));
4106 minfo (" %T\n", hash_entry
->root
.string
);
4113 hash_entry_addr_cmp (const void *a
, const void *b
)
4115 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4116 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4118 if (l
->u
.def
.value
< r
->u
.def
.value
)
4120 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4127 print_all_symbols (asection
*sec
)
4129 struct fat_user_section_struct
*ud
=
4130 (struct fat_user_section_struct
*) get_userdata (sec
);
4131 struct map_symbol_def
*def
;
4132 struct bfd_link_hash_entry
**entries
;
4138 *ud
->map_symbol_def_tail
= 0;
4140 /* Sort the symbols by address. */
4141 entries
= (struct bfd_link_hash_entry
**)
4142 obstack_alloc (&map_obstack
, ud
->map_symbol_def_count
* sizeof (*entries
));
4144 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4145 entries
[i
] = def
->entry
;
4147 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4148 hash_entry_addr_cmp
);
4150 /* Print the symbols. */
4151 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4152 print_one_symbol (entries
[i
], sec
);
4154 obstack_free (&map_obstack
, entries
);
4157 /* Print information about an input section to the map file. */
4160 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4162 bfd_size_type size
= i
->size
;
4169 minfo ("%s", i
->name
);
4171 len
= 1 + strlen (i
->name
);
4172 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4177 while (len
< SECTION_NAME_MAP_LENGTH
)
4183 if (i
->output_section
!= NULL
4184 && i
->output_section
->owner
== link_info
.output_bfd
)
4185 addr
= i
->output_section
->vma
+ i
->output_offset
;
4193 minfo ("0x%V %W %B\n", addr
, TO_ADDR (size
), i
->owner
);
4195 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4197 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4209 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4212 if (i
->output_section
!= NULL
4213 && i
->output_section
->owner
== link_info
.output_bfd
)
4215 if (link_info
.reduce_memory_overheads
)
4216 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4218 print_all_symbols (i
);
4220 /* Update print_dot, but make sure that we do not move it
4221 backwards - this could happen if we have overlays and a
4222 later overlay is shorter than an earier one. */
4223 if (addr
+ TO_ADDR (size
) > print_dot
)
4224 print_dot
= addr
+ TO_ADDR (size
);
4229 print_fill_statement (lang_fill_statement_type
*fill
)
4233 fputs (" FILL mask 0x", config
.map_file
);
4234 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4235 fprintf (config
.map_file
, "%02x", *p
);
4236 fputs ("\n", config
.map_file
);
4240 print_data_statement (lang_data_statement_type
*data
)
4248 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4251 addr
= data
->output_offset
;
4252 if (data
->output_section
!= NULL
)
4253 addr
+= data
->output_section
->vma
;
4281 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
4283 if (data
->exp
->type
.node_class
!= etree_value
)
4286 exp_print_tree (data
->exp
);
4291 print_dot
= addr
+ TO_ADDR (size
);
4294 /* Print an address statement. These are generated by options like
4298 print_address_statement (lang_address_statement_type
*address
)
4300 minfo (_("Address of section %s set to "), address
->section_name
);
4301 exp_print_tree (address
->address
);
4305 /* Print a reloc statement. */
4308 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4315 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4318 addr
= reloc
->output_offset
;
4319 if (reloc
->output_section
!= NULL
)
4320 addr
+= reloc
->output_section
->vma
;
4322 size
= bfd_get_reloc_size (reloc
->howto
);
4324 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
4326 if (reloc
->name
!= NULL
)
4327 minfo ("%s+", reloc
->name
);
4329 minfo ("%s+", reloc
->section
->name
);
4331 exp_print_tree (reloc
->addend_exp
);
4335 print_dot
= addr
+ TO_ADDR (size
);
4339 print_padding_statement (lang_padding_statement_type
*s
)
4347 len
= sizeof " *fill*" - 1;
4348 while (len
< SECTION_NAME_MAP_LENGTH
)
4354 addr
= s
->output_offset
;
4355 if (s
->output_section
!= NULL
)
4356 addr
+= s
->output_section
->vma
;
4357 minfo ("0x%V %W ", addr
, (bfd_vma
) s
->size
);
4359 if (s
->fill
->size
!= 0)
4363 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4364 fprintf (config
.map_file
, "%02x", *p
);
4369 print_dot
= addr
+ TO_ADDR (s
->size
);
4373 print_wild_statement (lang_wild_statement_type
*w
,
4374 lang_output_section_statement_type
*os
)
4376 struct wildcard_list
*sec
;
4380 if (w
->filenames_sorted
)
4382 if (w
->filename
!= NULL
)
4383 minfo ("%s", w
->filename
);
4386 if (w
->filenames_sorted
)
4390 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4392 if (sec
->spec
.sorted
)
4394 if (sec
->spec
.exclude_name_list
!= NULL
)
4397 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4398 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4399 minfo (" %s", tmp
->name
);
4402 if (sec
->spec
.name
!= NULL
)
4403 minfo ("%s", sec
->spec
.name
);
4406 if (sec
->spec
.sorted
)
4415 print_statement_list (w
->children
.head
, os
);
4418 /* Print a group statement. */
4421 print_group (lang_group_statement_type
*s
,
4422 lang_output_section_statement_type
*os
)
4424 fprintf (config
.map_file
, "START GROUP\n");
4425 print_statement_list (s
->children
.head
, os
);
4426 fprintf (config
.map_file
, "END GROUP\n");
4429 /* Print the list of statements in S.
4430 This can be called for any statement type. */
4433 print_statement_list (lang_statement_union_type
*s
,
4434 lang_output_section_statement_type
*os
)
4438 print_statement (s
, os
);
4443 /* Print the first statement in statement list S.
4444 This can be called for any statement type. */
4447 print_statement (lang_statement_union_type
*s
,
4448 lang_output_section_statement_type
*os
)
4450 switch (s
->header
.type
)
4453 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4456 case lang_constructors_statement_enum
:
4457 if (constructor_list
.head
!= NULL
)
4459 if (constructors_sorted
)
4460 minfo (" SORT (CONSTRUCTORS)\n");
4462 minfo (" CONSTRUCTORS\n");
4463 print_statement_list (constructor_list
.head
, os
);
4466 case lang_wild_statement_enum
:
4467 print_wild_statement (&s
->wild_statement
, os
);
4469 case lang_address_statement_enum
:
4470 print_address_statement (&s
->address_statement
);
4472 case lang_object_symbols_statement_enum
:
4473 minfo (" CREATE_OBJECT_SYMBOLS\n");
4475 case lang_fill_statement_enum
:
4476 print_fill_statement (&s
->fill_statement
);
4478 case lang_data_statement_enum
:
4479 print_data_statement (&s
->data_statement
);
4481 case lang_reloc_statement_enum
:
4482 print_reloc_statement (&s
->reloc_statement
);
4484 case lang_input_section_enum
:
4485 print_input_section (s
->input_section
.section
, FALSE
);
4487 case lang_padding_statement_enum
:
4488 print_padding_statement (&s
->padding_statement
);
4490 case lang_output_section_statement_enum
:
4491 print_output_section_statement (&s
->output_section_statement
);
4493 case lang_assignment_statement_enum
:
4494 print_assignment (&s
->assignment_statement
, os
);
4496 case lang_target_statement_enum
:
4497 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4499 case lang_output_statement_enum
:
4500 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4501 if (output_target
!= NULL
)
4502 minfo (" %s", output_target
);
4505 case lang_input_statement_enum
:
4506 print_input_statement (&s
->input_statement
);
4508 case lang_group_statement_enum
:
4509 print_group (&s
->group_statement
, os
);
4511 case lang_insert_statement_enum
:
4512 minfo ("INSERT %s %s\n",
4513 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4514 s
->insert_statement
.where
);
4520 print_statements (void)
4522 print_statement_list (statement_list
.head
, abs_output_section
);
4525 /* Print the first N statements in statement list S to STDERR.
4526 If N == 0, nothing is printed.
4527 If N < 0, the entire list is printed.
4528 Intended to be called from GDB. */
4531 dprint_statement (lang_statement_union_type
*s
, int n
)
4533 FILE *map_save
= config
.map_file
;
4535 config
.map_file
= stderr
;
4538 print_statement_list (s
, abs_output_section
);
4541 while (s
&& --n
>= 0)
4543 print_statement (s
, abs_output_section
);
4548 config
.map_file
= map_save
;
4552 insert_pad (lang_statement_union_type
**ptr
,
4554 unsigned int alignment_needed
,
4555 asection
*output_section
,
4558 static fill_type zero_fill
= { 1, { 0 } };
4559 lang_statement_union_type
*pad
= NULL
;
4561 if (ptr
!= &statement_list
.head
)
4562 pad
= ((lang_statement_union_type
*)
4563 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4565 && pad
->header
.type
== lang_padding_statement_enum
4566 && pad
->padding_statement
.output_section
== output_section
)
4568 /* Use the existing pad statement. */
4570 else if ((pad
= *ptr
) != NULL
4571 && pad
->header
.type
== lang_padding_statement_enum
4572 && pad
->padding_statement
.output_section
== output_section
)
4574 /* Use the existing pad statement. */
4578 /* Make a new padding statement, linked into existing chain. */
4579 pad
= (lang_statement_union_type
*)
4580 stat_alloc (sizeof (lang_padding_statement_type
));
4581 pad
->header
.next
= *ptr
;
4583 pad
->header
.type
= lang_padding_statement_enum
;
4584 pad
->padding_statement
.output_section
= output_section
;
4587 pad
->padding_statement
.fill
= fill
;
4589 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4590 pad
->padding_statement
.size
= alignment_needed
;
4591 output_section
->size
+= alignment_needed
;
4594 /* Work out how much this section will move the dot point. */
4598 (lang_statement_union_type
**this_ptr
,
4599 lang_output_section_statement_type
*output_section_statement
,
4603 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4604 asection
*i
= is
->section
;
4606 if (!((lang_input_statement_type
*) i
->owner
->usrdata
)->just_syms_flag
4607 && (i
->flags
& SEC_EXCLUDE
) == 0)
4609 unsigned int alignment_needed
;
4612 /* Align this section first to the input sections requirement,
4613 then to the output section's requirement. If this alignment
4614 is greater than any seen before, then record it too. Perform
4615 the alignment by inserting a magic 'padding' statement. */
4617 if (output_section_statement
->subsection_alignment
!= -1)
4618 i
->alignment_power
= output_section_statement
->subsection_alignment
;
4620 o
= output_section_statement
->bfd_section
;
4621 if (o
->alignment_power
< i
->alignment_power
)
4622 o
->alignment_power
= i
->alignment_power
;
4624 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4626 if (alignment_needed
!= 0)
4628 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4629 dot
+= alignment_needed
;
4632 /* Remember where in the output section this input section goes. */
4634 i
->output_offset
= dot
- o
->vma
;
4636 /* Mark how big the output section must be to contain this now. */
4637 dot
+= TO_ADDR (i
->size
);
4638 o
->size
= TO_SIZE (dot
- o
->vma
);
4642 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
4649 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4651 const asection
*sec1
= *(const asection
**) arg1
;
4652 const asection
*sec2
= *(const asection
**) arg2
;
4654 if (bfd_section_lma (sec1
->owner
, sec1
)
4655 < bfd_section_lma (sec2
->owner
, sec2
))
4657 else if (bfd_section_lma (sec1
->owner
, sec1
)
4658 > bfd_section_lma (sec2
->owner
, sec2
))
4660 else if (sec1
->id
< sec2
->id
)
4662 else if (sec1
->id
> sec2
->id
)
4668 #define IGNORE_SECTION(s) \
4669 ((s->flags & SEC_ALLOC) == 0 \
4670 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4671 && (s->flags & SEC_LOAD) == 0))
4673 /* Check to see if any allocated sections overlap with other allocated
4674 sections. This can happen if a linker script specifies the output
4675 section addresses of the two sections. Also check whether any memory
4676 region has overflowed. */
4679 lang_check_section_addresses (void)
4682 asection
**sections
, **spp
;
4689 lang_memory_region_type
*m
;
4691 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
4694 amt
= bfd_count_sections (link_info
.output_bfd
) * sizeof (asection
*);
4695 sections
= (asection
**) xmalloc (amt
);
4697 /* Scan all sections in the output list. */
4699 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4701 /* Only consider loadable sections with real contents. */
4702 if (!(s
->flags
& SEC_LOAD
)
4703 || !(s
->flags
& SEC_ALLOC
)
4707 sections
[count
] = s
;
4714 qsort (sections
, (size_t) count
, sizeof (asection
*),
4715 sort_sections_by_lma
);
4720 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4721 for (count
--; count
; count
--)
4723 /* We must check the sections' LMA addresses not their VMA
4724 addresses because overlay sections can have overlapping VMAs
4725 but they must have distinct LMAs. */
4731 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4733 /* Look for an overlap. We have sorted sections by lma, so we
4734 know that s_start >= p_start. Besides the obvious case of
4735 overlap when the current section starts before the previous
4736 one ends, we also must have overlap if the previous section
4737 wraps around the address space. */
4738 if (s_start
<= p_end
4740 einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),
4741 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
4746 /* If any memory region has overflowed, report by how much.
4747 We do not issue this diagnostic for regions that had sections
4748 explicitly placed outside their bounds; os_region_check's
4749 diagnostics are adequate for that case.
4751 FIXME: It is conceivable that m->current - (m->origin + m->length)
4752 might overflow a 32-bit integer. There is, alas, no way to print
4753 a bfd_vma quantity in decimal. */
4754 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
4755 if (m
->had_full_message
)
4756 einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4757 m
->name_list
.name
, (long)(m
->current
- (m
->origin
+ m
->length
)));
4761 /* Make sure the new address is within the region. We explicitly permit the
4762 current address to be at the exact end of the region when the address is
4763 non-zero, in case the region is at the end of addressable memory and the
4764 calculation wraps around. */
4767 os_region_check (lang_output_section_statement_type
*os
,
4768 lang_memory_region_type
*region
,
4772 if ((region
->current
< region
->origin
4773 || (region
->current
- region
->origin
> region
->length
))
4774 && ((region
->current
!= region
->origin
+ region
->length
)
4779 einfo (_("%X%P: address 0x%v of %B section `%s'"
4780 " is not within region `%s'\n"),
4782 os
->bfd_section
->owner
,
4783 os
->bfd_section
->name
,
4784 region
->name_list
.name
);
4786 else if (!region
->had_full_message
)
4788 region
->had_full_message
= TRUE
;
4790 einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4791 os
->bfd_section
->owner
,
4792 os
->bfd_section
->name
,
4793 region
->name_list
.name
);
4798 /* Set the sizes for all the output sections. */
4801 lang_size_sections_1
4802 (lang_statement_union_type
**prev
,
4803 lang_output_section_statement_type
*output_section_statement
,
4807 bfd_boolean check_regions
)
4809 lang_statement_union_type
*s
;
4811 /* Size up the sections from their constituent parts. */
4812 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
4814 switch (s
->header
.type
)
4816 case lang_output_section_statement_enum
:
4818 bfd_vma newdot
, after
;
4819 lang_output_section_statement_type
*os
;
4820 lang_memory_region_type
*r
;
4821 int section_alignment
= 0;
4823 os
= &s
->output_section_statement
;
4824 if (os
->constraint
== -1)
4827 /* FIXME: We shouldn't need to zero section vmas for ld -r
4828 here, in lang_insert_orphan, or in the default linker scripts.
4829 This is covering for coff backend linker bugs. See PR6945. */
4830 if (os
->addr_tree
== NULL
4831 && link_info
.relocatable
4832 && (bfd_get_flavour (link_info
.output_bfd
)
4833 == bfd_target_coff_flavour
))
4834 os
->addr_tree
= exp_intop (0);
4835 if (os
->addr_tree
!= NULL
)
4837 os
->processed_vma
= FALSE
;
4838 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
4840 if (expld
.result
.valid_p
)
4842 dot
= expld
.result
.value
;
4843 if (expld
.result
.section
!= NULL
)
4844 dot
+= expld
.result
.section
->vma
;
4846 else if (expld
.phase
!= lang_mark_phase_enum
)
4847 einfo (_("%F%S: non constant or forward reference"
4848 " address expression for section %s\n"),
4852 if (os
->bfd_section
== NULL
)
4853 /* This section was removed or never actually created. */
4856 /* If this is a COFF shared library section, use the size and
4857 address from the input section. FIXME: This is COFF
4858 specific; it would be cleaner if there were some other way
4859 to do this, but nothing simple comes to mind. */
4860 if (((bfd_get_flavour (link_info
.output_bfd
)
4861 == bfd_target_ecoff_flavour
)
4862 || (bfd_get_flavour (link_info
.output_bfd
)
4863 == bfd_target_coff_flavour
))
4864 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
4868 if (os
->children
.head
== NULL
4869 || os
->children
.head
->header
.next
!= NULL
4870 || (os
->children
.head
->header
.type
4871 != lang_input_section_enum
))
4872 einfo (_("%P%X: Internal error on COFF shared library"
4873 " section %s\n"), os
->name
);
4875 input
= os
->children
.head
->input_section
.section
;
4876 bfd_set_section_vma (os
->bfd_section
->owner
,
4878 bfd_section_vma (input
->owner
, input
));
4879 os
->bfd_section
->size
= input
->size
;
4884 if (bfd_is_abs_section (os
->bfd_section
))
4886 /* No matter what happens, an abs section starts at zero. */
4887 ASSERT (os
->bfd_section
->vma
== 0);
4891 if (os
->addr_tree
== NULL
)
4893 /* No address specified for this section, get one
4894 from the region specification. */
4895 if (os
->region
== NULL
4896 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
4897 && os
->region
->name_list
.name
[0] == '*'
4898 && strcmp (os
->region
->name_list
.name
,
4899 DEFAULT_MEMORY_REGION
) == 0))
4901 os
->region
= lang_memory_default (os
->bfd_section
);
4904 /* If a loadable section is using the default memory
4905 region, and some non default memory regions were
4906 defined, issue an error message. */
4908 && !IGNORE_SECTION (os
->bfd_section
)
4909 && ! link_info
.relocatable
4911 && strcmp (os
->region
->name_list
.name
,
4912 DEFAULT_MEMORY_REGION
) == 0
4913 && lang_memory_region_list
!= NULL
4914 && (strcmp (lang_memory_region_list
->name_list
.name
,
4915 DEFAULT_MEMORY_REGION
) != 0
4916 || lang_memory_region_list
->next
!= NULL
)
4917 && expld
.phase
!= lang_mark_phase_enum
)
4919 /* By default this is an error rather than just a
4920 warning because if we allocate the section to the
4921 default memory region we can end up creating an
4922 excessively large binary, or even seg faulting when
4923 attempting to perform a negative seek. See
4924 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4925 for an example of this. This behaviour can be
4926 overridden by the using the --no-check-sections
4928 if (command_line
.check_section_addresses
)
4929 einfo (_("%P%F: error: no memory region specified"
4930 " for loadable section `%s'\n"),
4931 bfd_get_section_name (link_info
.output_bfd
,
4934 einfo (_("%P: warning: no memory region specified"
4935 " for loadable section `%s'\n"),
4936 bfd_get_section_name (link_info
.output_bfd
,
4940 newdot
= os
->region
->current
;
4941 section_alignment
= os
->bfd_section
->alignment_power
;
4944 section_alignment
= os
->section_alignment
;
4946 /* Align to what the section needs. */
4947 if (section_alignment
> 0)
4949 bfd_vma savedot
= newdot
;
4950 newdot
= align_power (newdot
, section_alignment
);
4952 if (newdot
!= savedot
4953 && (config
.warn_section_align
4954 || os
->addr_tree
!= NULL
)
4955 && expld
.phase
!= lang_mark_phase_enum
)
4956 einfo (_("%P: warning: changing start of section"
4957 " %s by %lu bytes\n"),
4958 os
->name
, (unsigned long) (newdot
- savedot
));
4961 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
4963 os
->bfd_section
->output_offset
= 0;
4966 lang_size_sections_1 (&os
->children
.head
, os
,
4967 os
->fill
, newdot
, relax
, check_regions
);
4969 os
->processed_vma
= TRUE
;
4971 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
4972 /* Except for some special linker created sections,
4973 no output section should change from zero size
4974 after strip_excluded_output_sections. A non-zero
4975 size on an ignored section indicates that some
4976 input section was not sized early enough. */
4977 ASSERT (os
->bfd_section
->size
== 0);
4980 dot
= os
->bfd_section
->vma
;
4982 /* Put the section within the requested block size, or
4983 align at the block boundary. */
4985 + TO_ADDR (os
->bfd_section
->size
)
4986 + os
->block_value
- 1)
4987 & - (bfd_vma
) os
->block_value
);
4989 os
->bfd_section
->size
= TO_SIZE (after
- os
->bfd_section
->vma
);
4992 /* Set section lma. */
4995 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
4999 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5000 os
->bfd_section
->lma
= lma
;
5002 else if (os
->lma_region
!= NULL
)
5004 bfd_vma lma
= os
->lma_region
->current
;
5006 if (section_alignment
> 0)
5007 lma
= align_power (lma
, section_alignment
);
5008 os
->bfd_section
->lma
= lma
;
5010 else if (r
->last_os
!= NULL
5011 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5016 last
= r
->last_os
->output_section_statement
.bfd_section
;
5018 /* A backwards move of dot should be accompanied by
5019 an explicit assignment to the section LMA (ie.
5020 os->load_base set) because backwards moves can
5021 create overlapping LMAs. */
5023 && os
->bfd_section
->size
!= 0
5024 && dot
+ os
->bfd_section
->size
<= last
->vma
)
5026 /* If dot moved backwards then leave lma equal to
5027 vma. This is the old default lma, which might
5028 just happen to work when the backwards move is
5029 sufficiently large. Nag if this changes anything,
5030 so people can fix their linker scripts. */
5032 if (last
->vma
!= last
->lma
)
5033 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
5038 /* If this is an overlay, set the current lma to that
5039 at the end of the previous section. */
5040 if (os
->sectype
== overlay_section
)
5041 lma
= last
->lma
+ last
->size
;
5043 /* Otherwise, keep the same lma to vma relationship
5044 as the previous section. */
5046 lma
= dot
+ last
->lma
- last
->vma
;
5048 if (section_alignment
> 0)
5049 lma
= align_power (lma
, section_alignment
);
5050 os
->bfd_section
->lma
= lma
;
5053 os
->processed_lma
= TRUE
;
5055 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5058 /* Keep track of normal sections using the default
5059 lma region. We use this to set the lma for
5060 following sections. Overlays or other linker
5061 script assignment to lma might mean that the
5062 default lma == vma is incorrect.
5063 To avoid warnings about dot moving backwards when using
5064 -Ttext, don't start tracking sections until we find one
5065 of non-zero size or with lma set differently to vma. */
5066 if (((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5067 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0)
5068 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0
5069 && (os
->bfd_section
->size
!= 0
5070 || (r
->last_os
== NULL
5071 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5072 || (r
->last_os
!= NULL
5073 && dot
>= (r
->last_os
->output_section_statement
5074 .bfd_section
->vma
)))
5075 && os
->lma_region
== NULL
5076 && !link_info
.relocatable
)
5079 /* .tbss sections effectively have zero size. */
5080 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5081 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
5082 || link_info
.relocatable
)
5083 dot
+= TO_ADDR (os
->bfd_section
->size
);
5085 if (os
->update_dot_tree
!= 0)
5086 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5088 /* Update dot in the region ?
5089 We only do this if the section is going to be allocated,
5090 since unallocated sections do not contribute to the region's
5091 overall size in memory. */
5092 if (os
->region
!= NULL
5093 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5095 os
->region
->current
= dot
;
5098 /* Make sure the new address is within the region. */
5099 os_region_check (os
, os
->region
, os
->addr_tree
,
5100 os
->bfd_section
->vma
);
5102 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5103 && (os
->bfd_section
->flags
& SEC_LOAD
))
5105 os
->lma_region
->current
5106 = os
->bfd_section
->lma
+ TO_ADDR (os
->bfd_section
->size
);
5109 os_region_check (os
, os
->lma_region
, NULL
,
5110 os
->bfd_section
->lma
);
5116 case lang_constructors_statement_enum
:
5117 dot
= lang_size_sections_1 (&constructor_list
.head
,
5118 output_section_statement
,
5119 fill
, dot
, relax
, check_regions
);
5122 case lang_data_statement_enum
:
5124 unsigned int size
= 0;
5126 s
->data_statement
.output_offset
=
5127 dot
- output_section_statement
->bfd_section
->vma
;
5128 s
->data_statement
.output_section
=
5129 output_section_statement
->bfd_section
;
5131 /* We might refer to provided symbols in the expression, and
5132 need to mark them as needed. */
5133 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5135 switch (s
->data_statement
.type
)
5153 if (size
< TO_SIZE ((unsigned) 1))
5154 size
= TO_SIZE ((unsigned) 1);
5155 dot
+= TO_ADDR (size
);
5156 output_section_statement
->bfd_section
->size
+= size
;
5160 case lang_reloc_statement_enum
:
5164 s
->reloc_statement
.output_offset
=
5165 dot
- output_section_statement
->bfd_section
->vma
;
5166 s
->reloc_statement
.output_section
=
5167 output_section_statement
->bfd_section
;
5168 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5169 dot
+= TO_ADDR (size
);
5170 output_section_statement
->bfd_section
->size
+= size
;
5174 case lang_wild_statement_enum
:
5175 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5176 output_section_statement
,
5177 fill
, dot
, relax
, check_regions
);
5180 case lang_object_symbols_statement_enum
:
5181 link_info
.create_object_symbols_section
=
5182 output_section_statement
->bfd_section
;
5185 case lang_output_statement_enum
:
5186 case lang_target_statement_enum
:
5189 case lang_input_section_enum
:
5193 i
= s
->input_section
.section
;
5198 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5199 einfo (_("%P%F: can't relax section: %E\n"));
5203 dot
= size_input_section (prev
, output_section_statement
,
5204 output_section_statement
->fill
, dot
);
5208 case lang_input_statement_enum
:
5211 case lang_fill_statement_enum
:
5212 s
->fill_statement
.output_section
=
5213 output_section_statement
->bfd_section
;
5215 fill
= s
->fill_statement
.fill
;
5218 case lang_assignment_statement_enum
:
5220 bfd_vma newdot
= dot
;
5221 etree_type
*tree
= s
->assignment_statement
.exp
;
5223 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5225 exp_fold_tree (tree
,
5226 output_section_statement
->bfd_section
,
5229 if (expld
.dataseg
.relro
== exp_dataseg_relro_start
)
5231 if (!expld
.dataseg
.relro_start_stat
)
5232 expld
.dataseg
.relro_start_stat
= s
;
5235 ASSERT (expld
.dataseg
.relro_start_stat
== s
);
5238 else if (expld
.dataseg
.relro
== exp_dataseg_relro_end
)
5240 if (!expld
.dataseg
.relro_end_stat
)
5241 expld
.dataseg
.relro_end_stat
= s
;
5244 ASSERT (expld
.dataseg
.relro_end_stat
== s
);
5247 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5249 /* This symbol is relative to this section. */
5250 if ((tree
->type
.node_class
== etree_provided
5251 || tree
->type
.node_class
== etree_assign
)
5252 && (tree
->assign
.dst
[0] != '.'
5253 || tree
->assign
.dst
[1] != '\0'))
5254 output_section_statement
->section_relative_symbol
= 1;
5256 if (!output_section_statement
->ignored
)
5258 if (output_section_statement
== abs_output_section
)
5260 /* If we don't have an output section, then just adjust
5261 the default memory address. */
5262 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5263 FALSE
)->current
= newdot
;
5265 else if (newdot
!= dot
)
5267 /* Insert a pad after this statement. We can't
5268 put the pad before when relaxing, in case the
5269 assignment references dot. */
5270 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5271 output_section_statement
->bfd_section
, dot
);
5273 /* Don't neuter the pad below when relaxing. */
5276 /* If dot is advanced, this implies that the section
5277 should have space allocated to it, unless the
5278 user has explicitly stated that the section
5279 should not be allocated. */
5280 if (output_section_statement
->sectype
!= noalloc_section
5281 && (output_section_statement
->sectype
!= noload_section
5282 || (bfd_get_flavour (link_info
.output_bfd
)
5283 == bfd_target_elf_flavour
)))
5284 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5291 case lang_padding_statement_enum
:
5292 /* If this is the first time lang_size_sections is called,
5293 we won't have any padding statements. If this is the
5294 second or later passes when relaxing, we should allow
5295 padding to shrink. If padding is needed on this pass, it
5296 will be added back in. */
5297 s
->padding_statement
.size
= 0;
5299 /* Make sure output_offset is valid. If relaxation shrinks
5300 the section and this pad isn't needed, it's possible to
5301 have output_offset larger than the final size of the
5302 section. bfd_set_section_contents will complain even for
5303 a pad size of zero. */
5304 s
->padding_statement
.output_offset
5305 = dot
- output_section_statement
->bfd_section
->vma
;
5308 case lang_group_statement_enum
:
5309 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5310 output_section_statement
,
5311 fill
, dot
, relax
, check_regions
);
5314 case lang_insert_statement_enum
:
5317 /* We can only get here when relaxing is turned on. */
5318 case lang_address_statement_enum
:
5325 prev
= &s
->header
.next
;
5330 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5331 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5332 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5333 segments. We are allowed an opportunity to override this decision. */
5336 ldlang_override_segment_assignment (struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
5337 bfd
* abfd ATTRIBUTE_UNUSED
,
5338 asection
* current_section
,
5339 asection
* previous_section
,
5340 bfd_boolean new_segment
)
5342 lang_output_section_statement_type
* cur
;
5343 lang_output_section_statement_type
* prev
;
5345 /* The checks below are only necessary when the BFD library has decided
5346 that the two sections ought to be placed into the same segment. */
5350 /* Paranoia checks. */
5351 if (current_section
== NULL
|| previous_section
== NULL
)
5354 /* Find the memory regions associated with the two sections.
5355 We call lang_output_section_find() here rather than scanning the list
5356 of output sections looking for a matching section pointer because if
5357 we have a large number of sections then a hash lookup is faster. */
5358 cur
= lang_output_section_find (current_section
->name
);
5359 prev
= lang_output_section_find (previous_section
->name
);
5361 /* More paranoia. */
5362 if (cur
== NULL
|| prev
== NULL
)
5365 /* If the regions are different then force the sections to live in
5366 different segments. See the email thread starting at the following
5367 URL for the reasons why this is necessary:
5368 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5369 return cur
->region
!= prev
->region
;
5373 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5375 lang_statement_iteration
++;
5376 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5377 0, 0, relax
, check_regions
);
5381 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5383 expld
.phase
= lang_allocating_phase_enum
;
5384 expld
.dataseg
.phase
= exp_dataseg_none
;
5386 one_lang_size_sections_pass (relax
, check_regions
);
5387 if (expld
.dataseg
.phase
== exp_dataseg_end_seen
5388 && link_info
.relro
&& expld
.dataseg
.relro_end
)
5390 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
5391 to put expld.dataseg.relro on a (common) page boundary. */
5392 bfd_vma min_base
, old_base
, relro_end
, maxpage
;
5394 expld
.dataseg
.phase
= exp_dataseg_relro_adjust
;
5395 maxpage
= expld
.dataseg
.maxpagesize
;
5396 /* MIN_BASE is the absolute minimum address we are allowed to start the
5397 read-write segment (byte before will be mapped read-only). */
5398 min_base
= (expld
.dataseg
.min_base
+ maxpage
- 1) & ~(maxpage
- 1);
5399 /* OLD_BASE is the address for a feasible minimum address which will
5400 still not cause a data overlap inside MAXPAGE causing file offset skip
5402 old_base
= expld
.dataseg
.base
;
5403 expld
.dataseg
.base
+= (-expld
.dataseg
.relro_end
5404 & (expld
.dataseg
.pagesize
- 1));
5405 /* Compute the expected PT_GNU_RELRO segment end. */
5406 relro_end
= ((expld
.dataseg
.relro_end
+ expld
.dataseg
.pagesize
- 1)
5407 & ~(expld
.dataseg
.pagesize
- 1));
5408 if (min_base
+ maxpage
< expld
.dataseg
.base
)
5410 expld
.dataseg
.base
-= maxpage
;
5411 relro_end
-= maxpage
;
5413 lang_reset_memory_regions ();
5414 one_lang_size_sections_pass (relax
, check_regions
);
5415 if (expld
.dataseg
.relro_end
> relro_end
)
5417 /* The alignment of sections between DATA_SEGMENT_ALIGN
5418 and DATA_SEGMENT_RELRO_END caused huge padding to be
5419 inserted at DATA_SEGMENT_RELRO_END. Try to start a bit lower so
5420 that the section alignments will fit in. */
5422 unsigned int max_alignment_power
= 0;
5424 /* Find maximum alignment power of sections between
5425 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
5426 for (sec
= link_info
.output_bfd
->sections
; sec
; sec
= sec
->next
)
5427 if (sec
->vma
>= expld
.dataseg
.base
5428 && sec
->vma
< expld
.dataseg
.relro_end
5429 && sec
->alignment_power
> max_alignment_power
)
5430 max_alignment_power
= sec
->alignment_power
;
5432 if (((bfd_vma
) 1 << max_alignment_power
) < expld
.dataseg
.pagesize
)
5434 if (expld
.dataseg
.base
- (1 << max_alignment_power
) < old_base
)
5435 expld
.dataseg
.base
+= expld
.dataseg
.pagesize
;
5436 expld
.dataseg
.base
-= (1 << max_alignment_power
);
5437 lang_reset_memory_regions ();
5438 one_lang_size_sections_pass (relax
, check_regions
);
5441 link_info
.relro_start
= expld
.dataseg
.base
;
5442 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5444 else if (expld
.dataseg
.phase
== exp_dataseg_end_seen
)
5446 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5447 a page could be saved in the data segment. */
5448 bfd_vma first
, last
;
5450 first
= -expld
.dataseg
.base
& (expld
.dataseg
.pagesize
- 1);
5451 last
= expld
.dataseg
.end
& (expld
.dataseg
.pagesize
- 1);
5453 && ((expld
.dataseg
.base
& ~(expld
.dataseg
.pagesize
- 1))
5454 != (expld
.dataseg
.end
& ~(expld
.dataseg
.pagesize
- 1)))
5455 && first
+ last
<= expld
.dataseg
.pagesize
)
5457 expld
.dataseg
.phase
= exp_dataseg_adjust
;
5458 lang_reset_memory_regions ();
5459 one_lang_size_sections_pass (relax
, check_regions
);
5462 expld
.dataseg
.phase
= exp_dataseg_done
;
5465 expld
.dataseg
.phase
= exp_dataseg_done
;
5468 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5471 lang_do_assignments_1 (lang_statement_union_type
*s
,
5472 lang_output_section_statement_type
*current_os
,
5476 for (; s
!= NULL
; s
= s
->header
.next
)
5478 switch (s
->header
.type
)
5480 case lang_constructors_statement_enum
:
5481 dot
= lang_do_assignments_1 (constructor_list
.head
,
5482 current_os
, fill
, dot
);
5485 case lang_output_section_statement_enum
:
5487 lang_output_section_statement_type
*os
;
5489 os
= &(s
->output_section_statement
);
5490 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
5492 dot
= os
->bfd_section
->vma
;
5494 lang_do_assignments_1 (os
->children
.head
, os
, os
->fill
, dot
);
5496 /* .tbss sections effectively have zero size. */
5497 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5498 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
5499 || link_info
.relocatable
)
5500 dot
+= TO_ADDR (os
->bfd_section
->size
);
5502 if (os
->update_dot_tree
!= NULL
)
5503 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5508 case lang_wild_statement_enum
:
5510 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
5511 current_os
, fill
, dot
);
5514 case lang_object_symbols_statement_enum
:
5515 case lang_output_statement_enum
:
5516 case lang_target_statement_enum
:
5519 case lang_data_statement_enum
:
5520 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5521 if (expld
.result
.valid_p
)
5523 s
->data_statement
.value
= expld
.result
.value
;
5524 if (expld
.result
.section
!= NULL
)
5525 s
->data_statement
.value
+= expld
.result
.section
->vma
;
5528 einfo (_("%F%P: invalid data statement\n"));
5531 switch (s
->data_statement
.type
)
5549 if (size
< TO_SIZE ((unsigned) 1))
5550 size
= TO_SIZE ((unsigned) 1);
5551 dot
+= TO_ADDR (size
);
5555 case lang_reloc_statement_enum
:
5556 exp_fold_tree (s
->reloc_statement
.addend_exp
,
5557 bfd_abs_section_ptr
, &dot
);
5558 if (expld
.result
.valid_p
)
5559 s
->reloc_statement
.addend_value
= expld
.result
.value
;
5561 einfo (_("%F%P: invalid reloc statement\n"));
5562 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
5565 case lang_input_section_enum
:
5567 asection
*in
= s
->input_section
.section
;
5569 if ((in
->flags
& SEC_EXCLUDE
) == 0)
5570 dot
+= TO_ADDR (in
->size
);
5574 case lang_input_statement_enum
:
5577 case lang_fill_statement_enum
:
5578 fill
= s
->fill_statement
.fill
;
5581 case lang_assignment_statement_enum
:
5582 exp_fold_tree (s
->assignment_statement
.exp
,
5583 current_os
->bfd_section
,
5587 case lang_padding_statement_enum
:
5588 dot
+= TO_ADDR (s
->padding_statement
.size
);
5591 case lang_group_statement_enum
:
5592 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
5593 current_os
, fill
, dot
);
5596 case lang_insert_statement_enum
:
5599 case lang_address_statement_enum
:
5611 lang_do_assignments (lang_phase_type phase
)
5613 expld
.phase
= phase
;
5614 lang_statement_iteration
++;
5615 lang_do_assignments_1 (statement_list
.head
, abs_output_section
, NULL
, 0);
5618 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5619 operator .startof. (section_name), it produces an undefined symbol
5620 .startof.section_name. Similarly, when it sees
5621 .sizeof. (section_name), it produces an undefined symbol
5622 .sizeof.section_name. For all the output sections, we look for
5623 such symbols, and set them to the correct value. */
5626 lang_set_startof (void)
5630 if (link_info
.relocatable
)
5633 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5635 const char *secname
;
5637 struct bfd_link_hash_entry
*h
;
5639 secname
= bfd_get_section_name (link_info
.output_bfd
, s
);
5640 buf
= (char *) xmalloc (10 + strlen (secname
));
5642 sprintf (buf
, ".startof.%s", secname
);
5643 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5644 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5646 h
->type
= bfd_link_hash_defined
;
5647 h
->u
.def
.value
= bfd_get_section_vma (link_info
.output_bfd
, s
);
5648 h
->u
.def
.section
= bfd_abs_section_ptr
;
5651 sprintf (buf
, ".sizeof.%s", secname
);
5652 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5653 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5655 h
->type
= bfd_link_hash_defined
;
5656 h
->u
.def
.value
= TO_ADDR (s
->size
);
5657 h
->u
.def
.section
= bfd_abs_section_ptr
;
5667 struct bfd_link_hash_entry
*h
;
5670 if ((link_info
.relocatable
&& !link_info
.gc_sections
)
5671 || (link_info
.shared
&& !link_info
.executable
))
5672 warn
= entry_from_cmdline
;
5676 /* Force the user to specify a root when generating a relocatable with
5678 if (link_info
.gc_sections
&& link_info
.relocatable
5679 && !(entry_from_cmdline
|| undef_from_cmdline
))
5680 einfo (_("%P%F: gc-sections requires either an entry or "
5681 "an undefined symbol\n"));
5683 if (entry_symbol
.name
== NULL
)
5685 /* No entry has been specified. Look for the default entry, but
5686 don't warn if we don't find it. */
5687 entry_symbol
.name
= entry_symbol_default
;
5691 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
5692 FALSE
, FALSE
, TRUE
);
5694 && (h
->type
== bfd_link_hash_defined
5695 || h
->type
== bfd_link_hash_defweak
)
5696 && h
->u
.def
.section
->output_section
!= NULL
)
5700 val
= (h
->u
.def
.value
5701 + bfd_get_section_vma (link_info
.output_bfd
,
5702 h
->u
.def
.section
->output_section
)
5703 + h
->u
.def
.section
->output_offset
);
5704 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5705 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
5712 /* We couldn't find the entry symbol. Try parsing it as a
5714 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
5717 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5718 einfo (_("%P%F: can't set start address\n"));
5724 /* Can't find the entry symbol, and it's not a number. Use
5725 the first address in the text section. */
5726 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
5730 einfo (_("%P: warning: cannot find entry symbol %s;"
5731 " defaulting to %V\n"),
5733 bfd_get_section_vma (link_info
.output_bfd
, ts
));
5734 if (!(bfd_set_start_address
5735 (link_info
.output_bfd
,
5736 bfd_get_section_vma (link_info
.output_bfd
, ts
))))
5737 einfo (_("%P%F: can't set start address\n"));
5742 einfo (_("%P: warning: cannot find entry symbol %s;"
5743 " not setting start address\n"),
5749 /* Don't bfd_hash_table_free (&lang_definedness_table);
5750 map file output may result in a call of lang_track_definedness. */
5753 /* This is a small function used when we want to ignore errors from
5757 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
5759 /* Don't do anything. */
5762 /* Check that the architecture of all the input files is compatible
5763 with the output file. Also call the backend to let it do any
5764 other checking that is needed. */
5769 lang_statement_union_type
*file
;
5771 const bfd_arch_info_type
*compatible
;
5773 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
5775 #ifdef ENABLE_PLUGINS
5776 /* Don't check format of files claimed by plugin. */
5777 if (file
->input_statement
.claimed
)
5779 #endif /* ENABLE_PLUGINS */
5780 input_bfd
= file
->input_statement
.the_bfd
;
5782 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
5783 command_line
.accept_unknown_input_arch
);
5785 /* In general it is not possible to perform a relocatable
5786 link between differing object formats when the input
5787 file has relocations, because the relocations in the
5788 input format may not have equivalent representations in
5789 the output format (and besides BFD does not translate
5790 relocs for other link purposes than a final link). */
5791 if ((link_info
.relocatable
|| link_info
.emitrelocations
)
5792 && (compatible
== NULL
5793 || (bfd_get_flavour (input_bfd
)
5794 != bfd_get_flavour (link_info
.output_bfd
)))
5795 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
5797 einfo (_("%P%F: Relocatable linking with relocations from"
5798 " format %s (%B) to format %s (%B) is not supported\n"),
5799 bfd_get_target (input_bfd
), input_bfd
,
5800 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
5801 /* einfo with %F exits. */
5804 if (compatible
== NULL
)
5806 if (command_line
.warn_mismatch
)
5807 einfo (_("%P%X: %s architecture of input file `%B'"
5808 " is incompatible with %s output\n"),
5809 bfd_printable_name (input_bfd
), input_bfd
,
5810 bfd_printable_name (link_info
.output_bfd
));
5812 else if (bfd_count_sections (input_bfd
))
5814 /* If the input bfd has no contents, it shouldn't set the
5815 private data of the output bfd. */
5817 bfd_error_handler_type pfn
= NULL
;
5819 /* If we aren't supposed to warn about mismatched input
5820 files, temporarily set the BFD error handler to a
5821 function which will do nothing. We still want to call
5822 bfd_merge_private_bfd_data, since it may set up
5823 information which is needed in the output file. */
5824 if (! command_line
.warn_mismatch
)
5825 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
5826 if (! bfd_merge_private_bfd_data (input_bfd
, link_info
.output_bfd
))
5828 if (command_line
.warn_mismatch
)
5829 einfo (_("%P%X: failed to merge target specific data"
5830 " of file %B\n"), input_bfd
);
5832 if (! command_line
.warn_mismatch
)
5833 bfd_set_error_handler (pfn
);
5838 /* Look through all the global common symbols and attach them to the
5839 correct section. The -sort-common command line switch may be used
5840 to roughly sort the entries by alignment. */
5845 if (command_line
.inhibit_common_definition
)
5847 if (link_info
.relocatable
5848 && ! command_line
.force_common_definition
)
5851 if (! config
.sort_common
)
5852 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
5857 if (config
.sort_common
== sort_descending
)
5859 for (power
= 4; power
> 0; power
--)
5860 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5863 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5867 for (power
= 0; power
<= 4; power
++)
5868 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5871 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5876 /* Place one common symbol in the correct section. */
5879 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
5881 unsigned int power_of_two
;
5885 if (h
->type
!= bfd_link_hash_common
)
5889 power_of_two
= h
->u
.c
.p
->alignment_power
;
5891 if (config
.sort_common
== sort_descending
5892 && power_of_two
< *(unsigned int *) info
)
5894 else if (config
.sort_common
== sort_ascending
5895 && power_of_two
> *(unsigned int *) info
)
5898 section
= h
->u
.c
.p
->section
;
5899 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
5900 einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
5903 if (config
.map_file
!= NULL
)
5905 static bfd_boolean header_printed
;
5910 if (! header_printed
)
5912 minfo (_("\nAllocating common symbols\n"));
5913 minfo (_("Common symbol size file\n\n"));
5914 header_printed
= TRUE
;
5917 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
5918 DMGL_ANSI
| DMGL_PARAMS
);
5921 minfo ("%s", h
->root
.string
);
5922 len
= strlen (h
->root
.string
);
5927 len
= strlen (name
);
5943 if (size
<= 0xffffffff)
5944 sprintf (buf
, "%lx", (unsigned long) size
);
5946 sprintf_vma (buf
, size
);
5956 minfo ("%B\n", section
->owner
);
5962 /* Run through the input files and ensure that every input section has
5963 somewhere to go. If one is found without a destination then create
5964 an input request and place it into the statement tree. */
5967 lang_place_orphans (void)
5969 LANG_FOR_EACH_INPUT_STATEMENT (file
)
5973 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5975 if (s
->output_section
== NULL
)
5977 /* This section of the file is not attached, root
5978 around for a sensible place for it to go. */
5980 if (file
->just_syms_flag
)
5981 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
5982 else if ((s
->flags
& SEC_EXCLUDE
) != 0)
5983 s
->output_section
= bfd_abs_section_ptr
;
5984 else if (strcmp (s
->name
, "COMMON") == 0)
5986 /* This is a lonely common section which must have
5987 come from an archive. We attach to the section
5988 with the wildcard. */
5989 if (! link_info
.relocatable
5990 || command_line
.force_common_definition
)
5992 if (default_common_section
== NULL
)
5993 default_common_section
5994 = lang_output_section_statement_lookup (".bss", 0,
5996 lang_add_section (&default_common_section
->children
, s
,
5997 default_common_section
);
6002 const char *name
= s
->name
;
6005 if (config
.unique_orphan_sections
6006 || unique_section_p (s
, NULL
))
6007 constraint
= SPECIAL
;
6009 if (!ldemul_place_orphan (s
, name
, constraint
))
6011 lang_output_section_statement_type
*os
;
6012 os
= lang_output_section_statement_lookup (name
,
6015 if (os
->addr_tree
== NULL
6016 && (link_info
.relocatable
6017 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6018 os
->addr_tree
= exp_intop (0);
6019 lang_add_section (&os
->children
, s
, os
);
6028 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6030 flagword
*ptr_flags
;
6032 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6038 *ptr_flags
|= SEC_ALLOC
;
6042 *ptr_flags
|= SEC_READONLY
;
6046 *ptr_flags
|= SEC_DATA
;
6050 *ptr_flags
|= SEC_CODE
;
6055 *ptr_flags
|= SEC_LOAD
;
6059 einfo (_("%P%F: invalid syntax in flags\n"));
6066 /* Call a function on each input file. This function will be called
6067 on an archive, but not on the elements. */
6070 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6072 lang_input_statement_type
*f
;
6074 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
6076 f
= (lang_input_statement_type
*) f
->next_real_file
)
6080 /* Call a function on each file. The function will be called on all
6081 the elements of an archive which are included in the link, but will
6082 not be called on the archive file itself. */
6085 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6087 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6094 ldlang_add_file (lang_input_statement_type
*entry
)
6096 lang_statement_append (&file_chain
,
6097 (lang_statement_union_type
*) entry
,
6100 /* The BFD linker needs to have a list of all input BFDs involved in
6102 ASSERT (entry
->the_bfd
->link_next
== NULL
);
6103 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6105 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6106 link_info
.input_bfds_tail
= &entry
->the_bfd
->link_next
;
6107 entry
->the_bfd
->usrdata
= entry
;
6108 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6110 /* Look through the sections and check for any which should not be
6111 included in the link. We need to do this now, so that we can
6112 notice when the backend linker tries to report multiple
6113 definition errors for symbols which are in sections we aren't
6114 going to link. FIXME: It might be better to entirely ignore
6115 symbols which are defined in sections which are going to be
6116 discarded. This would require modifying the backend linker for
6117 each backend which might set the SEC_LINK_ONCE flag. If we do
6118 this, we should probably handle SEC_EXCLUDE in the same way. */
6120 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6124 lang_add_output (const char *name
, int from_script
)
6126 /* Make -o on command line override OUTPUT in script. */
6127 if (!had_output_filename
|| !from_script
)
6129 output_filename
= name
;
6130 had_output_filename
= TRUE
;
6134 static lang_output_section_statement_type
*current_section
;
6145 for (l
= 0; l
< 32; l
++)
6147 if (i
>= (unsigned int) x
)
6155 lang_output_section_statement_type
*
6156 lang_enter_output_section_statement (const char *output_section_statement_name
,
6157 etree_type
*address_exp
,
6158 enum section_type sectype
,
6160 etree_type
*subalign
,
6164 lang_output_section_statement_type
*os
;
6166 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6168 current_section
= os
;
6170 if (os
->addr_tree
== NULL
)
6172 os
->addr_tree
= address_exp
;
6174 os
->sectype
= sectype
;
6175 if (sectype
!= noload_section
)
6176 os
->flags
= SEC_NO_FLAGS
;
6178 os
->flags
= SEC_NEVER_LOAD
;
6179 os
->block_value
= 1;
6181 /* Make next things chain into subchain of this. */
6182 push_stat_ptr (&os
->children
);
6184 os
->subsection_alignment
=
6185 topower (exp_get_value_int (subalign
, -1, "subsection alignment"));
6186 os
->section_alignment
=
6187 topower (exp_get_value_int (align
, -1, "section alignment"));
6189 os
->load_base
= ebase
;
6196 lang_output_statement_type
*new_stmt
;
6198 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6199 new_stmt
->name
= output_filename
;
6203 /* Reset the current counters in the regions. */
6206 lang_reset_memory_regions (void)
6208 lang_memory_region_type
*p
= lang_memory_region_list
;
6210 lang_output_section_statement_type
*os
;
6212 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
6214 p
->current
= p
->origin
;
6218 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6222 os
->processed_vma
= FALSE
;
6223 os
->processed_lma
= FALSE
;
6226 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6228 /* Save the last size for possible use by bfd_relax_section. */
6229 o
->rawsize
= o
->size
;
6234 /* Worker for lang_gc_sections_1. */
6237 gc_section_callback (lang_wild_statement_type
*ptr
,
6238 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6240 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6241 void *data ATTRIBUTE_UNUSED
)
6243 /* If the wild pattern was marked KEEP, the member sections
6244 should be as well. */
6245 if (ptr
->keep_sections
)
6246 section
->flags
|= SEC_KEEP
;
6249 /* Iterate over sections marking them against GC. */
6252 lang_gc_sections_1 (lang_statement_union_type
*s
)
6254 for (; s
!= NULL
; s
= s
->header
.next
)
6256 switch (s
->header
.type
)
6258 case lang_wild_statement_enum
:
6259 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
6261 case lang_constructors_statement_enum
:
6262 lang_gc_sections_1 (constructor_list
.head
);
6264 case lang_output_section_statement_enum
:
6265 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
6267 case lang_group_statement_enum
:
6268 lang_gc_sections_1 (s
->group_statement
.children
.head
);
6277 lang_gc_sections (void)
6279 /* Keep all sections so marked in the link script. */
6281 lang_gc_sections_1 (statement_list
.head
);
6283 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6284 the special case of debug info. (See bfd/stabs.c)
6285 Twiddle the flag here, to simplify later linker code. */
6286 if (link_info
.relocatable
)
6288 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6291 #ifdef ENABLE_PLUGINS
6295 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6296 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
6297 sec
->flags
&= ~SEC_EXCLUDE
;
6301 if (link_info
.gc_sections
)
6302 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
6305 /* Worker for lang_find_relro_sections_1. */
6308 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
6309 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6311 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6314 /* Discarded, excluded and ignored sections effectively have zero
6316 if (section
->output_section
!= NULL
6317 && section
->output_section
->owner
== link_info
.output_bfd
6318 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
6319 && !IGNORE_SECTION (section
)
6320 && section
->size
!= 0)
6322 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
6323 *has_relro_section
= TRUE
;
6327 /* Iterate over sections for relro sections. */
6330 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
6331 bfd_boolean
*has_relro_section
)
6333 if (*has_relro_section
)
6336 for (; s
!= NULL
; s
= s
->header
.next
)
6338 if (s
== expld
.dataseg
.relro_end_stat
)
6341 switch (s
->header
.type
)
6343 case lang_wild_statement_enum
:
6344 walk_wild (&s
->wild_statement
,
6345 find_relro_section_callback
,
6348 case lang_constructors_statement_enum
:
6349 lang_find_relro_sections_1 (constructor_list
.head
,
6352 case lang_output_section_statement_enum
:
6353 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
6356 case lang_group_statement_enum
:
6357 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
6367 lang_find_relro_sections (void)
6369 bfd_boolean has_relro_section
= FALSE
;
6371 /* Check all sections in the link script. */
6373 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
6374 &has_relro_section
);
6376 if (!has_relro_section
)
6377 link_info
.relro
= FALSE
;
6380 /* Relax all sections until bfd_relax_section gives up. */
6383 lang_relax_sections (bfd_boolean need_layout
)
6385 if (RELAXATION_ENABLED
)
6387 /* We may need more than one relaxation pass. */
6388 int i
= link_info
.relax_pass
;
6390 /* The backend can use it to determine the current pass. */
6391 link_info
.relax_pass
= 0;
6395 /* Keep relaxing until bfd_relax_section gives up. */
6396 bfd_boolean relax_again
;
6398 link_info
.relax_trip
= -1;
6401 link_info
.relax_trip
++;
6403 /* Note: pe-dll.c does something like this also. If you find
6404 you need to change this code, you probably need to change
6405 pe-dll.c also. DJ */
6407 /* Do all the assignments with our current guesses as to
6409 lang_do_assignments (lang_assigning_phase_enum
);
6411 /* We must do this after lang_do_assignments, because it uses
6413 lang_reset_memory_regions ();
6415 /* Perform another relax pass - this time we know where the
6416 globals are, so can make a better guess. */
6417 relax_again
= FALSE
;
6418 lang_size_sections (&relax_again
, FALSE
);
6420 while (relax_again
);
6422 link_info
.relax_pass
++;
6429 /* Final extra sizing to report errors. */
6430 lang_do_assignments (lang_assigning_phase_enum
);
6431 lang_reset_memory_regions ();
6432 lang_size_sections (NULL
, TRUE
);
6436 #ifdef ENABLE_PLUGINS
6437 /* Find the insert point for the plugin's replacement files. We
6438 place them after the first claimed real object file, or if the
6439 first claimed object is an archive member, after the last real
6440 object file immediately preceding the archive. In the event
6441 no objects have been claimed at all, we return the first dummy
6442 object file on the list as the insert point; that works, but
6443 the callee must be careful when relinking the file_chain as it
6444 is not actually on that chain, only the statement_list and the
6445 input_file list; in that case, the replacement files must be
6446 inserted at the head of the file_chain. */
6448 static lang_input_statement_type
*
6449 find_replacements_insert_point (void)
6451 lang_input_statement_type
*claim1
, *lastobject
;
6452 lastobject
= &input_file_chain
.head
->input_statement
;
6453 for (claim1
= &file_chain
.head
->input_statement
;
6455 claim1
= &claim1
->next
->input_statement
)
6457 if (claim1
->claimed
)
6458 return claim1
->claim_archive
? lastobject
: claim1
;
6459 /* Update lastobject if this is a real object file. */
6460 if (claim1
->the_bfd
&& (claim1
->the_bfd
->my_archive
== NULL
))
6461 lastobject
= claim1
;
6463 /* No files were claimed by the plugin. Choose the last object
6464 file found on the list (maybe the first, dummy entry) as the
6469 /* Insert SRCLIST into DESTLIST after given element by chaining
6470 on FIELD as the next-pointer. (Counterintuitively does not need
6471 a pointer to the actual after-node itself, just its chain field.) */
6474 lang_list_insert_after (lang_statement_list_type
*destlist
,
6475 lang_statement_list_type
*srclist
,
6476 lang_statement_union_type
**field
)
6478 *(srclist
->tail
) = *field
;
6479 *field
= srclist
->head
;
6480 if (destlist
->tail
== field
)
6481 destlist
->tail
= srclist
->tail
;
6484 /* Detach new nodes added to DESTLIST since the time ORIGLIST
6485 was taken as a copy of it and leave them in ORIGLIST. */
6488 lang_list_remove_tail (lang_statement_list_type
*destlist
,
6489 lang_statement_list_type
*origlist
)
6491 union lang_statement_union
**savetail
;
6492 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
6493 ASSERT (origlist
->head
== destlist
->head
);
6494 savetail
= origlist
->tail
;
6495 origlist
->head
= *(savetail
);
6496 origlist
->tail
= destlist
->tail
;
6497 destlist
->tail
= savetail
;
6500 #endif /* ENABLE_PLUGINS */
6505 /* Finalize dynamic list. */
6506 if (link_info
.dynamic_list
)
6507 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
6509 current_target
= default_target
;
6511 /* Open the output file. */
6512 lang_for_each_statement (ldlang_open_output
);
6515 ldemul_create_output_section_statements ();
6517 /* Add to the hash table all undefineds on the command line. */
6518 lang_place_undefineds ();
6520 if (!bfd_section_already_linked_table_init ())
6521 einfo (_("%P%F: Failed to create hash table\n"));
6523 /* Create a bfd for each input file. */
6524 current_target
= default_target
;
6525 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
6527 #ifdef ENABLE_PLUGINS
6528 if (plugin_active_plugins_p ())
6530 lang_statement_list_type added
;
6531 lang_statement_list_type files
, inputfiles
;
6533 /* Now all files are read, let the plugin(s) decide if there
6534 are any more to be added to the link before we call the
6535 emulation's after_open hook. We create a private list of
6536 input statements for this purpose, which we will eventually
6537 insert into the global statment list after the first claimed
6540 /* We need to manipulate all three chains in synchrony. */
6542 inputfiles
= input_file_chain
;
6543 if (plugin_call_all_symbols_read ())
6544 einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
6545 plugin_error_plugin ());
6546 /* Open any newly added files, updating the file chains. */
6547 open_input_bfds (added
.head
, OPEN_BFD_NORMAL
);
6548 /* Restore the global list pointer now they have all been added. */
6549 lang_list_remove_tail (stat_ptr
, &added
);
6550 /* And detach the fresh ends of the file lists. */
6551 lang_list_remove_tail (&file_chain
, &files
);
6552 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
6553 /* Were any new files added? */
6554 if (added
.head
!= NULL
)
6556 /* If so, we will insert them into the statement list immediately
6557 after the first input file that was claimed by the plugin. */
6558 plugin_insert
= find_replacements_insert_point ();
6559 /* If a plugin adds input files without having claimed any, we
6560 don't really have a good idea where to place them. Just putting
6561 them at the start or end of the list is liable to leave them
6562 outside the crtbegin...crtend range. */
6563 ASSERT (plugin_insert
!= NULL
);
6564 /* Splice the new statement list into the old one. */
6565 lang_list_insert_after (stat_ptr
, &added
,
6566 &plugin_insert
->header
.next
);
6567 /* Likewise for the file chains. */
6568 lang_list_insert_after (&input_file_chain
, &inputfiles
,
6569 &plugin_insert
->next_real_file
);
6570 /* We must be careful when relinking file_chain; we may need to
6571 insert the new files at the head of the list if the insert
6572 point chosen is the dummy first input file. */
6573 if (plugin_insert
->filename
)
6574 lang_list_insert_after (&file_chain
, &files
, &plugin_insert
->next
);
6576 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
6578 /* Rescan archives in case new undefined symbols have appeared. */
6579 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
6582 #endif /* ENABLE_PLUGINS */
6584 link_info
.gc_sym_list
= &entry_symbol
;
6585 if (entry_symbol
.name
== NULL
)
6586 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
6588 ldemul_after_open ();
6590 bfd_section_already_linked_table_free ();
6592 /* Make sure that we're not mixing architectures. We call this
6593 after all the input files have been opened, but before we do any
6594 other processing, so that any operations merge_private_bfd_data
6595 does on the output file will be known during the rest of the
6599 /* Handle .exports instead of a version script if we're told to do so. */
6600 if (command_line
.version_exports_section
)
6601 lang_do_version_exports_section ();
6603 /* Build all sets based on the information gathered from the input
6605 ldctor_build_sets ();
6607 /* Remove unreferenced sections if asked to. */
6608 lang_gc_sections ();
6610 /* Size up the common data. */
6613 /* Update wild statements. */
6614 update_wild_statements (statement_list
.head
);
6616 /* Run through the contours of the script and attach input sections
6617 to the correct output sections. */
6618 lang_statement_iteration
++;
6619 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
6621 process_insert_statements ();
6623 /* Find any sections not attached explicitly and handle them. */
6624 lang_place_orphans ();
6626 if (! link_info
.relocatable
)
6630 /* Merge SEC_MERGE sections. This has to be done after GC of
6631 sections, so that GCed sections are not merged, but before
6632 assigning dynamic symbols, since removing whole input sections
6634 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
6636 /* Look for a text section and set the readonly attribute in it. */
6637 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
6641 if (config
.text_read_only
)
6642 found
->flags
|= SEC_READONLY
;
6644 found
->flags
&= ~SEC_READONLY
;
6648 /* Do anything special before sizing sections. This is where ELF
6649 and other back-ends size dynamic sections. */
6650 ldemul_before_allocation ();
6652 /* We must record the program headers before we try to fix the
6653 section positions, since they will affect SIZEOF_HEADERS. */
6654 lang_record_phdrs ();
6656 /* Check relro sections. */
6657 if (link_info
.relro
&& ! link_info
.relocatable
)
6658 lang_find_relro_sections ();
6660 /* Size up the sections. */
6661 lang_size_sections (NULL
, ! RELAXATION_ENABLED
);
6663 /* See if anything special should be done now we know how big
6664 everything is. This is where relaxation is done. */
6665 ldemul_after_allocation ();
6667 /* Fix any .startof. or .sizeof. symbols. */
6668 lang_set_startof ();
6670 /* Do all the assignments, now that we know the final resting places
6671 of all the symbols. */
6672 lang_do_assignments (lang_final_phase_enum
);
6676 /* Make sure that the section addresses make sense. */
6677 if (command_line
.check_section_addresses
)
6678 lang_check_section_addresses ();
6683 /* EXPORTED TO YACC */
6686 lang_add_wild (struct wildcard_spec
*filespec
,
6687 struct wildcard_list
*section_list
,
6688 bfd_boolean keep_sections
)
6690 struct wildcard_list
*curr
, *next
;
6691 lang_wild_statement_type
*new_stmt
;
6693 /* Reverse the list as the parser puts it back to front. */
6694 for (curr
= section_list
, section_list
= NULL
;
6696 section_list
= curr
, curr
= next
)
6698 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
6699 placed_commons
= TRUE
;
6702 curr
->next
= section_list
;
6705 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
6707 if (strcmp (filespec
->name
, "*") == 0)
6708 filespec
->name
= NULL
;
6709 else if (! wildcardp (filespec
->name
))
6710 lang_has_input_file
= TRUE
;
6713 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
6714 new_stmt
->filename
= NULL
;
6715 new_stmt
->filenames_sorted
= FALSE
;
6716 if (filespec
!= NULL
)
6718 new_stmt
->filename
= filespec
->name
;
6719 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
6721 new_stmt
->section_list
= section_list
;
6722 new_stmt
->keep_sections
= keep_sections
;
6723 lang_list_init (&new_stmt
->children
);
6724 analyze_walk_wild_section_handler (new_stmt
);
6728 lang_section_start (const char *name
, etree_type
*address
,
6729 const segment_type
*segment
)
6731 lang_address_statement_type
*ad
;
6733 ad
= new_stat (lang_address_statement
, stat_ptr
);
6734 ad
->section_name
= name
;
6735 ad
->address
= address
;
6736 ad
->segment
= segment
;
6739 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
6740 because of a -e argument on the command line, or zero if this is
6741 called by ENTRY in a linker script. Command line arguments take
6745 lang_add_entry (const char *name
, bfd_boolean cmdline
)
6747 if (entry_symbol
.name
== NULL
6749 || ! entry_from_cmdline
)
6751 entry_symbol
.name
= name
;
6752 entry_from_cmdline
= cmdline
;
6756 /* Set the default start symbol to NAME. .em files should use this,
6757 not lang_add_entry, to override the use of "start" if neither the
6758 linker script nor the command line specifies an entry point. NAME
6759 must be permanently allocated. */
6761 lang_default_entry (const char *name
)
6763 entry_symbol_default
= name
;
6767 lang_add_target (const char *name
)
6769 lang_target_statement_type
*new_stmt
;
6771 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
6772 new_stmt
->target
= name
;
6776 lang_add_map (const char *name
)
6783 map_option_f
= TRUE
;
6791 lang_add_fill (fill_type
*fill
)
6793 lang_fill_statement_type
*new_stmt
;
6795 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
6796 new_stmt
->fill
= fill
;
6800 lang_add_data (int type
, union etree_union
*exp
)
6802 lang_data_statement_type
*new_stmt
;
6804 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
6805 new_stmt
->exp
= exp
;
6806 new_stmt
->type
= type
;
6809 /* Create a new reloc statement. RELOC is the BFD relocation type to
6810 generate. HOWTO is the corresponding howto structure (we could
6811 look this up, but the caller has already done so). SECTION is the
6812 section to generate a reloc against, or NAME is the name of the
6813 symbol to generate a reloc against. Exactly one of SECTION and
6814 NAME must be NULL. ADDEND is an expression for the addend. */
6817 lang_add_reloc (bfd_reloc_code_real_type reloc
,
6818 reloc_howto_type
*howto
,
6821 union etree_union
*addend
)
6823 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
6827 p
->section
= section
;
6829 p
->addend_exp
= addend
;
6831 p
->addend_value
= 0;
6832 p
->output_section
= NULL
;
6833 p
->output_offset
= 0;
6836 lang_assignment_statement_type
*
6837 lang_add_assignment (etree_type
*exp
)
6839 lang_assignment_statement_type
*new_stmt
;
6841 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
6842 new_stmt
->exp
= exp
;
6847 lang_add_attribute (enum statement_enum attribute
)
6849 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
6853 lang_startup (const char *name
)
6855 if (first_file
->filename
!= NULL
)
6857 einfo (_("%P%F: multiple STARTUP files\n"));
6859 first_file
->filename
= name
;
6860 first_file
->local_sym_name
= name
;
6861 first_file
->real
= TRUE
;
6865 lang_float (bfd_boolean maybe
)
6867 lang_float_flag
= maybe
;
6871 /* Work out the load- and run-time regions from a script statement, and
6872 store them in *LMA_REGION and *REGION respectively.
6874 MEMSPEC is the name of the run-time region, or the value of
6875 DEFAULT_MEMORY_REGION if the statement didn't specify one.
6876 LMA_MEMSPEC is the name of the load-time region, or null if the
6877 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
6878 had an explicit load address.
6880 It is an error to specify both a load region and a load address. */
6883 lang_get_regions (lang_memory_region_type
**region
,
6884 lang_memory_region_type
**lma_region
,
6885 const char *memspec
,
6886 const char *lma_memspec
,
6887 bfd_boolean have_lma
,
6888 bfd_boolean have_vma
)
6890 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
6892 /* If no runtime region or VMA has been specified, but the load region
6893 has been specified, then use the load region for the runtime region
6895 if (lma_memspec
!= NULL
6897 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
6898 *region
= *lma_region
;
6900 *region
= lang_memory_region_lookup (memspec
, FALSE
);
6902 if (have_lma
&& lma_memspec
!= 0)
6903 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
6907 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
6908 lang_output_section_phdr_list
*phdrs
,
6909 const char *lma_memspec
)
6911 lang_get_regions (¤t_section
->region
,
6912 ¤t_section
->lma_region
,
6913 memspec
, lma_memspec
,
6914 current_section
->load_base
!= NULL
,
6915 current_section
->addr_tree
!= NULL
);
6917 /* If this section has no load region or base, but uses the same
6918 region as the previous section, then propagate the previous
6919 section's load region. */
6921 if (current_section
->lma_region
== NULL
6922 && current_section
->load_base
== NULL
6923 && current_section
->addr_tree
== NULL
6924 && current_section
->region
== current_section
->prev
->region
)
6925 current_section
->lma_region
= current_section
->prev
->lma_region
;
6927 current_section
->fill
= fill
;
6928 current_section
->phdrs
= phdrs
;
6932 /* Create an absolute symbol with the given name with the value of the
6933 address of first byte of the section named.
6935 If the symbol already exists, then do nothing. */
6938 lang_abs_symbol_at_beginning_of (const char *secname
, const char *name
)
6940 struct bfd_link_hash_entry
*h
;
6942 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
6944 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6946 if (h
->type
== bfd_link_hash_new
6947 || h
->type
== bfd_link_hash_undefined
)
6951 h
->type
= bfd_link_hash_defined
;
6953 sec
= bfd_get_section_by_name (link_info
.output_bfd
, secname
);
6957 h
->u
.def
.value
= bfd_get_section_vma (link_info
.output_bfd
, sec
);
6959 h
->u
.def
.section
= bfd_abs_section_ptr
;
6963 /* Create an absolute symbol with the given name with the value of the
6964 address of the first byte after the end of the section named.
6966 If the symbol already exists, then do nothing. */
6969 lang_abs_symbol_at_end_of (const char *secname
, const char *name
)
6971 struct bfd_link_hash_entry
*h
;
6973 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
6975 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6977 if (h
->type
== bfd_link_hash_new
6978 || h
->type
== bfd_link_hash_undefined
)
6982 h
->type
= bfd_link_hash_defined
;
6984 sec
= bfd_get_section_by_name (link_info
.output_bfd
, secname
);
6988 h
->u
.def
.value
= (bfd_get_section_vma (link_info
.output_bfd
, sec
)
6989 + TO_ADDR (sec
->size
));
6991 h
->u
.def
.section
= bfd_abs_section_ptr
;
6996 lang_statement_append (lang_statement_list_type
*list
,
6997 lang_statement_union_type
*element
,
6998 lang_statement_union_type
**field
)
7000 *(list
->tail
) = element
;
7004 /* Set the output format type. -oformat overrides scripts. */
7007 lang_add_output_format (const char *format
,
7012 if (output_target
== NULL
|| !from_script
)
7014 if (command_line
.endian
== ENDIAN_BIG
7017 else if (command_line
.endian
== ENDIAN_LITTLE
7021 output_target
= format
;
7026 lang_add_insert (const char *where
, int is_before
)
7028 lang_insert_statement_type
*new_stmt
;
7030 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7031 new_stmt
->where
= where
;
7032 new_stmt
->is_before
= is_before
;
7033 saved_script_handle
= previous_script_handle
;
7036 /* Enter a group. This creates a new lang_group_statement, and sets
7037 stat_ptr to build new statements within the group. */
7040 lang_enter_group (void)
7042 lang_group_statement_type
*g
;
7044 g
= new_stat (lang_group_statement
, stat_ptr
);
7045 lang_list_init (&g
->children
);
7046 push_stat_ptr (&g
->children
);
7049 /* Leave a group. This just resets stat_ptr to start writing to the
7050 regular list of statements again. Note that this will not work if
7051 groups can occur inside anything else which can adjust stat_ptr,
7052 but currently they can't. */
7055 lang_leave_group (void)
7060 /* Add a new program header. This is called for each entry in a PHDRS
7061 command in a linker script. */
7064 lang_new_phdr (const char *name
,
7066 bfd_boolean filehdr
,
7071 struct lang_phdr
*n
, **pp
;
7074 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
7077 n
->type
= exp_get_value_int (type
, 0, "program header type");
7078 n
->filehdr
= filehdr
;
7083 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
7085 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7088 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
7090 einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported when prior PT_LOAD headers lack them\n"));
7097 /* Record the program header information in the output BFD. FIXME: We
7098 should not be calling an ELF specific function here. */
7101 lang_record_phdrs (void)
7105 lang_output_section_phdr_list
*last
;
7106 struct lang_phdr
*l
;
7107 lang_output_section_statement_type
*os
;
7110 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
7113 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
7120 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7124 lang_output_section_phdr_list
*pl
;
7126 if (os
->constraint
< 0)
7134 if (os
->sectype
== noload_section
7135 || os
->bfd_section
== NULL
7136 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
7139 /* Don't add orphans to PT_INTERP header. */
7145 lang_output_section_statement_type
* tmp_os
;
7147 /* If we have not run across a section with a program
7148 header assigned to it yet, then scan forwards to find
7149 one. This prevents inconsistencies in the linker's
7150 behaviour when a script has specified just a single
7151 header and there are sections in that script which are
7152 not assigned to it, and which occur before the first
7153 use of that header. See here for more details:
7154 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
7155 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
7158 last
= tmp_os
->phdrs
;
7162 einfo (_("%F%P: no sections assigned to phdrs\n"));
7167 if (os
->bfd_section
== NULL
)
7170 for (; pl
!= NULL
; pl
= pl
->next
)
7172 if (strcmp (pl
->name
, l
->name
) == 0)
7177 secs
= (asection
**) xrealloc (secs
,
7178 alc
* sizeof (asection
*));
7180 secs
[c
] = os
->bfd_section
;
7187 if (l
->flags
== NULL
)
7190 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
7195 at
= exp_get_vma (l
->at
, 0, "phdr load address");
7197 if (! bfd_record_phdr (link_info
.output_bfd
, l
->type
,
7198 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
7199 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
7200 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
7205 /* Make sure all the phdr assignments succeeded. */
7206 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7210 lang_output_section_phdr_list
*pl
;
7212 if (os
->constraint
< 0
7213 || os
->bfd_section
== NULL
)
7216 for (pl
= os
->phdrs
;
7219 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
7220 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
7221 os
->name
, pl
->name
);
7225 /* Record a list of sections which may not be cross referenced. */
7228 lang_add_nocrossref (lang_nocrossref_type
*l
)
7230 struct lang_nocrossrefs
*n
;
7232 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
7233 n
->next
= nocrossref_list
;
7235 nocrossref_list
= n
;
7237 /* Set notice_all so that we get informed about all symbols. */
7238 link_info
.notice_all
= TRUE
;
7241 /* Overlay handling. We handle overlays with some static variables. */
7243 /* The overlay virtual address. */
7244 static etree_type
*overlay_vma
;
7245 /* And subsection alignment. */
7246 static etree_type
*overlay_subalign
;
7248 /* An expression for the maximum section size seen so far. */
7249 static etree_type
*overlay_max
;
7251 /* A list of all the sections in this overlay. */
7253 struct overlay_list
{
7254 struct overlay_list
*next
;
7255 lang_output_section_statement_type
*os
;
7258 static struct overlay_list
*overlay_list
;
7260 /* Start handling an overlay. */
7263 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
7265 /* The grammar should prevent nested overlays from occurring. */
7266 ASSERT (overlay_vma
== NULL
7267 && overlay_subalign
== NULL
7268 && overlay_max
== NULL
);
7270 overlay_vma
= vma_expr
;
7271 overlay_subalign
= subalign
;
7274 /* Start a section in an overlay. We handle this by calling
7275 lang_enter_output_section_statement with the correct VMA.
7276 lang_leave_overlay sets up the LMA and memory regions. */
7279 lang_enter_overlay_section (const char *name
)
7281 struct overlay_list
*n
;
7284 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
7285 0, overlay_subalign
, 0, 0);
7287 /* If this is the first section, then base the VMA of future
7288 sections on this one. This will work correctly even if `.' is
7289 used in the addresses. */
7290 if (overlay_list
== NULL
)
7291 overlay_vma
= exp_nameop (ADDR
, name
);
7293 /* Remember the section. */
7294 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
7295 n
->os
= current_section
;
7296 n
->next
= overlay_list
;
7299 size
= exp_nameop (SIZEOF
, name
);
7301 /* Arrange to work out the maximum section end address. */
7302 if (overlay_max
== NULL
)
7305 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
7308 /* Finish a section in an overlay. There isn't any special to do
7312 lang_leave_overlay_section (fill_type
*fill
,
7313 lang_output_section_phdr_list
*phdrs
)
7320 name
= current_section
->name
;
7322 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
7323 region and that no load-time region has been specified. It doesn't
7324 really matter what we say here, since lang_leave_overlay will
7326 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
7328 /* Define the magic symbols. */
7330 clean
= (char *) xmalloc (strlen (name
) + 1);
7332 for (s1
= name
; *s1
!= '\0'; s1
++)
7333 if (ISALNUM (*s1
) || *s1
== '_')
7337 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
7338 sprintf (buf
, "__load_start_%s", clean
);
7339 lang_add_assignment (exp_provide (buf
,
7340 exp_nameop (LOADADDR
, name
),
7343 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
7344 sprintf (buf
, "__load_stop_%s", clean
);
7345 lang_add_assignment (exp_provide (buf
,
7347 exp_nameop (LOADADDR
, name
),
7348 exp_nameop (SIZEOF
, name
)),
7354 /* Finish an overlay. If there are any overlay wide settings, this
7355 looks through all the sections in the overlay and sets them. */
7358 lang_leave_overlay (etree_type
*lma_expr
,
7361 const char *memspec
,
7362 lang_output_section_phdr_list
*phdrs
,
7363 const char *lma_memspec
)
7365 lang_memory_region_type
*region
;
7366 lang_memory_region_type
*lma_region
;
7367 struct overlay_list
*l
;
7368 lang_nocrossref_type
*nocrossref
;
7370 lang_get_regions (®ion
, &lma_region
,
7371 memspec
, lma_memspec
,
7372 lma_expr
!= NULL
, FALSE
);
7376 /* After setting the size of the last section, set '.' to end of the
7378 if (overlay_list
!= NULL
)
7379 overlay_list
->os
->update_dot_tree
7380 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
));
7385 struct overlay_list
*next
;
7387 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
7390 l
->os
->region
= region
;
7391 l
->os
->lma_region
= lma_region
;
7393 /* The first section has the load address specified in the
7394 OVERLAY statement. The rest are worked out from that.
7395 The base address is not needed (and should be null) if
7396 an LMA region was specified. */
7399 l
->os
->load_base
= lma_expr
;
7400 l
->os
->sectype
= normal_section
;
7402 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
7403 l
->os
->phdrs
= phdrs
;
7407 lang_nocrossref_type
*nc
;
7409 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
7410 nc
->name
= l
->os
->name
;
7411 nc
->next
= nocrossref
;
7420 if (nocrossref
!= NULL
)
7421 lang_add_nocrossref (nocrossref
);
7424 overlay_list
= NULL
;
7428 /* Version handling. This is only useful for ELF. */
7430 /* This global variable holds the version tree that we build. */
7432 struct bfd_elf_version_tree
*lang_elf_version_info
;
7434 /* If PREV is NULL, return first version pattern matching particular symbol.
7435 If PREV is non-NULL, return first version pattern matching particular
7436 symbol after PREV (previously returned by lang_vers_match). */
7438 static struct bfd_elf_version_expr
*
7439 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
7440 struct bfd_elf_version_expr
*prev
,
7444 const char *cxx_sym
= sym
;
7445 const char *java_sym
= sym
;
7446 struct bfd_elf_version_expr
*expr
= NULL
;
7447 enum demangling_styles curr_style
;
7449 curr_style
= CURRENT_DEMANGLING_STYLE
;
7450 cplus_demangle_set_style (no_demangling
);
7451 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
7454 cplus_demangle_set_style (curr_style
);
7456 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7458 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
7459 DMGL_PARAMS
| DMGL_ANSI
);
7463 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7465 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
7470 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
7472 struct bfd_elf_version_expr e
;
7474 switch (prev
? prev
->mask
: 0)
7477 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
7480 expr
= (struct bfd_elf_version_expr
*)
7481 htab_find ((htab_t
) head
->htab
, &e
);
7482 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
7483 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
7489 case BFD_ELF_VERSION_C_TYPE
:
7490 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7492 e
.pattern
= cxx_sym
;
7493 expr
= (struct bfd_elf_version_expr
*)
7494 htab_find ((htab_t
) head
->htab
, &e
);
7495 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
7496 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7502 case BFD_ELF_VERSION_CXX_TYPE
:
7503 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7505 e
.pattern
= java_sym
;
7506 expr
= (struct bfd_elf_version_expr
*)
7507 htab_find ((htab_t
) head
->htab
, &e
);
7508 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
7509 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7520 /* Finally, try the wildcards. */
7521 if (prev
== NULL
|| prev
->literal
)
7522 expr
= head
->remaining
;
7525 for (; expr
; expr
= expr
->next
)
7532 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
7535 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7537 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7541 if (fnmatch (expr
->pattern
, s
, 0) == 0)
7547 free ((char *) c_sym
);
7549 free ((char *) cxx_sym
);
7550 if (java_sym
!= sym
)
7551 free ((char *) java_sym
);
7555 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7556 return a pointer to the symbol name with any backslash quotes removed. */
7559 realsymbol (const char *pattern
)
7562 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
7563 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
7565 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
7567 /* It is a glob pattern only if there is no preceding
7571 /* Remove the preceding backslash. */
7578 if (*p
== '?' || *p
== '*' || *p
== '[')
7585 backslash
= *p
== '\\';
7601 /* This is called for each variable name or match expression. NEW_NAME is
7602 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7603 pattern to be matched against symbol names. */
7605 struct bfd_elf_version_expr
*
7606 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
7607 const char *new_name
,
7609 bfd_boolean literal_p
)
7611 struct bfd_elf_version_expr
*ret
;
7613 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
7617 ret
->literal
= TRUE
;
7618 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
7619 if (ret
->pattern
== NULL
)
7621 ret
->pattern
= new_name
;
7622 ret
->literal
= FALSE
;
7625 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
7626 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7627 else if (strcasecmp (lang
, "C++") == 0)
7628 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
7629 else if (strcasecmp (lang
, "Java") == 0)
7630 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
7633 einfo (_("%X%P: unknown language `%s' in version information\n"),
7635 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7638 return ldemul_new_vers_pattern (ret
);
7641 /* This is called for each set of variable names and match
7644 struct bfd_elf_version_tree
*
7645 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
7646 struct bfd_elf_version_expr
*locals
)
7648 struct bfd_elf_version_tree
*ret
;
7650 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
7651 ret
->globals
.list
= globals
;
7652 ret
->locals
.list
= locals
;
7653 ret
->match
= lang_vers_match
;
7654 ret
->name_indx
= (unsigned int) -1;
7658 /* This static variable keeps track of version indices. */
7660 static int version_index
;
7663 version_expr_head_hash (const void *p
)
7665 const struct bfd_elf_version_expr
*e
=
7666 (const struct bfd_elf_version_expr
*) p
;
7668 return htab_hash_string (e
->pattern
);
7672 version_expr_head_eq (const void *p1
, const void *p2
)
7674 const struct bfd_elf_version_expr
*e1
=
7675 (const struct bfd_elf_version_expr
*) p1
;
7676 const struct bfd_elf_version_expr
*e2
=
7677 (const struct bfd_elf_version_expr
*) p2
;
7679 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
7683 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
7686 struct bfd_elf_version_expr
*e
, *next
;
7687 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
7689 for (e
= head
->list
; e
; e
= e
->next
)
7693 head
->mask
|= e
->mask
;
7698 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
7699 version_expr_head_eq
, NULL
);
7700 list_loc
= &head
->list
;
7701 remaining_loc
= &head
->remaining
;
7702 for (e
= head
->list
; e
; e
= next
)
7708 remaining_loc
= &e
->next
;
7712 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
7716 struct bfd_elf_version_expr
*e1
, *last
;
7718 e1
= (struct bfd_elf_version_expr
*) *loc
;
7722 if (e1
->mask
== e
->mask
)
7730 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
7734 /* This is a duplicate. */
7735 /* FIXME: Memory leak. Sometimes pattern is not
7736 xmalloced alone, but in larger chunk of memory. */
7737 /* free (e->pattern); */
7742 e
->next
= last
->next
;
7750 list_loc
= &e
->next
;
7754 *remaining_loc
= NULL
;
7755 *list_loc
= head
->remaining
;
7758 head
->remaining
= head
->list
;
7761 /* This is called when we know the name and dependencies of the
7765 lang_register_vers_node (const char *name
,
7766 struct bfd_elf_version_tree
*version
,
7767 struct bfd_elf_version_deps
*deps
)
7769 struct bfd_elf_version_tree
*t
, **pp
;
7770 struct bfd_elf_version_expr
*e1
;
7775 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
7776 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
7778 einfo (_("%X%P: anonymous version tag cannot be combined"
7779 " with other version tags\n"));
7784 /* Make sure this node has a unique name. */
7785 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
7786 if (strcmp (t
->name
, name
) == 0)
7787 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
7789 lang_finalize_version_expr_head (&version
->globals
);
7790 lang_finalize_version_expr_head (&version
->locals
);
7792 /* Check the global and local match names, and make sure there
7793 aren't any duplicates. */
7795 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
7797 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
7799 struct bfd_elf_version_expr
*e2
;
7801 if (t
->locals
.htab
&& e1
->literal
)
7803 e2
= (struct bfd_elf_version_expr
*)
7804 htab_find ((htab_t
) t
->locals
.htab
, e1
);
7805 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
7807 if (e1
->mask
== e2
->mask
)
7808 einfo (_("%X%P: duplicate expression `%s'"
7809 " in version information\n"), e1
->pattern
);
7813 else if (!e1
->literal
)
7814 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7815 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7816 && e1
->mask
== e2
->mask
)
7817 einfo (_("%X%P: duplicate expression `%s'"
7818 " in version information\n"), e1
->pattern
);
7822 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
7824 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
7826 struct bfd_elf_version_expr
*e2
;
7828 if (t
->globals
.htab
&& e1
->literal
)
7830 e2
= (struct bfd_elf_version_expr
*)
7831 htab_find ((htab_t
) t
->globals
.htab
, e1
);
7832 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
7834 if (e1
->mask
== e2
->mask
)
7835 einfo (_("%X%P: duplicate expression `%s'"
7836 " in version information\n"),
7841 else if (!e1
->literal
)
7842 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7843 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7844 && e1
->mask
== e2
->mask
)
7845 einfo (_("%X%P: duplicate expression `%s'"
7846 " in version information\n"), e1
->pattern
);
7850 version
->deps
= deps
;
7851 version
->name
= name
;
7852 if (name
[0] != '\0')
7855 version
->vernum
= version_index
;
7858 version
->vernum
= 0;
7860 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7865 /* This is called when we see a version dependency. */
7867 struct bfd_elf_version_deps
*
7868 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
7870 struct bfd_elf_version_deps
*ret
;
7871 struct bfd_elf_version_tree
*t
;
7873 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
7876 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
7878 if (strcmp (t
->name
, name
) == 0)
7880 ret
->version_needed
= t
;
7885 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
7887 ret
->version_needed
= NULL
;
7892 lang_do_version_exports_section (void)
7894 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
7896 LANG_FOR_EACH_INPUT_STATEMENT (is
)
7898 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
7906 contents
= (char *) xmalloc (len
);
7907 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
7908 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
7911 while (p
< contents
+ len
)
7913 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
7914 p
= strchr (p
, '\0') + 1;
7917 /* Do not free the contents, as we used them creating the regex. */
7919 /* Do not include this section in the link. */
7920 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
7923 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
7924 lang_register_vers_node (command_line
.version_exports_section
,
7925 lang_new_vers_node (greg
, lreg
), NULL
);
7929 lang_add_unique (const char *name
)
7931 struct unique_sections
*ent
;
7933 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
7934 if (strcmp (ent
->name
, name
) == 0)
7937 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
7938 ent
->name
= xstrdup (name
);
7939 ent
->next
= unique_section_list
;
7940 unique_section_list
= ent
;
7943 /* Append the list of dynamic symbols to the existing one. */
7946 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
7948 if (link_info
.dynamic_list
)
7950 struct bfd_elf_version_expr
*tail
;
7951 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
7953 tail
->next
= link_info
.dynamic_list
->head
.list
;
7954 link_info
.dynamic_list
->head
.list
= dynamic
;
7958 struct bfd_elf_dynamic_list
*d
;
7960 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
7961 d
->head
.list
= dynamic
;
7962 d
->match
= lang_vers_match
;
7963 link_info
.dynamic_list
= d
;
7967 /* Append the list of C++ typeinfo dynamic symbols to the existing
7971 lang_append_dynamic_list_cpp_typeinfo (void)
7973 const char * symbols
[] =
7975 "typeinfo name for*",
7978 struct bfd_elf_version_expr
*dynamic
= NULL
;
7981 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
7982 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
7985 lang_append_dynamic_list (dynamic
);
7988 /* Append the list of C++ operator new and delete dynamic symbols to the
7992 lang_append_dynamic_list_cpp_new (void)
7994 const char * symbols
[] =
7999 struct bfd_elf_version_expr
*dynamic
= NULL
;
8002 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8003 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8006 lang_append_dynamic_list (dynamic
);
8009 /* Scan a space and/or comma separated string of features. */
8012 lang_ld_feature (char *str
)
8020 while (*p
== ',' || ISSPACE (*p
))
8025 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
8029 if (strcasecmp (p
, "SANE_EXPR") == 0)
8030 config
.sane_expr
= TRUE
;
8032 einfo (_("%X%P: unknown feature `%s'\n"), p
);