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, 2012
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
;
73 /* Forward declarations. */
74 static void exp_init_os (etree_type
*);
75 static void init_map_userdata (bfd
*, asection
*, void *);
76 static lang_input_statement_type
*lookup_name (const char *);
77 static struct bfd_hash_entry
*lang_definedness_newfunc
78 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
79 static void insert_undefined (const char *);
80 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
81 static void print_statement (lang_statement_union_type
*,
82 lang_output_section_statement_type
*);
83 static void print_statement_list (lang_statement_union_type
*,
84 lang_output_section_statement_type
*);
85 static void print_statements (void);
86 static void print_input_section (asection
*, bfd_boolean
);
87 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
88 static void lang_record_phdrs (void);
89 static void lang_do_version_exports_section (void);
90 static void lang_finalize_version_expr_head
91 (struct bfd_elf_version_expr_head
*);
93 /* Exported variables. */
94 const char *output_target
;
95 lang_output_section_statement_type
*abs_output_section
;
96 lang_statement_list_type lang_output_section_statement
;
97 lang_statement_list_type
*stat_ptr
= &statement_list
;
98 lang_statement_list_type file_chain
= { NULL
, NULL
};
99 lang_statement_list_type input_file_chain
;
100 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
101 const char *entry_section
= ".text";
102 struct lang_input_statement_flags input_flags
;
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
;
112 /* Functions that traverse the linker script and might evaluate
113 DEFINED() need to increment this. */
114 int lang_statement_iteration
= 0;
116 etree_type
*base
; /* Relocation base - or null */
118 /* Return TRUE if the PATTERN argument is a wildcard pattern.
119 Although backslashes are treated specially if a pattern contains
120 wildcards, we do not consider the mere presence of a backslash to
121 be enough to cause the pattern to be treated as a wildcard.
122 That lets us handle DOS filenames more naturally. */
123 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
125 #define new_stat(x, y) \
126 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
128 #define outside_section_address(q) \
129 ((q)->output_offset + (q)->output_section->vma)
131 #define outside_symbol_address(q) \
132 ((q)->value + outside_section_address (q->section))
134 #define SECTION_NAME_MAP_LENGTH (16)
137 stat_alloc (size_t size
)
139 return obstack_alloc (&stat_obstack
, size
);
143 name_match (const char *pattern
, const char *name
)
145 if (wildcardp (pattern
))
146 return fnmatch (pattern
, name
, 0);
147 return strcmp (pattern
, name
);
150 /* If PATTERN is of the form archive:file, return a pointer to the
151 separator. If not, return NULL. */
154 archive_path (const char *pattern
)
158 if (link_info
.path_separator
== 0)
161 p
= strchr (pattern
, link_info
.path_separator
);
162 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
163 if (p
== NULL
|| link_info
.path_separator
!= ':')
166 /* Assume a match on the second char is part of drive specifier,
167 as in "c:\silly.dos". */
168 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
169 p
= strchr (p
+ 1, link_info
.path_separator
);
174 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
175 return whether F matches FILE_SPEC. */
178 input_statement_is_archive_path (const char *file_spec
, char *sep
,
179 lang_input_statement_type
*f
)
181 bfd_boolean match
= FALSE
;
184 || name_match (sep
+ 1, f
->filename
) == 0)
185 && ((sep
!= file_spec
)
186 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
190 if (sep
!= file_spec
)
192 const char *aname
= f
->the_bfd
->my_archive
->filename
;
194 match
= name_match (file_spec
, aname
) == 0;
195 *sep
= link_info
.path_separator
;
202 unique_section_p (const asection
*sec
,
203 const lang_output_section_statement_type
*os
)
205 struct unique_sections
*unam
;
208 if (link_info
.relocatable
209 && sec
->owner
!= NULL
210 && bfd_is_group_section (sec
->owner
, sec
))
212 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
215 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
216 if (name_match (unam
->name
, secnam
) == 0)
222 /* Generic traversal routines for finding matching sections. */
224 /* Try processing a section against a wildcard. This just calls
225 the callback unless the filename exclusion list is present
226 and excludes the file. It's hardly ever present so this
227 function is very fast. */
230 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
231 lang_input_statement_type
*file
,
233 struct wildcard_list
*sec
,
237 struct name_list
*list_tmp
;
239 /* Propagate the section_flag_info from the wild statement to the section. */
240 s
->section_flag_info
= ptr
->section_flag_list
;
242 /* Don't process sections from files which were excluded. */
243 for (list_tmp
= sec
->spec
.exclude_name_list
;
245 list_tmp
= list_tmp
->next
)
247 char *p
= archive_path (list_tmp
->name
);
251 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
255 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
258 /* FIXME: Perhaps remove the following at some stage? Matching
259 unadorned archives like this was never documented and has
260 been superceded by the archive:path syntax. */
261 else if (file
->the_bfd
!= NULL
262 && file
->the_bfd
->my_archive
!= NULL
263 && name_match (list_tmp
->name
,
264 file
->the_bfd
->my_archive
->filename
) == 0)
268 (*callback
) (ptr
, sec
, s
, file
, data
);
271 /* Lowest common denominator routine that can handle everything correctly,
275 walk_wild_section_general (lang_wild_statement_type
*ptr
,
276 lang_input_statement_type
*file
,
281 struct wildcard_list
*sec
;
283 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
285 sec
= ptr
->section_list
;
287 (*callback
) (ptr
, sec
, s
, file
, data
);
291 bfd_boolean skip
= FALSE
;
293 if (sec
->spec
.name
!= NULL
)
295 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
297 skip
= name_match (sec
->spec
.name
, sname
) != 0;
301 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
308 /* Routines to find a single section given its name. If there's more
309 than one section with that name, we report that. */
313 asection
*found_section
;
314 bfd_boolean multiple_sections_found
;
315 } section_iterator_callback_data
;
318 section_iterator_callback (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
320 section_iterator_callback_data
*d
= (section_iterator_callback_data
*) data
;
322 if (d
->found_section
!= NULL
)
324 d
->multiple_sections_found
= TRUE
;
328 d
->found_section
= s
;
333 find_section (lang_input_statement_type
*file
,
334 struct wildcard_list
*sec
,
335 bfd_boolean
*multiple_sections_found
)
337 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
339 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
340 section_iterator_callback
, &cb_data
);
341 *multiple_sections_found
= cb_data
.multiple_sections_found
;
342 return cb_data
.found_section
;
345 /* Code for handling simple wildcards without going through fnmatch,
346 which can be expensive because of charset translations etc. */
348 /* A simple wild is a literal string followed by a single '*',
349 where the literal part is at least 4 characters long. */
352 is_simple_wild (const char *name
)
354 size_t len
= strcspn (name
, "*?[");
355 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
359 match_simple_wild (const char *pattern
, const char *name
)
361 /* The first four characters of the pattern are guaranteed valid
362 non-wildcard characters. So we can go faster. */
363 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
364 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
369 while (*pattern
!= '*')
370 if (*name
++ != *pattern
++)
376 /* Return the numerical value of the init_priority attribute from
377 section name NAME. */
380 get_init_priority (const char *name
)
383 unsigned long init_priority
;
385 /* GCC uses the following section names for the init_priority
386 attribute with numerical values 101 and 65535 inclusive. A
387 lower value means a higher priority.
389 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the
390 decimal numerical value of the init_priority attribute.
391 The order of execution in .init_array is forward and
392 .fini_array is backward.
393 2: .ctors.NNNN/.ctors.NNNN: Where NNNN is 65535 minus the
394 decimal numerical value of the init_priority attribute.
395 The order of execution in .ctors is backward and .dtors
398 if (strncmp (name
, ".init_array.", 12) == 0
399 || strncmp (name
, ".fini_array.", 12) == 0)
401 init_priority
= strtoul (name
+ 12, &end
, 10);
402 return *end
? 0 : init_priority
;
404 else if (strncmp (name
, ".ctors.", 7) == 0
405 || strncmp (name
, ".dtors.", 7) == 0)
407 init_priority
= strtoul (name
+ 7, &end
, 10);
408 return *end
? 0 : 65535 - init_priority
;
414 /* Compare sections ASEC and BSEC according to SORT. */
417 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
420 unsigned long ainit_priority
, binit_priority
;
427 case by_init_priority
:
429 = get_init_priority (bfd_get_section_name (asec
->owner
, asec
));
431 = get_init_priority (bfd_get_section_name (bsec
->owner
, bsec
));
432 if (ainit_priority
== 0 || binit_priority
== 0)
434 ret
= ainit_priority
- binit_priority
;
440 case by_alignment_name
:
441 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
442 - bfd_section_alignment (asec
->owner
, asec
));
449 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
450 bfd_get_section_name (bsec
->owner
, bsec
));
453 case by_name_alignment
:
454 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
455 bfd_get_section_name (bsec
->owner
, bsec
));
461 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
462 - bfd_section_alignment (asec
->owner
, asec
));
469 /* Build a Binary Search Tree to sort sections, unlike insertion sort
470 used in wild_sort(). BST is considerably faster if the number of
471 of sections are large. */
473 static lang_section_bst_type
**
474 wild_sort_fast (lang_wild_statement_type
*wild
,
475 struct wildcard_list
*sec
,
476 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
479 lang_section_bst_type
**tree
;
482 if (!wild
->filenames_sorted
483 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
485 /* Append at the right end of tree. */
487 tree
= &((*tree
)->right
);
493 /* Find the correct node to append this section. */
494 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
495 tree
= &((*tree
)->left
);
497 tree
= &((*tree
)->right
);
503 /* Use wild_sort_fast to build a BST to sort sections. */
506 output_section_callback_fast (lang_wild_statement_type
*ptr
,
507 struct wildcard_list
*sec
,
509 lang_input_statement_type
*file
,
512 lang_section_bst_type
*node
;
513 lang_section_bst_type
**tree
;
514 lang_output_section_statement_type
*os
;
516 os
= (lang_output_section_statement_type
*) output
;
518 if (unique_section_p (section
, os
))
521 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
524 node
->section
= section
;
526 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
531 /* Convert a sorted sections' BST back to list form. */
534 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
535 lang_section_bst_type
*tree
,
539 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
541 lang_add_section (&ptr
->children
, tree
->section
,
542 (lang_output_section_statement_type
*) output
);
545 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
550 /* Specialized, optimized routines for handling different kinds of
554 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
555 lang_input_statement_type
*file
,
559 /* We can just do a hash lookup for the section with the right name.
560 But if that lookup discovers more than one section with the name
561 (should be rare), we fall back to the general algorithm because
562 we would otherwise have to sort the sections to make sure they
563 get processed in the bfd's order. */
564 bfd_boolean multiple_sections_found
;
565 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
566 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
568 if (multiple_sections_found
)
569 walk_wild_section_general (ptr
, file
, callback
, data
);
571 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
575 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
576 lang_input_statement_type
*file
,
581 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
583 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
585 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
586 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
589 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
594 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
595 lang_input_statement_type
*file
,
600 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
601 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
602 bfd_boolean multiple_sections_found
;
603 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
605 if (multiple_sections_found
)
607 walk_wild_section_general (ptr
, file
, callback
, data
);
611 /* Note that if the section was not found, s0 is NULL and
612 we'll simply never succeed the s == s0 test below. */
613 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
615 /* Recall that in this code path, a section cannot satisfy more
616 than one spec, so if s == s0 then it cannot match
619 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
622 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
623 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
626 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
633 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
634 lang_input_statement_type
*file
,
639 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
640 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
641 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
642 bfd_boolean multiple_sections_found
;
643 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
645 if (multiple_sections_found
)
647 walk_wild_section_general (ptr
, file
, callback
, data
);
651 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
654 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
657 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
658 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
661 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
664 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
666 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
674 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
675 lang_input_statement_type
*file
,
680 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
681 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
682 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
683 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
684 bfd_boolean multiple_sections_found
;
685 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
687 if (multiple_sections_found
)
689 walk_wild_section_general (ptr
, file
, callback
, data
);
693 s1
= find_section (file
, sec1
, &multiple_sections_found
);
694 if (multiple_sections_found
)
696 walk_wild_section_general (ptr
, file
, callback
, data
);
700 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
703 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
706 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
709 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
710 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
714 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
718 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
720 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
728 walk_wild_section (lang_wild_statement_type
*ptr
,
729 lang_input_statement_type
*file
,
733 if (file
->flags
.just_syms
)
736 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
739 /* Returns TRUE when name1 is a wildcard spec that might match
740 something name2 can match. We're conservative: we return FALSE
741 only if the prefixes of name1 and name2 are different up to the
742 first wildcard character. */
745 wild_spec_can_overlap (const char *name1
, const char *name2
)
747 size_t prefix1_len
= strcspn (name1
, "?*[");
748 size_t prefix2_len
= strcspn (name2
, "?*[");
749 size_t min_prefix_len
;
751 /* Note that if there is no wildcard character, then we treat the
752 terminating 0 as part of the prefix. Thus ".text" won't match
753 ".text." or ".text.*", for example. */
754 if (name1
[prefix1_len
] == '\0')
756 if (name2
[prefix2_len
] == '\0')
759 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
761 return memcmp (name1
, name2
, min_prefix_len
) == 0;
764 /* Select specialized code to handle various kinds of wildcard
768 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
771 int wild_name_count
= 0;
772 struct wildcard_list
*sec
;
776 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
777 ptr
->handler_data
[0] = NULL
;
778 ptr
->handler_data
[1] = NULL
;
779 ptr
->handler_data
[2] = NULL
;
780 ptr
->handler_data
[3] = NULL
;
783 /* Count how many wildcard_specs there are, and how many of those
784 actually use wildcards in the name. Also, bail out if any of the
785 wildcard names are NULL. (Can this actually happen?
786 walk_wild_section used to test for it.) And bail out if any
787 of the wildcards are more complex than a simple string
788 ending in a single '*'. */
789 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
792 if (sec
->spec
.name
== NULL
)
794 if (wildcardp (sec
->spec
.name
))
797 if (!is_simple_wild (sec
->spec
.name
))
802 /* The zero-spec case would be easy to optimize but it doesn't
803 happen in practice. Likewise, more than 4 specs doesn't
804 happen in practice. */
805 if (sec_count
== 0 || sec_count
> 4)
808 /* Check that no two specs can match the same section. */
809 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
811 struct wildcard_list
*sec2
;
812 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
814 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
819 signature
= (sec_count
<< 8) + wild_name_count
;
823 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
826 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
829 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
832 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
835 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
841 /* Now fill the data array with pointers to the specs, first the
842 specs with non-wildcard names, then the specs with wildcard
843 names. It's OK to process the specs in different order from the
844 given order, because we've already determined that no section
845 will match more than one spec. */
847 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
848 if (!wildcardp (sec
->spec
.name
))
849 ptr
->handler_data
[data_counter
++] = sec
;
850 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
851 if (wildcardp (sec
->spec
.name
))
852 ptr
->handler_data
[data_counter
++] = sec
;
855 /* Handle a wild statement for a single file F. */
858 walk_wild_file (lang_wild_statement_type
*s
,
859 lang_input_statement_type
*f
,
863 if (f
->the_bfd
== NULL
864 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
865 walk_wild_section (s
, f
, callback
, data
);
870 /* This is an archive file. We must map each member of the
871 archive separately. */
872 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
873 while (member
!= NULL
)
875 /* When lookup_name is called, it will call the add_symbols
876 entry point for the archive. For each element of the
877 archive which is included, BFD will call ldlang_add_file,
878 which will set the usrdata field of the member to the
879 lang_input_statement. */
880 if (member
->usrdata
!= NULL
)
882 walk_wild_section (s
,
883 (lang_input_statement_type
*) member
->usrdata
,
887 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
893 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
895 const char *file_spec
= s
->filename
;
898 if (file_spec
== NULL
)
900 /* Perform the iteration over all files in the list. */
901 LANG_FOR_EACH_INPUT_STATEMENT (f
)
903 walk_wild_file (s
, f
, callback
, data
);
906 else if ((p
= archive_path (file_spec
)) != NULL
)
908 LANG_FOR_EACH_INPUT_STATEMENT (f
)
910 if (input_statement_is_archive_path (file_spec
, p
, f
))
911 walk_wild_file (s
, f
, callback
, data
);
914 else if (wildcardp (file_spec
))
916 LANG_FOR_EACH_INPUT_STATEMENT (f
)
918 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
919 walk_wild_file (s
, f
, callback
, data
);
924 lang_input_statement_type
*f
;
926 /* Perform the iteration over a single file. */
927 f
= lookup_name (file_spec
);
929 walk_wild_file (s
, f
, callback
, data
);
933 /* lang_for_each_statement walks the parse tree and calls the provided
934 function for each node, except those inside output section statements
935 with constraint set to -1. */
938 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
939 lang_statement_union_type
*s
)
941 for (; s
!= NULL
; s
= s
->header
.next
)
945 switch (s
->header
.type
)
947 case lang_constructors_statement_enum
:
948 lang_for_each_statement_worker (func
, constructor_list
.head
);
950 case lang_output_section_statement_enum
:
951 if (s
->output_section_statement
.constraint
!= -1)
952 lang_for_each_statement_worker
953 (func
, s
->output_section_statement
.children
.head
);
955 case lang_wild_statement_enum
:
956 lang_for_each_statement_worker (func
,
957 s
->wild_statement
.children
.head
);
959 case lang_group_statement_enum
:
960 lang_for_each_statement_worker (func
,
961 s
->group_statement
.children
.head
);
963 case lang_data_statement_enum
:
964 case lang_reloc_statement_enum
:
965 case lang_object_symbols_statement_enum
:
966 case lang_output_statement_enum
:
967 case lang_target_statement_enum
:
968 case lang_input_section_enum
:
969 case lang_input_statement_enum
:
970 case lang_assignment_statement_enum
:
971 case lang_padding_statement_enum
:
972 case lang_address_statement_enum
:
973 case lang_fill_statement_enum
:
974 case lang_insert_statement_enum
:
984 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
986 lang_for_each_statement_worker (func
, statement_list
.head
);
989 /*----------------------------------------------------------------------*/
992 lang_list_init (lang_statement_list_type
*list
)
995 list
->tail
= &list
->head
;
999 push_stat_ptr (lang_statement_list_type
*new_ptr
)
1001 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
1003 *stat_save_ptr
++ = stat_ptr
;
1010 if (stat_save_ptr
<= stat_save
)
1012 stat_ptr
= *--stat_save_ptr
;
1015 /* Build a new statement node for the parse tree. */
1017 static lang_statement_union_type
*
1018 new_statement (enum statement_enum type
,
1020 lang_statement_list_type
*list
)
1022 lang_statement_union_type
*new_stmt
;
1024 new_stmt
= (lang_statement_union_type
*) stat_alloc (size
);
1025 new_stmt
->header
.type
= type
;
1026 new_stmt
->header
.next
= NULL
;
1027 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1031 /* Build a new input file node for the language. There are several
1032 ways in which we treat an input file, eg, we only look at symbols,
1033 or prefix it with a -l etc.
1035 We can be supplied with requests for input files more than once;
1036 they may, for example be split over several lines like foo.o(.text)
1037 foo.o(.data) etc, so when asked for a file we check that we haven't
1038 got it already so we don't duplicate the bfd. */
1040 static lang_input_statement_type
*
1041 new_afile (const char *name
,
1042 lang_input_file_enum_type file_type
,
1044 bfd_boolean add_to_list
)
1046 lang_input_statement_type
*p
;
1048 lang_has_input_file
= TRUE
;
1051 p
= (lang_input_statement_type
*) new_stat (lang_input_statement
, stat_ptr
);
1054 p
= (lang_input_statement_type
*)
1055 stat_alloc (sizeof (lang_input_statement_type
));
1056 p
->header
.type
= lang_input_statement_enum
;
1057 p
->header
.next
= NULL
;
1060 memset (&p
->the_bfd
, 0,
1061 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1063 p
->flags
.dynamic
= input_flags
.dynamic
;
1064 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1065 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1066 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1068 if (file_type
== lang_input_file_is_l_enum
1069 && name
[0] == ':' && name
[1] != '\0')
1071 file_type
= lang_input_file_is_search_file_enum
;
1077 case lang_input_file_is_symbols_only_enum
:
1079 p
->local_sym_name
= name
;
1080 p
->flags
.real
= TRUE
;
1081 p
->flags
.just_syms
= TRUE
;
1083 case lang_input_file_is_fake_enum
:
1085 p
->local_sym_name
= name
;
1087 case lang_input_file_is_l_enum
:
1089 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1090 p
->flags
.maybe_archive
= TRUE
;
1091 p
->flags
.real
= TRUE
;
1092 p
->flags
.search_dirs
= TRUE
;
1094 case lang_input_file_is_marker_enum
:
1096 p
->local_sym_name
= name
;
1097 p
->flags
.search_dirs
= TRUE
;
1099 case lang_input_file_is_search_file_enum
:
1101 p
->local_sym_name
= name
;
1102 p
->flags
.real
= TRUE
;
1103 p
->flags
.search_dirs
= TRUE
;
1104 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1106 case lang_input_file_is_file_enum
:
1108 p
->local_sym_name
= name
;
1109 p
->flags
.real
= TRUE
;
1115 lang_statement_append (&input_file_chain
,
1116 (lang_statement_union_type
*) p
,
1117 &p
->next_real_file
);
1121 lang_input_statement_type
*
1122 lang_add_input_file (const char *name
,
1123 lang_input_file_enum_type file_type
,
1126 return new_afile (name
, file_type
, target
, TRUE
);
1129 struct out_section_hash_entry
1131 struct bfd_hash_entry root
;
1132 lang_statement_union_type s
;
1135 /* The hash table. */
1137 static struct bfd_hash_table output_section_statement_table
;
1139 /* Support routines for the hash table used by lang_output_section_find,
1140 initialize the table, fill in an entry and remove the table. */
1142 static struct bfd_hash_entry
*
1143 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1144 struct bfd_hash_table
*table
,
1147 lang_output_section_statement_type
**nextp
;
1148 struct out_section_hash_entry
*ret
;
1152 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1158 entry
= bfd_hash_newfunc (entry
, table
, string
);
1162 ret
= (struct out_section_hash_entry
*) entry
;
1163 memset (&ret
->s
, 0, sizeof (ret
->s
));
1164 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1165 ret
->s
.output_section_statement
.subsection_alignment
= -1;
1166 ret
->s
.output_section_statement
.section_alignment
= -1;
1167 ret
->s
.output_section_statement
.block_value
= 1;
1168 lang_list_init (&ret
->s
.output_section_statement
.children
);
1169 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1171 /* For every output section statement added to the list, except the
1172 first one, lang_output_section_statement.tail points to the "next"
1173 field of the last element of the list. */
1174 if (lang_output_section_statement
.head
!= NULL
)
1175 ret
->s
.output_section_statement
.prev
1176 = ((lang_output_section_statement_type
*)
1177 ((char *) lang_output_section_statement
.tail
1178 - offsetof (lang_output_section_statement_type
, next
)));
1180 /* GCC's strict aliasing rules prevent us from just casting the
1181 address, so we store the pointer in a variable and cast that
1183 nextp
= &ret
->s
.output_section_statement
.next
;
1184 lang_statement_append (&lang_output_section_statement
,
1186 (lang_statement_union_type
**) nextp
);
1191 output_section_statement_table_init (void)
1193 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1194 output_section_statement_newfunc
,
1195 sizeof (struct out_section_hash_entry
),
1197 einfo (_("%P%F: can not create hash table: %E\n"));
1201 output_section_statement_table_free (void)
1203 bfd_hash_table_free (&output_section_statement_table
);
1206 /* Build enough state so that the parser can build its tree. */
1211 obstack_begin (&stat_obstack
, 1000);
1213 stat_ptr
= &statement_list
;
1215 output_section_statement_table_init ();
1217 lang_list_init (stat_ptr
);
1219 lang_list_init (&input_file_chain
);
1220 lang_list_init (&lang_output_section_statement
);
1221 lang_list_init (&file_chain
);
1222 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1224 abs_output_section
=
1225 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1227 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1229 /* The value "3" is ad-hoc, somewhat related to the expected number of
1230 DEFINED expressions in a linker script. For most default linker
1231 scripts, there are none. Why a hash table then? Well, it's somewhat
1232 simpler to re-use working machinery than using a linked list in terms
1233 of code-complexity here in ld, besides the initialization which just
1234 looks like other code here. */
1235 if (!bfd_hash_table_init_n (&lang_definedness_table
,
1236 lang_definedness_newfunc
,
1237 sizeof (struct lang_definedness_hash_entry
),
1239 einfo (_("%P%F: can not create hash table: %E\n"));
1245 output_section_statement_table_free ();
1248 /*----------------------------------------------------------------------
1249 A region is an area of memory declared with the
1250 MEMORY { name:org=exp, len=exp ... }
1253 We maintain a list of all the regions here.
1255 If no regions are specified in the script, then the default is used
1256 which is created when looked up to be the entire data space.
1258 If create is true we are creating a region inside a MEMORY block.
1259 In this case it is probably an error to create a region that has
1260 already been created. If we are not inside a MEMORY block it is
1261 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1262 and so we issue a warning.
1264 Each region has at least one name. The first name is either
1265 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1266 alias names to an existing region within a script with
1267 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1270 static lang_memory_region_type
*lang_memory_region_list
;
1271 static lang_memory_region_type
**lang_memory_region_list_tail
1272 = &lang_memory_region_list
;
1274 lang_memory_region_type
*
1275 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1277 lang_memory_region_name
*n
;
1278 lang_memory_region_type
*r
;
1279 lang_memory_region_type
*new_region
;
1281 /* NAME is NULL for LMA memspecs if no region was specified. */
1285 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1286 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1287 if (strcmp (n
->name
, name
) == 0)
1290 einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
1295 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1296 einfo (_("%P:%S: warning: memory region `%s' not declared\n"),
1299 new_region
= (lang_memory_region_type
*)
1300 stat_alloc (sizeof (lang_memory_region_type
));
1302 new_region
->name_list
.name
= xstrdup (name
);
1303 new_region
->name_list
.next
= NULL
;
1304 new_region
->next
= NULL
;
1305 new_region
->origin
= 0;
1306 new_region
->length
= ~(bfd_size_type
) 0;
1307 new_region
->current
= 0;
1308 new_region
->last_os
= NULL
;
1309 new_region
->flags
= 0;
1310 new_region
->not_flags
= 0;
1311 new_region
->had_full_message
= FALSE
;
1313 *lang_memory_region_list_tail
= new_region
;
1314 lang_memory_region_list_tail
= &new_region
->next
;
1320 lang_memory_region_alias (const char * alias
, const char * region_name
)
1322 lang_memory_region_name
* n
;
1323 lang_memory_region_type
* r
;
1324 lang_memory_region_type
* region
;
1326 /* The default region must be unique. This ensures that it is not necessary
1327 to iterate through the name list if someone wants the check if a region is
1328 the default memory region. */
1329 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1330 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1331 einfo (_("%F%P:%S: error: alias for default memory region\n"), NULL
);
1333 /* Look for the target region and check if the alias is not already
1336 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1337 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1339 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1341 if (strcmp (n
->name
, alias
) == 0)
1342 einfo (_("%F%P:%S: error: redefinition of memory region "
1347 /* Check if the target region exists. */
1349 einfo (_("%F%P:%S: error: memory region `%s' "
1350 "for alias `%s' does not exist\n"),
1351 NULL
, region_name
, alias
);
1353 /* Add alias to region name list. */
1354 n
= (lang_memory_region_name
*) stat_alloc (sizeof (lang_memory_region_name
));
1355 n
->name
= xstrdup (alias
);
1356 n
->next
= region
->name_list
.next
;
1357 region
->name_list
.next
= n
;
1360 static lang_memory_region_type
*
1361 lang_memory_default (asection
* section
)
1363 lang_memory_region_type
*p
;
1365 flagword sec_flags
= section
->flags
;
1367 /* Override SEC_DATA to mean a writable section. */
1368 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1369 sec_flags
|= SEC_DATA
;
1371 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1373 if ((p
->flags
& sec_flags
) != 0
1374 && (p
->not_flags
& sec_flags
) == 0)
1379 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1382 /* Find or create an output_section_statement with the given NAME.
1383 If CONSTRAINT is non-zero match one with that constraint, otherwise
1384 match any non-negative constraint. If CREATE, always make a
1385 new output_section_statement for SPECIAL CONSTRAINT. */
1387 lang_output_section_statement_type
*
1388 lang_output_section_statement_lookup (const char *name
,
1392 struct out_section_hash_entry
*entry
;
1394 entry
= ((struct out_section_hash_entry
*)
1395 bfd_hash_lookup (&output_section_statement_table
, name
,
1400 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1404 if (entry
->s
.output_section_statement
.name
!= NULL
)
1406 /* We have a section of this name, but it might not have the correct
1408 struct out_section_hash_entry
*last_ent
;
1410 name
= entry
->s
.output_section_statement
.name
;
1411 if (create
&& constraint
== SPECIAL
)
1412 /* Not traversing to the end reverses the order of the second
1413 and subsequent SPECIAL sections in the hash table chain,
1414 but that shouldn't matter. */
1419 if (constraint
== entry
->s
.output_section_statement
.constraint
1421 && entry
->s
.output_section_statement
.constraint
>= 0))
1422 return &entry
->s
.output_section_statement
;
1424 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1426 while (entry
!= NULL
1427 && name
== entry
->s
.output_section_statement
.name
);
1433 = ((struct out_section_hash_entry
*)
1434 output_section_statement_newfunc (NULL
,
1435 &output_section_statement_table
,
1439 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1442 entry
->root
= last_ent
->root
;
1443 last_ent
->root
.next
= &entry
->root
;
1446 entry
->s
.output_section_statement
.name
= name
;
1447 entry
->s
.output_section_statement
.constraint
= constraint
;
1448 return &entry
->s
.output_section_statement
;
1451 /* Find the next output_section_statement with the same name as OS.
1452 If CONSTRAINT is non-zero, find one with that constraint otherwise
1453 match any non-negative constraint. */
1455 lang_output_section_statement_type
*
1456 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1459 /* All output_section_statements are actually part of a
1460 struct out_section_hash_entry. */
1461 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1463 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1464 const char *name
= os
->name
;
1466 ASSERT (name
== entry
->root
.string
);
1469 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1471 || name
!= entry
->s
.output_section_statement
.name
)
1474 while (constraint
!= entry
->s
.output_section_statement
.constraint
1476 || entry
->s
.output_section_statement
.constraint
< 0));
1478 return &entry
->s
.output_section_statement
;
1481 /* A variant of lang_output_section_find used by place_orphan.
1482 Returns the output statement that should precede a new output
1483 statement for SEC. If an exact match is found on certain flags,
1486 lang_output_section_statement_type
*
1487 lang_output_section_find_by_flags (const asection
*sec
,
1488 lang_output_section_statement_type
**exact
,
1489 lang_match_sec_type_func match_type
)
1491 lang_output_section_statement_type
*first
, *look
, *found
;
1494 /* We know the first statement on this list is *ABS*. May as well
1496 first
= &lang_output_section_statement
.head
->output_section_statement
;
1497 first
= first
->next
;
1499 /* First try for an exact match. */
1501 for (look
= first
; look
; look
= look
->next
)
1503 flags
= look
->flags
;
1504 if (look
->bfd_section
!= NULL
)
1506 flags
= look
->bfd_section
->flags
;
1507 if (match_type
&& !match_type (link_info
.output_bfd
,
1512 flags
^= sec
->flags
;
1513 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1514 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1524 if ((sec
->flags
& SEC_CODE
) != 0
1525 && (sec
->flags
& SEC_ALLOC
) != 0)
1527 /* Try for a rw code section. */
1528 for (look
= first
; look
; look
= look
->next
)
1530 flags
= look
->flags
;
1531 if (look
->bfd_section
!= NULL
)
1533 flags
= look
->bfd_section
->flags
;
1534 if (match_type
&& !match_type (link_info
.output_bfd
,
1539 flags
^= sec
->flags
;
1540 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1541 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1545 else if ((sec
->flags
& (SEC_READONLY
| SEC_THREAD_LOCAL
)) != 0
1546 && (sec
->flags
& SEC_ALLOC
) != 0)
1548 /* .rodata can go after .text, .sdata2 after .rodata. */
1549 for (look
= first
; look
; look
= look
->next
)
1551 flags
= look
->flags
;
1552 if (look
->bfd_section
!= NULL
)
1554 flags
= look
->bfd_section
->flags
;
1555 if (match_type
&& !match_type (link_info
.output_bfd
,
1560 flags
^= sec
->flags
;
1561 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1562 | SEC_READONLY
| SEC_SMALL_DATA
))
1563 || (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1565 && !(look
->flags
& SEC_SMALL_DATA
))
1566 || (!(flags
& (SEC_THREAD_LOCAL
| SEC_ALLOC
))
1567 && (look
->flags
& SEC_THREAD_LOCAL
)
1568 && (!(flags
& SEC_LOAD
)
1569 || (look
->flags
& SEC_LOAD
))))
1573 else if ((sec
->flags
& SEC_SMALL_DATA
) != 0
1574 && (sec
->flags
& SEC_ALLOC
) != 0)
1576 /* .sdata goes after .data, .sbss after .sdata. */
1577 for (look
= first
; look
; look
= look
->next
)
1579 flags
= look
->flags
;
1580 if (look
->bfd_section
!= NULL
)
1582 flags
= look
->bfd_section
->flags
;
1583 if (match_type
&& !match_type (link_info
.output_bfd
,
1588 flags
^= sec
->flags
;
1589 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1590 | SEC_THREAD_LOCAL
))
1591 || ((look
->flags
& SEC_SMALL_DATA
)
1592 && !(sec
->flags
& SEC_HAS_CONTENTS
)))
1596 else if ((sec
->flags
& SEC_HAS_CONTENTS
) != 0
1597 && (sec
->flags
& SEC_ALLOC
) != 0)
1599 /* .data goes after .rodata. */
1600 for (look
= first
; look
; look
= look
->next
)
1602 flags
= look
->flags
;
1603 if (look
->bfd_section
!= NULL
)
1605 flags
= look
->bfd_section
->flags
;
1606 if (match_type
&& !match_type (link_info
.output_bfd
,
1611 flags
^= sec
->flags
;
1612 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1613 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1617 else if ((sec
->flags
& SEC_ALLOC
) != 0)
1619 /* .bss goes after any other alloc section. */
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_ALLOC
))
1638 /* non-alloc go last. */
1639 for (look
= first
; look
; look
= look
->next
)
1641 flags
= look
->flags
;
1642 if (look
->bfd_section
!= NULL
)
1643 flags
= look
->bfd_section
->flags
;
1644 flags
^= sec
->flags
;
1645 if (!(flags
& SEC_DEBUGGING
))
1651 if (found
|| !match_type
)
1654 return lang_output_section_find_by_flags (sec
, NULL
, NULL
);
1657 /* Find the last output section before given output statement.
1658 Used by place_orphan. */
1661 output_prev_sec_find (lang_output_section_statement_type
*os
)
1663 lang_output_section_statement_type
*lookup
;
1665 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1667 if (lookup
->constraint
< 0)
1670 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1671 return lookup
->bfd_section
;
1677 /* Look for a suitable place for a new output section statement. The
1678 idea is to skip over anything that might be inside a SECTIONS {}
1679 statement in a script, before we find another output section
1680 statement. Assignments to "dot" before an output section statement
1681 are assumed to belong to it, except in two cases; The first
1682 assignment to dot, and assignments before non-alloc sections.
1683 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1684 similar assignments that set the initial address, or we might
1685 insert non-alloc note sections among assignments setting end of
1688 static lang_statement_union_type
**
1689 insert_os_after (lang_output_section_statement_type
*after
)
1691 lang_statement_union_type
**where
;
1692 lang_statement_union_type
**assign
= NULL
;
1693 bfd_boolean ignore_first
;
1696 = after
== &lang_output_section_statement
.head
->output_section_statement
;
1698 for (where
= &after
->header
.next
;
1700 where
= &(*where
)->header
.next
)
1702 switch ((*where
)->header
.type
)
1704 case lang_assignment_statement_enum
:
1707 lang_assignment_statement_type
*ass
;
1709 ass
= &(*where
)->assignment_statement
;
1710 if (ass
->exp
->type
.node_class
!= etree_assert
1711 && ass
->exp
->assign
.dst
[0] == '.'
1712 && ass
->exp
->assign
.dst
[1] == 0
1716 ignore_first
= FALSE
;
1718 case lang_wild_statement_enum
:
1719 case lang_input_section_enum
:
1720 case lang_object_symbols_statement_enum
:
1721 case lang_fill_statement_enum
:
1722 case lang_data_statement_enum
:
1723 case lang_reloc_statement_enum
:
1724 case lang_padding_statement_enum
:
1725 case lang_constructors_statement_enum
:
1728 case lang_output_section_statement_enum
:
1731 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1734 || s
->map_head
.s
== NULL
1735 || (s
->flags
& SEC_ALLOC
) != 0)
1739 case lang_input_statement_enum
:
1740 case lang_address_statement_enum
:
1741 case lang_target_statement_enum
:
1742 case lang_output_statement_enum
:
1743 case lang_group_statement_enum
:
1744 case lang_insert_statement_enum
:
1753 lang_output_section_statement_type
*
1754 lang_insert_orphan (asection
*s
,
1755 const char *secname
,
1757 lang_output_section_statement_type
*after
,
1758 struct orphan_save
*place
,
1759 etree_type
*address
,
1760 lang_statement_list_type
*add_child
)
1762 lang_statement_list_type add
;
1764 lang_output_section_statement_type
*os
;
1765 lang_output_section_statement_type
**os_tail
;
1767 /* If we have found an appropriate place for the output section
1768 statements for this orphan, add them to our own private list,
1769 inserting them later into the global statement list. */
1772 lang_list_init (&add
);
1773 push_stat_ptr (&add
);
1776 if (link_info
.relocatable
|| (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1777 address
= exp_intop (0);
1779 os_tail
= ((lang_output_section_statement_type
**)
1780 lang_output_section_statement
.tail
);
1781 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1782 NULL
, NULL
, NULL
, constraint
);
1785 if (config
.build_constructors
&& *os_tail
== os
)
1787 /* If the name of the section is representable in C, then create
1788 symbols to mark the start and the end of the section. */
1789 for (ps
= secname
; *ps
!= '\0'; ps
++)
1790 if (! ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
1795 etree_type
*e_align
;
1797 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__start_" + 1);
1798 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1799 sprintf (symname
+ (symname
[0] != 0), "__start_%s", secname
);
1800 e_align
= exp_unop (ALIGN_K
,
1801 exp_intop ((bfd_vma
) 1 << s
->alignment_power
));
1802 lang_add_assignment (exp_assign (".", e_align
));
1803 lang_add_assignment (exp_provide (symname
,
1805 exp_nameop (NAME
, ".")),
1810 if (add_child
== NULL
)
1811 add_child
= &os
->children
;
1812 lang_add_section (add_child
, s
, os
);
1814 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1816 const char *region
= (after
->region
1817 ? after
->region
->name_list
.name
1818 : DEFAULT_MEMORY_REGION
);
1819 const char *lma_region
= (after
->lma_region
1820 ? after
->lma_region
->name_list
.name
1822 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1826 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1829 if (ps
!= NULL
&& *ps
== '\0')
1833 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__stop_" + 1);
1834 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1835 sprintf (symname
+ (symname
[0] != 0), "__stop_%s", secname
);
1836 lang_add_assignment (exp_provide (symname
,
1837 exp_nameop (NAME
, "."),
1841 /* Restore the global list pointer. */
1845 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1847 asection
*snew
, *as
;
1849 snew
= os
->bfd_section
;
1851 /* Shuffle the bfd section list to make the output file look
1852 neater. This is really only cosmetic. */
1853 if (place
->section
== NULL
1854 && after
!= (&lang_output_section_statement
.head
1855 ->output_section_statement
))
1857 asection
*bfd_section
= after
->bfd_section
;
1859 /* If the output statement hasn't been used to place any input
1860 sections (and thus doesn't have an output bfd_section),
1861 look for the closest prior output statement having an
1863 if (bfd_section
== NULL
)
1864 bfd_section
= output_prev_sec_find (after
);
1866 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1867 place
->section
= &bfd_section
->next
;
1870 if (place
->section
== NULL
)
1871 place
->section
= &link_info
.output_bfd
->sections
;
1873 as
= *place
->section
;
1877 /* Put the section at the end of the list. */
1879 /* Unlink the section. */
1880 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1882 /* Now tack it back on in the right place. */
1883 bfd_section_list_append (link_info
.output_bfd
, snew
);
1885 else if (as
!= snew
&& as
->prev
!= snew
)
1887 /* Unlink the section. */
1888 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1890 /* Now tack it back on in the right place. */
1891 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
1894 /* Save the end of this list. Further ophans of this type will
1895 follow the one we've just added. */
1896 place
->section
= &snew
->next
;
1898 /* The following is non-cosmetic. We try to put the output
1899 statements in some sort of reasonable order here, because they
1900 determine the final load addresses of the orphan sections.
1901 In addition, placing output statements in the wrong order may
1902 require extra segments. For instance, given a typical
1903 situation of all read-only sections placed in one segment and
1904 following that a segment containing all the read-write
1905 sections, we wouldn't want to place an orphan read/write
1906 section before or amongst the read-only ones. */
1907 if (add
.head
!= NULL
)
1909 lang_output_section_statement_type
*newly_added_os
;
1911 if (place
->stmt
== NULL
)
1913 lang_statement_union_type
**where
= insert_os_after (after
);
1918 place
->os_tail
= &after
->next
;
1922 /* Put it after the last orphan statement we added. */
1923 *add
.tail
= *place
->stmt
;
1924 *place
->stmt
= add
.head
;
1927 /* Fix the global list pointer if we happened to tack our
1928 new list at the tail. */
1929 if (*stat_ptr
->tail
== add
.head
)
1930 stat_ptr
->tail
= add
.tail
;
1932 /* Save the end of this list. */
1933 place
->stmt
= add
.tail
;
1935 /* Do the same for the list of output section statements. */
1936 newly_added_os
= *os_tail
;
1938 newly_added_os
->prev
= (lang_output_section_statement_type
*)
1939 ((char *) place
->os_tail
1940 - offsetof (lang_output_section_statement_type
, next
));
1941 newly_added_os
->next
= *place
->os_tail
;
1942 if (newly_added_os
->next
!= NULL
)
1943 newly_added_os
->next
->prev
= newly_added_os
;
1944 *place
->os_tail
= newly_added_os
;
1945 place
->os_tail
= &newly_added_os
->next
;
1947 /* Fixing the global list pointer here is a little different.
1948 We added to the list in lang_enter_output_section_statement,
1949 trimmed off the new output_section_statment above when
1950 assigning *os_tail = NULL, but possibly added it back in
1951 the same place when assigning *place->os_tail. */
1952 if (*os_tail
== NULL
)
1953 lang_output_section_statement
.tail
1954 = (lang_statement_union_type
**) os_tail
;
1961 lang_map_flags (flagword flag
)
1963 if (flag
& SEC_ALLOC
)
1966 if (flag
& SEC_CODE
)
1969 if (flag
& SEC_READONLY
)
1972 if (flag
& SEC_DATA
)
1975 if (flag
& SEC_LOAD
)
1982 lang_memory_region_type
*m
;
1983 bfd_boolean dis_header_printed
= FALSE
;
1986 LANG_FOR_EACH_INPUT_STATEMENT (file
)
1990 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
1991 || file
->flags
.just_syms
)
1994 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
1995 if ((s
->output_section
== NULL
1996 || s
->output_section
->owner
!= link_info
.output_bfd
)
1997 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
1999 if (! dis_header_printed
)
2001 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2002 dis_header_printed
= TRUE
;
2005 print_input_section (s
, TRUE
);
2009 minfo (_("\nMemory Configuration\n\n"));
2010 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2011 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2013 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2018 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2020 sprintf_vma (buf
, m
->origin
);
2021 minfo ("0x%s ", buf
);
2029 minfo ("0x%V", m
->length
);
2030 if (m
->flags
|| m
->not_flags
)
2038 lang_map_flags (m
->flags
);
2044 lang_map_flags (m
->not_flags
);
2051 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2053 if (! link_info
.reduce_memory_overheads
)
2055 obstack_begin (&map_obstack
, 1000);
2056 for (p
= link_info
.input_bfds
; p
!= (bfd
*) NULL
; p
= p
->link_next
)
2057 bfd_map_over_sections (p
, init_map_userdata
, 0);
2058 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2060 lang_statement_iteration
++;
2061 print_statements ();
2065 init_map_userdata (bfd
*abfd ATTRIBUTE_UNUSED
,
2067 void *data ATTRIBUTE_UNUSED
)
2069 fat_section_userdata_type
*new_data
2070 = ((fat_section_userdata_type
*) (stat_alloc
2071 (sizeof (fat_section_userdata_type
))));
2073 ASSERT (get_userdata (sec
) == NULL
);
2074 get_userdata (sec
) = new_data
;
2075 new_data
->map_symbol_def_tail
= &new_data
->map_symbol_def_head
;
2076 new_data
->map_symbol_def_count
= 0;
2080 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2081 void *info ATTRIBUTE_UNUSED
)
2083 if (hash_entry
->type
== bfd_link_hash_defined
2084 || hash_entry
->type
== bfd_link_hash_defweak
)
2086 struct fat_user_section_struct
*ud
;
2087 struct map_symbol_def
*def
;
2089 ud
= (struct fat_user_section_struct
*)
2090 get_userdata (hash_entry
->u
.def
.section
);
2093 /* ??? What do we have to do to initialize this beforehand? */
2094 /* The first time we get here is bfd_abs_section... */
2095 init_map_userdata (0, hash_entry
->u
.def
.section
, 0);
2096 ud
= (struct fat_user_section_struct
*)
2097 get_userdata (hash_entry
->u
.def
.section
);
2099 else if (!ud
->map_symbol_def_tail
)
2100 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2102 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2103 def
->entry
= hash_entry
;
2104 *(ud
->map_symbol_def_tail
) = def
;
2105 ud
->map_symbol_def_tail
= &def
->next
;
2106 ud
->map_symbol_def_count
++;
2111 /* Initialize an output section. */
2114 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2116 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2117 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2119 if (s
->constraint
!= SPECIAL
)
2120 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2121 if (s
->bfd_section
== NULL
)
2122 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2124 if (s
->bfd_section
== NULL
)
2126 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2127 link_info
.output_bfd
->xvec
->name
, s
->name
);
2129 s
->bfd_section
->output_section
= s
->bfd_section
;
2130 s
->bfd_section
->output_offset
= 0;
2132 if (!link_info
.reduce_memory_overheads
)
2134 fat_section_userdata_type
*new_userdata
= (fat_section_userdata_type
*)
2135 stat_alloc (sizeof (fat_section_userdata_type
));
2136 memset (new_userdata
, 0, sizeof (fat_section_userdata_type
));
2137 get_userdata (s
->bfd_section
) = new_userdata
;
2140 /* If there is a base address, make sure that any sections it might
2141 mention are initialized. */
2142 if (s
->addr_tree
!= NULL
)
2143 exp_init_os (s
->addr_tree
);
2145 if (s
->load_base
!= NULL
)
2146 exp_init_os (s
->load_base
);
2148 /* If supplied an alignment, set it. */
2149 if (s
->section_alignment
!= -1)
2150 s
->bfd_section
->alignment_power
= s
->section_alignment
;
2153 /* Make sure that all output sections mentioned in an expression are
2157 exp_init_os (etree_type
*exp
)
2159 switch (exp
->type
.node_class
)
2163 exp_init_os (exp
->assign
.src
);
2167 exp_init_os (exp
->binary
.lhs
);
2168 exp_init_os (exp
->binary
.rhs
);
2172 exp_init_os (exp
->trinary
.cond
);
2173 exp_init_os (exp
->trinary
.lhs
);
2174 exp_init_os (exp
->trinary
.rhs
);
2178 exp_init_os (exp
->assert_s
.child
);
2182 exp_init_os (exp
->unary
.child
);
2186 switch (exp
->type
.node_code
)
2192 lang_output_section_statement_type
*os
;
2194 os
= lang_output_section_find (exp
->name
.name
);
2195 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2207 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2209 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2211 /* If we are only reading symbols from this object, then we want to
2212 discard all sections. */
2213 if (entry
->flags
.just_syms
)
2215 bfd_link_just_syms (abfd
, sec
, &link_info
);
2219 if (!(abfd
->flags
& DYNAMIC
))
2220 bfd_section_already_linked (abfd
, sec
, &link_info
);
2223 /* The wild routines.
2225 These expand statements like *(.text) and foo.o to a list of
2226 explicit actions, like foo.o(.text), bar.o(.text) and
2227 foo.o(.text, .data). */
2229 /* Add SECTION to the output section OUTPUT. Do this by creating a
2230 lang_input_section statement which is placed at PTR. FILE is the
2231 input file which holds SECTION. */
2234 lang_add_section (lang_statement_list_type
*ptr
,
2236 lang_output_section_statement_type
*output
)
2238 flagword flags
= section
->flags
;
2239 struct flag_info
*sflag_info
= section
->section_flag_info
;
2241 bfd_boolean discard
;
2242 lang_input_section_type
*new_section
;
2243 bfd
*abfd
= link_info
.output_bfd
;
2245 /* Discard sections marked with SEC_EXCLUDE. */
2246 discard
= (flags
& SEC_EXCLUDE
) != 0;
2248 /* Discard input sections which are assigned to a section named
2249 DISCARD_SECTION_NAME. */
2250 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2253 /* Discard debugging sections if we are stripping debugging
2255 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2256 && (flags
& SEC_DEBUGGING
) != 0)
2261 if (section
->output_section
== NULL
)
2263 /* This prevents future calls from assigning this section. */
2264 section
->output_section
= bfd_abs_section_ptr
;
2271 if (sflag_info
->flags_initialized
== FALSE
)
2272 bfd_lookup_section_flags (&link_info
, sflag_info
);
2274 if (sflag_info
->only_with_flags
!= 0
2275 && sflag_info
->not_with_flags
!= 0
2276 && ((sflag_info
->not_with_flags
& flags
) != 0
2277 || (sflag_info
->only_with_flags
& flags
)
2278 != sflag_info
->only_with_flags
))
2281 if (sflag_info
->only_with_flags
!= 0
2282 && (sflag_info
->only_with_flags
& flags
)
2283 != sflag_info
->only_with_flags
)
2286 if (sflag_info
->not_with_flags
!= 0
2287 && (sflag_info
->not_with_flags
& flags
) != 0)
2291 if (section
->output_section
!= NULL
)
2294 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2295 to an output section, because we want to be able to include a
2296 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2297 section (I don't know why we want to do this, but we do).
2298 build_link_order in ldwrite.c handles this case by turning
2299 the embedded SEC_NEVER_LOAD section into a fill. */
2300 flags
&= ~ SEC_NEVER_LOAD
;
2302 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2303 already been processed. One reason to do this is that on pe
2304 format targets, .text$foo sections go into .text and it's odd
2305 to see .text with SEC_LINK_ONCE set. */
2307 if (!link_info
.relocatable
)
2308 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2310 switch (output
->sectype
)
2312 case normal_section
:
2313 case overlay_section
:
2315 case noalloc_section
:
2316 flags
&= ~SEC_ALLOC
;
2318 case noload_section
:
2320 flags
|= SEC_NEVER_LOAD
;
2321 /* Unfortunately GNU ld has managed to evolve two different
2322 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2323 alloc, no contents section. All others get a noload, noalloc
2325 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2326 flags
&= ~SEC_HAS_CONTENTS
;
2328 flags
&= ~SEC_ALLOC
;
2332 if (output
->bfd_section
== NULL
)
2333 init_os (output
, flags
);
2335 /* If SEC_READONLY is not set in the input section, then clear
2336 it from the output section. */
2337 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2339 if (output
->bfd_section
->linker_has_input
)
2341 /* Only set SEC_READONLY flag on the first input section. */
2342 flags
&= ~ SEC_READONLY
;
2344 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2345 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2346 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2347 || ((flags
& SEC_MERGE
) != 0
2348 && output
->bfd_section
->entsize
!= section
->entsize
))
2350 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2351 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2354 output
->bfd_section
->flags
|= flags
;
2356 if (!output
->bfd_section
->linker_has_input
)
2358 output
->bfd_section
->linker_has_input
= 1;
2359 /* This must happen after flags have been updated. The output
2360 section may have been created before we saw its first input
2361 section, eg. for a data statement. */
2362 bfd_init_private_section_data (section
->owner
, section
,
2363 link_info
.output_bfd
,
2364 output
->bfd_section
,
2366 if ((flags
& SEC_MERGE
) != 0)
2367 output
->bfd_section
->entsize
= section
->entsize
;
2370 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2371 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2373 /* FIXME: This value should really be obtained from the bfd... */
2374 output
->block_value
= 128;
2377 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2378 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2380 section
->output_section
= output
->bfd_section
;
2382 if (!link_info
.relocatable
2383 && !stripped_excluded_sections
)
2385 asection
*s
= output
->bfd_section
->map_tail
.s
;
2386 output
->bfd_section
->map_tail
.s
= section
;
2387 section
->map_head
.s
= NULL
;
2388 section
->map_tail
.s
= s
;
2390 s
->map_head
.s
= section
;
2392 output
->bfd_section
->map_head
.s
= section
;
2395 /* Add a section reference to the list. */
2396 new_section
= new_stat (lang_input_section
, ptr
);
2397 new_section
->section
= section
;
2400 /* Handle wildcard sorting. This returns the lang_input_section which
2401 should follow the one we are going to create for SECTION and FILE,
2402 based on the sorting requirements of WILD. It returns NULL if the
2403 new section should just go at the end of the current list. */
2405 static lang_statement_union_type
*
2406 wild_sort (lang_wild_statement_type
*wild
,
2407 struct wildcard_list
*sec
,
2408 lang_input_statement_type
*file
,
2411 lang_statement_union_type
*l
;
2413 if (!wild
->filenames_sorted
2414 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2417 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2419 lang_input_section_type
*ls
;
2421 if (l
->header
.type
!= lang_input_section_enum
)
2423 ls
= &l
->input_section
;
2425 /* Sorting by filename takes precedence over sorting by section
2428 if (wild
->filenames_sorted
)
2430 const char *fn
, *ln
;
2434 /* The PE support for the .idata section as generated by
2435 dlltool assumes that files will be sorted by the name of
2436 the archive and then the name of the file within the
2439 if (file
->the_bfd
!= NULL
2440 && bfd_my_archive (file
->the_bfd
) != NULL
)
2442 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
2447 fn
= file
->filename
;
2451 if (bfd_my_archive (ls
->section
->owner
) != NULL
)
2453 ln
= bfd_get_filename (bfd_my_archive (ls
->section
->owner
));
2458 ln
= ls
->section
->owner
->filename
;
2462 i
= filename_cmp (fn
, ln
);
2471 fn
= file
->filename
;
2473 ln
= ls
->section
->owner
->filename
;
2475 i
= filename_cmp (fn
, ln
);
2483 /* Here either the files are not sorted by name, or we are
2484 looking at the sections for this file. */
2486 if (sec
!= NULL
&& sec
->spec
.sorted
!= none
)
2487 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2494 /* Expand a wild statement for a particular FILE. SECTION may be
2495 NULL, in which case it is a wild card. */
2498 output_section_callback (lang_wild_statement_type
*ptr
,
2499 struct wildcard_list
*sec
,
2501 lang_input_statement_type
*file
,
2504 lang_statement_union_type
*before
;
2505 lang_output_section_statement_type
*os
;
2507 os
= (lang_output_section_statement_type
*) output
;
2509 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2510 if (unique_section_p (section
, os
))
2513 before
= wild_sort (ptr
, sec
, file
, section
);
2515 /* Here BEFORE points to the lang_input_section which
2516 should follow the one we are about to add. If BEFORE
2517 is NULL, then the section should just go at the end
2518 of the current list. */
2521 lang_add_section (&ptr
->children
, section
, os
);
2524 lang_statement_list_type list
;
2525 lang_statement_union_type
**pp
;
2527 lang_list_init (&list
);
2528 lang_add_section (&list
, section
, os
);
2530 /* If we are discarding the section, LIST.HEAD will
2532 if (list
.head
!= NULL
)
2534 ASSERT (list
.head
->header
.next
== NULL
);
2536 for (pp
= &ptr
->children
.head
;
2538 pp
= &(*pp
)->header
.next
)
2539 ASSERT (*pp
!= NULL
);
2541 list
.head
->header
.next
= *pp
;
2547 /* Check if all sections in a wild statement for a particular FILE
2551 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2552 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2554 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2557 lang_output_section_statement_type
*os
;
2559 os
= (lang_output_section_statement_type
*) output
;
2561 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2562 if (unique_section_p (section
, os
))
2565 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2566 os
->all_input_readonly
= FALSE
;
2569 /* This is passed a file name which must have been seen already and
2570 added to the statement tree. We will see if it has been opened
2571 already and had its symbols read. If not then we'll read it. */
2573 static lang_input_statement_type
*
2574 lookup_name (const char *name
)
2576 lang_input_statement_type
*search
;
2578 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2580 search
= (lang_input_statement_type
*) search
->next_real_file
)
2582 /* Use the local_sym_name as the name of the file that has
2583 already been loaded as filename might have been transformed
2584 via the search directory lookup mechanism. */
2585 const char *filename
= search
->local_sym_name
;
2587 if (filename
!= NULL
2588 && filename_cmp (filename
, name
) == 0)
2593 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2594 default_target
, FALSE
);
2596 /* If we have already added this file, or this file is not real
2597 don't add this file. */
2598 if (search
->flags
.loaded
|| !search
->flags
.real
)
2601 if (! load_symbols (search
, NULL
))
2607 /* Save LIST as a list of libraries whose symbols should not be exported. */
2612 struct excluded_lib
*next
;
2614 static struct excluded_lib
*excluded_libs
;
2617 add_excluded_libs (const char *list
)
2619 const char *p
= list
, *end
;
2623 struct excluded_lib
*entry
;
2624 end
= strpbrk (p
, ",:");
2626 end
= p
+ strlen (p
);
2627 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2628 entry
->next
= excluded_libs
;
2629 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2630 memcpy (entry
->name
, p
, end
- p
);
2631 entry
->name
[end
- p
] = '\0';
2632 excluded_libs
= entry
;
2640 check_excluded_libs (bfd
*abfd
)
2642 struct excluded_lib
*lib
= excluded_libs
;
2646 int len
= strlen (lib
->name
);
2647 const char *filename
= lbasename (abfd
->filename
);
2649 if (strcmp (lib
->name
, "ALL") == 0)
2651 abfd
->no_export
= TRUE
;
2655 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2656 && (filename
[len
] == '\0'
2657 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2658 && filename
[len
+ 2] == '\0')))
2660 abfd
->no_export
= TRUE
;
2668 /* Get the symbols for an input file. */
2671 load_symbols (lang_input_statement_type
*entry
,
2672 lang_statement_list_type
*place
)
2676 if (entry
->flags
.loaded
)
2679 ldfile_open_file (entry
);
2681 /* Do not process further if the file was missing. */
2682 if (entry
->flags
.missing_file
)
2685 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
2686 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2689 struct lang_input_statement_flags save_flags
;
2691 err
= bfd_get_error ();
2693 /* See if the emulation has some special knowledge. */
2694 if (ldemul_unrecognized_file (entry
))
2697 if (err
== bfd_error_file_ambiguously_recognized
)
2701 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
2702 einfo (_("%B: matching formats:"), entry
->the_bfd
);
2703 for (p
= matching
; *p
!= NULL
; p
++)
2707 else if (err
!= bfd_error_file_not_recognized
2709 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
2711 bfd_close (entry
->the_bfd
);
2712 entry
->the_bfd
= NULL
;
2714 /* Try to interpret the file as a linker script. */
2715 save_flags
= input_flags
;
2716 ldfile_open_command_file (entry
->filename
);
2718 push_stat_ptr (place
);
2719 input_flags
.sysrooted
= entry
->flags
.sysrooted
;
2720 input_flags
.add_DT_NEEDED_for_regular
2721 = entry
->flags
.add_DT_NEEDED_for_regular
;
2722 input_flags
.add_DT_NEEDED_for_dynamic
2723 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
2724 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
2725 input_flags
.dynamic
= entry
->flags
.dynamic
;
2727 ldfile_assumed_script
= TRUE
;
2728 parser_input
= input_script
;
2730 ldfile_assumed_script
= FALSE
;
2732 /* missing_file is sticky. */
2733 save_flags
.missing_file
|= input_flags
.missing_file
;
2734 input_flags
= save_flags
;
2740 if (ldemul_recognized_file (entry
))
2743 /* We don't call ldlang_add_file for an archive. Instead, the
2744 add_symbols entry point will call ldlang_add_file, via the
2745 add_archive_element callback, for each element of the archive
2747 switch (bfd_get_format (entry
->the_bfd
))
2753 #ifdef ENABLE_PLUGINS
2754 if (!entry
->flags
.reload
)
2756 ldlang_add_file (entry
);
2757 if (trace_files
|| trace_file_tries
)
2758 info_msg ("%I\n", entry
);
2762 check_excluded_libs (entry
->the_bfd
);
2764 if (entry
->flags
.whole_archive
)
2767 bfd_boolean loaded
= TRUE
;
2772 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
2777 if (! bfd_check_format (member
, bfd_object
))
2779 einfo (_("%F%B: member %B in archive is not an object\n"),
2780 entry
->the_bfd
, member
);
2785 if (!(*link_info
.callbacks
2786 ->add_archive_element
) (&link_info
, member
,
2787 "--whole-archive", &subsbfd
))
2790 /* Potentially, the add_archive_element hook may have set a
2791 substitute BFD for us. */
2792 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
2794 einfo (_("%F%B: could not read symbols: %E\n"), member
);
2799 entry
->flags
.loaded
= loaded
;
2805 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
2806 entry
->flags
.loaded
= TRUE
;
2808 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
2810 return entry
->flags
.loaded
;
2813 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2814 may be NULL, indicating that it is a wildcard. Separate
2815 lang_input_section statements are created for each part of the
2816 expansion; they are added after the wild statement S. OUTPUT is
2817 the output section. */
2820 wild (lang_wild_statement_type
*s
,
2821 const char *target ATTRIBUTE_UNUSED
,
2822 lang_output_section_statement_type
*output
)
2824 struct wildcard_list
*sec
;
2826 if (s
->handler_data
[0]
2827 && s
->handler_data
[0]->spec
.sorted
== by_name
2828 && !s
->filenames_sorted
)
2830 lang_section_bst_type
*tree
;
2832 walk_wild (s
, output_section_callback_fast
, output
);
2837 output_section_callback_tree_to_list (s
, tree
, output
);
2842 walk_wild (s
, output_section_callback
, output
);
2844 if (default_common_section
== NULL
)
2845 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
2846 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
2848 /* Remember the section that common is going to in case we
2849 later get something which doesn't know where to put it. */
2850 default_common_section
= output
;
2855 /* Return TRUE iff target is the sought target. */
2858 get_target (const bfd_target
*target
, void *data
)
2860 const char *sought
= (const char *) data
;
2862 return strcmp (target
->name
, sought
) == 0;
2865 /* Like strcpy() but convert to lower case as well. */
2868 stricpy (char *dest
, char *src
)
2872 while ((c
= *src
++) != 0)
2873 *dest
++ = TOLOWER (c
);
2878 /* Remove the first occurrence of needle (if any) in haystack
2882 strcut (char *haystack
, char *needle
)
2884 haystack
= strstr (haystack
, needle
);
2890 for (src
= haystack
+ strlen (needle
); *src
;)
2891 *haystack
++ = *src
++;
2897 /* Compare two target format name strings.
2898 Return a value indicating how "similar" they are. */
2901 name_compare (char *first
, char *second
)
2907 copy1
= (char *) xmalloc (strlen (first
) + 1);
2908 copy2
= (char *) xmalloc (strlen (second
) + 1);
2910 /* Convert the names to lower case. */
2911 stricpy (copy1
, first
);
2912 stricpy (copy2
, second
);
2914 /* Remove size and endian strings from the name. */
2915 strcut (copy1
, "big");
2916 strcut (copy1
, "little");
2917 strcut (copy2
, "big");
2918 strcut (copy2
, "little");
2920 /* Return a value based on how many characters match,
2921 starting from the beginning. If both strings are
2922 the same then return 10 * their length. */
2923 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
2924 if (copy1
[result
] == 0)
2936 /* Set by closest_target_match() below. */
2937 static const bfd_target
*winner
;
2939 /* Scan all the valid bfd targets looking for one that has the endianness
2940 requirement that was specified on the command line, and is the nearest
2941 match to the original output target. */
2944 closest_target_match (const bfd_target
*target
, void *data
)
2946 const bfd_target
*original
= (const bfd_target
*) data
;
2948 if (command_line
.endian
== ENDIAN_BIG
2949 && target
->byteorder
!= BFD_ENDIAN_BIG
)
2952 if (command_line
.endian
== ENDIAN_LITTLE
2953 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
2956 /* Must be the same flavour. */
2957 if (target
->flavour
!= original
->flavour
)
2960 /* Ignore generic big and little endian elf vectors. */
2961 if (strcmp (target
->name
, "elf32-big") == 0
2962 || strcmp (target
->name
, "elf64-big") == 0
2963 || strcmp (target
->name
, "elf32-little") == 0
2964 || strcmp (target
->name
, "elf64-little") == 0)
2967 /* If we have not found a potential winner yet, then record this one. */
2974 /* Oh dear, we now have two potential candidates for a successful match.
2975 Compare their names and choose the better one. */
2976 if (name_compare (target
->name
, original
->name
)
2977 > name_compare (winner
->name
, original
->name
))
2980 /* Keep on searching until wqe have checked them all. */
2984 /* Return the BFD target format of the first input file. */
2987 get_first_input_target (void)
2989 char *target
= NULL
;
2991 LANG_FOR_EACH_INPUT_STATEMENT (s
)
2993 if (s
->header
.type
== lang_input_statement_enum
2996 ldfile_open_file (s
);
2998 if (s
->the_bfd
!= NULL
2999 && bfd_check_format (s
->the_bfd
, bfd_object
))
3001 target
= bfd_get_target (s
->the_bfd
);
3013 lang_get_output_target (void)
3017 /* Has the user told us which output format to use? */
3018 if (output_target
!= NULL
)
3019 return output_target
;
3021 /* No - has the current target been set to something other than
3023 if (current_target
!= default_target
&& current_target
!= NULL
)
3024 return current_target
;
3026 /* No - can we determine the format of the first input file? */
3027 target
= get_first_input_target ();
3031 /* Failed - use the default output target. */
3032 return default_target
;
3035 /* Open the output file. */
3038 open_output (const char *name
)
3040 output_target
= lang_get_output_target ();
3042 /* Has the user requested a particular endianness on the command
3044 if (command_line
.endian
!= ENDIAN_UNSET
)
3046 const bfd_target
*target
;
3047 enum bfd_endian desired_endian
;
3049 /* Get the chosen target. */
3050 target
= bfd_search_for_target (get_target
, (void *) output_target
);
3052 /* If the target is not supported, we cannot do anything. */
3055 if (command_line
.endian
== ENDIAN_BIG
)
3056 desired_endian
= BFD_ENDIAN_BIG
;
3058 desired_endian
= BFD_ENDIAN_LITTLE
;
3060 /* See if the target has the wrong endianness. This should
3061 not happen if the linker script has provided big and
3062 little endian alternatives, but some scrips don't do
3064 if (target
->byteorder
!= desired_endian
)
3066 /* If it does, then see if the target provides
3067 an alternative with the correct endianness. */
3068 if (target
->alternative_target
!= NULL
3069 && (target
->alternative_target
->byteorder
== desired_endian
))
3070 output_target
= target
->alternative_target
->name
;
3073 /* Try to find a target as similar as possible to
3074 the default target, but which has the desired
3075 endian characteristic. */
3076 bfd_search_for_target (closest_target_match
,
3079 /* Oh dear - we could not find any targets that
3080 satisfy our requirements. */
3082 einfo (_("%P: warning: could not find any targets"
3083 " that match endianness requirement\n"));
3085 output_target
= winner
->name
;
3091 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3093 if (link_info
.output_bfd
== NULL
)
3095 if (bfd_get_error () == bfd_error_invalid_target
)
3096 einfo (_("%P%F: target %s not found\n"), output_target
);
3098 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
3101 delete_output_file_on_failure
= TRUE
;
3103 if (! bfd_set_format (link_info
.output_bfd
, bfd_object
))
3104 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
3105 if (! bfd_set_arch_mach (link_info
.output_bfd
,
3106 ldfile_output_architecture
,
3107 ldfile_output_machine
))
3108 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
3110 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3111 if (link_info
.hash
== NULL
)
3112 einfo (_("%P%F: can not create hash table: %E\n"));
3114 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3118 ldlang_open_output (lang_statement_union_type
*statement
)
3120 switch (statement
->header
.type
)
3122 case lang_output_statement_enum
:
3123 ASSERT (link_info
.output_bfd
== NULL
);
3124 open_output (statement
->output_statement
.name
);
3125 ldemul_set_output_arch ();
3126 if (config
.magic_demand_paged
&& !link_info
.relocatable
)
3127 link_info
.output_bfd
->flags
|= D_PAGED
;
3129 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3130 if (config
.text_read_only
)
3131 link_info
.output_bfd
->flags
|= WP_TEXT
;
3133 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3134 if (link_info
.traditional_format
)
3135 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3137 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3140 case lang_target_statement_enum
:
3141 current_target
= statement
->target_statement
.target
;
3148 /* Convert between addresses in bytes and sizes in octets.
3149 For currently supported targets, octets_per_byte is always a power
3150 of two, so we can use shifts. */
3151 #define TO_ADDR(X) ((X) >> opb_shift)
3152 #define TO_SIZE(X) ((X) << opb_shift)
3154 /* Support the above. */
3155 static unsigned int opb_shift
= 0;
3160 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3161 ldfile_output_machine
);
3164 while ((x
& 1) == 0)
3172 /* Open all the input files. */
3176 OPEN_BFD_NORMAL
= 0,
3180 #ifdef ENABLE_PLUGINS
3181 static lang_input_statement_type
*plugin_insert
= NULL
;
3185 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3187 for (; s
!= NULL
; s
= s
->header
.next
)
3189 switch (s
->header
.type
)
3191 case lang_constructors_statement_enum
:
3192 open_input_bfds (constructor_list
.head
, mode
);
3194 case lang_output_section_statement_enum
:
3195 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3197 case lang_wild_statement_enum
:
3198 /* Maybe we should load the file's symbols. */
3199 if ((mode
& OPEN_BFD_RESCAN
) == 0
3200 && s
->wild_statement
.filename
3201 && !wildcardp (s
->wild_statement
.filename
)
3202 && !archive_path (s
->wild_statement
.filename
))
3203 lookup_name (s
->wild_statement
.filename
);
3204 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3206 case lang_group_statement_enum
:
3208 struct bfd_link_hash_entry
*undefs
;
3210 /* We must continually search the entries in the group
3211 until no new symbols are added to the list of undefined
3216 undefs
= link_info
.hash
->undefs_tail
;
3217 open_input_bfds (s
->group_statement
.children
.head
,
3218 mode
| OPEN_BFD_FORCE
);
3220 while (undefs
!= link_info
.hash
->undefs_tail
);
3223 case lang_target_statement_enum
:
3224 current_target
= s
->target_statement
.target
;
3226 case lang_input_statement_enum
:
3227 if (s
->input_statement
.flags
.real
)
3229 lang_statement_union_type
**os_tail
;
3230 lang_statement_list_type add
;
3232 s
->input_statement
.target
= current_target
;
3234 /* If we are being called from within a group, and this
3235 is an archive which has already been searched, then
3236 force it to be researched unless the whole archive
3237 has been loaded already. Do the same for a rescan. */
3238 if (mode
!= OPEN_BFD_NORMAL
3239 #ifdef ENABLE_PLUGINS
3240 && ((mode
& OPEN_BFD_RESCAN
) == 0
3241 || plugin_insert
== NULL
)
3243 && !s
->input_statement
.flags
.whole_archive
3244 && s
->input_statement
.flags
.loaded
3245 && bfd_check_format (s
->input_statement
.the_bfd
,
3247 s
->input_statement
.flags
.loaded
= FALSE
;
3248 #ifdef ENABLE_PLUGINS
3249 /* When rescanning, reload --as-needed shared libs. */
3250 else if ((mode
& OPEN_BFD_RESCAN
) != 0
3251 && plugin_insert
== NULL
3252 && s
->input_statement
.flags
.loaded
3253 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3254 && ((s
->input_statement
.the_bfd
->flags
) & DYNAMIC
) != 0
3255 && plugin_should_reload (s
->input_statement
.the_bfd
))
3257 s
->input_statement
.flags
.loaded
= FALSE
;
3258 s
->input_statement
.flags
.reload
= TRUE
;
3262 os_tail
= lang_output_section_statement
.tail
;
3263 lang_list_init (&add
);
3265 if (! load_symbols (&s
->input_statement
, &add
))
3266 config
.make_executable
= FALSE
;
3268 if (add
.head
!= NULL
)
3270 /* If this was a script with output sections then
3271 tack any added statements on to the end of the
3272 list. This avoids having to reorder the output
3273 section statement list. Very likely the user
3274 forgot -T, and whatever we do here will not meet
3275 naive user expectations. */
3276 if (os_tail
!= lang_output_section_statement
.tail
)
3278 einfo (_("%P: warning: %s contains output sections;"
3279 " did you forget -T?\n"),
3280 s
->input_statement
.filename
);
3281 *stat_ptr
->tail
= add
.head
;
3282 stat_ptr
->tail
= add
.tail
;
3286 *add
.tail
= s
->header
.next
;
3287 s
->header
.next
= add
.head
;
3291 #ifdef ENABLE_PLUGINS
3292 /* If we have found the point at which a plugin added new
3293 files, clear plugin_insert to enable archive rescan. */
3294 if (&s
->input_statement
== plugin_insert
)
3295 plugin_insert
= NULL
;
3298 case lang_assignment_statement_enum
:
3299 if (s
->assignment_statement
.exp
->assign
.hidden
)
3300 /* This is from a --defsym on the command line. */
3301 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3308 /* Exit if any of the files were missing. */
3309 if (input_flags
.missing_file
)
3313 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
3316 lang_track_definedness (const char *name
)
3318 if (bfd_hash_lookup (&lang_definedness_table
, name
, TRUE
, FALSE
) == NULL
)
3319 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
3322 /* New-function for the definedness hash table. */
3324 static struct bfd_hash_entry
*
3325 lang_definedness_newfunc (struct bfd_hash_entry
*entry
,
3326 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
3327 const char *name ATTRIBUTE_UNUSED
)
3329 struct lang_definedness_hash_entry
*ret
3330 = (struct lang_definedness_hash_entry
*) entry
;
3333 ret
= (struct lang_definedness_hash_entry
*)
3334 bfd_hash_allocate (table
, sizeof (struct lang_definedness_hash_entry
));
3337 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
3339 ret
->iteration
= -1;
3343 /* Return the iteration when the definition of NAME was last updated. A
3344 value of -1 means that the symbol is not defined in the linker script
3345 or the command line, but may be defined in the linker symbol table. */
3348 lang_symbol_definition_iteration (const char *name
)
3350 struct lang_definedness_hash_entry
*defentry
3351 = (struct lang_definedness_hash_entry
*)
3352 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
3354 /* We've already created this one on the presence of DEFINED in the
3355 script, so it can't be NULL unless something is borked elsewhere in
3357 if (defentry
== NULL
)
3360 return defentry
->iteration
;
3363 /* Update the definedness state of NAME. */
3366 lang_update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
3368 struct lang_definedness_hash_entry
*defentry
3369 = (struct lang_definedness_hash_entry
*)
3370 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
3372 /* We don't keep track of symbols not tested with DEFINED. */
3373 if (defentry
== NULL
)
3376 /* If the symbol was already defined, and not from an earlier statement
3377 iteration, don't update the definedness iteration, because that'd
3378 make the symbol seem defined in the linker script at this point, and
3379 it wasn't; it was defined in some object. If we do anyway, DEFINED
3380 would start to yield false before this point and the construct "sym =
3381 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3383 if (h
->type
!= bfd_link_hash_undefined
3384 && h
->type
!= bfd_link_hash_common
3385 && h
->type
!= bfd_link_hash_new
3386 && defentry
->iteration
== -1)
3389 defentry
->iteration
= lang_statement_iteration
;
3392 /* Add the supplied name to the symbol table as an undefined reference.
3393 This is a two step process as the symbol table doesn't even exist at
3394 the time the ld command line is processed. First we put the name
3395 on a list, then, once the output file has been opened, transfer the
3396 name to the symbol table. */
3398 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3400 #define ldlang_undef_chain_list_head entry_symbol.next
3403 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3405 ldlang_undef_chain_list_type
*new_undef
;
3407 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3408 new_undef
= (ldlang_undef_chain_list_type
*) stat_alloc (sizeof (*new_undef
));
3409 new_undef
->next
= ldlang_undef_chain_list_head
;
3410 ldlang_undef_chain_list_head
= new_undef
;
3412 new_undef
->name
= xstrdup (name
);
3414 if (link_info
.output_bfd
!= NULL
)
3415 insert_undefined (new_undef
->name
);
3418 /* Insert NAME as undefined in the symbol table. */
3421 insert_undefined (const char *name
)
3423 struct bfd_link_hash_entry
*h
;
3425 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3427 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3428 if (h
->type
== bfd_link_hash_new
)
3430 h
->type
= bfd_link_hash_undefined
;
3431 h
->u
.undef
.abfd
= NULL
;
3432 bfd_link_add_undef (link_info
.hash
, h
);
3436 /* Run through the list of undefineds created above and place them
3437 into the linker hash table as undefined symbols belonging to the
3441 lang_place_undefineds (void)
3443 ldlang_undef_chain_list_type
*ptr
;
3445 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3446 insert_undefined (ptr
->name
);
3449 /* Check for all readonly or some readwrite sections. */
3452 check_input_sections
3453 (lang_statement_union_type
*s
,
3454 lang_output_section_statement_type
*output_section_statement
)
3456 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3458 switch (s
->header
.type
)
3460 case lang_wild_statement_enum
:
3461 walk_wild (&s
->wild_statement
, check_section_callback
,
3462 output_section_statement
);
3463 if (! output_section_statement
->all_input_readonly
)
3466 case lang_constructors_statement_enum
:
3467 check_input_sections (constructor_list
.head
,
3468 output_section_statement
);
3469 if (! output_section_statement
->all_input_readonly
)
3472 case lang_group_statement_enum
:
3473 check_input_sections (s
->group_statement
.children
.head
,
3474 output_section_statement
);
3475 if (! output_section_statement
->all_input_readonly
)
3484 /* Update wildcard statements if needed. */
3487 update_wild_statements (lang_statement_union_type
*s
)
3489 struct wildcard_list
*sec
;
3491 switch (sort_section
)
3501 for (; s
!= NULL
; s
= s
->header
.next
)
3503 switch (s
->header
.type
)
3508 case lang_wild_statement_enum
:
3509 sec
= s
->wild_statement
.section_list
;
3510 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3513 switch (sec
->spec
.sorted
)
3516 sec
->spec
.sorted
= sort_section
;
3519 if (sort_section
== by_alignment
)
3520 sec
->spec
.sorted
= by_name_alignment
;
3523 if (sort_section
== by_name
)
3524 sec
->spec
.sorted
= by_alignment_name
;
3532 case lang_constructors_statement_enum
:
3533 update_wild_statements (constructor_list
.head
);
3536 case lang_output_section_statement_enum
:
3537 update_wild_statements
3538 (s
->output_section_statement
.children
.head
);
3541 case lang_group_statement_enum
:
3542 update_wild_statements (s
->group_statement
.children
.head
);
3550 /* Open input files and attach to output sections. */
3553 map_input_to_output_sections
3554 (lang_statement_union_type
*s
, const char *target
,
3555 lang_output_section_statement_type
*os
)
3557 for (; s
!= NULL
; s
= s
->header
.next
)
3559 lang_output_section_statement_type
*tos
;
3562 switch (s
->header
.type
)
3564 case lang_wild_statement_enum
:
3565 wild (&s
->wild_statement
, target
, os
);
3567 case lang_constructors_statement_enum
:
3568 map_input_to_output_sections (constructor_list
.head
,
3572 case lang_output_section_statement_enum
:
3573 tos
= &s
->output_section_statement
;
3574 if (tos
->constraint
!= 0)
3576 if (tos
->constraint
!= ONLY_IF_RW
3577 && tos
->constraint
!= ONLY_IF_RO
)
3579 tos
->all_input_readonly
= TRUE
;
3580 check_input_sections (tos
->children
.head
, tos
);
3581 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3583 tos
->constraint
= -1;
3587 map_input_to_output_sections (tos
->children
.head
,
3591 case lang_output_statement_enum
:
3593 case lang_target_statement_enum
:
3594 target
= s
->target_statement
.target
;
3596 case lang_group_statement_enum
:
3597 map_input_to_output_sections (s
->group_statement
.children
.head
,
3601 case lang_data_statement_enum
:
3602 /* Make sure that any sections mentioned in the expression
3604 exp_init_os (s
->data_statement
.exp
);
3605 /* The output section gets CONTENTS, ALLOC and LOAD, but
3606 these may be overridden by the script. */
3607 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3608 switch (os
->sectype
)
3610 case normal_section
:
3611 case overlay_section
:
3613 case noalloc_section
:
3614 flags
= SEC_HAS_CONTENTS
;
3616 case noload_section
:
3617 if (bfd_get_flavour (link_info
.output_bfd
)
3618 == bfd_target_elf_flavour
)
3619 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3621 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3624 if (os
->bfd_section
== NULL
)
3625 init_os (os
, flags
);
3627 os
->bfd_section
->flags
|= flags
;
3629 case lang_input_section_enum
:
3631 case lang_fill_statement_enum
:
3632 case lang_object_symbols_statement_enum
:
3633 case lang_reloc_statement_enum
:
3634 case lang_padding_statement_enum
:
3635 case lang_input_statement_enum
:
3636 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3639 case lang_assignment_statement_enum
:
3640 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3643 /* Make sure that any sections mentioned in the assignment
3645 exp_init_os (s
->assignment_statement
.exp
);
3647 case lang_address_statement_enum
:
3648 /* Mark the specified section with the supplied address.
3649 If this section was actually a segment marker, then the
3650 directive is ignored if the linker script explicitly
3651 processed the segment marker. Originally, the linker
3652 treated segment directives (like -Ttext on the
3653 command-line) as section directives. We honor the
3654 section directive semantics for backwards compatibilty;
3655 linker scripts that do not specifically check for
3656 SEGMENT_START automatically get the old semantics. */
3657 if (!s
->address_statement
.segment
3658 || !s
->address_statement
.segment
->used
)
3660 const char *name
= s
->address_statement
.section_name
;
3662 /* Create the output section statement here so that
3663 orphans with a set address will be placed after other
3664 script sections. If we let the orphan placement code
3665 place them in amongst other sections then the address
3666 will affect following script sections, which is
3667 likely to surprise naive users. */
3668 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3669 tos
->addr_tree
= s
->address_statement
.address
;
3670 if (tos
->bfd_section
== NULL
)
3674 case lang_insert_statement_enum
:
3680 /* An insert statement snips out all the linker statements from the
3681 start of the list and places them after the output section
3682 statement specified by the insert. This operation is complicated
3683 by the fact that we keep a doubly linked list of output section
3684 statements as well as the singly linked list of all statements. */
3687 process_insert_statements (void)
3689 lang_statement_union_type
**s
;
3690 lang_output_section_statement_type
*first_os
= NULL
;
3691 lang_output_section_statement_type
*last_os
= NULL
;
3692 lang_output_section_statement_type
*os
;
3694 /* "start of list" is actually the statement immediately after
3695 the special abs_section output statement, so that it isn't
3697 s
= &lang_output_section_statement
.head
;
3698 while (*(s
= &(*s
)->header
.next
) != NULL
)
3700 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3702 /* Keep pointers to the first and last output section
3703 statement in the sequence we may be about to move. */
3704 os
= &(*s
)->output_section_statement
;
3706 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3709 /* Set constraint negative so that lang_output_section_find
3710 won't match this output section statement. At this
3711 stage in linking constraint has values in the range
3712 [-1, ONLY_IN_RW]. */
3713 last_os
->constraint
= -2 - last_os
->constraint
;
3714 if (first_os
== NULL
)
3717 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3719 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3720 lang_output_section_statement_type
*where
;
3721 lang_statement_union_type
**ptr
;
3722 lang_statement_union_type
*first
;
3724 where
= lang_output_section_find (i
->where
);
3725 if (where
!= NULL
&& i
->is_before
)
3728 where
= where
->prev
;
3729 while (where
!= NULL
&& where
->constraint
< 0);
3733 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
3737 /* Deal with reordering the output section statement list. */
3738 if (last_os
!= NULL
)
3740 asection
*first_sec
, *last_sec
;
3741 struct lang_output_section_statement_struct
**next
;
3743 /* Snip out the output sections we are moving. */
3744 first_os
->prev
->next
= last_os
->next
;
3745 if (last_os
->next
== NULL
)
3747 next
= &first_os
->prev
->next
;
3748 lang_output_section_statement
.tail
3749 = (lang_statement_union_type
**) next
;
3752 last_os
->next
->prev
= first_os
->prev
;
3753 /* Add them in at the new position. */
3754 last_os
->next
= where
->next
;
3755 if (where
->next
== NULL
)
3757 next
= &last_os
->next
;
3758 lang_output_section_statement
.tail
3759 = (lang_statement_union_type
**) next
;
3762 where
->next
->prev
= last_os
;
3763 first_os
->prev
= where
;
3764 where
->next
= first_os
;
3766 /* Move the bfd sections in the same way. */
3769 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3771 os
->constraint
= -2 - os
->constraint
;
3772 if (os
->bfd_section
!= NULL
3773 && os
->bfd_section
->owner
!= NULL
)
3775 last_sec
= os
->bfd_section
;
3776 if (first_sec
== NULL
)
3777 first_sec
= last_sec
;
3782 if (last_sec
!= NULL
)
3784 asection
*sec
= where
->bfd_section
;
3786 sec
= output_prev_sec_find (where
);
3788 /* The place we want to insert must come after the
3789 sections we are moving. So if we find no
3790 section or if the section is the same as our
3791 last section, then no move is needed. */
3792 if (sec
!= NULL
&& sec
!= last_sec
)
3794 /* Trim them off. */
3795 if (first_sec
->prev
!= NULL
)
3796 first_sec
->prev
->next
= last_sec
->next
;
3798 link_info
.output_bfd
->sections
= last_sec
->next
;
3799 if (last_sec
->next
!= NULL
)
3800 last_sec
->next
->prev
= first_sec
->prev
;
3802 link_info
.output_bfd
->section_last
= first_sec
->prev
;
3804 last_sec
->next
= sec
->next
;
3805 if (sec
->next
!= NULL
)
3806 sec
->next
->prev
= last_sec
;
3808 link_info
.output_bfd
->section_last
= last_sec
;
3809 first_sec
->prev
= sec
;
3810 sec
->next
= first_sec
;
3818 ptr
= insert_os_after (where
);
3819 /* Snip everything after the abs_section output statement we
3820 know is at the start of the list, up to and including
3821 the insert statement we are currently processing. */
3822 first
= lang_output_section_statement
.head
->header
.next
;
3823 lang_output_section_statement
.head
->header
.next
= (*s
)->header
.next
;
3824 /* Add them back where they belong. */
3827 statement_list
.tail
= s
;
3829 s
= &lang_output_section_statement
.head
;
3833 /* Undo constraint twiddling. */
3834 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3836 os
->constraint
= -2 - os
->constraint
;
3842 /* An output section might have been removed after its statement was
3843 added. For example, ldemul_before_allocation can remove dynamic
3844 sections if they turn out to be not needed. Clean them up here. */
3847 strip_excluded_output_sections (void)
3849 lang_output_section_statement_type
*os
;
3851 /* Run lang_size_sections (if not already done). */
3852 if (expld
.phase
!= lang_mark_phase_enum
)
3854 expld
.phase
= lang_mark_phase_enum
;
3855 expld
.dataseg
.phase
= exp_dataseg_none
;
3856 one_lang_size_sections_pass (NULL
, FALSE
);
3857 lang_reset_memory_regions ();
3860 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3864 asection
*output_section
;
3865 bfd_boolean exclude
;
3867 if (os
->constraint
< 0)
3870 output_section
= os
->bfd_section
;
3871 if (output_section
== NULL
)
3874 exclude
= (output_section
->rawsize
== 0
3875 && (output_section
->flags
& SEC_KEEP
) == 0
3876 && !bfd_section_removed_from_list (link_info
.output_bfd
,
3879 /* Some sections have not yet been sized, notably .gnu.version,
3880 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3881 input sections, so don't drop output sections that have such
3882 input sections unless they are also marked SEC_EXCLUDE. */
3883 if (exclude
&& output_section
->map_head
.s
!= NULL
)
3887 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
3888 if ((s
->flags
& SEC_LINKER_CREATED
) != 0
3889 && (s
->flags
& SEC_EXCLUDE
) == 0)
3896 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3897 output_section
->map_head
.link_order
= NULL
;
3898 output_section
->map_tail
.link_order
= NULL
;
3902 /* We don't set bfd_section to NULL since bfd_section of the
3903 removed output section statement may still be used. */
3904 if (!os
->section_relative_symbol
3905 && !os
->update_dot_tree
)
3907 output_section
->flags
|= SEC_EXCLUDE
;
3908 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
3909 link_info
.output_bfd
->section_count
--;
3913 /* Stop future calls to lang_add_section from messing with map_head
3914 and map_tail link_order fields. */
3915 stripped_excluded_sections
= TRUE
;
3919 print_output_section_statement
3920 (lang_output_section_statement_type
*output_section_statement
)
3922 asection
*section
= output_section_statement
->bfd_section
;
3925 if (output_section_statement
!= abs_output_section
)
3927 minfo ("\n%s", output_section_statement
->name
);
3929 if (section
!= NULL
)
3931 print_dot
= section
->vma
;
3933 len
= strlen (output_section_statement
->name
);
3934 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3939 while (len
< SECTION_NAME_MAP_LENGTH
)
3945 minfo ("0x%V %W", section
->vma
, section
->size
);
3947 if (section
->vma
!= section
->lma
)
3948 minfo (_(" load address 0x%V"), section
->lma
);
3950 if (output_section_statement
->update_dot_tree
!= NULL
)
3951 exp_fold_tree (output_section_statement
->update_dot_tree
,
3952 bfd_abs_section_ptr
, &print_dot
);
3958 print_statement_list (output_section_statement
->children
.head
,
3959 output_section_statement
);
3962 /* Scan for the use of the destination in the right hand side
3963 of an expression. In such cases we will not compute the
3964 correct expression, since the value of DST that is used on
3965 the right hand side will be its final value, not its value
3966 just before this expression is evaluated. */
3969 scan_for_self_assignment (const char * dst
, etree_type
* rhs
)
3971 if (rhs
== NULL
|| dst
== NULL
)
3974 switch (rhs
->type
.node_class
)
3977 return (scan_for_self_assignment (dst
, rhs
->binary
.lhs
)
3978 || scan_for_self_assignment (dst
, rhs
->binary
.rhs
));
3981 return (scan_for_self_assignment (dst
, rhs
->trinary
.lhs
)
3982 || scan_for_self_assignment (dst
, rhs
->trinary
.rhs
));
3985 case etree_provided
:
3987 if (strcmp (dst
, rhs
->assign
.dst
) == 0)
3989 return scan_for_self_assignment (dst
, rhs
->assign
.src
);
3992 return scan_for_self_assignment (dst
, rhs
->unary
.child
);
3996 return strcmp (dst
, rhs
->value
.str
) == 0;
4001 return strcmp (dst
, rhs
->name
.name
) == 0;
4013 print_assignment (lang_assignment_statement_type
*assignment
,
4014 lang_output_section_statement_type
*output_section
)
4018 bfd_boolean computation_is_valid
= TRUE
;
4022 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4025 if (assignment
->exp
->type
.node_class
== etree_assert
)
4028 tree
= assignment
->exp
->assert_s
.child
;
4029 computation_is_valid
= TRUE
;
4033 const char *dst
= assignment
->exp
->assign
.dst
;
4035 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4036 tree
= assignment
->exp
->assign
.src
;
4037 computation_is_valid
= is_dot
|| !scan_for_self_assignment (dst
, tree
);
4040 osec
= output_section
->bfd_section
;
4042 osec
= bfd_abs_section_ptr
;
4043 exp_fold_tree (tree
, osec
, &print_dot
);
4044 if (expld
.result
.valid_p
)
4048 if (computation_is_valid
)
4050 value
= expld
.result
.value
;
4052 if (expld
.result
.section
!= NULL
)
4053 value
+= expld
.result
.section
->vma
;
4055 minfo ("0x%V", value
);
4061 struct bfd_link_hash_entry
*h
;
4063 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4064 FALSE
, FALSE
, TRUE
);
4067 value
= h
->u
.def
.value
;
4068 value
+= h
->u
.def
.section
->output_section
->vma
;
4069 value
+= h
->u
.def
.section
->output_offset
;
4071 minfo ("[0x%V]", value
);
4074 minfo ("[unresolved]");
4086 exp_print_tree (assignment
->exp
);
4091 print_input_statement (lang_input_statement_type
*statm
)
4093 if (statm
->filename
!= NULL
4094 && (statm
->the_bfd
== NULL
4095 || (statm
->the_bfd
->flags
& BFD_LINKER_CREATED
) == 0))
4096 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4099 /* Print all symbols defined in a particular section. This is called
4100 via bfd_link_hash_traverse, or by print_all_symbols. */
4103 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4105 asection
*sec
= (asection
*) ptr
;
4107 if ((hash_entry
->type
== bfd_link_hash_defined
4108 || hash_entry
->type
== bfd_link_hash_defweak
)
4109 && sec
== hash_entry
->u
.def
.section
)
4113 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4116 (hash_entry
->u
.def
.value
4117 + hash_entry
->u
.def
.section
->output_offset
4118 + hash_entry
->u
.def
.section
->output_section
->vma
));
4120 minfo (" %T\n", hash_entry
->root
.string
);
4127 hash_entry_addr_cmp (const void *a
, const void *b
)
4129 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4130 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4132 if (l
->u
.def
.value
< r
->u
.def
.value
)
4134 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4141 print_all_symbols (asection
*sec
)
4143 struct fat_user_section_struct
*ud
=
4144 (struct fat_user_section_struct
*) get_userdata (sec
);
4145 struct map_symbol_def
*def
;
4146 struct bfd_link_hash_entry
**entries
;
4152 *ud
->map_symbol_def_tail
= 0;
4154 /* Sort the symbols by address. */
4155 entries
= (struct bfd_link_hash_entry
**)
4156 obstack_alloc (&map_obstack
, ud
->map_symbol_def_count
* sizeof (*entries
));
4158 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4159 entries
[i
] = def
->entry
;
4161 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4162 hash_entry_addr_cmp
);
4164 /* Print the symbols. */
4165 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4166 print_one_symbol (entries
[i
], sec
);
4168 obstack_free (&map_obstack
, entries
);
4171 /* Print information about an input section to the map file. */
4174 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4176 bfd_size_type size
= i
->size
;
4183 minfo ("%s", i
->name
);
4185 len
= 1 + strlen (i
->name
);
4186 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4191 while (len
< SECTION_NAME_MAP_LENGTH
)
4197 if (i
->output_section
!= NULL
4198 && i
->output_section
->owner
== link_info
.output_bfd
)
4199 addr
= i
->output_section
->vma
+ i
->output_offset
;
4207 minfo ("0x%V %W %B\n", addr
, TO_ADDR (size
), i
->owner
);
4209 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4211 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4223 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4226 if (i
->output_section
!= NULL
4227 && i
->output_section
->owner
== link_info
.output_bfd
)
4229 if (link_info
.reduce_memory_overheads
)
4230 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4232 print_all_symbols (i
);
4234 /* Update print_dot, but make sure that we do not move it
4235 backwards - this could happen if we have overlays and a
4236 later overlay is shorter than an earier one. */
4237 if (addr
+ TO_ADDR (size
) > print_dot
)
4238 print_dot
= addr
+ TO_ADDR (size
);
4243 print_fill_statement (lang_fill_statement_type
*fill
)
4247 fputs (" FILL mask 0x", config
.map_file
);
4248 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4249 fprintf (config
.map_file
, "%02x", *p
);
4250 fputs ("\n", config
.map_file
);
4254 print_data_statement (lang_data_statement_type
*data
)
4262 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4265 addr
= data
->output_offset
;
4266 if (data
->output_section
!= NULL
)
4267 addr
+= data
->output_section
->vma
;
4295 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
4297 if (data
->exp
->type
.node_class
!= etree_value
)
4300 exp_print_tree (data
->exp
);
4305 print_dot
= addr
+ TO_ADDR (size
);
4308 /* Print an address statement. These are generated by options like
4312 print_address_statement (lang_address_statement_type
*address
)
4314 minfo (_("Address of section %s set to "), address
->section_name
);
4315 exp_print_tree (address
->address
);
4319 /* Print a reloc statement. */
4322 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4329 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4332 addr
= reloc
->output_offset
;
4333 if (reloc
->output_section
!= NULL
)
4334 addr
+= reloc
->output_section
->vma
;
4336 size
= bfd_get_reloc_size (reloc
->howto
);
4338 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
4340 if (reloc
->name
!= NULL
)
4341 minfo ("%s+", reloc
->name
);
4343 minfo ("%s+", reloc
->section
->name
);
4345 exp_print_tree (reloc
->addend_exp
);
4349 print_dot
= addr
+ TO_ADDR (size
);
4353 print_padding_statement (lang_padding_statement_type
*s
)
4361 len
= sizeof " *fill*" - 1;
4362 while (len
< SECTION_NAME_MAP_LENGTH
)
4368 addr
= s
->output_offset
;
4369 if (s
->output_section
!= NULL
)
4370 addr
+= s
->output_section
->vma
;
4371 minfo ("0x%V %W ", addr
, (bfd_vma
) s
->size
);
4373 if (s
->fill
->size
!= 0)
4377 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4378 fprintf (config
.map_file
, "%02x", *p
);
4383 print_dot
= addr
+ TO_ADDR (s
->size
);
4387 print_wild_statement (lang_wild_statement_type
*w
,
4388 lang_output_section_statement_type
*os
)
4390 struct wildcard_list
*sec
;
4394 if (w
->filenames_sorted
)
4396 if (w
->filename
!= NULL
)
4397 minfo ("%s", w
->filename
);
4400 if (w
->filenames_sorted
)
4404 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4406 if (sec
->spec
.sorted
)
4408 if (sec
->spec
.exclude_name_list
!= NULL
)
4411 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4412 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4413 minfo (" %s", tmp
->name
);
4416 if (sec
->spec
.name
!= NULL
)
4417 minfo ("%s", sec
->spec
.name
);
4420 if (sec
->spec
.sorted
)
4429 print_statement_list (w
->children
.head
, os
);
4432 /* Print a group statement. */
4435 print_group (lang_group_statement_type
*s
,
4436 lang_output_section_statement_type
*os
)
4438 fprintf (config
.map_file
, "START GROUP\n");
4439 print_statement_list (s
->children
.head
, os
);
4440 fprintf (config
.map_file
, "END GROUP\n");
4443 /* Print the list of statements in S.
4444 This can be called for any statement type. */
4447 print_statement_list (lang_statement_union_type
*s
,
4448 lang_output_section_statement_type
*os
)
4452 print_statement (s
, os
);
4457 /* Print the first statement in statement list S.
4458 This can be called for any statement type. */
4461 print_statement (lang_statement_union_type
*s
,
4462 lang_output_section_statement_type
*os
)
4464 switch (s
->header
.type
)
4467 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4470 case lang_constructors_statement_enum
:
4471 if (constructor_list
.head
!= NULL
)
4473 if (constructors_sorted
)
4474 minfo (" SORT (CONSTRUCTORS)\n");
4476 minfo (" CONSTRUCTORS\n");
4477 print_statement_list (constructor_list
.head
, os
);
4480 case lang_wild_statement_enum
:
4481 print_wild_statement (&s
->wild_statement
, os
);
4483 case lang_address_statement_enum
:
4484 print_address_statement (&s
->address_statement
);
4486 case lang_object_symbols_statement_enum
:
4487 minfo (" CREATE_OBJECT_SYMBOLS\n");
4489 case lang_fill_statement_enum
:
4490 print_fill_statement (&s
->fill_statement
);
4492 case lang_data_statement_enum
:
4493 print_data_statement (&s
->data_statement
);
4495 case lang_reloc_statement_enum
:
4496 print_reloc_statement (&s
->reloc_statement
);
4498 case lang_input_section_enum
:
4499 print_input_section (s
->input_section
.section
, FALSE
);
4501 case lang_padding_statement_enum
:
4502 print_padding_statement (&s
->padding_statement
);
4504 case lang_output_section_statement_enum
:
4505 print_output_section_statement (&s
->output_section_statement
);
4507 case lang_assignment_statement_enum
:
4508 print_assignment (&s
->assignment_statement
, os
);
4510 case lang_target_statement_enum
:
4511 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4513 case lang_output_statement_enum
:
4514 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4515 if (output_target
!= NULL
)
4516 minfo (" %s", output_target
);
4519 case lang_input_statement_enum
:
4520 print_input_statement (&s
->input_statement
);
4522 case lang_group_statement_enum
:
4523 print_group (&s
->group_statement
, os
);
4525 case lang_insert_statement_enum
:
4526 minfo ("INSERT %s %s\n",
4527 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4528 s
->insert_statement
.where
);
4534 print_statements (void)
4536 print_statement_list (statement_list
.head
, abs_output_section
);
4539 /* Print the first N statements in statement list S to STDERR.
4540 If N == 0, nothing is printed.
4541 If N < 0, the entire list is printed.
4542 Intended to be called from GDB. */
4545 dprint_statement (lang_statement_union_type
*s
, int n
)
4547 FILE *map_save
= config
.map_file
;
4549 config
.map_file
= stderr
;
4552 print_statement_list (s
, abs_output_section
);
4555 while (s
&& --n
>= 0)
4557 print_statement (s
, abs_output_section
);
4562 config
.map_file
= map_save
;
4566 insert_pad (lang_statement_union_type
**ptr
,
4568 bfd_size_type alignment_needed
,
4569 asection
*output_section
,
4572 static fill_type zero_fill
;
4573 lang_statement_union_type
*pad
= NULL
;
4575 if (ptr
!= &statement_list
.head
)
4576 pad
= ((lang_statement_union_type
*)
4577 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4579 && pad
->header
.type
== lang_padding_statement_enum
4580 && pad
->padding_statement
.output_section
== output_section
)
4582 /* Use the existing pad statement. */
4584 else if ((pad
= *ptr
) != NULL
4585 && pad
->header
.type
== lang_padding_statement_enum
4586 && pad
->padding_statement
.output_section
== output_section
)
4588 /* Use the existing pad statement. */
4592 /* Make a new padding statement, linked into existing chain. */
4593 pad
= (lang_statement_union_type
*)
4594 stat_alloc (sizeof (lang_padding_statement_type
));
4595 pad
->header
.next
= *ptr
;
4597 pad
->header
.type
= lang_padding_statement_enum
;
4598 pad
->padding_statement
.output_section
= output_section
;
4601 pad
->padding_statement
.fill
= fill
;
4603 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4604 pad
->padding_statement
.size
= alignment_needed
;
4605 output_section
->size
+= alignment_needed
;
4608 /* Work out how much this section will move the dot point. */
4612 (lang_statement_union_type
**this_ptr
,
4613 lang_output_section_statement_type
*output_section_statement
,
4617 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4618 asection
*i
= is
->section
;
4620 if (!((lang_input_statement_type
*) i
->owner
->usrdata
)->flags
.just_syms
4621 && (i
->flags
& SEC_EXCLUDE
) == 0)
4623 bfd_size_type alignment_needed
;
4626 /* Align this section first to the input sections requirement,
4627 then to the output section's requirement. If this alignment
4628 is greater than any seen before, then record it too. Perform
4629 the alignment by inserting a magic 'padding' statement. */
4631 if (output_section_statement
->subsection_alignment
!= -1)
4632 i
->alignment_power
= output_section_statement
->subsection_alignment
;
4634 o
= output_section_statement
->bfd_section
;
4635 if (o
->alignment_power
< i
->alignment_power
)
4636 o
->alignment_power
= i
->alignment_power
;
4638 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4640 if (alignment_needed
!= 0)
4642 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4643 dot
+= alignment_needed
;
4646 /* Remember where in the output section this input section goes. */
4648 i
->output_offset
= dot
- o
->vma
;
4650 /* Mark how big the output section must be to contain this now. */
4651 dot
+= TO_ADDR (i
->size
);
4652 o
->size
= TO_SIZE (dot
- o
->vma
);
4656 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
4663 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4665 const asection
*sec1
= *(const asection
**) arg1
;
4666 const asection
*sec2
= *(const asection
**) arg2
;
4668 if (bfd_section_lma (sec1
->owner
, sec1
)
4669 < bfd_section_lma (sec2
->owner
, sec2
))
4671 else if (bfd_section_lma (sec1
->owner
, sec1
)
4672 > bfd_section_lma (sec2
->owner
, sec2
))
4674 else if (sec1
->id
< sec2
->id
)
4676 else if (sec1
->id
> sec2
->id
)
4682 #define IGNORE_SECTION(s) \
4683 ((s->flags & SEC_ALLOC) == 0 \
4684 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4685 && (s->flags & SEC_LOAD) == 0))
4687 /* Check to see if any allocated sections overlap with other allocated
4688 sections. This can happen if a linker script specifies the output
4689 section addresses of the two sections. Also check whether any memory
4690 region has overflowed. */
4693 lang_check_section_addresses (void)
4696 asection
**sections
, **spp
;
4703 lang_memory_region_type
*m
;
4705 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
4708 amt
= bfd_count_sections (link_info
.output_bfd
) * sizeof (asection
*);
4709 sections
= (asection
**) xmalloc (amt
);
4711 /* Scan all sections in the output list. */
4713 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4715 /* Only consider loadable sections with real contents. */
4716 if (!(s
->flags
& SEC_LOAD
)
4717 || !(s
->flags
& SEC_ALLOC
)
4721 sections
[count
] = s
;
4728 qsort (sections
, (size_t) count
, sizeof (asection
*),
4729 sort_sections_by_lma
);
4734 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4735 for (count
--; count
; count
--)
4737 /* We must check the sections' LMA addresses not their VMA
4738 addresses because overlay sections can have overlapping VMAs
4739 but they must have distinct LMAs. */
4745 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4747 /* Look for an overlap. We have sorted sections by lma, so we
4748 know that s_start >= p_start. Besides the obvious case of
4749 overlap when the current section starts before the previous
4750 one ends, we also must have overlap if the previous section
4751 wraps around the address space. */
4752 if (s_start
<= p_end
4754 einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),
4755 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
4760 /* If any memory region has overflowed, report by how much.
4761 We do not issue this diagnostic for regions that had sections
4762 explicitly placed outside their bounds; os_region_check's
4763 diagnostics are adequate for that case.
4765 FIXME: It is conceivable that m->current - (m->origin + m->length)
4766 might overflow a 32-bit integer. There is, alas, no way to print
4767 a bfd_vma quantity in decimal. */
4768 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
4769 if (m
->had_full_message
)
4770 einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4771 m
->name_list
.name
, (long)(m
->current
- (m
->origin
+ m
->length
)));
4775 /* Make sure the new address is within the region. We explicitly permit the
4776 current address to be at the exact end of the region when the address is
4777 non-zero, in case the region is at the end of addressable memory and the
4778 calculation wraps around. */
4781 os_region_check (lang_output_section_statement_type
*os
,
4782 lang_memory_region_type
*region
,
4786 if ((region
->current
< region
->origin
4787 || (region
->current
- region
->origin
> region
->length
))
4788 && ((region
->current
!= region
->origin
+ region
->length
)
4793 einfo (_("%X%P: address 0x%v of %B section `%s'"
4794 " is not within region `%s'\n"),
4796 os
->bfd_section
->owner
,
4797 os
->bfd_section
->name
,
4798 region
->name_list
.name
);
4800 else if (!region
->had_full_message
)
4802 region
->had_full_message
= TRUE
;
4804 einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4805 os
->bfd_section
->owner
,
4806 os
->bfd_section
->name
,
4807 region
->name_list
.name
);
4812 /* Set the sizes for all the output sections. */
4815 lang_size_sections_1
4816 (lang_statement_union_type
**prev
,
4817 lang_output_section_statement_type
*output_section_statement
,
4821 bfd_boolean check_regions
)
4823 lang_statement_union_type
*s
;
4825 /* Size up the sections from their constituent parts. */
4826 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
4828 switch (s
->header
.type
)
4830 case lang_output_section_statement_enum
:
4832 bfd_vma newdot
, after
;
4833 lang_output_section_statement_type
*os
;
4834 lang_memory_region_type
*r
;
4835 int section_alignment
= 0;
4837 os
= &s
->output_section_statement
;
4838 if (os
->constraint
== -1)
4841 /* FIXME: We shouldn't need to zero section vmas for ld -r
4842 here, in lang_insert_orphan, or in the default linker scripts.
4843 This is covering for coff backend linker bugs. See PR6945. */
4844 if (os
->addr_tree
== NULL
4845 && link_info
.relocatable
4846 && (bfd_get_flavour (link_info
.output_bfd
)
4847 == bfd_target_coff_flavour
))
4848 os
->addr_tree
= exp_intop (0);
4849 if (os
->addr_tree
!= NULL
)
4851 os
->processed_vma
= FALSE
;
4852 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
4854 if (expld
.result
.valid_p
)
4856 dot
= expld
.result
.value
;
4857 if (expld
.result
.section
!= NULL
)
4858 dot
+= expld
.result
.section
->vma
;
4860 else if (expld
.phase
!= lang_mark_phase_enum
)
4861 einfo (_("%F%S: non constant or forward reference"
4862 " address expression for section %s\n"),
4863 os
->addr_tree
, os
->name
);
4866 if (os
->bfd_section
== NULL
)
4867 /* This section was removed or never actually created. */
4870 /* If this is a COFF shared library section, use the size and
4871 address from the input section. FIXME: This is COFF
4872 specific; it would be cleaner if there were some other way
4873 to do this, but nothing simple comes to mind. */
4874 if (((bfd_get_flavour (link_info
.output_bfd
)
4875 == bfd_target_ecoff_flavour
)
4876 || (bfd_get_flavour (link_info
.output_bfd
)
4877 == bfd_target_coff_flavour
))
4878 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
4882 if (os
->children
.head
== NULL
4883 || os
->children
.head
->header
.next
!= NULL
4884 || (os
->children
.head
->header
.type
4885 != lang_input_section_enum
))
4886 einfo (_("%P%X: Internal error on COFF shared library"
4887 " section %s\n"), os
->name
);
4889 input
= os
->children
.head
->input_section
.section
;
4890 bfd_set_section_vma (os
->bfd_section
->owner
,
4892 bfd_section_vma (input
->owner
, input
));
4893 os
->bfd_section
->size
= input
->size
;
4898 if (bfd_is_abs_section (os
->bfd_section
))
4900 /* No matter what happens, an abs section starts at zero. */
4901 ASSERT (os
->bfd_section
->vma
== 0);
4905 if (os
->addr_tree
== NULL
)
4907 /* No address specified for this section, get one
4908 from the region specification. */
4909 if (os
->region
== NULL
4910 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
4911 && os
->region
->name_list
.name
[0] == '*'
4912 && strcmp (os
->region
->name_list
.name
,
4913 DEFAULT_MEMORY_REGION
) == 0))
4915 os
->region
= lang_memory_default (os
->bfd_section
);
4918 /* If a loadable section is using the default memory
4919 region, and some non default memory regions were
4920 defined, issue an error message. */
4922 && !IGNORE_SECTION (os
->bfd_section
)
4923 && ! link_info
.relocatable
4925 && strcmp (os
->region
->name_list
.name
,
4926 DEFAULT_MEMORY_REGION
) == 0
4927 && lang_memory_region_list
!= NULL
4928 && (strcmp (lang_memory_region_list
->name_list
.name
,
4929 DEFAULT_MEMORY_REGION
) != 0
4930 || lang_memory_region_list
->next
!= NULL
)
4931 && expld
.phase
!= lang_mark_phase_enum
)
4933 /* By default this is an error rather than just a
4934 warning because if we allocate the section to the
4935 default memory region we can end up creating an
4936 excessively large binary, or even seg faulting when
4937 attempting to perform a negative seek. See
4938 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4939 for an example of this. This behaviour can be
4940 overridden by the using the --no-check-sections
4942 if (command_line
.check_section_addresses
)
4943 einfo (_("%P%F: error: no memory region specified"
4944 " for loadable section `%s'\n"),
4945 bfd_get_section_name (link_info
.output_bfd
,
4948 einfo (_("%P: warning: no memory region specified"
4949 " for loadable section `%s'\n"),
4950 bfd_get_section_name (link_info
.output_bfd
,
4954 newdot
= os
->region
->current
;
4955 section_alignment
= os
->bfd_section
->alignment_power
;
4958 section_alignment
= os
->section_alignment
;
4960 /* Align to what the section needs. */
4961 if (section_alignment
> 0)
4963 bfd_vma savedot
= newdot
;
4964 newdot
= align_power (newdot
, section_alignment
);
4966 if (newdot
!= savedot
4967 && (config
.warn_section_align
4968 || os
->addr_tree
!= NULL
)
4969 && expld
.phase
!= lang_mark_phase_enum
)
4970 einfo (_("%P: warning: changing start of section"
4971 " %s by %lu bytes\n"),
4972 os
->name
, (unsigned long) (newdot
- savedot
));
4975 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
4977 os
->bfd_section
->output_offset
= 0;
4980 lang_size_sections_1 (&os
->children
.head
, os
,
4981 os
->fill
, newdot
, relax
, check_regions
);
4983 os
->processed_vma
= TRUE
;
4985 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
4986 /* Except for some special linker created sections,
4987 no output section should change from zero size
4988 after strip_excluded_output_sections. A non-zero
4989 size on an ignored section indicates that some
4990 input section was not sized early enough. */
4991 ASSERT (os
->bfd_section
->size
== 0);
4994 dot
= os
->bfd_section
->vma
;
4996 /* Put the section within the requested block size, or
4997 align at the block boundary. */
4999 + TO_ADDR (os
->bfd_section
->size
)
5000 + os
->block_value
- 1)
5001 & - (bfd_vma
) os
->block_value
);
5003 os
->bfd_section
->size
= TO_SIZE (after
- os
->bfd_section
->vma
);
5006 /* Set section lma. */
5009 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5013 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5014 os
->bfd_section
->lma
= lma
;
5016 else if (os
->lma_region
!= NULL
)
5018 bfd_vma lma
= os
->lma_region
->current
;
5020 if (section_alignment
> 0)
5021 lma
= align_power (lma
, section_alignment
);
5022 os
->bfd_section
->lma
= lma
;
5024 else if (r
->last_os
!= NULL
5025 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5030 last
= r
->last_os
->output_section_statement
.bfd_section
;
5032 /* A backwards move of dot should be accompanied by
5033 an explicit assignment to the section LMA (ie.
5034 os->load_base set) because backwards moves can
5035 create overlapping LMAs. */
5037 && os
->bfd_section
->size
!= 0
5038 && dot
+ os
->bfd_section
->size
<= last
->vma
)
5040 /* If dot moved backwards then leave lma equal to
5041 vma. This is the old default lma, which might
5042 just happen to work when the backwards move is
5043 sufficiently large. Nag if this changes anything,
5044 so people can fix their linker scripts. */
5046 if (last
->vma
!= last
->lma
)
5047 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
5052 /* If this is an overlay, set the current lma to that
5053 at the end of the previous section. */
5054 if (os
->sectype
== overlay_section
)
5055 lma
= last
->lma
+ last
->size
;
5057 /* Otherwise, keep the same lma to vma relationship
5058 as the previous section. */
5060 lma
= dot
+ last
->lma
- last
->vma
;
5062 if (section_alignment
> 0)
5063 lma
= align_power (lma
, section_alignment
);
5064 os
->bfd_section
->lma
= lma
;
5067 os
->processed_lma
= TRUE
;
5069 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5072 /* Keep track of normal sections using the default
5073 lma region. We use this to set the lma for
5074 following sections. Overlays or other linker
5075 script assignment to lma might mean that the
5076 default lma == vma is incorrect.
5077 To avoid warnings about dot moving backwards when using
5078 -Ttext, don't start tracking sections until we find one
5079 of non-zero size or with lma set differently to vma. */
5080 if (((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5081 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0)
5082 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0
5083 && (os
->bfd_section
->size
!= 0
5084 || (r
->last_os
== NULL
5085 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5086 || (r
->last_os
!= NULL
5087 && dot
>= (r
->last_os
->output_section_statement
5088 .bfd_section
->vma
)))
5089 && os
->lma_region
== NULL
5090 && !link_info
.relocatable
)
5093 /* .tbss sections effectively have zero size. */
5094 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5095 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
5096 || link_info
.relocatable
)
5097 dot
+= TO_ADDR (os
->bfd_section
->size
);
5099 if (os
->update_dot_tree
!= 0)
5100 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5102 /* Update dot in the region ?
5103 We only do this if the section is going to be allocated,
5104 since unallocated sections do not contribute to the region's
5105 overall size in memory. */
5106 if (os
->region
!= NULL
5107 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5109 os
->region
->current
= dot
;
5112 /* Make sure the new address is within the region. */
5113 os_region_check (os
, os
->region
, os
->addr_tree
,
5114 os
->bfd_section
->vma
);
5116 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5117 && (os
->bfd_section
->flags
& SEC_LOAD
))
5119 os
->lma_region
->current
5120 = os
->bfd_section
->lma
+ TO_ADDR (os
->bfd_section
->size
);
5123 os_region_check (os
, os
->lma_region
, NULL
,
5124 os
->bfd_section
->lma
);
5130 case lang_constructors_statement_enum
:
5131 dot
= lang_size_sections_1 (&constructor_list
.head
,
5132 output_section_statement
,
5133 fill
, dot
, relax
, check_regions
);
5136 case lang_data_statement_enum
:
5138 unsigned int size
= 0;
5140 s
->data_statement
.output_offset
=
5141 dot
- output_section_statement
->bfd_section
->vma
;
5142 s
->data_statement
.output_section
=
5143 output_section_statement
->bfd_section
;
5145 /* We might refer to provided symbols in the expression, and
5146 need to mark them as needed. */
5147 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5149 switch (s
->data_statement
.type
)
5167 if (size
< TO_SIZE ((unsigned) 1))
5168 size
= TO_SIZE ((unsigned) 1);
5169 dot
+= TO_ADDR (size
);
5170 output_section_statement
->bfd_section
->size
+= size
;
5174 case lang_reloc_statement_enum
:
5178 s
->reloc_statement
.output_offset
=
5179 dot
- output_section_statement
->bfd_section
->vma
;
5180 s
->reloc_statement
.output_section
=
5181 output_section_statement
->bfd_section
;
5182 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5183 dot
+= TO_ADDR (size
);
5184 output_section_statement
->bfd_section
->size
+= size
;
5188 case lang_wild_statement_enum
:
5189 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5190 output_section_statement
,
5191 fill
, dot
, relax
, check_regions
);
5194 case lang_object_symbols_statement_enum
:
5195 link_info
.create_object_symbols_section
=
5196 output_section_statement
->bfd_section
;
5199 case lang_output_statement_enum
:
5200 case lang_target_statement_enum
:
5203 case lang_input_section_enum
:
5207 i
= s
->input_section
.section
;
5212 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5213 einfo (_("%P%F: can't relax section: %E\n"));
5217 dot
= size_input_section (prev
, output_section_statement
,
5218 output_section_statement
->fill
, dot
);
5222 case lang_input_statement_enum
:
5225 case lang_fill_statement_enum
:
5226 s
->fill_statement
.output_section
=
5227 output_section_statement
->bfd_section
;
5229 fill
= s
->fill_statement
.fill
;
5232 case lang_assignment_statement_enum
:
5234 bfd_vma newdot
= dot
;
5235 etree_type
*tree
= s
->assignment_statement
.exp
;
5237 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5239 exp_fold_tree (tree
,
5240 output_section_statement
->bfd_section
,
5243 if (expld
.dataseg
.relro
== exp_dataseg_relro_start
)
5245 if (!expld
.dataseg
.relro_start_stat
)
5246 expld
.dataseg
.relro_start_stat
= s
;
5249 ASSERT (expld
.dataseg
.relro_start_stat
== s
);
5252 else if (expld
.dataseg
.relro
== exp_dataseg_relro_end
)
5254 if (!expld
.dataseg
.relro_end_stat
)
5255 expld
.dataseg
.relro_end_stat
= s
;
5258 ASSERT (expld
.dataseg
.relro_end_stat
== s
);
5261 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5263 /* This symbol is relative to this section. */
5264 if ((tree
->type
.node_class
== etree_provided
5265 || tree
->type
.node_class
== etree_assign
)
5266 && (tree
->assign
.dst
[0] != '.'
5267 || tree
->assign
.dst
[1] != '\0'))
5268 output_section_statement
->section_relative_symbol
= 1;
5270 if (!output_section_statement
->ignored
)
5272 if (output_section_statement
== abs_output_section
)
5274 /* If we don't have an output section, then just adjust
5275 the default memory address. */
5276 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5277 FALSE
)->current
= newdot
;
5279 else if (newdot
!= dot
)
5281 /* Insert a pad after this statement. We can't
5282 put the pad before when relaxing, in case the
5283 assignment references dot. */
5284 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5285 output_section_statement
->bfd_section
, dot
);
5287 /* Don't neuter the pad below when relaxing. */
5290 /* If dot is advanced, this implies that the section
5291 should have space allocated to it, unless the
5292 user has explicitly stated that the section
5293 should not be allocated. */
5294 if (output_section_statement
->sectype
!= noalloc_section
5295 && (output_section_statement
->sectype
!= noload_section
5296 || (bfd_get_flavour (link_info
.output_bfd
)
5297 == bfd_target_elf_flavour
)))
5298 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5305 case lang_padding_statement_enum
:
5306 /* If this is the first time lang_size_sections is called,
5307 we won't have any padding statements. If this is the
5308 second or later passes when relaxing, we should allow
5309 padding to shrink. If padding is needed on this pass, it
5310 will be added back in. */
5311 s
->padding_statement
.size
= 0;
5313 /* Make sure output_offset is valid. If relaxation shrinks
5314 the section and this pad isn't needed, it's possible to
5315 have output_offset larger than the final size of the
5316 section. bfd_set_section_contents will complain even for
5317 a pad size of zero. */
5318 s
->padding_statement
.output_offset
5319 = dot
- output_section_statement
->bfd_section
->vma
;
5322 case lang_group_statement_enum
:
5323 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5324 output_section_statement
,
5325 fill
, dot
, relax
, check_regions
);
5328 case lang_insert_statement_enum
:
5331 /* We can only get here when relaxing is turned on. */
5332 case lang_address_statement_enum
:
5339 prev
= &s
->header
.next
;
5344 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5345 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5346 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5347 segments. We are allowed an opportunity to override this decision. */
5350 ldlang_override_segment_assignment (struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
5351 bfd
* abfd ATTRIBUTE_UNUSED
,
5352 asection
* current_section
,
5353 asection
* previous_section
,
5354 bfd_boolean new_segment
)
5356 lang_output_section_statement_type
* cur
;
5357 lang_output_section_statement_type
* prev
;
5359 /* The checks below are only necessary when the BFD library has decided
5360 that the two sections ought to be placed into the same segment. */
5364 /* Paranoia checks. */
5365 if (current_section
== NULL
|| previous_section
== NULL
)
5368 /* Find the memory regions associated with the two sections.
5369 We call lang_output_section_find() here rather than scanning the list
5370 of output sections looking for a matching section pointer because if
5371 we have a large number of sections then a hash lookup is faster. */
5372 cur
= lang_output_section_find (current_section
->name
);
5373 prev
= lang_output_section_find (previous_section
->name
);
5375 /* More paranoia. */
5376 if (cur
== NULL
|| prev
== NULL
)
5379 /* If the regions are different then force the sections to live in
5380 different segments. See the email thread starting at the following
5381 URL for the reasons why this is necessary:
5382 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5383 return cur
->region
!= prev
->region
;
5387 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5389 lang_statement_iteration
++;
5390 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5391 0, 0, relax
, check_regions
);
5395 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5397 expld
.phase
= lang_allocating_phase_enum
;
5398 expld
.dataseg
.phase
= exp_dataseg_none
;
5400 one_lang_size_sections_pass (relax
, check_regions
);
5401 if (expld
.dataseg
.phase
== exp_dataseg_end_seen
5402 && link_info
.relro
&& expld
.dataseg
.relro_end
)
5404 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
5405 to put expld.dataseg.relro on a (common) page boundary. */
5406 bfd_vma min_base
, old_base
, relro_end
, maxpage
;
5408 expld
.dataseg
.phase
= exp_dataseg_relro_adjust
;
5409 maxpage
= expld
.dataseg
.maxpagesize
;
5410 /* MIN_BASE is the absolute minimum address we are allowed to start the
5411 read-write segment (byte before will be mapped read-only). */
5412 min_base
= (expld
.dataseg
.min_base
+ maxpage
- 1) & ~(maxpage
- 1);
5413 /* OLD_BASE is the address for a feasible minimum address which will
5414 still not cause a data overlap inside MAXPAGE causing file offset skip
5416 old_base
= expld
.dataseg
.base
;
5417 expld
.dataseg
.base
+= (-expld
.dataseg
.relro_end
5418 & (expld
.dataseg
.pagesize
- 1));
5419 /* Compute the expected PT_GNU_RELRO segment end. */
5420 relro_end
= ((expld
.dataseg
.relro_end
+ expld
.dataseg
.pagesize
- 1)
5421 & ~(expld
.dataseg
.pagesize
- 1));
5422 if (min_base
+ maxpage
< expld
.dataseg
.base
)
5424 expld
.dataseg
.base
-= maxpage
;
5425 relro_end
-= maxpage
;
5427 lang_reset_memory_regions ();
5428 one_lang_size_sections_pass (relax
, check_regions
);
5429 if (expld
.dataseg
.relro_end
> relro_end
)
5431 /* The alignment of sections between DATA_SEGMENT_ALIGN
5432 and DATA_SEGMENT_RELRO_END caused huge padding to be
5433 inserted at DATA_SEGMENT_RELRO_END. Try to start a bit lower so
5434 that the section alignments will fit in. */
5436 unsigned int max_alignment_power
= 0;
5438 /* Find maximum alignment power of sections between
5439 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
5440 for (sec
= link_info
.output_bfd
->sections
; sec
; sec
= sec
->next
)
5441 if (sec
->vma
>= expld
.dataseg
.base
5442 && sec
->vma
< expld
.dataseg
.relro_end
5443 && sec
->alignment_power
> max_alignment_power
)
5444 max_alignment_power
= sec
->alignment_power
;
5446 if (((bfd_vma
) 1 << max_alignment_power
) < expld
.dataseg
.pagesize
)
5448 if (expld
.dataseg
.base
- (1 << max_alignment_power
) < old_base
)
5449 expld
.dataseg
.base
+= expld
.dataseg
.pagesize
;
5450 expld
.dataseg
.base
-= (1 << max_alignment_power
);
5451 lang_reset_memory_regions ();
5452 one_lang_size_sections_pass (relax
, check_regions
);
5455 link_info
.relro_start
= expld
.dataseg
.base
;
5456 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5458 else if (expld
.dataseg
.phase
== exp_dataseg_end_seen
)
5460 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5461 a page could be saved in the data segment. */
5462 bfd_vma first
, last
;
5464 first
= -expld
.dataseg
.base
& (expld
.dataseg
.pagesize
- 1);
5465 last
= expld
.dataseg
.end
& (expld
.dataseg
.pagesize
- 1);
5467 && ((expld
.dataseg
.base
& ~(expld
.dataseg
.pagesize
- 1))
5468 != (expld
.dataseg
.end
& ~(expld
.dataseg
.pagesize
- 1)))
5469 && first
+ last
<= expld
.dataseg
.pagesize
)
5471 expld
.dataseg
.phase
= exp_dataseg_adjust
;
5472 lang_reset_memory_regions ();
5473 one_lang_size_sections_pass (relax
, check_regions
);
5476 expld
.dataseg
.phase
= exp_dataseg_done
;
5479 expld
.dataseg
.phase
= exp_dataseg_done
;
5482 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5485 lang_do_assignments_1 (lang_statement_union_type
*s
,
5486 lang_output_section_statement_type
*current_os
,
5490 for (; s
!= NULL
; s
= s
->header
.next
)
5492 switch (s
->header
.type
)
5494 case lang_constructors_statement_enum
:
5495 dot
= lang_do_assignments_1 (constructor_list
.head
,
5496 current_os
, fill
, dot
);
5499 case lang_output_section_statement_enum
:
5501 lang_output_section_statement_type
*os
;
5503 os
= &(s
->output_section_statement
);
5504 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
5506 dot
= os
->bfd_section
->vma
;
5508 lang_do_assignments_1 (os
->children
.head
, os
, os
->fill
, dot
);
5510 /* .tbss sections effectively have zero size. */
5511 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5512 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
5513 || link_info
.relocatable
)
5514 dot
+= TO_ADDR (os
->bfd_section
->size
);
5516 if (os
->update_dot_tree
!= NULL
)
5517 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5522 case lang_wild_statement_enum
:
5524 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
5525 current_os
, fill
, dot
);
5528 case lang_object_symbols_statement_enum
:
5529 case lang_output_statement_enum
:
5530 case lang_target_statement_enum
:
5533 case lang_data_statement_enum
:
5534 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5535 if (expld
.result
.valid_p
)
5537 s
->data_statement
.value
= expld
.result
.value
;
5538 if (expld
.result
.section
!= NULL
)
5539 s
->data_statement
.value
+= expld
.result
.section
->vma
;
5542 einfo (_("%F%P: invalid data statement\n"));
5545 switch (s
->data_statement
.type
)
5563 if (size
< TO_SIZE ((unsigned) 1))
5564 size
= TO_SIZE ((unsigned) 1);
5565 dot
+= TO_ADDR (size
);
5569 case lang_reloc_statement_enum
:
5570 exp_fold_tree (s
->reloc_statement
.addend_exp
,
5571 bfd_abs_section_ptr
, &dot
);
5572 if (expld
.result
.valid_p
)
5573 s
->reloc_statement
.addend_value
= expld
.result
.value
;
5575 einfo (_("%F%P: invalid reloc statement\n"));
5576 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
5579 case lang_input_section_enum
:
5581 asection
*in
= s
->input_section
.section
;
5583 if ((in
->flags
& SEC_EXCLUDE
) == 0)
5584 dot
+= TO_ADDR (in
->size
);
5588 case lang_input_statement_enum
:
5591 case lang_fill_statement_enum
:
5592 fill
= s
->fill_statement
.fill
;
5595 case lang_assignment_statement_enum
:
5596 exp_fold_tree (s
->assignment_statement
.exp
,
5597 current_os
->bfd_section
,
5601 case lang_padding_statement_enum
:
5602 dot
+= TO_ADDR (s
->padding_statement
.size
);
5605 case lang_group_statement_enum
:
5606 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
5607 current_os
, fill
, dot
);
5610 case lang_insert_statement_enum
:
5613 case lang_address_statement_enum
:
5625 lang_do_assignments (lang_phase_type phase
)
5627 expld
.phase
= phase
;
5628 lang_statement_iteration
++;
5629 lang_do_assignments_1 (statement_list
.head
, abs_output_section
, NULL
, 0);
5632 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5633 operator .startof. (section_name), it produces an undefined symbol
5634 .startof.section_name. Similarly, when it sees
5635 .sizeof. (section_name), it produces an undefined symbol
5636 .sizeof.section_name. For all the output sections, we look for
5637 such symbols, and set them to the correct value. */
5640 lang_set_startof (void)
5644 if (link_info
.relocatable
)
5647 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5649 const char *secname
;
5651 struct bfd_link_hash_entry
*h
;
5653 secname
= bfd_get_section_name (link_info
.output_bfd
, s
);
5654 buf
= (char *) xmalloc (10 + strlen (secname
));
5656 sprintf (buf
, ".startof.%s", secname
);
5657 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5658 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5660 h
->type
= bfd_link_hash_defined
;
5661 h
->u
.def
.value
= bfd_get_section_vma (link_info
.output_bfd
, s
);
5662 h
->u
.def
.section
= bfd_abs_section_ptr
;
5665 sprintf (buf
, ".sizeof.%s", secname
);
5666 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5667 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5669 h
->type
= bfd_link_hash_defined
;
5670 h
->u
.def
.value
= TO_ADDR (s
->size
);
5671 h
->u
.def
.section
= bfd_abs_section_ptr
;
5681 struct bfd_link_hash_entry
*h
;
5684 if ((link_info
.relocatable
&& !link_info
.gc_sections
)
5685 || (link_info
.shared
&& !link_info
.executable
))
5686 warn
= entry_from_cmdline
;
5690 /* Force the user to specify a root when generating a relocatable with
5692 if (link_info
.gc_sections
&& link_info
.relocatable
5693 && !(entry_from_cmdline
|| undef_from_cmdline
))
5694 einfo (_("%P%F: gc-sections requires either an entry or "
5695 "an undefined symbol\n"));
5697 if (entry_symbol
.name
== NULL
)
5699 /* No entry has been specified. Look for the default entry, but
5700 don't warn if we don't find it. */
5701 entry_symbol
.name
= entry_symbol_default
;
5705 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
5706 FALSE
, FALSE
, TRUE
);
5708 && (h
->type
== bfd_link_hash_defined
5709 || h
->type
== bfd_link_hash_defweak
)
5710 && h
->u
.def
.section
->output_section
!= NULL
)
5714 val
= (h
->u
.def
.value
5715 + bfd_get_section_vma (link_info
.output_bfd
,
5716 h
->u
.def
.section
->output_section
)
5717 + h
->u
.def
.section
->output_offset
);
5718 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5719 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
5726 /* We couldn't find the entry symbol. Try parsing it as a
5728 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
5731 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5732 einfo (_("%P%F: can't set start address\n"));
5738 /* Can't find the entry symbol, and it's not a number. Use
5739 the first address in the text section. */
5740 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
5744 einfo (_("%P: warning: cannot find entry symbol %s;"
5745 " defaulting to %V\n"),
5747 bfd_get_section_vma (link_info
.output_bfd
, ts
));
5748 if (!(bfd_set_start_address
5749 (link_info
.output_bfd
,
5750 bfd_get_section_vma (link_info
.output_bfd
, ts
))))
5751 einfo (_("%P%F: can't set start address\n"));
5756 einfo (_("%P: warning: cannot find entry symbol %s;"
5757 " not setting start address\n"),
5763 /* Don't bfd_hash_table_free (&lang_definedness_table);
5764 map file output may result in a call of lang_track_definedness. */
5767 /* This is a small function used when we want to ignore errors from
5771 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
5773 /* Don't do anything. */
5776 /* Check that the architecture of all the input files is compatible
5777 with the output file. Also call the backend to let it do any
5778 other checking that is needed. */
5783 lang_statement_union_type
*file
;
5785 const bfd_arch_info_type
*compatible
;
5787 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
5789 #ifdef ENABLE_PLUGINS
5790 /* Don't check format of files claimed by plugin. */
5791 if (file
->input_statement
.flags
.claimed
)
5793 #endif /* ENABLE_PLUGINS */
5794 input_bfd
= file
->input_statement
.the_bfd
;
5796 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
5797 command_line
.accept_unknown_input_arch
);
5799 /* In general it is not possible to perform a relocatable
5800 link between differing object formats when the input
5801 file has relocations, because the relocations in the
5802 input format may not have equivalent representations in
5803 the output format (and besides BFD does not translate
5804 relocs for other link purposes than a final link). */
5805 if ((link_info
.relocatable
|| link_info
.emitrelocations
)
5806 && (compatible
== NULL
5807 || (bfd_get_flavour (input_bfd
)
5808 != bfd_get_flavour (link_info
.output_bfd
)))
5809 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
5811 einfo (_("%P%F: Relocatable linking with relocations from"
5812 " format %s (%B) to format %s (%B) is not supported\n"),
5813 bfd_get_target (input_bfd
), input_bfd
,
5814 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
5815 /* einfo with %F exits. */
5818 if (compatible
== NULL
)
5820 if (command_line
.warn_mismatch
)
5821 einfo (_("%P%X: %s architecture of input file `%B'"
5822 " is incompatible with %s output\n"),
5823 bfd_printable_name (input_bfd
), input_bfd
,
5824 bfd_printable_name (link_info
.output_bfd
));
5826 else if (bfd_count_sections (input_bfd
))
5828 /* If the input bfd has no contents, it shouldn't set the
5829 private data of the output bfd. */
5831 bfd_error_handler_type pfn
= NULL
;
5833 /* If we aren't supposed to warn about mismatched input
5834 files, temporarily set the BFD error handler to a
5835 function which will do nothing. We still want to call
5836 bfd_merge_private_bfd_data, since it may set up
5837 information which is needed in the output file. */
5838 if (! command_line
.warn_mismatch
)
5839 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
5840 if (! bfd_merge_private_bfd_data (input_bfd
, link_info
.output_bfd
))
5842 if (command_line
.warn_mismatch
)
5843 einfo (_("%P%X: failed to merge target specific data"
5844 " of file %B\n"), input_bfd
);
5846 if (! command_line
.warn_mismatch
)
5847 bfd_set_error_handler (pfn
);
5852 /* Look through all the global common symbols and attach them to the
5853 correct section. The -sort-common command line switch may be used
5854 to roughly sort the entries by alignment. */
5859 if (command_line
.inhibit_common_definition
)
5861 if (link_info
.relocatable
5862 && ! command_line
.force_common_definition
)
5865 if (! config
.sort_common
)
5866 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
5871 if (config
.sort_common
== sort_descending
)
5873 for (power
= 4; power
> 0; power
--)
5874 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5877 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5881 for (power
= 0; power
<= 4; power
++)
5882 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5885 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5890 /* Place one common symbol in the correct section. */
5893 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
5895 unsigned int power_of_two
;
5899 if (h
->type
!= bfd_link_hash_common
)
5903 power_of_two
= h
->u
.c
.p
->alignment_power
;
5905 if (config
.sort_common
== sort_descending
5906 && power_of_two
< *(unsigned int *) info
)
5908 else if (config
.sort_common
== sort_ascending
5909 && power_of_two
> *(unsigned int *) info
)
5912 section
= h
->u
.c
.p
->section
;
5913 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
5914 einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
5917 if (config
.map_file
!= NULL
)
5919 static bfd_boolean header_printed
;
5924 if (! header_printed
)
5926 minfo (_("\nAllocating common symbols\n"));
5927 minfo (_("Common symbol size file\n\n"));
5928 header_printed
= TRUE
;
5931 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
5932 DMGL_ANSI
| DMGL_PARAMS
);
5935 minfo ("%s", h
->root
.string
);
5936 len
= strlen (h
->root
.string
);
5941 len
= strlen (name
);
5957 if (size
<= 0xffffffff)
5958 sprintf (buf
, "%lx", (unsigned long) size
);
5960 sprintf_vma (buf
, size
);
5970 minfo ("%B\n", section
->owner
);
5976 /* Run through the input files and ensure that every input section has
5977 somewhere to go. If one is found without a destination then create
5978 an input request and place it into the statement tree. */
5981 lang_place_orphans (void)
5983 LANG_FOR_EACH_INPUT_STATEMENT (file
)
5987 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5989 if (s
->output_section
== NULL
)
5991 /* This section of the file is not attached, root
5992 around for a sensible place for it to go. */
5994 if (file
->flags
.just_syms
)
5995 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
5996 else if ((s
->flags
& SEC_EXCLUDE
) != 0)
5997 s
->output_section
= bfd_abs_section_ptr
;
5998 else if (strcmp (s
->name
, "COMMON") == 0)
6000 /* This is a lonely common section which must have
6001 come from an archive. We attach to the section
6002 with the wildcard. */
6003 if (! link_info
.relocatable
6004 || command_line
.force_common_definition
)
6006 if (default_common_section
== NULL
)
6007 default_common_section
6008 = lang_output_section_statement_lookup (".bss", 0,
6010 lang_add_section (&default_common_section
->children
, s
,
6011 default_common_section
);
6016 const char *name
= s
->name
;
6019 if (config
.unique_orphan_sections
6020 || unique_section_p (s
, NULL
))
6021 constraint
= SPECIAL
;
6023 if (!ldemul_place_orphan (s
, name
, constraint
))
6025 lang_output_section_statement_type
*os
;
6026 os
= lang_output_section_statement_lookup (name
,
6029 if (os
->addr_tree
== NULL
6030 && (link_info
.relocatable
6031 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6032 os
->addr_tree
= exp_intop (0);
6033 lang_add_section (&os
->children
, s
, os
);
6042 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6044 flagword
*ptr_flags
;
6046 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6052 *ptr_flags
|= SEC_ALLOC
;
6056 *ptr_flags
|= SEC_READONLY
;
6060 *ptr_flags
|= SEC_DATA
;
6064 *ptr_flags
|= SEC_CODE
;
6069 *ptr_flags
|= SEC_LOAD
;
6073 einfo (_("%P%F: invalid syntax in flags\n"));
6080 /* Call a function on each input file. This function will be called
6081 on an archive, but not on the elements. */
6084 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6086 lang_input_statement_type
*f
;
6088 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
6090 f
= (lang_input_statement_type
*) f
->next_real_file
)
6094 /* Call a function on each file. The function will be called on all
6095 the elements of an archive which are included in the link, but will
6096 not be called on the archive file itself. */
6099 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6101 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6108 ldlang_add_file (lang_input_statement_type
*entry
)
6110 lang_statement_append (&file_chain
,
6111 (lang_statement_union_type
*) entry
,
6114 /* The BFD linker needs to have a list of all input BFDs involved in
6116 ASSERT (entry
->the_bfd
->link_next
== NULL
);
6117 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6119 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6120 link_info
.input_bfds_tail
= &entry
->the_bfd
->link_next
;
6121 entry
->the_bfd
->usrdata
= entry
;
6122 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6124 /* Look through the sections and check for any which should not be
6125 included in the link. We need to do this now, so that we can
6126 notice when the backend linker tries to report multiple
6127 definition errors for symbols which are in sections we aren't
6128 going to link. FIXME: It might be better to entirely ignore
6129 symbols which are defined in sections which are going to be
6130 discarded. This would require modifying the backend linker for
6131 each backend which might set the SEC_LINK_ONCE flag. If we do
6132 this, we should probably handle SEC_EXCLUDE in the same way. */
6134 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6138 lang_add_output (const char *name
, int from_script
)
6140 /* Make -o on command line override OUTPUT in script. */
6141 if (!had_output_filename
|| !from_script
)
6143 output_filename
= name
;
6144 had_output_filename
= TRUE
;
6148 static lang_output_section_statement_type
*current_section
;
6159 for (l
= 0; l
< 32; l
++)
6161 if (i
>= (unsigned int) x
)
6169 lang_output_section_statement_type
*
6170 lang_enter_output_section_statement (const char *output_section_statement_name
,
6171 etree_type
*address_exp
,
6172 enum section_type sectype
,
6174 etree_type
*subalign
,
6178 lang_output_section_statement_type
*os
;
6180 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6182 current_section
= os
;
6184 if (os
->addr_tree
== NULL
)
6186 os
->addr_tree
= address_exp
;
6188 os
->sectype
= sectype
;
6189 if (sectype
!= noload_section
)
6190 os
->flags
= SEC_NO_FLAGS
;
6192 os
->flags
= SEC_NEVER_LOAD
;
6193 os
->block_value
= 1;
6195 /* Make next things chain into subchain of this. */
6196 push_stat_ptr (&os
->children
);
6198 os
->subsection_alignment
=
6199 topower (exp_get_value_int (subalign
, -1, "subsection alignment"));
6200 os
->section_alignment
=
6201 topower (exp_get_value_int (align
, -1, "section alignment"));
6203 os
->load_base
= ebase
;
6210 lang_output_statement_type
*new_stmt
;
6212 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6213 new_stmt
->name
= output_filename
;
6217 /* Reset the current counters in the regions. */
6220 lang_reset_memory_regions (void)
6222 lang_memory_region_type
*p
= lang_memory_region_list
;
6224 lang_output_section_statement_type
*os
;
6226 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
6228 p
->current
= p
->origin
;
6232 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6236 os
->processed_vma
= FALSE
;
6237 os
->processed_lma
= FALSE
;
6240 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6242 /* Save the last size for possible use by bfd_relax_section. */
6243 o
->rawsize
= o
->size
;
6248 /* Worker for lang_gc_sections_1. */
6251 gc_section_callback (lang_wild_statement_type
*ptr
,
6252 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6254 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6255 void *data ATTRIBUTE_UNUSED
)
6257 /* If the wild pattern was marked KEEP, the member sections
6258 should be as well. */
6259 if (ptr
->keep_sections
)
6260 section
->flags
|= SEC_KEEP
;
6263 /* Iterate over sections marking them against GC. */
6266 lang_gc_sections_1 (lang_statement_union_type
*s
)
6268 for (; s
!= NULL
; s
= s
->header
.next
)
6270 switch (s
->header
.type
)
6272 case lang_wild_statement_enum
:
6273 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
6275 case lang_constructors_statement_enum
:
6276 lang_gc_sections_1 (constructor_list
.head
);
6278 case lang_output_section_statement_enum
:
6279 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
6281 case lang_group_statement_enum
:
6282 lang_gc_sections_1 (s
->group_statement
.children
.head
);
6291 lang_gc_sections (void)
6293 /* Keep all sections so marked in the link script. */
6295 lang_gc_sections_1 (statement_list
.head
);
6297 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6298 the special case of debug info. (See bfd/stabs.c)
6299 Twiddle the flag here, to simplify later linker code. */
6300 if (link_info
.relocatable
)
6302 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6305 #ifdef ENABLE_PLUGINS
6306 if (f
->flags
.claimed
)
6309 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6310 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
6311 sec
->flags
&= ~SEC_EXCLUDE
;
6315 if (link_info
.gc_sections
)
6316 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
6319 /* Worker for lang_find_relro_sections_1. */
6322 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
6323 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6325 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6328 /* Discarded, excluded and ignored sections effectively have zero
6330 if (section
->output_section
!= NULL
6331 && section
->output_section
->owner
== link_info
.output_bfd
6332 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
6333 && !IGNORE_SECTION (section
)
6334 && section
->size
!= 0)
6336 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
6337 *has_relro_section
= TRUE
;
6341 /* Iterate over sections for relro sections. */
6344 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
6345 bfd_boolean
*has_relro_section
)
6347 if (*has_relro_section
)
6350 for (; s
!= NULL
; s
= s
->header
.next
)
6352 if (s
== expld
.dataseg
.relro_end_stat
)
6355 switch (s
->header
.type
)
6357 case lang_wild_statement_enum
:
6358 walk_wild (&s
->wild_statement
,
6359 find_relro_section_callback
,
6362 case lang_constructors_statement_enum
:
6363 lang_find_relro_sections_1 (constructor_list
.head
,
6366 case lang_output_section_statement_enum
:
6367 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
6370 case lang_group_statement_enum
:
6371 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
6381 lang_find_relro_sections (void)
6383 bfd_boolean has_relro_section
= FALSE
;
6385 /* Check all sections in the link script. */
6387 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
6388 &has_relro_section
);
6390 if (!has_relro_section
)
6391 link_info
.relro
= FALSE
;
6394 /* Relax all sections until bfd_relax_section gives up. */
6397 lang_relax_sections (bfd_boolean need_layout
)
6399 if (RELAXATION_ENABLED
)
6401 /* We may need more than one relaxation pass. */
6402 int i
= link_info
.relax_pass
;
6404 /* The backend can use it to determine the current pass. */
6405 link_info
.relax_pass
= 0;
6409 /* Keep relaxing until bfd_relax_section gives up. */
6410 bfd_boolean relax_again
;
6412 link_info
.relax_trip
= -1;
6415 link_info
.relax_trip
++;
6417 /* Note: pe-dll.c does something like this also. If you find
6418 you need to change this code, you probably need to change
6419 pe-dll.c also. DJ */
6421 /* Do all the assignments with our current guesses as to
6423 lang_do_assignments (lang_assigning_phase_enum
);
6425 /* We must do this after lang_do_assignments, because it uses
6427 lang_reset_memory_regions ();
6429 /* Perform another relax pass - this time we know where the
6430 globals are, so can make a better guess. */
6431 relax_again
= FALSE
;
6432 lang_size_sections (&relax_again
, FALSE
);
6434 while (relax_again
);
6436 link_info
.relax_pass
++;
6443 /* Final extra sizing to report errors. */
6444 lang_do_assignments (lang_assigning_phase_enum
);
6445 lang_reset_memory_regions ();
6446 lang_size_sections (NULL
, TRUE
);
6450 #ifdef ENABLE_PLUGINS
6451 /* Find the insert point for the plugin's replacement files. We
6452 place them after the first claimed real object file, or if the
6453 first claimed object is an archive member, after the last real
6454 object file immediately preceding the archive. In the event
6455 no objects have been claimed at all, we return the first dummy
6456 object file on the list as the insert point; that works, but
6457 the callee must be careful when relinking the file_chain as it
6458 is not actually on that chain, only the statement_list and the
6459 input_file list; in that case, the replacement files must be
6460 inserted at the head of the file_chain. */
6462 static lang_input_statement_type
*
6463 find_replacements_insert_point (void)
6465 lang_input_statement_type
*claim1
, *lastobject
;
6466 lastobject
= &input_file_chain
.head
->input_statement
;
6467 for (claim1
= &file_chain
.head
->input_statement
;
6469 claim1
= &claim1
->next
->input_statement
)
6471 if (claim1
->flags
.claimed
)
6472 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
6473 /* Update lastobject if this is a real object file. */
6474 if (claim1
->the_bfd
&& (claim1
->the_bfd
->my_archive
== NULL
))
6475 lastobject
= claim1
;
6477 /* No files were claimed by the plugin. Choose the last object
6478 file found on the list (maybe the first, dummy entry) as the
6483 /* Insert SRCLIST into DESTLIST after given element by chaining
6484 on FIELD as the next-pointer. (Counterintuitively does not need
6485 a pointer to the actual after-node itself, just its chain field.) */
6488 lang_list_insert_after (lang_statement_list_type
*destlist
,
6489 lang_statement_list_type
*srclist
,
6490 lang_statement_union_type
**field
)
6492 *(srclist
->tail
) = *field
;
6493 *field
= srclist
->head
;
6494 if (destlist
->tail
== field
)
6495 destlist
->tail
= srclist
->tail
;
6498 /* Detach new nodes added to DESTLIST since the time ORIGLIST
6499 was taken as a copy of it and leave them in ORIGLIST. */
6502 lang_list_remove_tail (lang_statement_list_type
*destlist
,
6503 lang_statement_list_type
*origlist
)
6505 union lang_statement_union
**savetail
;
6506 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
6507 ASSERT (origlist
->head
== destlist
->head
);
6508 savetail
= origlist
->tail
;
6509 origlist
->head
= *(savetail
);
6510 origlist
->tail
= destlist
->tail
;
6511 destlist
->tail
= savetail
;
6514 #endif /* ENABLE_PLUGINS */
6519 /* Finalize dynamic list. */
6520 if (link_info
.dynamic_list
)
6521 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
6523 current_target
= default_target
;
6525 /* Open the output file. */
6526 lang_for_each_statement (ldlang_open_output
);
6529 ldemul_create_output_section_statements ();
6531 /* Add to the hash table all undefineds on the command line. */
6532 lang_place_undefineds ();
6534 if (!bfd_section_already_linked_table_init ())
6535 einfo (_("%P%F: Failed to create hash table\n"));
6537 /* Create a bfd for each input file. */
6538 current_target
= default_target
;
6539 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
6541 #ifdef ENABLE_PLUGINS
6542 if (plugin_active_plugins_p ())
6544 lang_statement_list_type added
;
6545 lang_statement_list_type files
, inputfiles
;
6547 /* Now all files are read, let the plugin(s) decide if there
6548 are any more to be added to the link before we call the
6549 emulation's after_open hook. We create a private list of
6550 input statements for this purpose, which we will eventually
6551 insert into the global statment list after the first claimed
6554 /* We need to manipulate all three chains in synchrony. */
6556 inputfiles
= input_file_chain
;
6557 if (plugin_call_all_symbols_read ())
6558 einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
6559 plugin_error_plugin ());
6560 /* Open any newly added files, updating the file chains. */
6561 link_info
.loading_lto_outputs
= TRUE
;
6562 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
6563 /* Restore the global list pointer now they have all been added. */
6564 lang_list_remove_tail (stat_ptr
, &added
);
6565 /* And detach the fresh ends of the file lists. */
6566 lang_list_remove_tail (&file_chain
, &files
);
6567 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
6568 /* Were any new files added? */
6569 if (added
.head
!= NULL
)
6571 /* If so, we will insert them into the statement list immediately
6572 after the first input file that was claimed by the plugin. */
6573 plugin_insert
= find_replacements_insert_point ();
6574 /* If a plugin adds input files without having claimed any, we
6575 don't really have a good idea where to place them. Just putting
6576 them at the start or end of the list is liable to leave them
6577 outside the crtbegin...crtend range. */
6578 ASSERT (plugin_insert
!= NULL
);
6579 /* Splice the new statement list into the old one. */
6580 lang_list_insert_after (stat_ptr
, &added
,
6581 &plugin_insert
->header
.next
);
6582 /* Likewise for the file chains. */
6583 lang_list_insert_after (&input_file_chain
, &inputfiles
,
6584 &plugin_insert
->next_real_file
);
6585 /* We must be careful when relinking file_chain; we may need to
6586 insert the new files at the head of the list if the insert
6587 point chosen is the dummy first input file. */
6588 if (plugin_insert
->filename
)
6589 lang_list_insert_after (&file_chain
, &files
, &plugin_insert
->next
);
6591 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
6593 /* Rescan archives in case new undefined symbols have appeared. */
6594 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
6597 #endif /* ENABLE_PLUGINS */
6599 link_info
.gc_sym_list
= &entry_symbol
;
6600 if (entry_symbol
.name
== NULL
)
6601 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
6603 ldemul_after_open ();
6605 bfd_section_already_linked_table_free ();
6607 /* Make sure that we're not mixing architectures. We call this
6608 after all the input files have been opened, but before we do any
6609 other processing, so that any operations merge_private_bfd_data
6610 does on the output file will be known during the rest of the
6614 /* Handle .exports instead of a version script if we're told to do so. */
6615 if (command_line
.version_exports_section
)
6616 lang_do_version_exports_section ();
6618 /* Build all sets based on the information gathered from the input
6620 ldctor_build_sets ();
6622 /* PR 13683: We must rerun the assignments prior to running garbage
6623 collection in order to make sure that all symbol aliases are resolved. */
6624 lang_do_assignments (lang_mark_phase_enum
);
6625 expld
.phase
= lang_first_phase_enum
;
6627 /* Remove unreferenced sections if asked to. */
6628 lang_gc_sections ();
6630 /* Size up the common data. */
6633 /* Update wild statements. */
6634 update_wild_statements (statement_list
.head
);
6636 /* Run through the contours of the script and attach input sections
6637 to the correct output sections. */
6638 lang_statement_iteration
++;
6639 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
6641 process_insert_statements ();
6643 /* Find any sections not attached explicitly and handle them. */
6644 lang_place_orphans ();
6646 if (! link_info
.relocatable
)
6650 /* Merge SEC_MERGE sections. This has to be done after GC of
6651 sections, so that GCed sections are not merged, but before
6652 assigning dynamic symbols, since removing whole input sections
6654 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
6656 /* Look for a text section and set the readonly attribute in it. */
6657 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
6661 if (config
.text_read_only
)
6662 found
->flags
|= SEC_READONLY
;
6664 found
->flags
&= ~SEC_READONLY
;
6668 /* Do anything special before sizing sections. This is where ELF
6669 and other back-ends size dynamic sections. */
6670 ldemul_before_allocation ();
6672 /* We must record the program headers before we try to fix the
6673 section positions, since they will affect SIZEOF_HEADERS. */
6674 lang_record_phdrs ();
6676 /* Check relro sections. */
6677 if (link_info
.relro
&& ! link_info
.relocatable
)
6678 lang_find_relro_sections ();
6680 /* Size up the sections. */
6681 lang_size_sections (NULL
, ! RELAXATION_ENABLED
);
6683 /* See if anything special should be done now we know how big
6684 everything is. This is where relaxation is done. */
6685 ldemul_after_allocation ();
6687 /* Fix any .startof. or .sizeof. symbols. */
6688 lang_set_startof ();
6690 /* Do all the assignments, now that we know the final resting places
6691 of all the symbols. */
6692 lang_do_assignments (lang_final_phase_enum
);
6696 /* Make sure that the section addresses make sense. */
6697 if (command_line
.check_section_addresses
)
6698 lang_check_section_addresses ();
6703 /* EXPORTED TO YACC */
6706 lang_add_wild (struct wildcard_spec
*filespec
,
6707 struct wildcard_list
*section_list
,
6708 bfd_boolean keep_sections
)
6710 struct wildcard_list
*curr
, *next
;
6711 lang_wild_statement_type
*new_stmt
;
6713 /* Reverse the list as the parser puts it back to front. */
6714 for (curr
= section_list
, section_list
= NULL
;
6716 section_list
= curr
, curr
= next
)
6718 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
6719 placed_commons
= TRUE
;
6722 curr
->next
= section_list
;
6725 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
6727 if (strcmp (filespec
->name
, "*") == 0)
6728 filespec
->name
= NULL
;
6729 else if (! wildcardp (filespec
->name
))
6730 lang_has_input_file
= TRUE
;
6733 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
6734 new_stmt
->filename
= NULL
;
6735 new_stmt
->filenames_sorted
= FALSE
;
6736 new_stmt
->section_flag_list
= NULL
;
6737 if (filespec
!= NULL
)
6739 new_stmt
->filename
= filespec
->name
;
6740 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
6741 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
6743 new_stmt
->section_list
= section_list
;
6744 new_stmt
->keep_sections
= keep_sections
;
6745 lang_list_init (&new_stmt
->children
);
6746 analyze_walk_wild_section_handler (new_stmt
);
6750 lang_section_start (const char *name
, etree_type
*address
,
6751 const segment_type
*segment
)
6753 lang_address_statement_type
*ad
;
6755 ad
= new_stat (lang_address_statement
, stat_ptr
);
6756 ad
->section_name
= name
;
6757 ad
->address
= address
;
6758 ad
->segment
= segment
;
6761 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
6762 because of a -e argument on the command line, or zero if this is
6763 called by ENTRY in a linker script. Command line arguments take
6767 lang_add_entry (const char *name
, bfd_boolean cmdline
)
6769 if (entry_symbol
.name
== NULL
6771 || ! entry_from_cmdline
)
6773 entry_symbol
.name
= name
;
6774 entry_from_cmdline
= cmdline
;
6778 /* Set the default start symbol to NAME. .em files should use this,
6779 not lang_add_entry, to override the use of "start" if neither the
6780 linker script nor the command line specifies an entry point. NAME
6781 must be permanently allocated. */
6783 lang_default_entry (const char *name
)
6785 entry_symbol_default
= name
;
6789 lang_add_target (const char *name
)
6791 lang_target_statement_type
*new_stmt
;
6793 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
6794 new_stmt
->target
= name
;
6798 lang_add_map (const char *name
)
6805 map_option_f
= TRUE
;
6813 lang_add_fill (fill_type
*fill
)
6815 lang_fill_statement_type
*new_stmt
;
6817 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
6818 new_stmt
->fill
= fill
;
6822 lang_add_data (int type
, union etree_union
*exp
)
6824 lang_data_statement_type
*new_stmt
;
6826 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
6827 new_stmt
->exp
= exp
;
6828 new_stmt
->type
= type
;
6831 /* Create a new reloc statement. RELOC is the BFD relocation type to
6832 generate. HOWTO is the corresponding howto structure (we could
6833 look this up, but the caller has already done so). SECTION is the
6834 section to generate a reloc against, or NAME is the name of the
6835 symbol to generate a reloc against. Exactly one of SECTION and
6836 NAME must be NULL. ADDEND is an expression for the addend. */
6839 lang_add_reloc (bfd_reloc_code_real_type reloc
,
6840 reloc_howto_type
*howto
,
6843 union etree_union
*addend
)
6845 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
6849 p
->section
= section
;
6851 p
->addend_exp
= addend
;
6853 p
->addend_value
= 0;
6854 p
->output_section
= NULL
;
6855 p
->output_offset
= 0;
6858 lang_assignment_statement_type
*
6859 lang_add_assignment (etree_type
*exp
)
6861 lang_assignment_statement_type
*new_stmt
;
6863 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
6864 new_stmt
->exp
= exp
;
6869 lang_add_attribute (enum statement_enum attribute
)
6871 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
6875 lang_startup (const char *name
)
6877 if (first_file
->filename
!= NULL
)
6879 einfo (_("%P%F: multiple STARTUP files\n"));
6881 first_file
->filename
= name
;
6882 first_file
->local_sym_name
= name
;
6883 first_file
->flags
.real
= TRUE
;
6887 lang_float (bfd_boolean maybe
)
6889 lang_float_flag
= maybe
;
6893 /* Work out the load- and run-time regions from a script statement, and
6894 store them in *LMA_REGION and *REGION respectively.
6896 MEMSPEC is the name of the run-time region, or the value of
6897 DEFAULT_MEMORY_REGION if the statement didn't specify one.
6898 LMA_MEMSPEC is the name of the load-time region, or null if the
6899 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
6900 had an explicit load address.
6902 It is an error to specify both a load region and a load address. */
6905 lang_get_regions (lang_memory_region_type
**region
,
6906 lang_memory_region_type
**lma_region
,
6907 const char *memspec
,
6908 const char *lma_memspec
,
6909 bfd_boolean have_lma
,
6910 bfd_boolean have_vma
)
6912 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
6914 /* If no runtime region or VMA has been specified, but the load region
6915 has been specified, then use the load region for the runtime region
6917 if (lma_memspec
!= NULL
6919 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
6920 *region
= *lma_region
;
6922 *region
= lang_memory_region_lookup (memspec
, FALSE
);
6924 if (have_lma
&& lma_memspec
!= 0)
6925 einfo (_("%X%P:%S: section has both a load address and a load region\n"),
6930 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
6931 lang_output_section_phdr_list
*phdrs
,
6932 const char *lma_memspec
)
6934 lang_get_regions (¤t_section
->region
,
6935 ¤t_section
->lma_region
,
6936 memspec
, lma_memspec
,
6937 current_section
->load_base
!= NULL
,
6938 current_section
->addr_tree
!= NULL
);
6940 /* If this section has no load region or base, but uses the same
6941 region as the previous section, then propagate the previous
6942 section's load region. */
6944 if (current_section
->lma_region
== NULL
6945 && current_section
->load_base
== NULL
6946 && current_section
->addr_tree
== NULL
6947 && current_section
->region
== current_section
->prev
->region
)
6948 current_section
->lma_region
= current_section
->prev
->lma_region
;
6950 current_section
->fill
= fill
;
6951 current_section
->phdrs
= phdrs
;
6955 /* Create an absolute symbol with the given name with the value of the
6956 address of first byte of the section named.
6958 If the symbol already exists, then do nothing. */
6961 lang_abs_symbol_at_beginning_of (const char *secname
, const char *name
)
6963 struct bfd_link_hash_entry
*h
;
6965 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
6967 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6969 if (h
->type
== bfd_link_hash_new
6970 || h
->type
== bfd_link_hash_undefined
)
6974 h
->type
= bfd_link_hash_defined
;
6976 sec
= bfd_get_section_by_name (link_info
.output_bfd
, secname
);
6980 h
->u
.def
.value
= bfd_get_section_vma (link_info
.output_bfd
, sec
);
6982 h
->u
.def
.section
= bfd_abs_section_ptr
;
6986 /* Create an absolute symbol with the given name with the value of the
6987 address of the first byte after the end of the section named.
6989 If the symbol already exists, then do nothing. */
6992 lang_abs_symbol_at_end_of (const char *secname
, const char *name
)
6994 struct bfd_link_hash_entry
*h
;
6996 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
6998 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
7000 if (h
->type
== bfd_link_hash_new
7001 || h
->type
== bfd_link_hash_undefined
)
7005 h
->type
= bfd_link_hash_defined
;
7007 sec
= bfd_get_section_by_name (link_info
.output_bfd
, secname
);
7011 h
->u
.def
.value
= (bfd_get_section_vma (link_info
.output_bfd
, sec
)
7012 + TO_ADDR (sec
->size
));
7014 h
->u
.def
.section
= bfd_abs_section_ptr
;
7019 lang_statement_append (lang_statement_list_type
*list
,
7020 lang_statement_union_type
*element
,
7021 lang_statement_union_type
**field
)
7023 *(list
->tail
) = element
;
7027 /* Set the output format type. -oformat overrides scripts. */
7030 lang_add_output_format (const char *format
,
7035 if (output_target
== NULL
|| !from_script
)
7037 if (command_line
.endian
== ENDIAN_BIG
7040 else if (command_line
.endian
== ENDIAN_LITTLE
7044 output_target
= format
;
7049 lang_add_insert (const char *where
, int is_before
)
7051 lang_insert_statement_type
*new_stmt
;
7053 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7054 new_stmt
->where
= where
;
7055 new_stmt
->is_before
= is_before
;
7056 saved_script_handle
= previous_script_handle
;
7059 /* Enter a group. This creates a new lang_group_statement, and sets
7060 stat_ptr to build new statements within the group. */
7063 lang_enter_group (void)
7065 lang_group_statement_type
*g
;
7067 g
= new_stat (lang_group_statement
, stat_ptr
);
7068 lang_list_init (&g
->children
);
7069 push_stat_ptr (&g
->children
);
7072 /* Leave a group. This just resets stat_ptr to start writing to the
7073 regular list of statements again. Note that this will not work if
7074 groups can occur inside anything else which can adjust stat_ptr,
7075 but currently they can't. */
7078 lang_leave_group (void)
7083 /* Add a new program header. This is called for each entry in a PHDRS
7084 command in a linker script. */
7087 lang_new_phdr (const char *name
,
7089 bfd_boolean filehdr
,
7094 struct lang_phdr
*n
, **pp
;
7097 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
7100 n
->type
= exp_get_value_int (type
, 0, "program header type");
7101 n
->filehdr
= filehdr
;
7106 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
7108 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7111 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
7113 einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported"
7114 " when prior PT_LOAD headers lack them\n"), NULL
);
7121 /* Record the program header information in the output BFD. FIXME: We
7122 should not be calling an ELF specific function here. */
7125 lang_record_phdrs (void)
7129 lang_output_section_phdr_list
*last
;
7130 struct lang_phdr
*l
;
7131 lang_output_section_statement_type
*os
;
7134 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
7137 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
7144 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7148 lang_output_section_phdr_list
*pl
;
7150 if (os
->constraint
< 0)
7158 if (os
->sectype
== noload_section
7159 || os
->bfd_section
== NULL
7160 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
7163 /* Don't add orphans to PT_INTERP header. */
7169 lang_output_section_statement_type
* tmp_os
;
7171 /* If we have not run across a section with a program
7172 header assigned to it yet, then scan forwards to find
7173 one. This prevents inconsistencies in the linker's
7174 behaviour when a script has specified just a single
7175 header and there are sections in that script which are
7176 not assigned to it, and which occur before the first
7177 use of that header. See here for more details:
7178 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
7179 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
7182 last
= tmp_os
->phdrs
;
7186 einfo (_("%F%P: no sections assigned to phdrs\n"));
7191 if (os
->bfd_section
== NULL
)
7194 for (; pl
!= NULL
; pl
= pl
->next
)
7196 if (strcmp (pl
->name
, l
->name
) == 0)
7201 secs
= (asection
**) xrealloc (secs
,
7202 alc
* sizeof (asection
*));
7204 secs
[c
] = os
->bfd_section
;
7211 if (l
->flags
== NULL
)
7214 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
7219 at
= exp_get_vma (l
->at
, 0, "phdr load address");
7221 if (! bfd_record_phdr (link_info
.output_bfd
, l
->type
,
7222 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
7223 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
7224 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
7229 /* Make sure all the phdr assignments succeeded. */
7230 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7234 lang_output_section_phdr_list
*pl
;
7236 if (os
->constraint
< 0
7237 || os
->bfd_section
== NULL
)
7240 for (pl
= os
->phdrs
;
7243 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
7244 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
7245 os
->name
, pl
->name
);
7249 /* Record a list of sections which may not be cross referenced. */
7252 lang_add_nocrossref (lang_nocrossref_type
*l
)
7254 struct lang_nocrossrefs
*n
;
7256 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
7257 n
->next
= nocrossref_list
;
7259 nocrossref_list
= n
;
7261 /* Set notice_all so that we get informed about all symbols. */
7262 link_info
.notice_all
= TRUE
;
7265 /* Overlay handling. We handle overlays with some static variables. */
7267 /* The overlay virtual address. */
7268 static etree_type
*overlay_vma
;
7269 /* And subsection alignment. */
7270 static etree_type
*overlay_subalign
;
7272 /* An expression for the maximum section size seen so far. */
7273 static etree_type
*overlay_max
;
7275 /* A list of all the sections in this overlay. */
7277 struct overlay_list
{
7278 struct overlay_list
*next
;
7279 lang_output_section_statement_type
*os
;
7282 static struct overlay_list
*overlay_list
;
7284 /* Start handling an overlay. */
7287 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
7289 /* The grammar should prevent nested overlays from occurring. */
7290 ASSERT (overlay_vma
== NULL
7291 && overlay_subalign
== NULL
7292 && overlay_max
== NULL
);
7294 overlay_vma
= vma_expr
;
7295 overlay_subalign
= subalign
;
7298 /* Start a section in an overlay. We handle this by calling
7299 lang_enter_output_section_statement with the correct VMA.
7300 lang_leave_overlay sets up the LMA and memory regions. */
7303 lang_enter_overlay_section (const char *name
)
7305 struct overlay_list
*n
;
7308 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
7309 0, overlay_subalign
, 0, 0);
7311 /* If this is the first section, then base the VMA of future
7312 sections on this one. This will work correctly even if `.' is
7313 used in the addresses. */
7314 if (overlay_list
== NULL
)
7315 overlay_vma
= exp_nameop (ADDR
, name
);
7317 /* Remember the section. */
7318 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
7319 n
->os
= current_section
;
7320 n
->next
= overlay_list
;
7323 size
= exp_nameop (SIZEOF
, name
);
7325 /* Arrange to work out the maximum section end address. */
7326 if (overlay_max
== NULL
)
7329 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
7332 /* Finish a section in an overlay. There isn't any special to do
7336 lang_leave_overlay_section (fill_type
*fill
,
7337 lang_output_section_phdr_list
*phdrs
)
7344 name
= current_section
->name
;
7346 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
7347 region and that no load-time region has been specified. It doesn't
7348 really matter what we say here, since lang_leave_overlay will
7350 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
7352 /* Define the magic symbols. */
7354 clean
= (char *) xmalloc (strlen (name
) + 1);
7356 for (s1
= name
; *s1
!= '\0'; s1
++)
7357 if (ISALNUM (*s1
) || *s1
== '_')
7361 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
7362 sprintf (buf
, "__load_start_%s", clean
);
7363 lang_add_assignment (exp_provide (buf
,
7364 exp_nameop (LOADADDR
, name
),
7367 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
7368 sprintf (buf
, "__load_stop_%s", clean
);
7369 lang_add_assignment (exp_provide (buf
,
7371 exp_nameop (LOADADDR
, name
),
7372 exp_nameop (SIZEOF
, name
)),
7378 /* Finish an overlay. If there are any overlay wide settings, this
7379 looks through all the sections in the overlay and sets them. */
7382 lang_leave_overlay (etree_type
*lma_expr
,
7385 const char *memspec
,
7386 lang_output_section_phdr_list
*phdrs
,
7387 const char *lma_memspec
)
7389 lang_memory_region_type
*region
;
7390 lang_memory_region_type
*lma_region
;
7391 struct overlay_list
*l
;
7392 lang_nocrossref_type
*nocrossref
;
7394 lang_get_regions (®ion
, &lma_region
,
7395 memspec
, lma_memspec
,
7396 lma_expr
!= NULL
, FALSE
);
7400 /* After setting the size of the last section, set '.' to end of the
7402 if (overlay_list
!= NULL
)
7403 overlay_list
->os
->update_dot_tree
7404 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
));
7409 struct overlay_list
*next
;
7411 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
7414 l
->os
->region
= region
;
7415 l
->os
->lma_region
= lma_region
;
7417 /* The first section has the load address specified in the
7418 OVERLAY statement. The rest are worked out from that.
7419 The base address is not needed (and should be null) if
7420 an LMA region was specified. */
7423 l
->os
->load_base
= lma_expr
;
7424 l
->os
->sectype
= normal_section
;
7426 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
7427 l
->os
->phdrs
= phdrs
;
7431 lang_nocrossref_type
*nc
;
7433 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
7434 nc
->name
= l
->os
->name
;
7435 nc
->next
= nocrossref
;
7444 if (nocrossref
!= NULL
)
7445 lang_add_nocrossref (nocrossref
);
7448 overlay_list
= NULL
;
7452 /* Version handling. This is only useful for ELF. */
7454 /* If PREV is NULL, return first version pattern matching particular symbol.
7455 If PREV is non-NULL, return first version pattern matching particular
7456 symbol after PREV (previously returned by lang_vers_match). */
7458 static struct bfd_elf_version_expr
*
7459 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
7460 struct bfd_elf_version_expr
*prev
,
7464 const char *cxx_sym
= sym
;
7465 const char *java_sym
= sym
;
7466 struct bfd_elf_version_expr
*expr
= NULL
;
7467 enum demangling_styles curr_style
;
7469 curr_style
= CURRENT_DEMANGLING_STYLE
;
7470 cplus_demangle_set_style (no_demangling
);
7471 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
7474 cplus_demangle_set_style (curr_style
);
7476 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7478 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
7479 DMGL_PARAMS
| DMGL_ANSI
);
7483 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7485 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
7490 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
7492 struct bfd_elf_version_expr e
;
7494 switch (prev
? prev
->mask
: 0)
7497 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
7500 expr
= (struct bfd_elf_version_expr
*)
7501 htab_find ((htab_t
) head
->htab
, &e
);
7502 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
7503 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
7509 case BFD_ELF_VERSION_C_TYPE
:
7510 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7512 e
.pattern
= cxx_sym
;
7513 expr
= (struct bfd_elf_version_expr
*)
7514 htab_find ((htab_t
) head
->htab
, &e
);
7515 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
7516 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7522 case BFD_ELF_VERSION_CXX_TYPE
:
7523 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7525 e
.pattern
= java_sym
;
7526 expr
= (struct bfd_elf_version_expr
*)
7527 htab_find ((htab_t
) head
->htab
, &e
);
7528 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
7529 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7540 /* Finally, try the wildcards. */
7541 if (prev
== NULL
|| prev
->literal
)
7542 expr
= head
->remaining
;
7545 for (; expr
; expr
= expr
->next
)
7552 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
7555 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7557 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7561 if (fnmatch (expr
->pattern
, s
, 0) == 0)
7567 free ((char *) c_sym
);
7569 free ((char *) cxx_sym
);
7570 if (java_sym
!= sym
)
7571 free ((char *) java_sym
);
7575 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7576 return a pointer to the symbol name with any backslash quotes removed. */
7579 realsymbol (const char *pattern
)
7582 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
7583 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
7585 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
7587 /* It is a glob pattern only if there is no preceding
7591 /* Remove the preceding backslash. */
7598 if (*p
== '?' || *p
== '*' || *p
== '[')
7605 backslash
= *p
== '\\';
7621 /* This is called for each variable name or match expression. NEW_NAME is
7622 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7623 pattern to be matched against symbol names. */
7625 struct bfd_elf_version_expr
*
7626 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
7627 const char *new_name
,
7629 bfd_boolean literal_p
)
7631 struct bfd_elf_version_expr
*ret
;
7633 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
7637 ret
->literal
= TRUE
;
7638 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
7639 if (ret
->pattern
== NULL
)
7641 ret
->pattern
= new_name
;
7642 ret
->literal
= FALSE
;
7645 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
7646 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7647 else if (strcasecmp (lang
, "C++") == 0)
7648 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
7649 else if (strcasecmp (lang
, "Java") == 0)
7650 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
7653 einfo (_("%X%P: unknown language `%s' in version information\n"),
7655 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7658 return ldemul_new_vers_pattern (ret
);
7661 /* This is called for each set of variable names and match
7664 struct bfd_elf_version_tree
*
7665 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
7666 struct bfd_elf_version_expr
*locals
)
7668 struct bfd_elf_version_tree
*ret
;
7670 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
7671 ret
->globals
.list
= globals
;
7672 ret
->locals
.list
= locals
;
7673 ret
->match
= lang_vers_match
;
7674 ret
->name_indx
= (unsigned int) -1;
7678 /* This static variable keeps track of version indices. */
7680 static int version_index
;
7683 version_expr_head_hash (const void *p
)
7685 const struct bfd_elf_version_expr
*e
=
7686 (const struct bfd_elf_version_expr
*) p
;
7688 return htab_hash_string (e
->pattern
);
7692 version_expr_head_eq (const void *p1
, const void *p2
)
7694 const struct bfd_elf_version_expr
*e1
=
7695 (const struct bfd_elf_version_expr
*) p1
;
7696 const struct bfd_elf_version_expr
*e2
=
7697 (const struct bfd_elf_version_expr
*) p2
;
7699 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
7703 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
7706 struct bfd_elf_version_expr
*e
, *next
;
7707 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
7709 for (e
= head
->list
; e
; e
= e
->next
)
7713 head
->mask
|= e
->mask
;
7718 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
7719 version_expr_head_eq
, NULL
);
7720 list_loc
= &head
->list
;
7721 remaining_loc
= &head
->remaining
;
7722 for (e
= head
->list
; e
; e
= next
)
7728 remaining_loc
= &e
->next
;
7732 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
7736 struct bfd_elf_version_expr
*e1
, *last
;
7738 e1
= (struct bfd_elf_version_expr
*) *loc
;
7742 if (e1
->mask
== e
->mask
)
7750 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
7754 /* This is a duplicate. */
7755 /* FIXME: Memory leak. Sometimes pattern is not
7756 xmalloced alone, but in larger chunk of memory. */
7757 /* free (e->pattern); */
7762 e
->next
= last
->next
;
7770 list_loc
= &e
->next
;
7774 *remaining_loc
= NULL
;
7775 *list_loc
= head
->remaining
;
7778 head
->remaining
= head
->list
;
7781 /* This is called when we know the name and dependencies of the
7785 lang_register_vers_node (const char *name
,
7786 struct bfd_elf_version_tree
*version
,
7787 struct bfd_elf_version_deps
*deps
)
7789 struct bfd_elf_version_tree
*t
, **pp
;
7790 struct bfd_elf_version_expr
*e1
;
7795 if (link_info
.version_info
!= NULL
7796 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
7798 einfo (_("%X%P: anonymous version tag cannot be combined"
7799 " with other version tags\n"));
7804 /* Make sure this node has a unique name. */
7805 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7806 if (strcmp (t
->name
, name
) == 0)
7807 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
7809 lang_finalize_version_expr_head (&version
->globals
);
7810 lang_finalize_version_expr_head (&version
->locals
);
7812 /* Check the global and local match names, and make sure there
7813 aren't any duplicates. */
7815 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
7817 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7819 struct bfd_elf_version_expr
*e2
;
7821 if (t
->locals
.htab
&& e1
->literal
)
7823 e2
= (struct bfd_elf_version_expr
*)
7824 htab_find ((htab_t
) t
->locals
.htab
, e1
);
7825 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
7827 if (e1
->mask
== e2
->mask
)
7828 einfo (_("%X%P: duplicate expression `%s'"
7829 " in version information\n"), e1
->pattern
);
7833 else if (!e1
->literal
)
7834 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7835 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7836 && e1
->mask
== e2
->mask
)
7837 einfo (_("%X%P: duplicate expression `%s'"
7838 " in version information\n"), e1
->pattern
);
7842 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
7844 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7846 struct bfd_elf_version_expr
*e2
;
7848 if (t
->globals
.htab
&& e1
->literal
)
7850 e2
= (struct bfd_elf_version_expr
*)
7851 htab_find ((htab_t
) t
->globals
.htab
, e1
);
7852 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
7854 if (e1
->mask
== e2
->mask
)
7855 einfo (_("%X%P: duplicate expression `%s'"
7856 " in version information\n"),
7861 else if (!e1
->literal
)
7862 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7863 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7864 && e1
->mask
== e2
->mask
)
7865 einfo (_("%X%P: duplicate expression `%s'"
7866 " in version information\n"), e1
->pattern
);
7870 version
->deps
= deps
;
7871 version
->name
= name
;
7872 if (name
[0] != '\0')
7875 version
->vernum
= version_index
;
7878 version
->vernum
= 0;
7880 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7885 /* This is called when we see a version dependency. */
7887 struct bfd_elf_version_deps
*
7888 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
7890 struct bfd_elf_version_deps
*ret
;
7891 struct bfd_elf_version_tree
*t
;
7893 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
7896 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7898 if (strcmp (t
->name
, name
) == 0)
7900 ret
->version_needed
= t
;
7905 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
7907 ret
->version_needed
= NULL
;
7912 lang_do_version_exports_section (void)
7914 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
7916 LANG_FOR_EACH_INPUT_STATEMENT (is
)
7918 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
7926 contents
= (char *) xmalloc (len
);
7927 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
7928 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
7931 while (p
< contents
+ len
)
7933 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
7934 p
= strchr (p
, '\0') + 1;
7937 /* Do not free the contents, as we used them creating the regex. */
7939 /* Do not include this section in the link. */
7940 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
7943 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
7944 lang_register_vers_node (command_line
.version_exports_section
,
7945 lang_new_vers_node (greg
, lreg
), NULL
);
7949 lang_add_unique (const char *name
)
7951 struct unique_sections
*ent
;
7953 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
7954 if (strcmp (ent
->name
, name
) == 0)
7957 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
7958 ent
->name
= xstrdup (name
);
7959 ent
->next
= unique_section_list
;
7960 unique_section_list
= ent
;
7963 /* Append the list of dynamic symbols to the existing one. */
7966 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
7968 if (link_info
.dynamic_list
)
7970 struct bfd_elf_version_expr
*tail
;
7971 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
7973 tail
->next
= link_info
.dynamic_list
->head
.list
;
7974 link_info
.dynamic_list
->head
.list
= dynamic
;
7978 struct bfd_elf_dynamic_list
*d
;
7980 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
7981 d
->head
.list
= dynamic
;
7982 d
->match
= lang_vers_match
;
7983 link_info
.dynamic_list
= d
;
7987 /* Append the list of C++ typeinfo dynamic symbols to the existing
7991 lang_append_dynamic_list_cpp_typeinfo (void)
7993 const char * symbols
[] =
7995 "typeinfo name for*",
7998 struct bfd_elf_version_expr
*dynamic
= NULL
;
8001 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8002 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8005 lang_append_dynamic_list (dynamic
);
8008 /* Append the list of C++ operator new and delete dynamic symbols to the
8012 lang_append_dynamic_list_cpp_new (void)
8014 const char * symbols
[] =
8019 struct bfd_elf_version_expr
*dynamic
= NULL
;
8022 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8023 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8026 lang_append_dynamic_list (dynamic
);
8029 /* Scan a space and/or comma separated string of features. */
8032 lang_ld_feature (char *str
)
8040 while (*p
== ',' || ISSPACE (*p
))
8045 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
8049 if (strcasecmp (p
, "SANE_EXPR") == 0)
8050 config
.sane_expr
= TRUE
;
8052 einfo (_("%X%P: unknown feature `%s'\n"), p
);