1 /* Linker command language support.
2 Copyright (C) 1991-2014 Free Software Foundation, Inc.
4 This file is part of the GNU Binutils.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
23 #include "libiberty.h"
24 #include "filenames.h"
25 #include "safe-ctype.h"
46 #endif /* ENABLE_PLUGINS */
49 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
52 /* Locals variables. */
53 static struct obstack stat_obstack
;
54 static struct obstack map_obstack
;
56 #define obstack_chunk_alloc xmalloc
57 #define obstack_chunk_free free
58 static const char *entry_symbol_default
= "start";
59 static bfd_boolean placed_commons
= FALSE
;
60 static bfd_boolean map_head_is_link_order
= FALSE
;
61 static lang_output_section_statement_type
*default_common_section
;
62 static bfd_boolean map_option_f
;
63 static bfd_vma print_dot
;
64 static lang_input_statement_type
*first_file
;
65 static const char *current_target
;
66 static lang_statement_list_type statement_list
;
67 static struct bfd_hash_table lang_definedness_table
;
68 static lang_statement_list_type
*stat_save
[10];
69 static lang_statement_list_type
**stat_save_ptr
= &stat_save
[0];
70 static struct unique_sections
*unique_section_list
;
71 static struct asneeded_minfo
*asneeded_list_head
;
73 /* Forward declarations. */
74 static void exp_init_os (etree_type
*);
75 static lang_input_statement_type
*lookup_name (const char *);
76 static struct bfd_hash_entry
*lang_definedness_newfunc
77 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
78 static void insert_undefined (const char *);
79 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
80 static void print_statement (lang_statement_union_type
*,
81 lang_output_section_statement_type
*);
82 static void print_statement_list (lang_statement_union_type
*,
83 lang_output_section_statement_type
*);
84 static void print_statements (void);
85 static void print_input_section (asection
*, bfd_boolean
);
86 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
87 static void lang_record_phdrs (void);
88 static void lang_do_version_exports_section (void);
89 static void lang_finalize_version_expr_head
90 (struct bfd_elf_version_expr_head
*);
92 /* Exported variables. */
93 const char *output_target
;
94 lang_output_section_statement_type
*abs_output_section
;
95 lang_statement_list_type lang_output_section_statement
;
96 lang_statement_list_type
*stat_ptr
= &statement_list
;
97 lang_statement_list_type file_chain
= { NULL
, NULL
};
98 lang_statement_list_type input_file_chain
;
99 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
100 const char *entry_section
= ".text";
101 struct lang_input_statement_flags input_flags
;
102 bfd_boolean entry_from_cmdline
;
103 bfd_boolean undef_from_cmdline
;
104 bfd_boolean lang_has_input_file
= FALSE
;
105 bfd_boolean had_output_filename
= FALSE
;
106 bfd_boolean lang_float_flag
= FALSE
;
107 bfd_boolean delete_output_file_on_failure
= FALSE
;
108 struct lang_phdr
*lang_phdr_list
;
109 struct lang_nocrossrefs
*nocrossref_list
;
110 struct asneeded_minfo
**asneeded_list_tail
;
112 /* Functions that traverse the linker script and might evaluate
113 DEFINED() need to increment this at the start of the traversal. */
114 int lang_statement_iteration
= 0;
116 /* Return TRUE if the PATTERN argument is a wildcard pattern.
117 Although backslashes are treated specially if a pattern contains
118 wildcards, we do not consider the mere presence of a backslash to
119 be enough to cause the pattern to be treated as a wildcard.
120 That lets us handle DOS filenames more naturally. */
121 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
123 #define new_stat(x, y) \
124 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
126 #define outside_section_address(q) \
127 ((q)->output_offset + (q)->output_section->vma)
129 #define outside_symbol_address(q) \
130 ((q)->value + outside_section_address (q->section))
132 #define SECTION_NAME_MAP_LENGTH (16)
135 stat_alloc (size_t size
)
137 return obstack_alloc (&stat_obstack
, size
);
141 name_match (const char *pattern
, const char *name
)
143 if (wildcardp (pattern
))
144 return fnmatch (pattern
, name
, 0);
145 return strcmp (pattern
, name
);
148 /* If PATTERN is of the form archive:file, return a pointer to the
149 separator. If not, return NULL. */
152 archive_path (const char *pattern
)
156 if (link_info
.path_separator
== 0)
159 p
= strchr (pattern
, link_info
.path_separator
);
160 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
161 if (p
== NULL
|| link_info
.path_separator
!= ':')
164 /* Assume a match on the second char is part of drive specifier,
165 as in "c:\silly.dos". */
166 if (p
== pattern
+ 1 && ISALPHA (*pattern
))
167 p
= strchr (p
+ 1, link_info
.path_separator
);
172 /* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
173 return whether F matches FILE_SPEC. */
176 input_statement_is_archive_path (const char *file_spec
, char *sep
,
177 lang_input_statement_type
*f
)
179 bfd_boolean match
= FALSE
;
182 || name_match (sep
+ 1, f
->filename
) == 0)
183 && ((sep
!= file_spec
)
184 == (f
->the_bfd
!= NULL
&& f
->the_bfd
->my_archive
!= NULL
)))
188 if (sep
!= file_spec
)
190 const char *aname
= f
->the_bfd
->my_archive
->filename
;
192 match
= name_match (file_spec
, aname
) == 0;
193 *sep
= link_info
.path_separator
;
200 unique_section_p (const asection
*sec
,
201 const lang_output_section_statement_type
*os
)
203 struct unique_sections
*unam
;
206 if (link_info
.relocatable
207 && sec
->owner
!= NULL
208 && bfd_is_group_section (sec
->owner
, sec
))
210 && strcmp (os
->name
, DISCARD_SECTION_NAME
) == 0);
213 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
214 if (name_match (unam
->name
, secnam
) == 0)
220 /* Generic traversal routines for finding matching sections. */
222 /* Try processing a section against a wildcard. This just calls
223 the callback unless the filename exclusion list is present
224 and excludes the file. It's hardly ever present so this
225 function is very fast. */
228 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
229 lang_input_statement_type
*file
,
231 struct wildcard_list
*sec
,
235 struct name_list
*list_tmp
;
237 /* Don't process sections from files which were excluded. */
238 for (list_tmp
= sec
->spec
.exclude_name_list
;
240 list_tmp
= list_tmp
->next
)
242 char *p
= archive_path (list_tmp
->name
);
246 if (input_statement_is_archive_path (list_tmp
->name
, p
, file
))
250 else if (name_match (list_tmp
->name
, file
->filename
) == 0)
253 /* FIXME: Perhaps remove the following at some stage? Matching
254 unadorned archives like this was never documented and has
255 been superceded by the archive:path syntax. */
256 else if (file
->the_bfd
!= NULL
257 && file
->the_bfd
->my_archive
!= NULL
258 && name_match (list_tmp
->name
,
259 file
->the_bfd
->my_archive
->filename
) == 0)
263 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
266 /* Lowest common denominator routine that can handle everything correctly,
270 walk_wild_section_general (lang_wild_statement_type
*ptr
,
271 lang_input_statement_type
*file
,
276 struct wildcard_list
*sec
;
278 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
280 sec
= ptr
->section_list
;
282 (*callback
) (ptr
, sec
, s
, ptr
->section_flag_list
, file
, data
);
286 bfd_boolean skip
= FALSE
;
288 if (sec
->spec
.name
!= NULL
)
290 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
292 skip
= name_match (sec
->spec
.name
, sname
) != 0;
296 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
303 /* Routines to find a single section given its name. If there's more
304 than one section with that name, we report that. */
308 asection
*found_section
;
309 bfd_boolean multiple_sections_found
;
310 } section_iterator_callback_data
;
313 section_iterator_callback (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
315 section_iterator_callback_data
*d
= (section_iterator_callback_data
*) data
;
317 if (d
->found_section
!= NULL
)
319 d
->multiple_sections_found
= TRUE
;
323 d
->found_section
= s
;
328 find_section (lang_input_statement_type
*file
,
329 struct wildcard_list
*sec
,
330 bfd_boolean
*multiple_sections_found
)
332 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
334 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
335 section_iterator_callback
, &cb_data
);
336 *multiple_sections_found
= cb_data
.multiple_sections_found
;
337 return cb_data
.found_section
;
340 /* Code for handling simple wildcards without going through fnmatch,
341 which can be expensive because of charset translations etc. */
343 /* A simple wild is a literal string followed by a single '*',
344 where the literal part is at least 4 characters long. */
347 is_simple_wild (const char *name
)
349 size_t len
= strcspn (name
, "*?[");
350 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
354 match_simple_wild (const char *pattern
, const char *name
)
356 /* The first four characters of the pattern are guaranteed valid
357 non-wildcard characters. So we can go faster. */
358 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
359 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
364 while (*pattern
!= '*')
365 if (*name
++ != *pattern
++)
371 /* Return the numerical value of the init_priority attribute from
372 section name NAME. */
375 get_init_priority (const char *name
)
378 unsigned long init_priority
;
380 /* GCC uses the following section names for the init_priority
381 attribute with numerical values 101 and 65535 inclusive. A
382 lower value means a higher priority.
384 1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the
385 decimal numerical value of the init_priority attribute.
386 The order of execution in .init_array is forward and
387 .fini_array is backward.
388 2: .ctors.NNNN/.dtors.NNNN: Where NNNN is 65535 minus the
389 decimal numerical value of the init_priority attribute.
390 The order of execution in .ctors is backward and .dtors
393 if (strncmp (name
, ".init_array.", 12) == 0
394 || strncmp (name
, ".fini_array.", 12) == 0)
396 init_priority
= strtoul (name
+ 12, &end
, 10);
397 return *end
? 0 : init_priority
;
399 else if (strncmp (name
, ".ctors.", 7) == 0
400 || strncmp (name
, ".dtors.", 7) == 0)
402 init_priority
= strtoul (name
+ 7, &end
, 10);
403 return *end
? 0 : 65535 - init_priority
;
409 /* Compare sections ASEC and BSEC according to SORT. */
412 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
415 unsigned long ainit_priority
, binit_priority
;
422 case by_init_priority
:
424 = get_init_priority (bfd_get_section_name (asec
->owner
, asec
));
426 = get_init_priority (bfd_get_section_name (bsec
->owner
, bsec
));
427 if (ainit_priority
== 0 || binit_priority
== 0)
429 ret
= ainit_priority
- binit_priority
;
435 case by_alignment_name
:
436 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
437 - bfd_section_alignment (asec
->owner
, asec
));
444 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
445 bfd_get_section_name (bsec
->owner
, bsec
));
448 case by_name_alignment
:
449 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
450 bfd_get_section_name (bsec
->owner
, bsec
));
456 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
457 - bfd_section_alignment (asec
->owner
, asec
));
464 /* Build a Binary Search Tree to sort sections, unlike insertion sort
465 used in wild_sort(). BST is considerably faster if the number of
466 of sections are large. */
468 static lang_section_bst_type
**
469 wild_sort_fast (lang_wild_statement_type
*wild
,
470 struct wildcard_list
*sec
,
471 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
474 lang_section_bst_type
**tree
;
477 if (!wild
->filenames_sorted
478 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
480 /* Append at the right end of tree. */
482 tree
= &((*tree
)->right
);
488 /* Find the correct node to append this section. */
489 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
490 tree
= &((*tree
)->left
);
492 tree
= &((*tree
)->right
);
498 /* Use wild_sort_fast to build a BST to sort sections. */
501 output_section_callback_fast (lang_wild_statement_type
*ptr
,
502 struct wildcard_list
*sec
,
504 struct flag_info
*sflag_list ATTRIBUTE_UNUSED
,
505 lang_input_statement_type
*file
,
508 lang_section_bst_type
*node
;
509 lang_section_bst_type
**tree
;
510 lang_output_section_statement_type
*os
;
512 os
= (lang_output_section_statement_type
*) output
;
514 if (unique_section_p (section
, os
))
517 node
= (lang_section_bst_type
*) xmalloc (sizeof (lang_section_bst_type
));
520 node
->section
= section
;
522 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
527 /* Convert a sorted sections' BST back to list form. */
530 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
531 lang_section_bst_type
*tree
,
535 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
537 lang_add_section (&ptr
->children
, tree
->section
, NULL
,
538 (lang_output_section_statement_type
*) output
);
541 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
546 /* Specialized, optimized routines for handling different kinds of
550 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
551 lang_input_statement_type
*file
,
555 /* We can just do a hash lookup for the section with the right name.
556 But if that lookup discovers more than one section with the name
557 (should be rare), we fall back to the general algorithm because
558 we would otherwise have to sort the sections to make sure they
559 get processed in the bfd's order. */
560 bfd_boolean multiple_sections_found
;
561 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
562 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
564 if (multiple_sections_found
)
565 walk_wild_section_general (ptr
, file
, callback
, data
);
567 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
571 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
572 lang_input_statement_type
*file
,
577 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
579 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
581 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
582 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
585 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
590 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
591 lang_input_statement_type
*file
,
596 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
597 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
598 bfd_boolean multiple_sections_found
;
599 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
601 if (multiple_sections_found
)
603 walk_wild_section_general (ptr
, file
, callback
, data
);
607 /* Note that if the section was not found, s0 is NULL and
608 we'll simply never succeed the s == s0 test below. */
609 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
611 /* Recall that in this code path, a section cannot satisfy more
612 than one spec, so if s == s0 then it cannot match
615 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
618 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
619 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
622 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
629 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
630 lang_input_statement_type
*file
,
635 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
636 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
637 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
638 bfd_boolean multiple_sections_found
;
639 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
641 if (multiple_sections_found
)
643 walk_wild_section_general (ptr
, file
, callback
, data
);
647 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
650 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
653 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
654 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
657 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
660 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
662 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
670 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
671 lang_input_statement_type
*file
,
676 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
677 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
678 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
679 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
680 bfd_boolean multiple_sections_found
;
681 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
683 if (multiple_sections_found
)
685 walk_wild_section_general (ptr
, file
, callback
, data
);
689 s1
= find_section (file
, sec1
, &multiple_sections_found
);
690 if (multiple_sections_found
)
692 walk_wild_section_general (ptr
, file
, callback
, data
);
696 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
699 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
702 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
705 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
706 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
710 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
714 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
716 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
724 walk_wild_section (lang_wild_statement_type
*ptr
,
725 lang_input_statement_type
*file
,
729 if (file
->flags
.just_syms
)
732 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
735 /* Returns TRUE when name1 is a wildcard spec that might match
736 something name2 can match. We're conservative: we return FALSE
737 only if the prefixes of name1 and name2 are different up to the
738 first wildcard character. */
741 wild_spec_can_overlap (const char *name1
, const char *name2
)
743 size_t prefix1_len
= strcspn (name1
, "?*[");
744 size_t prefix2_len
= strcspn (name2
, "?*[");
745 size_t min_prefix_len
;
747 /* Note that if there is no wildcard character, then we treat the
748 terminating 0 as part of the prefix. Thus ".text" won't match
749 ".text." or ".text.*", for example. */
750 if (name1
[prefix1_len
] == '\0')
752 if (name2
[prefix2_len
] == '\0')
755 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
757 return memcmp (name1
, name2
, min_prefix_len
) == 0;
760 /* Select specialized code to handle various kinds of wildcard
764 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
767 int wild_name_count
= 0;
768 struct wildcard_list
*sec
;
772 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
773 ptr
->handler_data
[0] = NULL
;
774 ptr
->handler_data
[1] = NULL
;
775 ptr
->handler_data
[2] = NULL
;
776 ptr
->handler_data
[3] = NULL
;
779 /* Count how many wildcard_specs there are, and how many of those
780 actually use wildcards in the name. Also, bail out if any of the
781 wildcard names are NULL. (Can this actually happen?
782 walk_wild_section used to test for it.) And bail out if any
783 of the wildcards are more complex than a simple string
784 ending in a single '*'. */
785 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
788 if (sec
->spec
.name
== NULL
)
790 if (wildcardp (sec
->spec
.name
))
793 if (!is_simple_wild (sec
->spec
.name
))
798 /* The zero-spec case would be easy to optimize but it doesn't
799 happen in practice. Likewise, more than 4 specs doesn't
800 happen in practice. */
801 if (sec_count
== 0 || sec_count
> 4)
804 /* Check that no two specs can match the same section. */
805 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
807 struct wildcard_list
*sec2
;
808 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
810 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
815 signature
= (sec_count
<< 8) + wild_name_count
;
819 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
822 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
825 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
828 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
831 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
837 /* Now fill the data array with pointers to the specs, first the
838 specs with non-wildcard names, then the specs with wildcard
839 names. It's OK to process the specs in different order from the
840 given order, because we've already determined that no section
841 will match more than one spec. */
843 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
844 if (!wildcardp (sec
->spec
.name
))
845 ptr
->handler_data
[data_counter
++] = sec
;
846 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
847 if (wildcardp (sec
->spec
.name
))
848 ptr
->handler_data
[data_counter
++] = sec
;
851 /* Handle a wild statement for a single file F. */
854 walk_wild_file (lang_wild_statement_type
*s
,
855 lang_input_statement_type
*f
,
859 if (f
->the_bfd
== NULL
860 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
861 walk_wild_section (s
, f
, callback
, data
);
866 /* This is an archive file. We must map each member of the
867 archive separately. */
868 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
869 while (member
!= NULL
)
871 /* When lookup_name is called, it will call the add_symbols
872 entry point for the archive. For each element of the
873 archive which is included, BFD will call ldlang_add_file,
874 which will set the usrdata field of the member to the
875 lang_input_statement. */
876 if (member
->usrdata
!= NULL
)
878 walk_wild_section (s
,
879 (lang_input_statement_type
*) member
->usrdata
,
883 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
889 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
891 const char *file_spec
= s
->filename
;
894 if (file_spec
== NULL
)
896 /* Perform the iteration over all files in the list. */
897 LANG_FOR_EACH_INPUT_STATEMENT (f
)
899 walk_wild_file (s
, f
, callback
, data
);
902 else if ((p
= archive_path (file_spec
)) != NULL
)
904 LANG_FOR_EACH_INPUT_STATEMENT (f
)
906 if (input_statement_is_archive_path (file_spec
, p
, f
))
907 walk_wild_file (s
, f
, callback
, data
);
910 else if (wildcardp (file_spec
))
912 LANG_FOR_EACH_INPUT_STATEMENT (f
)
914 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
915 walk_wild_file (s
, f
, callback
, data
);
920 lang_input_statement_type
*f
;
922 /* Perform the iteration over a single file. */
923 f
= lookup_name (file_spec
);
925 walk_wild_file (s
, f
, callback
, data
);
929 /* lang_for_each_statement walks the parse tree and calls the provided
930 function for each node, except those inside output section statements
931 with constraint set to -1. */
934 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
935 lang_statement_union_type
*s
)
937 for (; s
!= NULL
; s
= s
->header
.next
)
941 switch (s
->header
.type
)
943 case lang_constructors_statement_enum
:
944 lang_for_each_statement_worker (func
, constructor_list
.head
);
946 case lang_output_section_statement_enum
:
947 if (s
->output_section_statement
.constraint
!= -1)
948 lang_for_each_statement_worker
949 (func
, s
->output_section_statement
.children
.head
);
951 case lang_wild_statement_enum
:
952 lang_for_each_statement_worker (func
,
953 s
->wild_statement
.children
.head
);
955 case lang_group_statement_enum
:
956 lang_for_each_statement_worker (func
,
957 s
->group_statement
.children
.head
);
959 case lang_data_statement_enum
:
960 case lang_reloc_statement_enum
:
961 case lang_object_symbols_statement_enum
:
962 case lang_output_statement_enum
:
963 case lang_target_statement_enum
:
964 case lang_input_section_enum
:
965 case lang_input_statement_enum
:
966 case lang_assignment_statement_enum
:
967 case lang_padding_statement_enum
:
968 case lang_address_statement_enum
:
969 case lang_fill_statement_enum
:
970 case lang_insert_statement_enum
:
980 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
982 lang_for_each_statement_worker (func
, statement_list
.head
);
985 /*----------------------------------------------------------------------*/
988 lang_list_init (lang_statement_list_type
*list
)
991 list
->tail
= &list
->head
;
995 push_stat_ptr (lang_statement_list_type
*new_ptr
)
997 if (stat_save_ptr
>= stat_save
+ sizeof (stat_save
) / sizeof (stat_save
[0]))
999 *stat_save_ptr
++ = stat_ptr
;
1006 if (stat_save_ptr
<= stat_save
)
1008 stat_ptr
= *--stat_save_ptr
;
1011 /* Build a new statement node for the parse tree. */
1013 static lang_statement_union_type
*
1014 new_statement (enum statement_enum type
,
1016 lang_statement_list_type
*list
)
1018 lang_statement_union_type
*new_stmt
;
1020 new_stmt
= (lang_statement_union_type
*) stat_alloc (size
);
1021 new_stmt
->header
.type
= type
;
1022 new_stmt
->header
.next
= NULL
;
1023 lang_statement_append (list
, new_stmt
, &new_stmt
->header
.next
);
1027 /* Build a new input file node for the language. There are several
1028 ways in which we treat an input file, eg, we only look at symbols,
1029 or prefix it with a -l etc.
1031 We can be supplied with requests for input files more than once;
1032 they may, for example be split over several lines like foo.o(.text)
1033 foo.o(.data) etc, so when asked for a file we check that we haven't
1034 got it already so we don't duplicate the bfd. */
1036 static lang_input_statement_type
*
1037 new_afile (const char *name
,
1038 lang_input_file_enum_type file_type
,
1040 bfd_boolean add_to_list
)
1042 lang_input_statement_type
*p
;
1044 lang_has_input_file
= TRUE
;
1047 p
= (lang_input_statement_type
*) new_stat (lang_input_statement
, stat_ptr
);
1050 p
= (lang_input_statement_type
*)
1051 stat_alloc (sizeof (lang_input_statement_type
));
1052 p
->header
.type
= lang_input_statement_enum
;
1053 p
->header
.next
= NULL
;
1056 memset (&p
->the_bfd
, 0,
1057 sizeof (*p
) - offsetof (lang_input_statement_type
, the_bfd
));
1059 p
->flags
.dynamic
= input_flags
.dynamic
;
1060 p
->flags
.add_DT_NEEDED_for_dynamic
= input_flags
.add_DT_NEEDED_for_dynamic
;
1061 p
->flags
.add_DT_NEEDED_for_regular
= input_flags
.add_DT_NEEDED_for_regular
;
1062 p
->flags
.whole_archive
= input_flags
.whole_archive
;
1063 p
->flags
.sysrooted
= input_flags
.sysrooted
;
1067 case lang_input_file_is_symbols_only_enum
:
1069 p
->local_sym_name
= name
;
1070 p
->flags
.real
= TRUE
;
1071 p
->flags
.just_syms
= TRUE
;
1073 case lang_input_file_is_fake_enum
:
1075 p
->local_sym_name
= name
;
1077 case lang_input_file_is_l_enum
:
1078 if (name
[0] == ':' && name
[1] != '\0')
1080 p
->filename
= name
+ 1;
1081 p
->flags
.full_name_provided
= TRUE
;
1085 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
1086 p
->flags
.maybe_archive
= TRUE
;
1087 p
->flags
.real
= TRUE
;
1088 p
->flags
.search_dirs
= TRUE
;
1090 case lang_input_file_is_marker_enum
:
1092 p
->local_sym_name
= name
;
1093 p
->flags
.search_dirs
= TRUE
;
1095 case lang_input_file_is_search_file_enum
:
1097 p
->local_sym_name
= name
;
1098 p
->flags
.real
= TRUE
;
1099 p
->flags
.search_dirs
= TRUE
;
1101 case lang_input_file_is_file_enum
:
1103 p
->local_sym_name
= name
;
1104 p
->flags
.real
= TRUE
;
1110 lang_statement_append (&input_file_chain
,
1111 (lang_statement_union_type
*) p
,
1112 &p
->next_real_file
);
1116 lang_input_statement_type
*
1117 lang_add_input_file (const char *name
,
1118 lang_input_file_enum_type file_type
,
1121 return new_afile (name
, file_type
, target
, TRUE
);
1124 struct out_section_hash_entry
1126 struct bfd_hash_entry root
;
1127 lang_statement_union_type s
;
1130 /* The hash table. */
1132 static struct bfd_hash_table output_section_statement_table
;
1134 /* Support routines for the hash table used by lang_output_section_find,
1135 initialize the table, fill in an entry and remove the table. */
1137 static struct bfd_hash_entry
*
1138 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1139 struct bfd_hash_table
*table
,
1142 lang_output_section_statement_type
**nextp
;
1143 struct out_section_hash_entry
*ret
;
1147 entry
= (struct bfd_hash_entry
*) bfd_hash_allocate (table
,
1153 entry
= bfd_hash_newfunc (entry
, table
, string
);
1157 ret
= (struct out_section_hash_entry
*) entry
;
1158 memset (&ret
->s
, 0, sizeof (ret
->s
));
1159 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1160 ret
->s
.output_section_statement
.subsection_alignment
= -1;
1161 ret
->s
.output_section_statement
.section_alignment
= -1;
1162 ret
->s
.output_section_statement
.block_value
= 1;
1163 lang_list_init (&ret
->s
.output_section_statement
.children
);
1164 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1166 /* For every output section statement added to the list, except the
1167 first one, lang_output_section_statement.tail points to the "next"
1168 field of the last element of the list. */
1169 if (lang_output_section_statement
.head
!= NULL
)
1170 ret
->s
.output_section_statement
.prev
1171 = ((lang_output_section_statement_type
*)
1172 ((char *) lang_output_section_statement
.tail
1173 - offsetof (lang_output_section_statement_type
, next
)));
1175 /* GCC's strict aliasing rules prevent us from just casting the
1176 address, so we store the pointer in a variable and cast that
1178 nextp
= &ret
->s
.output_section_statement
.next
;
1179 lang_statement_append (&lang_output_section_statement
,
1181 (lang_statement_union_type
**) nextp
);
1186 output_section_statement_table_init (void)
1188 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1189 output_section_statement_newfunc
,
1190 sizeof (struct out_section_hash_entry
),
1192 einfo (_("%P%F: can not create hash table: %E\n"));
1196 output_section_statement_table_free (void)
1198 bfd_hash_table_free (&output_section_statement_table
);
1201 /* Build enough state so that the parser can build its tree. */
1206 obstack_begin (&stat_obstack
, 1000);
1208 stat_ptr
= &statement_list
;
1210 output_section_statement_table_init ();
1212 lang_list_init (stat_ptr
);
1214 lang_list_init (&input_file_chain
);
1215 lang_list_init (&lang_output_section_statement
);
1216 lang_list_init (&file_chain
);
1217 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1219 abs_output_section
=
1220 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
, 0, TRUE
);
1222 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1224 /* The value "13" is ad-hoc, somewhat related to the expected number of
1225 assignments in a linker script. */
1226 if (!bfd_hash_table_init_n (&lang_definedness_table
,
1227 lang_definedness_newfunc
,
1228 sizeof (struct lang_definedness_hash_entry
),
1230 einfo (_("%P%F: can not create hash table: %E\n"));
1232 asneeded_list_head
= NULL
;
1233 asneeded_list_tail
= &asneeded_list_head
;
1239 bfd_hash_table_free (&lang_definedness_table
);
1240 output_section_statement_table_free ();
1243 /*----------------------------------------------------------------------
1244 A region is an area of memory declared with the
1245 MEMORY { name:org=exp, len=exp ... }
1248 We maintain a list of all the regions here.
1250 If no regions are specified in the script, then the default is used
1251 which is created when looked up to be the entire data space.
1253 If create is true we are creating a region inside a MEMORY block.
1254 In this case it is probably an error to create a region that has
1255 already been created. If we are not inside a MEMORY block it is
1256 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1257 and so we issue a warning.
1259 Each region has at least one name. The first name is either
1260 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1261 alias names to an existing region within a script with
1262 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1265 static lang_memory_region_type
*lang_memory_region_list
;
1266 static lang_memory_region_type
**lang_memory_region_list_tail
1267 = &lang_memory_region_list
;
1269 lang_memory_region_type
*
1270 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1272 lang_memory_region_name
*n
;
1273 lang_memory_region_type
*r
;
1274 lang_memory_region_type
*new_region
;
1276 /* NAME is NULL for LMA memspecs if no region was specified. */
1280 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1281 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1282 if (strcmp (n
->name
, name
) == 0)
1285 einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
1290 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1291 einfo (_("%P:%S: warning: memory region `%s' not declared\n"),
1294 new_region
= (lang_memory_region_type
*)
1295 stat_alloc (sizeof (lang_memory_region_type
));
1297 new_region
->name_list
.name
= xstrdup (name
);
1298 new_region
->name_list
.next
= NULL
;
1299 new_region
->next
= NULL
;
1300 new_region
->origin
= 0;
1301 new_region
->length
= ~(bfd_size_type
) 0;
1302 new_region
->current
= 0;
1303 new_region
->last_os
= NULL
;
1304 new_region
->flags
= 0;
1305 new_region
->not_flags
= 0;
1306 new_region
->had_full_message
= FALSE
;
1308 *lang_memory_region_list_tail
= new_region
;
1309 lang_memory_region_list_tail
= &new_region
->next
;
1315 lang_memory_region_alias (const char * alias
, const char * region_name
)
1317 lang_memory_region_name
* n
;
1318 lang_memory_region_type
* r
;
1319 lang_memory_region_type
* region
;
1321 /* The default region must be unique. This ensures that it is not necessary
1322 to iterate through the name list if someone wants the check if a region is
1323 the default memory region. */
1324 if (strcmp (region_name
, DEFAULT_MEMORY_REGION
) == 0
1325 || strcmp (alias
, DEFAULT_MEMORY_REGION
) == 0)
1326 einfo (_("%F%P:%S: error: alias for default memory region\n"), NULL
);
1328 /* Look for the target region and check if the alias is not already
1331 for (r
= lang_memory_region_list
; r
!= NULL
; r
= r
->next
)
1332 for (n
= &r
->name_list
; n
!= NULL
; n
= n
->next
)
1334 if (region
== NULL
&& strcmp (n
->name
, region_name
) == 0)
1336 if (strcmp (n
->name
, alias
) == 0)
1337 einfo (_("%F%P:%S: error: redefinition of memory region "
1342 /* Check if the target region exists. */
1344 einfo (_("%F%P:%S: error: memory region `%s' "
1345 "for alias `%s' does not exist\n"),
1346 NULL
, region_name
, alias
);
1348 /* Add alias to region name list. */
1349 n
= (lang_memory_region_name
*) stat_alloc (sizeof (lang_memory_region_name
));
1350 n
->name
= xstrdup (alias
);
1351 n
->next
= region
->name_list
.next
;
1352 region
->name_list
.next
= n
;
1355 static lang_memory_region_type
*
1356 lang_memory_default (asection
* section
)
1358 lang_memory_region_type
*p
;
1360 flagword sec_flags
= section
->flags
;
1362 /* Override SEC_DATA to mean a writable section. */
1363 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1364 sec_flags
|= SEC_DATA
;
1366 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1368 if ((p
->flags
& sec_flags
) != 0
1369 && (p
->not_flags
& sec_flags
) == 0)
1374 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1377 /* Get the output section statement directly from the userdata. */
1379 lang_output_section_statement_type
*
1380 lang_output_section_get (const asection
*output_section
)
1382 return get_userdata (output_section
);
1385 /* Find or create an output_section_statement with the given NAME.
1386 If CONSTRAINT is non-zero match one with that constraint, otherwise
1387 match any non-negative constraint. If CREATE, always make a
1388 new output_section_statement for SPECIAL CONSTRAINT. */
1390 lang_output_section_statement_type
*
1391 lang_output_section_statement_lookup (const char *name
,
1395 struct out_section_hash_entry
*entry
;
1397 entry
= ((struct out_section_hash_entry
*)
1398 bfd_hash_lookup (&output_section_statement_table
, name
,
1403 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1407 if (entry
->s
.output_section_statement
.name
!= NULL
)
1409 /* We have a section of this name, but it might not have the correct
1411 struct out_section_hash_entry
*last_ent
;
1413 name
= entry
->s
.output_section_statement
.name
;
1414 if (create
&& constraint
== SPECIAL
)
1415 /* Not traversing to the end reverses the order of the second
1416 and subsequent SPECIAL sections in the hash table chain,
1417 but that shouldn't matter. */
1422 if (constraint
== entry
->s
.output_section_statement
.constraint
1424 && entry
->s
.output_section_statement
.constraint
>= 0))
1425 return &entry
->s
.output_section_statement
;
1427 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1429 while (entry
!= NULL
1430 && name
== entry
->s
.output_section_statement
.name
);
1436 = ((struct out_section_hash_entry
*)
1437 output_section_statement_newfunc (NULL
,
1438 &output_section_statement_table
,
1442 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1445 entry
->root
= last_ent
->root
;
1446 last_ent
->root
.next
= &entry
->root
;
1449 entry
->s
.output_section_statement
.name
= name
;
1450 entry
->s
.output_section_statement
.constraint
= constraint
;
1451 return &entry
->s
.output_section_statement
;
1454 /* Find the next output_section_statement with the same name as OS.
1455 If CONSTRAINT is non-zero, find one with that constraint otherwise
1456 match any non-negative constraint. */
1458 lang_output_section_statement_type
*
1459 next_matching_output_section_statement (lang_output_section_statement_type
*os
,
1462 /* All output_section_statements are actually part of a
1463 struct out_section_hash_entry. */
1464 struct out_section_hash_entry
*entry
= (struct out_section_hash_entry
*)
1466 - offsetof (struct out_section_hash_entry
, s
.output_section_statement
));
1467 const char *name
= os
->name
;
1469 ASSERT (name
== entry
->root
.string
);
1472 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1474 || name
!= entry
->s
.output_section_statement
.name
)
1477 while (constraint
!= entry
->s
.output_section_statement
.constraint
1479 || entry
->s
.output_section_statement
.constraint
< 0));
1481 return &entry
->s
.output_section_statement
;
1484 /* A variant of lang_output_section_find used by place_orphan.
1485 Returns the output statement that should precede a new output
1486 statement for SEC. If an exact match is found on certain flags,
1489 lang_output_section_statement_type
*
1490 lang_output_section_find_by_flags (const asection
*sec
,
1491 lang_output_section_statement_type
**exact
,
1492 lang_match_sec_type_func match_type
)
1494 lang_output_section_statement_type
*first
, *look
, *found
;
1495 flagword look_flags
, sec_flags
, differ
;
1497 /* We know the first statement on this list is *ABS*. May as well
1499 first
= &lang_output_section_statement
.head
->output_section_statement
;
1500 first
= first
->next
;
1502 /* First try for an exact match. */
1503 sec_flags
= sec
->flags
;
1505 for (look
= first
; look
; look
= look
->next
)
1507 look_flags
= look
->flags
;
1508 if (look
->bfd_section
!= NULL
)
1510 look_flags
= look
->bfd_section
->flags
;
1511 if (match_type
&& !match_type (link_info
.output_bfd
,
1516 differ
= look_flags
^ sec_flags
;
1517 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1518 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1528 if ((sec_flags
& SEC_CODE
) != 0
1529 && (sec_flags
& SEC_ALLOC
) != 0)
1531 /* Try for a rw code section. */
1532 for (look
= first
; look
; look
= look
->next
)
1534 look_flags
= look
->flags
;
1535 if (look
->bfd_section
!= NULL
)
1537 look_flags
= look
->bfd_section
->flags
;
1538 if (match_type
&& !match_type (link_info
.output_bfd
,
1543 differ
= look_flags
^ sec_flags
;
1544 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1545 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1549 else if ((sec_flags
& SEC_READONLY
) != 0
1550 && (sec_flags
& SEC_ALLOC
) != 0)
1552 /* .rodata can go after .text, .sdata2 after .rodata. */
1553 for (look
= first
; look
; look
= look
->next
)
1555 look_flags
= look
->flags
;
1556 if (look
->bfd_section
!= NULL
)
1558 look_flags
= look
->bfd_section
->flags
;
1559 if (match_type
&& !match_type (link_info
.output_bfd
,
1564 differ
= look_flags
^ sec_flags
;
1565 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1566 | SEC_READONLY
| SEC_SMALL_DATA
))
1567 || (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1569 && !(look_flags
& SEC_SMALL_DATA
)))
1573 else if ((sec_flags
& SEC_THREAD_LOCAL
) != 0
1574 && (sec_flags
& SEC_ALLOC
) != 0)
1576 /* .tdata can go after .data, .tbss after .tdata. Treat .tbss
1577 as if it were a loaded section, and don't use match_type. */
1578 bfd_boolean seen_thread_local
= FALSE
;
1581 for (look
= first
; look
; look
= look
->next
)
1583 look_flags
= look
->flags
;
1584 if (look
->bfd_section
!= NULL
)
1585 look_flags
= look
->bfd_section
->flags
;
1587 differ
= look_flags
^ (sec_flags
| SEC_LOAD
| SEC_HAS_CONTENTS
);
1588 if (!(differ
& (SEC_THREAD_LOCAL
| SEC_ALLOC
)))
1590 /* .tdata and .tbss must be adjacent and in that order. */
1591 if (!(look_flags
& SEC_LOAD
)
1592 && (sec_flags
& SEC_LOAD
))
1593 /* ..so if we're at a .tbss section and we're placing
1594 a .tdata section stop looking and return the
1595 previous section. */
1598 seen_thread_local
= TRUE
;
1600 else if (seen_thread_local
)
1602 else if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
)))
1606 else if ((sec_flags
& SEC_SMALL_DATA
) != 0
1607 && (sec_flags
& SEC_ALLOC
) != 0)
1609 /* .sdata goes after .data, .sbss after .sdata. */
1610 for (look
= first
; look
; look
= look
->next
)
1612 look_flags
= look
->flags
;
1613 if (look
->bfd_section
!= NULL
)
1615 look_flags
= look
->bfd_section
->flags
;
1616 if (match_type
&& !match_type (link_info
.output_bfd
,
1621 differ
= look_flags
^ sec_flags
;
1622 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1623 | SEC_THREAD_LOCAL
))
1624 || ((look_flags
& SEC_SMALL_DATA
)
1625 && !(sec_flags
& SEC_HAS_CONTENTS
)))
1629 else if ((sec_flags
& SEC_HAS_CONTENTS
) != 0
1630 && (sec_flags
& SEC_ALLOC
) != 0)
1632 /* .data goes after .rodata. */
1633 for (look
= first
; look
; look
= look
->next
)
1635 look_flags
= look
->flags
;
1636 if (look
->bfd_section
!= NULL
)
1638 look_flags
= look
->bfd_section
->flags
;
1639 if (match_type
&& !match_type (link_info
.output_bfd
,
1644 differ
= look_flags
^ sec_flags
;
1645 if (!(differ
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1646 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1650 else if ((sec_flags
& SEC_ALLOC
) != 0)
1652 /* .bss goes after any other alloc section. */
1653 for (look
= first
; look
; look
= look
->next
)
1655 look_flags
= look
->flags
;
1656 if (look
->bfd_section
!= NULL
)
1658 look_flags
= look
->bfd_section
->flags
;
1659 if (match_type
&& !match_type (link_info
.output_bfd
,
1664 differ
= look_flags
^ sec_flags
;
1665 if (!(differ
& SEC_ALLOC
))
1671 /* non-alloc go last. */
1672 for (look
= first
; look
; look
= look
->next
)
1674 look_flags
= look
->flags
;
1675 if (look
->bfd_section
!= NULL
)
1676 look_flags
= look
->bfd_section
->flags
;
1677 differ
= look_flags
^ sec_flags
;
1678 if (!(differ
& SEC_DEBUGGING
))
1684 if (found
|| !match_type
)
1687 return lang_output_section_find_by_flags (sec
, NULL
, NULL
);
1690 /* Find the last output section before given output statement.
1691 Used by place_orphan. */
1694 output_prev_sec_find (lang_output_section_statement_type
*os
)
1696 lang_output_section_statement_type
*lookup
;
1698 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1700 if (lookup
->constraint
< 0)
1703 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1704 return lookup
->bfd_section
;
1710 /* Look for a suitable place for a new output section statement. The
1711 idea is to skip over anything that might be inside a SECTIONS {}
1712 statement in a script, before we find another output section
1713 statement. Assignments to "dot" before an output section statement
1714 are assumed to belong to it, except in two cases; The first
1715 assignment to dot, and assignments before non-alloc sections.
1716 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1717 similar assignments that set the initial address, or we might
1718 insert non-alloc note sections among assignments setting end of
1721 static lang_statement_union_type
**
1722 insert_os_after (lang_output_section_statement_type
*after
)
1724 lang_statement_union_type
**where
;
1725 lang_statement_union_type
**assign
= NULL
;
1726 bfd_boolean ignore_first
;
1729 = after
== &lang_output_section_statement
.head
->output_section_statement
;
1731 for (where
= &after
->header
.next
;
1733 where
= &(*where
)->header
.next
)
1735 switch ((*where
)->header
.type
)
1737 case lang_assignment_statement_enum
:
1740 lang_assignment_statement_type
*ass
;
1742 ass
= &(*where
)->assignment_statement
;
1743 if (ass
->exp
->type
.node_class
!= etree_assert
1744 && ass
->exp
->assign
.dst
[0] == '.'
1745 && ass
->exp
->assign
.dst
[1] == 0
1749 ignore_first
= FALSE
;
1751 case lang_wild_statement_enum
:
1752 case lang_input_section_enum
:
1753 case lang_object_symbols_statement_enum
:
1754 case lang_fill_statement_enum
:
1755 case lang_data_statement_enum
:
1756 case lang_reloc_statement_enum
:
1757 case lang_padding_statement_enum
:
1758 case lang_constructors_statement_enum
:
1761 case lang_output_section_statement_enum
:
1764 asection
*s
= (*where
)->output_section_statement
.bfd_section
;
1767 || s
->map_head
.s
== NULL
1768 || (s
->flags
& SEC_ALLOC
) != 0)
1772 case lang_input_statement_enum
:
1773 case lang_address_statement_enum
:
1774 case lang_target_statement_enum
:
1775 case lang_output_statement_enum
:
1776 case lang_group_statement_enum
:
1777 case lang_insert_statement_enum
:
1786 lang_output_section_statement_type
*
1787 lang_insert_orphan (asection
*s
,
1788 const char *secname
,
1790 lang_output_section_statement_type
*after
,
1791 struct orphan_save
*place
,
1792 etree_type
*address
,
1793 lang_statement_list_type
*add_child
)
1795 lang_statement_list_type add
;
1797 lang_output_section_statement_type
*os
;
1798 lang_output_section_statement_type
**os_tail
;
1800 /* If we have found an appropriate place for the output section
1801 statements for this orphan, add them to our own private list,
1802 inserting them later into the global statement list. */
1805 lang_list_init (&add
);
1806 push_stat_ptr (&add
);
1809 if (link_info
.relocatable
|| (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1810 address
= exp_intop (0);
1812 os_tail
= ((lang_output_section_statement_type
**)
1813 lang_output_section_statement
.tail
);
1814 os
= lang_enter_output_section_statement (secname
, address
, normal_section
,
1815 NULL
, NULL
, NULL
, constraint
, 0);
1818 if (config
.build_constructors
&& *os_tail
== os
)
1820 /* If the name of the section is representable in C, then create
1821 symbols to mark the start and the end of the section. */
1822 for (ps
= secname
; *ps
!= '\0'; ps
++)
1823 if (! ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
1829 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__start_" + 1);
1830 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1831 sprintf (symname
+ (symname
[0] != 0), "__start_%s", secname
);
1832 lang_add_assignment (exp_provide (symname
,
1833 exp_nameop (NAME
, "."),
1838 if (add_child
== NULL
)
1839 add_child
= &os
->children
;
1840 lang_add_section (add_child
, s
, NULL
, os
);
1842 if (after
&& (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) != 0)
1844 const char *region
= (after
->region
1845 ? after
->region
->name_list
.name
1846 : DEFAULT_MEMORY_REGION
);
1847 const char *lma_region
= (after
->lma_region
1848 ? after
->lma_region
->name_list
.name
1850 lang_leave_output_section_statement (NULL
, region
, after
->phdrs
,
1854 lang_leave_output_section_statement (NULL
, DEFAULT_MEMORY_REGION
, NULL
,
1857 if (ps
!= NULL
&& *ps
== '\0')
1861 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__stop_" + 1);
1862 symname
[0] = bfd_get_symbol_leading_char (link_info
.output_bfd
);
1863 sprintf (symname
+ (symname
[0] != 0), "__stop_%s", secname
);
1864 lang_add_assignment (exp_provide (symname
,
1865 exp_nameop (NAME
, "."),
1869 /* Restore the global list pointer. */
1873 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1875 asection
*snew
, *as
;
1877 snew
= os
->bfd_section
;
1879 /* Shuffle the bfd section list to make the output file look
1880 neater. This is really only cosmetic. */
1881 if (place
->section
== NULL
1882 && after
!= (&lang_output_section_statement
.head
1883 ->output_section_statement
))
1885 asection
*bfd_section
= after
->bfd_section
;
1887 /* If the output statement hasn't been used to place any input
1888 sections (and thus doesn't have an output bfd_section),
1889 look for the closest prior output statement having an
1891 if (bfd_section
== NULL
)
1892 bfd_section
= output_prev_sec_find (after
);
1894 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1895 place
->section
= &bfd_section
->next
;
1898 if (place
->section
== NULL
)
1899 place
->section
= &link_info
.output_bfd
->sections
;
1901 as
= *place
->section
;
1905 /* Put the section at the end of the list. */
1907 /* Unlink the section. */
1908 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1910 /* Now tack it back on in the right place. */
1911 bfd_section_list_append (link_info
.output_bfd
, snew
);
1913 else if (as
!= snew
&& as
->prev
!= snew
)
1915 /* Unlink the section. */
1916 bfd_section_list_remove (link_info
.output_bfd
, snew
);
1918 /* Now tack it back on in the right place. */
1919 bfd_section_list_insert_before (link_info
.output_bfd
, as
, snew
);
1922 /* Save the end of this list. Further ophans of this type will
1923 follow the one we've just added. */
1924 place
->section
= &snew
->next
;
1926 /* The following is non-cosmetic. We try to put the output
1927 statements in some sort of reasonable order here, because they
1928 determine the final load addresses of the orphan sections.
1929 In addition, placing output statements in the wrong order may
1930 require extra segments. For instance, given a typical
1931 situation of all read-only sections placed in one segment and
1932 following that a segment containing all the read-write
1933 sections, we wouldn't want to place an orphan read/write
1934 section before or amongst the read-only ones. */
1935 if (add
.head
!= NULL
)
1937 lang_output_section_statement_type
*newly_added_os
;
1939 if (place
->stmt
== NULL
)
1941 lang_statement_union_type
**where
= insert_os_after (after
);
1946 place
->os_tail
= &after
->next
;
1950 /* Put it after the last orphan statement we added. */
1951 *add
.tail
= *place
->stmt
;
1952 *place
->stmt
= add
.head
;
1955 /* Fix the global list pointer if we happened to tack our
1956 new list at the tail. */
1957 if (*stat_ptr
->tail
== add
.head
)
1958 stat_ptr
->tail
= add
.tail
;
1960 /* Save the end of this list. */
1961 place
->stmt
= add
.tail
;
1963 /* Do the same for the list of output section statements. */
1964 newly_added_os
= *os_tail
;
1966 newly_added_os
->prev
= (lang_output_section_statement_type
*)
1967 ((char *) place
->os_tail
1968 - offsetof (lang_output_section_statement_type
, next
));
1969 newly_added_os
->next
= *place
->os_tail
;
1970 if (newly_added_os
->next
!= NULL
)
1971 newly_added_os
->next
->prev
= newly_added_os
;
1972 *place
->os_tail
= newly_added_os
;
1973 place
->os_tail
= &newly_added_os
->next
;
1975 /* Fixing the global list pointer here is a little different.
1976 We added to the list in lang_enter_output_section_statement,
1977 trimmed off the new output_section_statment above when
1978 assigning *os_tail = NULL, but possibly added it back in
1979 the same place when assigning *place->os_tail. */
1980 if (*os_tail
== NULL
)
1981 lang_output_section_statement
.tail
1982 = (lang_statement_union_type
**) os_tail
;
1989 lang_print_asneeded (void)
1991 struct asneeded_minfo
*m
;
1994 if (asneeded_list_head
== NULL
)
1997 sprintf (buf
, _("\nAs-needed library included "
1998 "to satisfy reference by file (symbol)\n\n"));
2001 for (m
= asneeded_list_head
; m
!= NULL
; m
= m
->next
)
2005 minfo ("%s", m
->soname
);
2006 len
= strlen (m
->soname
);
2020 minfo ("%B ", m
->ref
);
2021 minfo ("(%T)\n", m
->name
);
2026 lang_map_flags (flagword flag
)
2028 if (flag
& SEC_ALLOC
)
2031 if (flag
& SEC_CODE
)
2034 if (flag
& SEC_READONLY
)
2037 if (flag
& SEC_DATA
)
2040 if (flag
& SEC_LOAD
)
2047 lang_memory_region_type
*m
;
2048 bfd_boolean dis_header_printed
= FALSE
;
2050 LANG_FOR_EACH_INPUT_STATEMENT (file
)
2054 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
2055 || file
->flags
.just_syms
)
2058 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2059 if ((s
->output_section
== NULL
2060 || s
->output_section
->owner
!= link_info
.output_bfd
)
2061 && (s
->flags
& (SEC_LINKER_CREATED
| SEC_KEEP
)) == 0)
2063 if (! dis_header_printed
)
2065 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
2066 dis_header_printed
= TRUE
;
2069 print_input_section (s
, TRUE
);
2073 minfo (_("\nMemory Configuration\n\n"));
2074 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
2075 _("Name"), _("Origin"), _("Length"), _("Attributes"));
2077 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
2082 fprintf (config
.map_file
, "%-16s ", m
->name_list
.name
);
2084 sprintf_vma (buf
, m
->origin
);
2085 minfo ("0x%s ", buf
);
2093 minfo ("0x%V", m
->length
);
2094 if (m
->flags
|| m
->not_flags
)
2102 lang_map_flags (m
->flags
);
2108 lang_map_flags (m
->not_flags
);
2115 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
2117 if (! link_info
.reduce_memory_overheads
)
2119 obstack_begin (&map_obstack
, 1000);
2120 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
2122 lang_statement_iteration
++;
2123 print_statements ();
2125 ldemul_extra_map_file_text (link_info
.output_bfd
, &link_info
, config
.map_file
);
2129 sort_def_symbol (struct bfd_link_hash_entry
*hash_entry
,
2130 void *info ATTRIBUTE_UNUSED
)
2132 if ((hash_entry
->type
== bfd_link_hash_defined
2133 || hash_entry
->type
== bfd_link_hash_defweak
)
2134 && hash_entry
->u
.def
.section
->owner
!= link_info
.output_bfd
2135 && hash_entry
->u
.def
.section
->owner
!= NULL
)
2137 input_section_userdata_type
*ud
;
2138 struct map_symbol_def
*def
;
2140 ud
= ((input_section_userdata_type
*)
2141 get_userdata (hash_entry
->u
.def
.section
));
2144 ud
= (input_section_userdata_type
*) stat_alloc (sizeof (*ud
));
2145 get_userdata (hash_entry
->u
.def
.section
) = ud
;
2146 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2147 ud
->map_symbol_def_count
= 0;
2149 else if (!ud
->map_symbol_def_tail
)
2150 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
2152 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
2153 def
->entry
= hash_entry
;
2154 *(ud
->map_symbol_def_tail
) = def
;
2155 ud
->map_symbol_def_tail
= &def
->next
;
2156 ud
->map_symbol_def_count
++;
2161 /* Initialize an output section. */
2164 init_os (lang_output_section_statement_type
*s
, flagword flags
)
2166 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
2167 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
2169 if (s
->constraint
!= SPECIAL
)
2170 s
->bfd_section
= bfd_get_section_by_name (link_info
.output_bfd
, s
->name
);
2171 if (s
->bfd_section
== NULL
)
2172 s
->bfd_section
= bfd_make_section_anyway_with_flags (link_info
.output_bfd
,
2174 if (s
->bfd_section
== NULL
)
2176 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2177 link_info
.output_bfd
->xvec
->name
, s
->name
);
2179 s
->bfd_section
->output_section
= s
->bfd_section
;
2180 s
->bfd_section
->output_offset
= 0;
2182 /* Set the userdata of the output section to the output section
2183 statement to avoid lookup. */
2184 get_userdata (s
->bfd_section
) = s
;
2186 /* If there is a base address, make sure that any sections it might
2187 mention are initialized. */
2188 if (s
->addr_tree
!= NULL
)
2189 exp_init_os (s
->addr_tree
);
2191 if (s
->load_base
!= NULL
)
2192 exp_init_os (s
->load_base
);
2194 /* If supplied an alignment, set it. */
2195 if (s
->section_alignment
!= -1)
2196 s
->bfd_section
->alignment_power
= s
->section_alignment
;
2199 /* Make sure that all output sections mentioned in an expression are
2203 exp_init_os (etree_type
*exp
)
2205 switch (exp
->type
.node_class
)
2209 exp_init_os (exp
->assign
.src
);
2213 exp_init_os (exp
->binary
.lhs
);
2214 exp_init_os (exp
->binary
.rhs
);
2218 exp_init_os (exp
->trinary
.cond
);
2219 exp_init_os (exp
->trinary
.lhs
);
2220 exp_init_os (exp
->trinary
.rhs
);
2224 exp_init_os (exp
->assert_s
.child
);
2228 exp_init_os (exp
->unary
.child
);
2232 switch (exp
->type
.node_code
)
2238 lang_output_section_statement_type
*os
;
2240 os
= lang_output_section_find (exp
->name
.name
);
2241 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2253 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
2255 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
2257 /* If we are only reading symbols from this object, then we want to
2258 discard all sections. */
2259 if (entry
->flags
.just_syms
)
2261 bfd_link_just_syms (abfd
, sec
, &link_info
);
2265 if (!(abfd
->flags
& DYNAMIC
))
2266 bfd_section_already_linked (abfd
, sec
, &link_info
);
2269 /* The wild routines.
2271 These expand statements like *(.text) and foo.o to a list of
2272 explicit actions, like foo.o(.text), bar.o(.text) and
2273 foo.o(.text, .data). */
2275 /* Add SECTION to the output section OUTPUT. Do this by creating a
2276 lang_input_section statement which is placed at PTR. */
2279 lang_add_section (lang_statement_list_type
*ptr
,
2281 struct flag_info
*sflag_info
,
2282 lang_output_section_statement_type
*output
)
2284 flagword flags
= section
->flags
;
2286 bfd_boolean discard
;
2287 lang_input_section_type
*new_section
;
2288 bfd
*abfd
= link_info
.output_bfd
;
2290 /* Discard sections marked with SEC_EXCLUDE. */
2291 discard
= (flags
& SEC_EXCLUDE
) != 0;
2293 /* Discard input sections which are assigned to a section named
2294 DISCARD_SECTION_NAME. */
2295 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
2298 /* Discard debugging sections if we are stripping debugging
2300 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2301 && (flags
& SEC_DEBUGGING
) != 0)
2306 if (section
->output_section
== NULL
)
2308 /* This prevents future calls from assigning this section. */
2309 section
->output_section
= bfd_abs_section_ptr
;
2318 keep
= bfd_lookup_section_flags (&link_info
, sflag_info
, section
);
2323 if (section
->output_section
!= NULL
)
2326 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2327 to an output section, because we want to be able to include a
2328 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2329 section (I don't know why we want to do this, but we do).
2330 build_link_order in ldwrite.c handles this case by turning
2331 the embedded SEC_NEVER_LOAD section into a fill. */
2332 flags
&= ~ SEC_NEVER_LOAD
;
2334 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2335 already been processed. One reason to do this is that on pe
2336 format targets, .text$foo sections go into .text and it's odd
2337 to see .text with SEC_LINK_ONCE set. */
2339 if (!link_info
.relocatable
)
2340 flags
&= ~(SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
| SEC_RELOC
);
2342 switch (output
->sectype
)
2344 case normal_section
:
2345 case overlay_section
:
2347 case noalloc_section
:
2348 flags
&= ~SEC_ALLOC
;
2350 case noload_section
:
2352 flags
|= SEC_NEVER_LOAD
;
2353 /* Unfortunately GNU ld has managed to evolve two different
2354 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2355 alloc, no contents section. All others get a noload, noalloc
2357 if (bfd_get_flavour (link_info
.output_bfd
) == bfd_target_elf_flavour
)
2358 flags
&= ~SEC_HAS_CONTENTS
;
2360 flags
&= ~SEC_ALLOC
;
2364 if (output
->bfd_section
== NULL
)
2365 init_os (output
, flags
);
2367 /* If SEC_READONLY is not set in the input section, then clear
2368 it from the output section. */
2369 output
->bfd_section
->flags
&= flags
| ~SEC_READONLY
;
2371 if (output
->bfd_section
->linker_has_input
)
2373 /* Only set SEC_READONLY flag on the first input section. */
2374 flags
&= ~ SEC_READONLY
;
2376 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2377 if ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2378 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2379 || ((flags
& SEC_MERGE
) != 0
2380 && output
->bfd_section
->entsize
!= section
->entsize
))
2382 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2383 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2386 output
->bfd_section
->flags
|= flags
;
2388 if (!output
->bfd_section
->linker_has_input
)
2390 output
->bfd_section
->linker_has_input
= 1;
2391 /* This must happen after flags have been updated. The output
2392 section may have been created before we saw its first input
2393 section, eg. for a data statement. */
2394 bfd_init_private_section_data (section
->owner
, section
,
2395 link_info
.output_bfd
,
2396 output
->bfd_section
,
2398 if ((flags
& SEC_MERGE
) != 0)
2399 output
->bfd_section
->entsize
= section
->entsize
;
2402 if ((flags
& SEC_TIC54X_BLOCK
) != 0
2403 && bfd_get_arch (section
->owner
) == bfd_arch_tic54x
)
2405 /* FIXME: This value should really be obtained from the bfd... */
2406 output
->block_value
= 128;
2409 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2410 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2412 section
->output_section
= output
->bfd_section
;
2414 if (!link_info
.relocatable
2415 && !map_head_is_link_order
)
2417 asection
*s
= output
->bfd_section
->map_tail
.s
;
2418 output
->bfd_section
->map_tail
.s
= section
;
2419 section
->map_head
.s
= NULL
;
2420 section
->map_tail
.s
= s
;
2422 s
->map_head
.s
= section
;
2424 output
->bfd_section
->map_head
.s
= section
;
2427 /* Add a section reference to the list. */
2428 new_section
= new_stat (lang_input_section
, ptr
);
2429 new_section
->section
= section
;
2432 /* Handle wildcard sorting. This returns the lang_input_section which
2433 should follow the one we are going to create for SECTION and FILE,
2434 based on the sorting requirements of WILD. It returns NULL if the
2435 new section should just go at the end of the current list. */
2437 static lang_statement_union_type
*
2438 wild_sort (lang_wild_statement_type
*wild
,
2439 struct wildcard_list
*sec
,
2440 lang_input_statement_type
*file
,
2443 lang_statement_union_type
*l
;
2445 if (!wild
->filenames_sorted
2446 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2449 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2451 lang_input_section_type
*ls
;
2453 if (l
->header
.type
!= lang_input_section_enum
)
2455 ls
= &l
->input_section
;
2457 /* Sorting by filename takes precedence over sorting by section
2460 if (wild
->filenames_sorted
)
2462 const char *fn
, *ln
;
2466 /* The PE support for the .idata section as generated by
2467 dlltool assumes that files will be sorted by the name of
2468 the archive and then the name of the file within the
2471 if (file
->the_bfd
!= NULL
2472 && bfd_my_archive (file
->the_bfd
) != NULL
)
2474 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
2479 fn
= file
->filename
;
2483 if (bfd_my_archive (ls
->section
->owner
) != NULL
)
2485 ln
= bfd_get_filename (bfd_my_archive (ls
->section
->owner
));
2490 ln
= ls
->section
->owner
->filename
;
2494 i
= filename_cmp (fn
, ln
);
2503 fn
= file
->filename
;
2505 ln
= ls
->section
->owner
->filename
;
2507 i
= filename_cmp (fn
, ln
);
2515 /* Here either the files are not sorted by name, or we are
2516 looking at the sections for this file. */
2519 && sec
->spec
.sorted
!= none
2520 && sec
->spec
.sorted
!= by_none
)
2521 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2528 /* Expand a wild statement for a particular FILE. SECTION may be
2529 NULL, in which case it is a wild card. */
2532 output_section_callback (lang_wild_statement_type
*ptr
,
2533 struct wildcard_list
*sec
,
2535 struct flag_info
*sflag_info
,
2536 lang_input_statement_type
*file
,
2539 lang_statement_union_type
*before
;
2540 lang_output_section_statement_type
*os
;
2542 os
= (lang_output_section_statement_type
*) output
;
2544 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2545 if (unique_section_p (section
, os
))
2548 before
= wild_sort (ptr
, sec
, file
, section
);
2550 /* Here BEFORE points to the lang_input_section which
2551 should follow the one we are about to add. If BEFORE
2552 is NULL, then the section should just go at the end
2553 of the current list. */
2556 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2559 lang_statement_list_type list
;
2560 lang_statement_union_type
**pp
;
2562 lang_list_init (&list
);
2563 lang_add_section (&list
, section
, sflag_info
, os
);
2565 /* If we are discarding the section, LIST.HEAD will
2567 if (list
.head
!= NULL
)
2569 ASSERT (list
.head
->header
.next
== NULL
);
2571 for (pp
= &ptr
->children
.head
;
2573 pp
= &(*pp
)->header
.next
)
2574 ASSERT (*pp
!= NULL
);
2576 list
.head
->header
.next
= *pp
;
2582 /* Check if all sections in a wild statement for a particular FILE
2586 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2587 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2589 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2590 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2593 lang_output_section_statement_type
*os
;
2595 os
= (lang_output_section_statement_type
*) output
;
2597 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2598 if (unique_section_p (section
, os
))
2601 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2602 os
->all_input_readonly
= FALSE
;
2605 /* This is passed a file name which must have been seen already and
2606 added to the statement tree. We will see if it has been opened
2607 already and had its symbols read. If not then we'll read it. */
2609 static lang_input_statement_type
*
2610 lookup_name (const char *name
)
2612 lang_input_statement_type
*search
;
2614 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2616 search
= (lang_input_statement_type
*) search
->next_real_file
)
2618 /* Use the local_sym_name as the name of the file that has
2619 already been loaded as filename might have been transformed
2620 via the search directory lookup mechanism. */
2621 const char *filename
= search
->local_sym_name
;
2623 if (filename
!= NULL
2624 && filename_cmp (filename
, name
) == 0)
2629 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2630 default_target
, FALSE
);
2632 /* If we have already added this file, or this file is not real
2633 don't add this file. */
2634 if (search
->flags
.loaded
|| !search
->flags
.real
)
2637 if (! load_symbols (search
, NULL
))
2643 /* Save LIST as a list of libraries whose symbols should not be exported. */
2648 struct excluded_lib
*next
;
2650 static struct excluded_lib
*excluded_libs
;
2653 add_excluded_libs (const char *list
)
2655 const char *p
= list
, *end
;
2659 struct excluded_lib
*entry
;
2660 end
= strpbrk (p
, ",:");
2662 end
= p
+ strlen (p
);
2663 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2664 entry
->next
= excluded_libs
;
2665 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2666 memcpy (entry
->name
, p
, end
- p
);
2667 entry
->name
[end
- p
] = '\0';
2668 excluded_libs
= entry
;
2676 check_excluded_libs (bfd
*abfd
)
2678 struct excluded_lib
*lib
= excluded_libs
;
2682 int len
= strlen (lib
->name
);
2683 const char *filename
= lbasename (abfd
->filename
);
2685 if (strcmp (lib
->name
, "ALL") == 0)
2687 abfd
->no_export
= TRUE
;
2691 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2692 && (filename
[len
] == '\0'
2693 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2694 && filename
[len
+ 2] == '\0')))
2696 abfd
->no_export
= TRUE
;
2704 /* Get the symbols for an input file. */
2707 load_symbols (lang_input_statement_type
*entry
,
2708 lang_statement_list_type
*place
)
2712 if (entry
->flags
.loaded
)
2715 ldfile_open_file (entry
);
2717 /* Do not process further if the file was missing. */
2718 if (entry
->flags
.missing_file
)
2721 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
2722 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2725 struct lang_input_statement_flags save_flags
;
2728 err
= bfd_get_error ();
2730 /* See if the emulation has some special knowledge. */
2731 if (ldemul_unrecognized_file (entry
))
2734 if (err
== bfd_error_file_ambiguously_recognized
)
2738 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
2739 einfo (_("%B: matching formats:"), entry
->the_bfd
);
2740 for (p
= matching
; *p
!= NULL
; p
++)
2744 else if (err
!= bfd_error_file_not_recognized
2746 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
2748 bfd_close (entry
->the_bfd
);
2749 entry
->the_bfd
= NULL
;
2751 /* Try to interpret the file as a linker script. */
2752 save_flags
= input_flags
;
2753 ldfile_open_command_file (entry
->filename
);
2755 push_stat_ptr (place
);
2756 input_flags
.add_DT_NEEDED_for_regular
2757 = entry
->flags
.add_DT_NEEDED_for_regular
;
2758 input_flags
.add_DT_NEEDED_for_dynamic
2759 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
2760 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
2761 input_flags
.dynamic
= entry
->flags
.dynamic
;
2763 ldfile_assumed_script
= TRUE
;
2764 parser_input
= input_script
;
2766 ldfile_assumed_script
= FALSE
;
2768 /* missing_file is sticky. sysrooted will already have been
2769 restored when seeing EOF in yyparse, but no harm to restore
2771 save_flags
.missing_file
|= input_flags
.missing_file
;
2772 input_flags
= save_flags
;
2776 entry
->flags
.loaded
= TRUE
;
2781 if (ldemul_recognized_file (entry
))
2784 /* We don't call ldlang_add_file for an archive. Instead, the
2785 add_symbols entry point will call ldlang_add_file, via the
2786 add_archive_element callback, for each element of the archive
2788 switch (bfd_get_format (entry
->the_bfd
))
2794 if (!entry
->flags
.reload
)
2795 ldlang_add_file (entry
);
2796 if (trace_files
|| verbose
)
2797 info_msg ("%I\n", entry
);
2801 check_excluded_libs (entry
->the_bfd
);
2803 if (entry
->flags
.whole_archive
)
2806 bfd_boolean loaded
= TRUE
;
2811 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
2816 if (! bfd_check_format (member
, bfd_object
))
2818 einfo (_("%F%B: member %B in archive is not an object\n"),
2819 entry
->the_bfd
, member
);
2824 if (!(*link_info
.callbacks
2825 ->add_archive_element
) (&link_info
, member
,
2826 "--whole-archive", &subsbfd
))
2829 /* Potentially, the add_archive_element hook may have set a
2830 substitute BFD for us. */
2831 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
2833 einfo (_("%F%B: error adding symbols: %E\n"), member
);
2838 entry
->flags
.loaded
= loaded
;
2844 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
2845 entry
->flags
.loaded
= TRUE
;
2847 einfo (_("%F%B: error adding symbols: %E\n"), entry
->the_bfd
);
2849 return entry
->flags
.loaded
;
2852 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2853 may be NULL, indicating that it is a wildcard. Separate
2854 lang_input_section statements are created for each part of the
2855 expansion; they are added after the wild statement S. OUTPUT is
2856 the output section. */
2859 wild (lang_wild_statement_type
*s
,
2860 const char *target ATTRIBUTE_UNUSED
,
2861 lang_output_section_statement_type
*output
)
2863 struct wildcard_list
*sec
;
2865 if (s
->handler_data
[0]
2866 && s
->handler_data
[0]->spec
.sorted
== by_name
2867 && !s
->filenames_sorted
)
2869 lang_section_bst_type
*tree
;
2871 walk_wild (s
, output_section_callback_fast
, output
);
2876 output_section_callback_tree_to_list (s
, tree
, output
);
2881 walk_wild (s
, output_section_callback
, output
);
2883 if (default_common_section
== NULL
)
2884 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
2885 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
2887 /* Remember the section that common is going to in case we
2888 later get something which doesn't know where to put it. */
2889 default_common_section
= output
;
2894 /* Return TRUE iff target is the sought target. */
2897 get_target (const bfd_target
*target
, void *data
)
2899 const char *sought
= (const char *) data
;
2901 return strcmp (target
->name
, sought
) == 0;
2904 /* Like strcpy() but convert to lower case as well. */
2907 stricpy (char *dest
, char *src
)
2911 while ((c
= *src
++) != 0)
2912 *dest
++ = TOLOWER (c
);
2917 /* Remove the first occurrence of needle (if any) in haystack
2921 strcut (char *haystack
, char *needle
)
2923 haystack
= strstr (haystack
, needle
);
2929 for (src
= haystack
+ strlen (needle
); *src
;)
2930 *haystack
++ = *src
++;
2936 /* Compare two target format name strings.
2937 Return a value indicating how "similar" they are. */
2940 name_compare (char *first
, char *second
)
2946 copy1
= (char *) xmalloc (strlen (first
) + 1);
2947 copy2
= (char *) xmalloc (strlen (second
) + 1);
2949 /* Convert the names to lower case. */
2950 stricpy (copy1
, first
);
2951 stricpy (copy2
, second
);
2953 /* Remove size and endian strings from the name. */
2954 strcut (copy1
, "big");
2955 strcut (copy1
, "little");
2956 strcut (copy2
, "big");
2957 strcut (copy2
, "little");
2959 /* Return a value based on how many characters match,
2960 starting from the beginning. If both strings are
2961 the same then return 10 * their length. */
2962 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
2963 if (copy1
[result
] == 0)
2975 /* Set by closest_target_match() below. */
2976 static const bfd_target
*winner
;
2978 /* Scan all the valid bfd targets looking for one that has the endianness
2979 requirement that was specified on the command line, and is the nearest
2980 match to the original output target. */
2983 closest_target_match (const bfd_target
*target
, void *data
)
2985 const bfd_target
*original
= (const bfd_target
*) data
;
2987 if (command_line
.endian
== ENDIAN_BIG
2988 && target
->byteorder
!= BFD_ENDIAN_BIG
)
2991 if (command_line
.endian
== ENDIAN_LITTLE
2992 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
2995 /* Must be the same flavour. */
2996 if (target
->flavour
!= original
->flavour
)
2999 /* Ignore generic big and little endian elf vectors. */
3000 if (strcmp (target
->name
, "elf32-big") == 0
3001 || strcmp (target
->name
, "elf64-big") == 0
3002 || strcmp (target
->name
, "elf32-little") == 0
3003 || strcmp (target
->name
, "elf64-little") == 0)
3006 /* If we have not found a potential winner yet, then record this one. */
3013 /* Oh dear, we now have two potential candidates for a successful match.
3014 Compare their names and choose the better one. */
3015 if (name_compare (target
->name
, original
->name
)
3016 > name_compare (winner
->name
, original
->name
))
3019 /* Keep on searching until wqe have checked them all. */
3023 /* Return the BFD target format of the first input file. */
3026 get_first_input_target (void)
3028 char *target
= NULL
;
3030 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3032 if (s
->header
.type
== lang_input_statement_enum
3035 ldfile_open_file (s
);
3037 if (s
->the_bfd
!= NULL
3038 && bfd_check_format (s
->the_bfd
, bfd_object
))
3040 target
= bfd_get_target (s
->the_bfd
);
3052 lang_get_output_target (void)
3056 /* Has the user told us which output format to use? */
3057 if (output_target
!= NULL
)
3058 return output_target
;
3060 /* No - has the current target been set to something other than
3062 if (current_target
!= default_target
&& current_target
!= NULL
)
3063 return current_target
;
3065 /* No - can we determine the format of the first input file? */
3066 target
= get_first_input_target ();
3070 /* Failed - use the default output target. */
3071 return default_target
;
3074 /* Open the output file. */
3077 open_output (const char *name
)
3079 output_target
= lang_get_output_target ();
3081 /* Has the user requested a particular endianness on the command
3083 if (command_line
.endian
!= ENDIAN_UNSET
)
3085 const bfd_target
*target
;
3086 enum bfd_endian desired_endian
;
3088 /* Get the chosen target. */
3089 target
= bfd_search_for_target (get_target
, (void *) output_target
);
3091 /* If the target is not supported, we cannot do anything. */
3094 if (command_line
.endian
== ENDIAN_BIG
)
3095 desired_endian
= BFD_ENDIAN_BIG
;
3097 desired_endian
= BFD_ENDIAN_LITTLE
;
3099 /* See if the target has the wrong endianness. This should
3100 not happen if the linker script has provided big and
3101 little endian alternatives, but some scrips don't do
3103 if (target
->byteorder
!= desired_endian
)
3105 /* If it does, then see if the target provides
3106 an alternative with the correct endianness. */
3107 if (target
->alternative_target
!= NULL
3108 && (target
->alternative_target
->byteorder
== desired_endian
))
3109 output_target
= target
->alternative_target
->name
;
3112 /* Try to find a target as similar as possible to
3113 the default target, but which has the desired
3114 endian characteristic. */
3115 bfd_search_for_target (closest_target_match
,
3118 /* Oh dear - we could not find any targets that
3119 satisfy our requirements. */
3121 einfo (_("%P: warning: could not find any targets"
3122 " that match endianness requirement\n"));
3124 output_target
= winner
->name
;
3130 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3132 if (link_info
.output_bfd
== NULL
)
3134 if (bfd_get_error () == bfd_error_invalid_target
)
3135 einfo (_("%P%F: target %s not found\n"), output_target
);
3137 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
3140 delete_output_file_on_failure
= TRUE
;
3142 if (! bfd_set_format (link_info
.output_bfd
, bfd_object
))
3143 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
3144 if (! bfd_set_arch_mach (link_info
.output_bfd
,
3145 ldfile_output_architecture
,
3146 ldfile_output_machine
))
3147 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
3149 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3150 if (link_info
.hash
== NULL
)
3151 einfo (_("%P%F: can not create hash table: %E\n"));
3153 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3157 ldlang_open_output (lang_statement_union_type
*statement
)
3159 switch (statement
->header
.type
)
3161 case lang_output_statement_enum
:
3162 ASSERT (link_info
.output_bfd
== NULL
);
3163 open_output (statement
->output_statement
.name
);
3164 ldemul_set_output_arch ();
3165 if (config
.magic_demand_paged
&& !link_info
.relocatable
)
3166 link_info
.output_bfd
->flags
|= D_PAGED
;
3168 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3169 if (config
.text_read_only
)
3170 link_info
.output_bfd
->flags
|= WP_TEXT
;
3172 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3173 if (link_info
.traditional_format
)
3174 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3176 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3179 case lang_target_statement_enum
:
3180 current_target
= statement
->target_statement
.target
;
3187 /* Convert between addresses in bytes and sizes in octets.
3188 For currently supported targets, octets_per_byte is always a power
3189 of two, so we can use shifts. */
3190 #define TO_ADDR(X) ((X) >> opb_shift)
3191 #define TO_SIZE(X) ((X) << opb_shift)
3193 /* Support the above. */
3194 static unsigned int opb_shift
= 0;
3199 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3200 ldfile_output_machine
);
3203 while ((x
& 1) == 0)
3211 /* Open all the input files. */
3215 OPEN_BFD_NORMAL
= 0,
3219 #ifdef ENABLE_PLUGINS
3220 static lang_input_statement_type
*plugin_insert
= NULL
;
3224 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3226 for (; s
!= NULL
; s
= s
->header
.next
)
3228 switch (s
->header
.type
)
3230 case lang_constructors_statement_enum
:
3231 open_input_bfds (constructor_list
.head
, mode
);
3233 case lang_output_section_statement_enum
:
3234 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3236 case lang_wild_statement_enum
:
3237 /* Maybe we should load the file's symbols. */
3238 if ((mode
& OPEN_BFD_RESCAN
) == 0
3239 && s
->wild_statement
.filename
3240 && !wildcardp (s
->wild_statement
.filename
)
3241 && !archive_path (s
->wild_statement
.filename
))
3242 lookup_name (s
->wild_statement
.filename
);
3243 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3245 case lang_group_statement_enum
:
3247 struct bfd_link_hash_entry
*undefs
;
3249 /* We must continually search the entries in the group
3250 until no new symbols are added to the list of undefined
3255 undefs
= link_info
.hash
->undefs_tail
;
3256 open_input_bfds (s
->group_statement
.children
.head
,
3257 mode
| OPEN_BFD_FORCE
);
3259 while (undefs
!= link_info
.hash
->undefs_tail
);
3262 case lang_target_statement_enum
:
3263 current_target
= s
->target_statement
.target
;
3265 case lang_input_statement_enum
:
3266 if (s
->input_statement
.flags
.real
)
3268 lang_statement_union_type
**os_tail
;
3269 lang_statement_list_type add
;
3272 s
->input_statement
.target
= current_target
;
3274 /* If we are being called from within a group, and this
3275 is an archive which has already been searched, then
3276 force it to be researched unless the whole archive
3277 has been loaded already. Do the same for a rescan.
3278 Likewise reload --as-needed shared libs. */
3279 if (mode
!= OPEN_BFD_NORMAL
3280 #ifdef ENABLE_PLUGINS
3281 && ((mode
& OPEN_BFD_RESCAN
) == 0
3282 || plugin_insert
== NULL
)
3284 && s
->input_statement
.flags
.loaded
3285 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3286 && ((bfd_get_format (abfd
) == bfd_archive
3287 && !s
->input_statement
.flags
.whole_archive
)
3288 || (bfd_get_format (abfd
) == bfd_object
3289 && ((abfd
->flags
) & DYNAMIC
) != 0
3290 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3291 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3292 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3294 s
->input_statement
.flags
.loaded
= FALSE
;
3295 s
->input_statement
.flags
.reload
= TRUE
;
3298 os_tail
= lang_output_section_statement
.tail
;
3299 lang_list_init (&add
);
3301 if (! load_symbols (&s
->input_statement
, &add
))
3302 config
.make_executable
= FALSE
;
3304 if (add
.head
!= NULL
)
3306 /* If this was a script with output sections then
3307 tack any added statements on to the end of the
3308 list. This avoids having to reorder the output
3309 section statement list. Very likely the user
3310 forgot -T, and whatever we do here will not meet
3311 naive user expectations. */
3312 if (os_tail
!= lang_output_section_statement
.tail
)
3314 einfo (_("%P: warning: %s contains output sections;"
3315 " did you forget -T?\n"),
3316 s
->input_statement
.filename
);
3317 *stat_ptr
->tail
= add
.head
;
3318 stat_ptr
->tail
= add
.tail
;
3322 *add
.tail
= s
->header
.next
;
3323 s
->header
.next
= add
.head
;
3327 #ifdef ENABLE_PLUGINS
3328 /* If we have found the point at which a plugin added new
3329 files, clear plugin_insert to enable archive rescan. */
3330 if (&s
->input_statement
== plugin_insert
)
3331 plugin_insert
= NULL
;
3334 case lang_assignment_statement_enum
:
3335 if (s
->assignment_statement
.exp
->assign
.defsym
)
3336 /* This is from a --defsym on the command line. */
3337 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3344 /* Exit if any of the files were missing. */
3345 if (input_flags
.missing_file
)
3349 /* New-function for the definedness hash table. */
3351 static struct bfd_hash_entry
*
3352 lang_definedness_newfunc (struct bfd_hash_entry
*entry
,
3353 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
3354 const char *name ATTRIBUTE_UNUSED
)
3356 struct lang_definedness_hash_entry
*ret
3357 = (struct lang_definedness_hash_entry
*) entry
;
3360 ret
= (struct lang_definedness_hash_entry
*)
3361 bfd_hash_allocate (table
, sizeof (struct lang_definedness_hash_entry
));
3364 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
3372 /* Called during processing of linker script script expressions.
3373 For symbols assigned in a linker script, return a struct describing
3374 where the symbol is defined relative to the current expression,
3375 otherwise return NULL. */
3377 struct lang_definedness_hash_entry
*
3378 lang_symbol_defined (const char *name
)
3380 return ((struct lang_definedness_hash_entry
*)
3381 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
));
3384 /* Update the definedness state of NAME. */
3387 lang_update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
3389 struct lang_definedness_hash_entry
*defentry
3390 = (struct lang_definedness_hash_entry
*)
3391 bfd_hash_lookup (&lang_definedness_table
, name
, TRUE
, FALSE
);
3393 if (defentry
== NULL
)
3394 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
3396 /* If the symbol was already defined, and not by a script, then it
3397 must be defined by an object file. */
3398 if (!defentry
->by_script
3399 && h
->type
!= bfd_link_hash_undefined
3400 && h
->type
!= bfd_link_hash_common
3401 && h
->type
!= bfd_link_hash_new
)
3402 defentry
->by_object
= 1;
3404 defentry
->by_script
= 1;
3405 defentry
->iteration
= lang_statement_iteration
;
3408 /* Add the supplied name to the symbol table as an undefined reference.
3409 This is a two step process as the symbol table doesn't even exist at
3410 the time the ld command line is processed. First we put the name
3411 on a list, then, once the output file has been opened, transfer the
3412 name to the symbol table. */
3414 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3416 #define ldlang_undef_chain_list_head entry_symbol.next
3419 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3421 ldlang_undef_chain_list_type
*new_undef
;
3423 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3424 new_undef
= (ldlang_undef_chain_list_type
*) stat_alloc (sizeof (*new_undef
));
3425 new_undef
->next
= ldlang_undef_chain_list_head
;
3426 ldlang_undef_chain_list_head
= new_undef
;
3428 new_undef
->name
= xstrdup (name
);
3430 if (link_info
.output_bfd
!= NULL
)
3431 insert_undefined (new_undef
->name
);
3434 /* Insert NAME as undefined in the symbol table. */
3437 insert_undefined (const char *name
)
3439 struct bfd_link_hash_entry
*h
;
3441 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3443 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3444 if (h
->type
== bfd_link_hash_new
)
3446 h
->type
= bfd_link_hash_undefined
;
3447 h
->u
.undef
.abfd
= NULL
;
3448 bfd_link_add_undef (link_info
.hash
, h
);
3452 /* Run through the list of undefineds created above and place them
3453 into the linker hash table as undefined symbols belonging to the
3457 lang_place_undefineds (void)
3459 ldlang_undef_chain_list_type
*ptr
;
3461 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3462 insert_undefined (ptr
->name
);
3465 /* Check for all readonly or some readwrite sections. */
3468 check_input_sections
3469 (lang_statement_union_type
*s
,
3470 lang_output_section_statement_type
*output_section_statement
)
3472 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3474 switch (s
->header
.type
)
3476 case lang_wild_statement_enum
:
3477 walk_wild (&s
->wild_statement
, check_section_callback
,
3478 output_section_statement
);
3479 if (! output_section_statement
->all_input_readonly
)
3482 case lang_constructors_statement_enum
:
3483 check_input_sections (constructor_list
.head
,
3484 output_section_statement
);
3485 if (! output_section_statement
->all_input_readonly
)
3488 case lang_group_statement_enum
:
3489 check_input_sections (s
->group_statement
.children
.head
,
3490 output_section_statement
);
3491 if (! output_section_statement
->all_input_readonly
)
3500 /* Update wildcard statements if needed. */
3503 update_wild_statements (lang_statement_union_type
*s
)
3505 struct wildcard_list
*sec
;
3507 switch (sort_section
)
3517 for (; s
!= NULL
; s
= s
->header
.next
)
3519 switch (s
->header
.type
)
3524 case lang_wild_statement_enum
:
3525 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3528 switch (sec
->spec
.sorted
)
3531 sec
->spec
.sorted
= sort_section
;
3534 if (sort_section
== by_alignment
)
3535 sec
->spec
.sorted
= by_name_alignment
;
3538 if (sort_section
== by_name
)
3539 sec
->spec
.sorted
= by_alignment_name
;
3547 case lang_constructors_statement_enum
:
3548 update_wild_statements (constructor_list
.head
);
3551 case lang_output_section_statement_enum
:
3552 /* Don't sort .init/.fini sections. */
3553 if (strcmp (s
->output_section_statement
.name
, ".init") != 0
3554 && strcmp (s
->output_section_statement
.name
, ".fini") != 0)
3555 update_wild_statements
3556 (s
->output_section_statement
.children
.head
);
3559 case lang_group_statement_enum
:
3560 update_wild_statements (s
->group_statement
.children
.head
);
3568 /* Open input files and attach to output sections. */
3571 map_input_to_output_sections
3572 (lang_statement_union_type
*s
, const char *target
,
3573 lang_output_section_statement_type
*os
)
3575 for (; s
!= NULL
; s
= s
->header
.next
)
3577 lang_output_section_statement_type
*tos
;
3580 switch (s
->header
.type
)
3582 case lang_wild_statement_enum
:
3583 wild (&s
->wild_statement
, target
, os
);
3585 case lang_constructors_statement_enum
:
3586 map_input_to_output_sections (constructor_list
.head
,
3590 case lang_output_section_statement_enum
:
3591 tos
= &s
->output_section_statement
;
3592 if (tos
->constraint
!= 0)
3594 if (tos
->constraint
!= ONLY_IF_RW
3595 && tos
->constraint
!= ONLY_IF_RO
)
3597 tos
->all_input_readonly
= TRUE
;
3598 check_input_sections (tos
->children
.head
, tos
);
3599 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3601 tos
->constraint
= -1;
3605 map_input_to_output_sections (tos
->children
.head
,
3609 case lang_output_statement_enum
:
3611 case lang_target_statement_enum
:
3612 target
= s
->target_statement
.target
;
3614 case lang_group_statement_enum
:
3615 map_input_to_output_sections (s
->group_statement
.children
.head
,
3619 case lang_data_statement_enum
:
3620 /* Make sure that any sections mentioned in the expression
3622 exp_init_os (s
->data_statement
.exp
);
3623 /* The output section gets CONTENTS, ALLOC and LOAD, but
3624 these may be overridden by the script. */
3625 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3626 switch (os
->sectype
)
3628 case normal_section
:
3629 case overlay_section
:
3631 case noalloc_section
:
3632 flags
= SEC_HAS_CONTENTS
;
3634 case noload_section
:
3635 if (bfd_get_flavour (link_info
.output_bfd
)
3636 == bfd_target_elf_flavour
)
3637 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3639 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3642 if (os
->bfd_section
== NULL
)
3643 init_os (os
, flags
);
3645 os
->bfd_section
->flags
|= flags
;
3647 case lang_input_section_enum
:
3649 case lang_fill_statement_enum
:
3650 case lang_object_symbols_statement_enum
:
3651 case lang_reloc_statement_enum
:
3652 case lang_padding_statement_enum
:
3653 case lang_input_statement_enum
:
3654 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3657 case lang_assignment_statement_enum
:
3658 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3661 /* Make sure that any sections mentioned in the assignment
3663 exp_init_os (s
->assignment_statement
.exp
);
3665 case lang_address_statement_enum
:
3666 /* Mark the specified section with the supplied address.
3667 If this section was actually a segment marker, then the
3668 directive is ignored if the linker script explicitly
3669 processed the segment marker. Originally, the linker
3670 treated segment directives (like -Ttext on the
3671 command-line) as section directives. We honor the
3672 section directive semantics for backwards compatibilty;
3673 linker scripts that do not specifically check for
3674 SEGMENT_START automatically get the old semantics. */
3675 if (!s
->address_statement
.segment
3676 || !s
->address_statement
.segment
->used
)
3678 const char *name
= s
->address_statement
.section_name
;
3680 /* Create the output section statement here so that
3681 orphans with a set address will be placed after other
3682 script sections. If we let the orphan placement code
3683 place them in amongst other sections then the address
3684 will affect following script sections, which is
3685 likely to surprise naive users. */
3686 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3687 tos
->addr_tree
= s
->address_statement
.address
;
3688 if (tos
->bfd_section
== NULL
)
3692 case lang_insert_statement_enum
:
3698 /* An insert statement snips out all the linker statements from the
3699 start of the list and places them after the output section
3700 statement specified by the insert. This operation is complicated
3701 by the fact that we keep a doubly linked list of output section
3702 statements as well as the singly linked list of all statements. */
3705 process_insert_statements (void)
3707 lang_statement_union_type
**s
;
3708 lang_output_section_statement_type
*first_os
= NULL
;
3709 lang_output_section_statement_type
*last_os
= NULL
;
3710 lang_output_section_statement_type
*os
;
3712 /* "start of list" is actually the statement immediately after
3713 the special abs_section output statement, so that it isn't
3715 s
= &lang_output_section_statement
.head
;
3716 while (*(s
= &(*s
)->header
.next
) != NULL
)
3718 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3720 /* Keep pointers to the first and last output section
3721 statement in the sequence we may be about to move. */
3722 os
= &(*s
)->output_section_statement
;
3724 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3727 /* Set constraint negative so that lang_output_section_find
3728 won't match this output section statement. At this
3729 stage in linking constraint has values in the range
3730 [-1, ONLY_IN_RW]. */
3731 last_os
->constraint
= -2 - last_os
->constraint
;
3732 if (first_os
== NULL
)
3735 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3737 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3738 lang_output_section_statement_type
*where
;
3739 lang_statement_union_type
**ptr
;
3740 lang_statement_union_type
*first
;
3742 where
= lang_output_section_find (i
->where
);
3743 if (where
!= NULL
&& i
->is_before
)
3746 where
= where
->prev
;
3747 while (where
!= NULL
&& where
->constraint
< 0);
3751 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
3755 /* Deal with reordering the output section statement list. */
3756 if (last_os
!= NULL
)
3758 asection
*first_sec
, *last_sec
;
3759 struct lang_output_section_statement_struct
**next
;
3761 /* Snip out the output sections we are moving. */
3762 first_os
->prev
->next
= last_os
->next
;
3763 if (last_os
->next
== NULL
)
3765 next
= &first_os
->prev
->next
;
3766 lang_output_section_statement
.tail
3767 = (lang_statement_union_type
**) next
;
3770 last_os
->next
->prev
= first_os
->prev
;
3771 /* Add them in at the new position. */
3772 last_os
->next
= where
->next
;
3773 if (where
->next
== NULL
)
3775 next
= &last_os
->next
;
3776 lang_output_section_statement
.tail
3777 = (lang_statement_union_type
**) next
;
3780 where
->next
->prev
= last_os
;
3781 first_os
->prev
= where
;
3782 where
->next
= first_os
;
3784 /* Move the bfd sections in the same way. */
3787 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3789 os
->constraint
= -2 - os
->constraint
;
3790 if (os
->bfd_section
!= NULL
3791 && os
->bfd_section
->owner
!= NULL
)
3793 last_sec
= os
->bfd_section
;
3794 if (first_sec
== NULL
)
3795 first_sec
= last_sec
;
3800 if (last_sec
!= NULL
)
3802 asection
*sec
= where
->bfd_section
;
3804 sec
= output_prev_sec_find (where
);
3806 /* The place we want to insert must come after the
3807 sections we are moving. So if we find no
3808 section or if the section is the same as our
3809 last section, then no move is needed. */
3810 if (sec
!= NULL
&& sec
!= last_sec
)
3812 /* Trim them off. */
3813 if (first_sec
->prev
!= NULL
)
3814 first_sec
->prev
->next
= last_sec
->next
;
3816 link_info
.output_bfd
->sections
= last_sec
->next
;
3817 if (last_sec
->next
!= NULL
)
3818 last_sec
->next
->prev
= first_sec
->prev
;
3820 link_info
.output_bfd
->section_last
= first_sec
->prev
;
3822 last_sec
->next
= sec
->next
;
3823 if (sec
->next
!= NULL
)
3824 sec
->next
->prev
= last_sec
;
3826 link_info
.output_bfd
->section_last
= last_sec
;
3827 first_sec
->prev
= sec
;
3828 sec
->next
= first_sec
;
3836 ptr
= insert_os_after (where
);
3837 /* Snip everything after the abs_section output statement we
3838 know is at the start of the list, up to and including
3839 the insert statement we are currently processing. */
3840 first
= lang_output_section_statement
.head
->header
.next
;
3841 lang_output_section_statement
.head
->header
.next
= (*s
)->header
.next
;
3842 /* Add them back where they belong. */
3845 statement_list
.tail
= s
;
3847 s
= &lang_output_section_statement
.head
;
3851 /* Undo constraint twiddling. */
3852 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3854 os
->constraint
= -2 - os
->constraint
;
3860 /* An output section might have been removed after its statement was
3861 added. For example, ldemul_before_allocation can remove dynamic
3862 sections if they turn out to be not needed. Clean them up here. */
3865 strip_excluded_output_sections (void)
3867 lang_output_section_statement_type
*os
;
3869 /* Run lang_size_sections (if not already done). */
3870 if (expld
.phase
!= lang_mark_phase_enum
)
3872 expld
.phase
= lang_mark_phase_enum
;
3873 expld
.dataseg
.phase
= exp_dataseg_none
;
3874 one_lang_size_sections_pass (NULL
, FALSE
);
3875 lang_reset_memory_regions ();
3878 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3882 asection
*output_section
;
3883 bfd_boolean exclude
;
3885 if (os
->constraint
< 0)
3888 output_section
= os
->bfd_section
;
3889 if (output_section
== NULL
)
3892 exclude
= (output_section
->rawsize
== 0
3893 && (output_section
->flags
& SEC_KEEP
) == 0
3894 && !bfd_section_removed_from_list (link_info
.output_bfd
,
3897 /* Some sections have not yet been sized, notably .gnu.version,
3898 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3899 input sections, so don't drop output sections that have such
3900 input sections unless they are also marked SEC_EXCLUDE. */
3901 if (exclude
&& output_section
->map_head
.s
!= NULL
)
3905 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
3906 if ((s
->flags
& SEC_EXCLUDE
) == 0
3907 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
3908 || link_info
.emitrelocations
))
3917 /* We don't set bfd_section to NULL since bfd_section of the
3918 removed output section statement may still be used. */
3919 if (!os
->update_dot
)
3921 output_section
->flags
|= SEC_EXCLUDE
;
3922 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
3923 link_info
.output_bfd
->section_count
--;
3928 /* Called from ldwrite to clear out asection.map_head and
3929 asection.map_tail for use as link_orders in ldwrite.
3930 FIXME: Except for sh64elf.em which starts creating link_orders in
3931 its after_allocation routine so needs to call it early. */
3934 lang_clear_os_map (void)
3936 lang_output_section_statement_type
*os
;
3938 if (map_head_is_link_order
)
3941 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3945 asection
*output_section
;
3947 if (os
->constraint
< 0)
3950 output_section
= os
->bfd_section
;
3951 if (output_section
== NULL
)
3954 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3955 output_section
->map_head
.link_order
= NULL
;
3956 output_section
->map_tail
.link_order
= NULL
;
3959 /* Stop future calls to lang_add_section from messing with map_head
3960 and map_tail link_order fields. */
3961 map_head_is_link_order
= TRUE
;
3965 print_output_section_statement
3966 (lang_output_section_statement_type
*output_section_statement
)
3968 asection
*section
= output_section_statement
->bfd_section
;
3971 if (output_section_statement
!= abs_output_section
)
3973 minfo ("\n%s", output_section_statement
->name
);
3975 if (section
!= NULL
)
3977 print_dot
= section
->vma
;
3979 len
= strlen (output_section_statement
->name
);
3980 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3985 while (len
< SECTION_NAME_MAP_LENGTH
)
3991 minfo ("0x%V %W", section
->vma
, section
->size
);
3993 if (section
->vma
!= section
->lma
)
3994 minfo (_(" load address 0x%V"), section
->lma
);
3996 if (output_section_statement
->update_dot_tree
!= NULL
)
3997 exp_fold_tree (output_section_statement
->update_dot_tree
,
3998 bfd_abs_section_ptr
, &print_dot
);
4004 print_statement_list (output_section_statement
->children
.head
,
4005 output_section_statement
);
4009 print_assignment (lang_assignment_statement_type
*assignment
,
4010 lang_output_section_statement_type
*output_section
)
4017 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4020 if (assignment
->exp
->type
.node_class
== etree_assert
)
4023 tree
= assignment
->exp
->assert_s
.child
;
4027 const char *dst
= assignment
->exp
->assign
.dst
;
4029 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4031 expld
.assign_name
= dst
;
4032 tree
= assignment
->exp
->assign
.src
;
4035 osec
= output_section
->bfd_section
;
4037 osec
= bfd_abs_section_ptr
;
4038 exp_fold_tree (tree
, osec
, &print_dot
);
4039 if (expld
.result
.valid_p
)
4043 if (assignment
->exp
->type
.node_class
== etree_assert
4045 || expld
.assign_name
!= NULL
)
4047 value
= expld
.result
.value
;
4049 if (expld
.result
.section
!= NULL
)
4050 value
+= expld
.result
.section
->vma
;
4052 minfo ("0x%V", value
);
4058 struct bfd_link_hash_entry
*h
;
4060 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4061 FALSE
, FALSE
, TRUE
);
4064 value
= h
->u
.def
.value
;
4065 value
+= h
->u
.def
.section
->output_section
->vma
;
4066 value
+= h
->u
.def
.section
->output_offset
;
4068 minfo ("[0x%V]", value
);
4071 minfo ("[unresolved]");
4081 expld
.assign_name
= NULL
;
4084 exp_print_tree (assignment
->exp
);
4089 print_input_statement (lang_input_statement_type
*statm
)
4091 if (statm
->filename
!= NULL
4092 && (statm
->the_bfd
== NULL
4093 || (statm
->the_bfd
->flags
& BFD_LINKER_CREATED
) == 0))
4094 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4097 /* Print all symbols defined in a particular section. This is called
4098 via bfd_link_hash_traverse, or by print_all_symbols. */
4101 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4103 asection
*sec
= (asection
*) ptr
;
4105 if ((hash_entry
->type
== bfd_link_hash_defined
4106 || hash_entry
->type
== bfd_link_hash_defweak
)
4107 && sec
== hash_entry
->u
.def
.section
)
4111 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4114 (hash_entry
->u
.def
.value
4115 + hash_entry
->u
.def
.section
->output_offset
4116 + hash_entry
->u
.def
.section
->output_section
->vma
));
4118 minfo (" %T\n", hash_entry
->root
.string
);
4125 hash_entry_addr_cmp (const void *a
, const void *b
)
4127 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4128 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4130 if (l
->u
.def
.value
< r
->u
.def
.value
)
4132 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4139 print_all_symbols (asection
*sec
)
4141 input_section_userdata_type
*ud
4142 = (input_section_userdata_type
*) get_userdata (sec
);
4143 struct map_symbol_def
*def
;
4144 struct bfd_link_hash_entry
**entries
;
4150 *ud
->map_symbol_def_tail
= 0;
4152 /* Sort the symbols by address. */
4153 entries
= (struct bfd_link_hash_entry
**)
4154 obstack_alloc (&map_obstack
, ud
->map_symbol_def_count
* sizeof (*entries
));
4156 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4157 entries
[i
] = def
->entry
;
4159 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4160 hash_entry_addr_cmp
);
4162 /* Print the symbols. */
4163 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4164 print_one_symbol (entries
[i
], sec
);
4166 obstack_free (&map_obstack
, entries
);
4169 /* Print information about an input section to the map file. */
4172 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4174 bfd_size_type size
= i
->size
;
4181 minfo ("%s", i
->name
);
4183 len
= 1 + strlen (i
->name
);
4184 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4189 while (len
< SECTION_NAME_MAP_LENGTH
)
4195 if (i
->output_section
!= NULL
4196 && i
->output_section
->owner
== link_info
.output_bfd
)
4197 addr
= i
->output_section
->vma
+ i
->output_offset
;
4205 minfo ("0x%V %W %B\n", addr
, TO_ADDR (size
), i
->owner
);
4207 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4209 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4221 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4224 if (i
->output_section
!= NULL
4225 && i
->output_section
->owner
== link_info
.output_bfd
)
4227 if (link_info
.reduce_memory_overheads
)
4228 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4230 print_all_symbols (i
);
4232 /* Update print_dot, but make sure that we do not move it
4233 backwards - this could happen if we have overlays and a
4234 later overlay is shorter than an earier one. */
4235 if (addr
+ TO_ADDR (size
) > print_dot
)
4236 print_dot
= addr
+ TO_ADDR (size
);
4241 print_fill_statement (lang_fill_statement_type
*fill
)
4245 fputs (" FILL mask 0x", config
.map_file
);
4246 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4247 fprintf (config
.map_file
, "%02x", *p
);
4248 fputs ("\n", config
.map_file
);
4252 print_data_statement (lang_data_statement_type
*data
)
4260 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4263 addr
= data
->output_offset
;
4264 if (data
->output_section
!= NULL
)
4265 addr
+= data
->output_section
->vma
;
4293 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
4295 if (data
->exp
->type
.node_class
!= etree_value
)
4298 exp_print_tree (data
->exp
);
4303 print_dot
= addr
+ TO_ADDR (size
);
4306 /* Print an address statement. These are generated by options like
4310 print_address_statement (lang_address_statement_type
*address
)
4312 minfo (_("Address of section %s set to "), address
->section_name
);
4313 exp_print_tree (address
->address
);
4317 /* Print a reloc statement. */
4320 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4327 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4330 addr
= reloc
->output_offset
;
4331 if (reloc
->output_section
!= NULL
)
4332 addr
+= reloc
->output_section
->vma
;
4334 size
= bfd_get_reloc_size (reloc
->howto
);
4336 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
4338 if (reloc
->name
!= NULL
)
4339 minfo ("%s+", reloc
->name
);
4341 minfo ("%s+", reloc
->section
->name
);
4343 exp_print_tree (reloc
->addend_exp
);
4347 print_dot
= addr
+ TO_ADDR (size
);
4351 print_padding_statement (lang_padding_statement_type
*s
)
4359 len
= sizeof " *fill*" - 1;
4360 while (len
< SECTION_NAME_MAP_LENGTH
)
4366 addr
= s
->output_offset
;
4367 if (s
->output_section
!= NULL
)
4368 addr
+= s
->output_section
->vma
;
4369 minfo ("0x%V %W ", addr
, (bfd_vma
) s
->size
);
4371 if (s
->fill
->size
!= 0)
4375 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4376 fprintf (config
.map_file
, "%02x", *p
);
4381 print_dot
= addr
+ TO_ADDR (s
->size
);
4385 print_wild_statement (lang_wild_statement_type
*w
,
4386 lang_output_section_statement_type
*os
)
4388 struct wildcard_list
*sec
;
4392 if (w
->filenames_sorted
)
4394 if (w
->filename
!= NULL
)
4395 minfo ("%s", w
->filename
);
4398 if (w
->filenames_sorted
)
4402 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4404 if (sec
->spec
.sorted
)
4406 if (sec
->spec
.exclude_name_list
!= NULL
)
4409 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4410 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4411 minfo (" %s", tmp
->name
);
4414 if (sec
->spec
.name
!= NULL
)
4415 minfo ("%s", sec
->spec
.name
);
4418 if (sec
->spec
.sorted
)
4427 print_statement_list (w
->children
.head
, os
);
4430 /* Print a group statement. */
4433 print_group (lang_group_statement_type
*s
,
4434 lang_output_section_statement_type
*os
)
4436 fprintf (config
.map_file
, "START GROUP\n");
4437 print_statement_list (s
->children
.head
, os
);
4438 fprintf (config
.map_file
, "END GROUP\n");
4441 /* Print the list of statements in S.
4442 This can be called for any statement type. */
4445 print_statement_list (lang_statement_union_type
*s
,
4446 lang_output_section_statement_type
*os
)
4450 print_statement (s
, os
);
4455 /* Print the first statement in statement list S.
4456 This can be called for any statement type. */
4459 print_statement (lang_statement_union_type
*s
,
4460 lang_output_section_statement_type
*os
)
4462 switch (s
->header
.type
)
4465 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4468 case lang_constructors_statement_enum
:
4469 if (constructor_list
.head
!= NULL
)
4471 if (constructors_sorted
)
4472 minfo (" SORT (CONSTRUCTORS)\n");
4474 minfo (" CONSTRUCTORS\n");
4475 print_statement_list (constructor_list
.head
, os
);
4478 case lang_wild_statement_enum
:
4479 print_wild_statement (&s
->wild_statement
, os
);
4481 case lang_address_statement_enum
:
4482 print_address_statement (&s
->address_statement
);
4484 case lang_object_symbols_statement_enum
:
4485 minfo (" CREATE_OBJECT_SYMBOLS\n");
4487 case lang_fill_statement_enum
:
4488 print_fill_statement (&s
->fill_statement
);
4490 case lang_data_statement_enum
:
4491 print_data_statement (&s
->data_statement
);
4493 case lang_reloc_statement_enum
:
4494 print_reloc_statement (&s
->reloc_statement
);
4496 case lang_input_section_enum
:
4497 print_input_section (s
->input_section
.section
, FALSE
);
4499 case lang_padding_statement_enum
:
4500 print_padding_statement (&s
->padding_statement
);
4502 case lang_output_section_statement_enum
:
4503 print_output_section_statement (&s
->output_section_statement
);
4505 case lang_assignment_statement_enum
:
4506 print_assignment (&s
->assignment_statement
, os
);
4508 case lang_target_statement_enum
:
4509 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4511 case lang_output_statement_enum
:
4512 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4513 if (output_target
!= NULL
)
4514 minfo (" %s", output_target
);
4517 case lang_input_statement_enum
:
4518 print_input_statement (&s
->input_statement
);
4520 case lang_group_statement_enum
:
4521 print_group (&s
->group_statement
, os
);
4523 case lang_insert_statement_enum
:
4524 minfo ("INSERT %s %s\n",
4525 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4526 s
->insert_statement
.where
);
4532 print_statements (void)
4534 print_statement_list (statement_list
.head
, abs_output_section
);
4537 /* Print the first N statements in statement list S to STDERR.
4538 If N == 0, nothing is printed.
4539 If N < 0, the entire list is printed.
4540 Intended to be called from GDB. */
4543 dprint_statement (lang_statement_union_type
*s
, int n
)
4545 FILE *map_save
= config
.map_file
;
4547 config
.map_file
= stderr
;
4550 print_statement_list (s
, abs_output_section
);
4553 while (s
&& --n
>= 0)
4555 print_statement (s
, abs_output_section
);
4560 config
.map_file
= map_save
;
4564 insert_pad (lang_statement_union_type
**ptr
,
4566 bfd_size_type alignment_needed
,
4567 asection
*output_section
,
4570 static fill_type zero_fill
;
4571 lang_statement_union_type
*pad
= NULL
;
4573 if (ptr
!= &statement_list
.head
)
4574 pad
= ((lang_statement_union_type
*)
4575 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4577 && pad
->header
.type
== lang_padding_statement_enum
4578 && pad
->padding_statement
.output_section
== output_section
)
4580 /* Use the existing pad statement. */
4582 else if ((pad
= *ptr
) != NULL
4583 && pad
->header
.type
== lang_padding_statement_enum
4584 && pad
->padding_statement
.output_section
== output_section
)
4586 /* Use the existing pad statement. */
4590 /* Make a new padding statement, linked into existing chain. */
4591 pad
= (lang_statement_union_type
*)
4592 stat_alloc (sizeof (lang_padding_statement_type
));
4593 pad
->header
.next
= *ptr
;
4595 pad
->header
.type
= lang_padding_statement_enum
;
4596 pad
->padding_statement
.output_section
= output_section
;
4599 pad
->padding_statement
.fill
= fill
;
4601 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4602 pad
->padding_statement
.size
= alignment_needed
;
4603 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
4604 - output_section
->vma
);
4607 /* Work out how much this section will move the dot point. */
4611 (lang_statement_union_type
**this_ptr
,
4612 lang_output_section_statement_type
*output_section_statement
,
4616 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4617 asection
*i
= is
->section
;
4618 asection
*o
= output_section_statement
->bfd_section
;
4620 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4621 i
->output_offset
= i
->vma
- o
->vma
;
4622 else if ((i
->flags
& SEC_EXCLUDE
) != 0)
4623 i
->output_offset
= dot
- o
->vma
;
4626 bfd_size_type alignment_needed
;
4628 /* Align this section first to the input sections requirement,
4629 then to the output section's requirement. If this alignment
4630 is greater than any seen before, then record it too. Perform
4631 the alignment by inserting a magic 'padding' statement. */
4633 if (output_section_statement
->subsection_alignment
!= -1)
4634 i
->alignment_power
= output_section_statement
->subsection_alignment
;
4636 if (o
->alignment_power
< i
->alignment_power
)
4637 o
->alignment_power
= i
->alignment_power
;
4639 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4641 if (alignment_needed
!= 0)
4643 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4644 dot
+= alignment_needed
;
4647 /* 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
);
4659 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4661 const asection
*sec1
= *(const asection
**) arg1
;
4662 const asection
*sec2
= *(const asection
**) arg2
;
4664 if (bfd_section_lma (sec1
->owner
, sec1
)
4665 < bfd_section_lma (sec2
->owner
, sec2
))
4667 else if (bfd_section_lma (sec1
->owner
, sec1
)
4668 > bfd_section_lma (sec2
->owner
, sec2
))
4670 else if (sec1
->id
< sec2
->id
)
4672 else if (sec1
->id
> sec2
->id
)
4678 #define IGNORE_SECTION(s) \
4679 ((s->flags & SEC_ALLOC) == 0 \
4680 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4681 && (s->flags & SEC_LOAD) == 0))
4683 /* Check to see if any allocated sections overlap with other allocated
4684 sections. This can happen if a linker script specifies the output
4685 section addresses of the two sections. Also check whether any memory
4686 region has overflowed. */
4689 lang_check_section_addresses (void)
4692 asection
**sections
, **spp
;
4699 lang_memory_region_type
*m
;
4701 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
4704 amt
= bfd_count_sections (link_info
.output_bfd
) * sizeof (asection
*);
4705 sections
= (asection
**) xmalloc (amt
);
4707 /* Scan all sections in the output list. */
4709 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4711 /* Only consider loadable sections with real contents. */
4712 if (!(s
->flags
& SEC_LOAD
)
4713 || !(s
->flags
& SEC_ALLOC
)
4717 sections
[count
] = s
;
4724 qsort (sections
, (size_t) count
, sizeof (asection
*),
4725 sort_sections_by_lma
);
4730 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4731 for (count
--; count
; count
--)
4733 /* We must check the sections' LMA addresses not their VMA
4734 addresses because overlay sections can have overlapping VMAs
4735 but they must have distinct LMAs. */
4741 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4743 /* Look for an overlap. We have sorted sections by lma, so we
4744 know that s_start >= p_start. Besides the obvious case of
4745 overlap when the current section starts before the previous
4746 one ends, we also must have overlap if the previous section
4747 wraps around the address space. */
4748 if (s_start
<= p_end
4750 einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),
4751 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
4756 /* If any memory region has overflowed, report by how much.
4757 We do not issue this diagnostic for regions that had sections
4758 explicitly placed outside their bounds; os_region_check's
4759 diagnostics are adequate for that case.
4761 FIXME: It is conceivable that m->current - (m->origin + m->length)
4762 might overflow a 32-bit integer. There is, alas, no way to print
4763 a bfd_vma quantity in decimal. */
4764 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
4765 if (m
->had_full_message
)
4766 einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4767 m
->name_list
.name
, (long)(m
->current
- (m
->origin
+ m
->length
)));
4771 /* Make sure the new address is within the region. We explicitly permit the
4772 current address to be at the exact end of the region when the address is
4773 non-zero, in case the region is at the end of addressable memory and the
4774 calculation wraps around. */
4777 os_region_check (lang_output_section_statement_type
*os
,
4778 lang_memory_region_type
*region
,
4782 if ((region
->current
< region
->origin
4783 || (region
->current
- region
->origin
> region
->length
))
4784 && ((region
->current
!= region
->origin
+ region
->length
)
4789 einfo (_("%X%P: address 0x%v of %B section `%s'"
4790 " is not within region `%s'\n"),
4792 os
->bfd_section
->owner
,
4793 os
->bfd_section
->name
,
4794 region
->name_list
.name
);
4796 else if (!region
->had_full_message
)
4798 region
->had_full_message
= TRUE
;
4800 einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4801 os
->bfd_section
->owner
,
4802 os
->bfd_section
->name
,
4803 region
->name_list
.name
);
4808 /* Set the sizes for all the output sections. */
4811 lang_size_sections_1
4812 (lang_statement_union_type
**prev
,
4813 lang_output_section_statement_type
*output_section_statement
,
4817 bfd_boolean check_regions
)
4819 lang_statement_union_type
*s
;
4821 /* Size up the sections from their constituent parts. */
4822 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
4824 switch (s
->header
.type
)
4826 case lang_output_section_statement_enum
:
4828 bfd_vma newdot
, after
, dotdelta
;
4829 lang_output_section_statement_type
*os
;
4830 lang_memory_region_type
*r
;
4831 int section_alignment
= 0;
4833 os
= &s
->output_section_statement
;
4834 if (os
->constraint
== -1)
4837 /* FIXME: We shouldn't need to zero section vmas for ld -r
4838 here, in lang_insert_orphan, or in the default linker scripts.
4839 This is covering for coff backend linker bugs. See PR6945. */
4840 if (os
->addr_tree
== NULL
4841 && link_info
.relocatable
4842 && (bfd_get_flavour (link_info
.output_bfd
)
4843 == bfd_target_coff_flavour
))
4844 os
->addr_tree
= exp_intop (0);
4845 if (os
->addr_tree
!= NULL
)
4847 os
->processed_vma
= FALSE
;
4848 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
4850 if (expld
.result
.valid_p
)
4852 dot
= expld
.result
.value
;
4853 if (expld
.result
.section
!= NULL
)
4854 dot
+= expld
.result
.section
->vma
;
4856 else if (expld
.phase
!= lang_mark_phase_enum
)
4857 einfo (_("%F%S: non constant or forward reference"
4858 " address expression for section %s\n"),
4859 os
->addr_tree
, os
->name
);
4862 if (os
->bfd_section
== NULL
)
4863 /* This section was removed or never actually created. */
4866 /* If this is a COFF shared library section, use the size and
4867 address from the input section. FIXME: This is COFF
4868 specific; it would be cleaner if there were some other way
4869 to do this, but nothing simple comes to mind. */
4870 if (((bfd_get_flavour (link_info
.output_bfd
)
4871 == bfd_target_ecoff_flavour
)
4872 || (bfd_get_flavour (link_info
.output_bfd
)
4873 == bfd_target_coff_flavour
))
4874 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
4878 if (os
->children
.head
== NULL
4879 || os
->children
.head
->header
.next
!= NULL
4880 || (os
->children
.head
->header
.type
4881 != lang_input_section_enum
))
4882 einfo (_("%P%X: Internal error on COFF shared library"
4883 " section %s\n"), os
->name
);
4885 input
= os
->children
.head
->input_section
.section
;
4886 bfd_set_section_vma (os
->bfd_section
->owner
,
4888 bfd_section_vma (input
->owner
, input
));
4889 os
->bfd_section
->size
= input
->size
;
4895 if (bfd_is_abs_section (os
->bfd_section
))
4897 /* No matter what happens, an abs section starts at zero. */
4898 ASSERT (os
->bfd_section
->vma
== 0);
4902 if (os
->addr_tree
== NULL
)
4904 /* No address specified for this section, get one
4905 from the region specification. */
4906 if (os
->region
== NULL
4907 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
4908 && os
->region
->name_list
.name
[0] == '*'
4909 && strcmp (os
->region
->name_list
.name
,
4910 DEFAULT_MEMORY_REGION
) == 0))
4912 os
->region
= lang_memory_default (os
->bfd_section
);
4915 /* If a loadable section is using the default memory
4916 region, and some non default memory regions were
4917 defined, issue an error message. */
4919 && !IGNORE_SECTION (os
->bfd_section
)
4920 && ! link_info
.relocatable
4922 && strcmp (os
->region
->name_list
.name
,
4923 DEFAULT_MEMORY_REGION
) == 0
4924 && lang_memory_region_list
!= NULL
4925 && (strcmp (lang_memory_region_list
->name_list
.name
,
4926 DEFAULT_MEMORY_REGION
) != 0
4927 || lang_memory_region_list
->next
!= NULL
)
4928 && expld
.phase
!= lang_mark_phase_enum
)
4930 /* By default this is an error rather than just a
4931 warning because if we allocate the section to the
4932 default memory region we can end up creating an
4933 excessively large binary, or even seg faulting when
4934 attempting to perform a negative seek. See
4935 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4936 for an example of this. This behaviour can be
4937 overridden by the using the --no-check-sections
4939 if (command_line
.check_section_addresses
)
4940 einfo (_("%P%F: error: no memory region specified"
4941 " for loadable section `%s'\n"),
4942 bfd_get_section_name (link_info
.output_bfd
,
4945 einfo (_("%P: warning: no memory region specified"
4946 " for loadable section `%s'\n"),
4947 bfd_get_section_name (link_info
.output_bfd
,
4951 newdot
= os
->region
->current
;
4952 section_alignment
= os
->bfd_section
->alignment_power
;
4955 section_alignment
= os
->section_alignment
;
4957 /* Align to what the section needs. */
4958 if (section_alignment
> 0)
4960 bfd_vma savedot
= newdot
;
4961 newdot
= align_power (newdot
, section_alignment
);
4963 dotdelta
= newdot
- savedot
;
4965 && (config
.warn_section_align
4966 || os
->addr_tree
!= NULL
)
4967 && expld
.phase
!= lang_mark_phase_enum
)
4968 einfo (_("%P: warning: changing start of section"
4969 " %s by %lu bytes\n"),
4970 os
->name
, (unsigned long) dotdelta
);
4973 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
4975 os
->bfd_section
->output_offset
= 0;
4978 lang_size_sections_1 (&os
->children
.head
, os
,
4979 os
->fill
, newdot
, relax
, check_regions
);
4981 os
->processed_vma
= TRUE
;
4983 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
4984 /* Except for some special linker created sections,
4985 no output section should change from zero size
4986 after strip_excluded_output_sections. A non-zero
4987 size on an ignored section indicates that some
4988 input section was not sized early enough. */
4989 ASSERT (os
->bfd_section
->size
== 0);
4992 dot
= os
->bfd_section
->vma
;
4994 /* Put the section within the requested block size, or
4995 align at the block boundary. */
4997 + TO_ADDR (os
->bfd_section
->size
)
4998 + os
->block_value
- 1)
4999 & - (bfd_vma
) os
->block_value
);
5001 os
->bfd_section
->size
= TO_SIZE (after
- os
->bfd_section
->vma
);
5004 /* Set section lma. */
5007 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5011 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5012 os
->bfd_section
->lma
= lma
;
5014 else if (os
->lma_region
!= NULL
)
5016 bfd_vma lma
= os
->lma_region
->current
;
5018 if (os
->align_lma_with_input
)
5022 /* When LMA_REGION is the same as REGION, align the LMA
5023 as we did for the VMA, possibly including alignment
5024 from the bfd section. If a different region, then
5025 only align according to the value in the output
5027 if (os
->lma_region
!= os
->region
)
5028 section_alignment
= os
->section_alignment
;
5029 if (section_alignment
> 0)
5030 lma
= align_power (lma
, section_alignment
);
5032 os
->bfd_section
->lma
= lma
;
5034 else if (r
->last_os
!= NULL
5035 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5040 last
= r
->last_os
->output_section_statement
.bfd_section
;
5042 /* A backwards move of dot should be accompanied by
5043 an explicit assignment to the section LMA (ie.
5044 os->load_base set) because backwards moves can
5045 create overlapping LMAs. */
5047 && os
->bfd_section
->size
!= 0
5048 && dot
+ os
->bfd_section
->size
<= last
->vma
)
5050 /* If dot moved backwards then leave lma equal to
5051 vma. This is the old default lma, which might
5052 just happen to work when the backwards move is
5053 sufficiently large. Nag if this changes anything,
5054 so people can fix their linker scripts. */
5056 if (last
->vma
!= last
->lma
)
5057 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
5062 /* If this is an overlay, set the current lma to that
5063 at the end of the previous section. */
5064 if (os
->sectype
== overlay_section
)
5065 lma
= last
->lma
+ last
->size
;
5067 /* Otherwise, keep the same lma to vma relationship
5068 as the previous section. */
5070 lma
= dot
+ last
->lma
- last
->vma
;
5072 if (section_alignment
> 0)
5073 lma
= align_power (lma
, section_alignment
);
5074 os
->bfd_section
->lma
= lma
;
5077 os
->processed_lma
= TRUE
;
5079 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5082 /* Keep track of normal sections using the default
5083 lma region. We use this to set the lma for
5084 following sections. Overlays or other linker
5085 script assignment to lma might mean that the
5086 default lma == vma is incorrect.
5087 To avoid warnings about dot moving backwards when using
5088 -Ttext, don't start tracking sections until we find one
5089 of non-zero size or with lma set differently to vma. */
5090 if (((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5091 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0)
5092 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0
5093 && (os
->bfd_section
->size
!= 0
5094 || (r
->last_os
== NULL
5095 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5096 || (r
->last_os
!= NULL
5097 && dot
>= (r
->last_os
->output_section_statement
5098 .bfd_section
->vma
)))
5099 && os
->lma_region
== NULL
5100 && !link_info
.relocatable
)
5103 /* .tbss sections effectively have zero size. */
5104 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5105 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
5106 || link_info
.relocatable
)
5107 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5112 if (os
->update_dot_tree
!= 0)
5113 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5115 /* Update dot in the region ?
5116 We only do this if the section is going to be allocated,
5117 since unallocated sections do not contribute to the region's
5118 overall size in memory. */
5119 if (os
->region
!= NULL
5120 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5122 os
->region
->current
= dot
;
5125 /* Make sure the new address is within the region. */
5126 os_region_check (os
, os
->region
, os
->addr_tree
,
5127 os
->bfd_section
->vma
);
5129 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5130 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5131 || os
->align_lma_with_input
))
5133 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5136 os_region_check (os
, os
->lma_region
, NULL
,
5137 os
->bfd_section
->lma
);
5143 case lang_constructors_statement_enum
:
5144 dot
= lang_size_sections_1 (&constructor_list
.head
,
5145 output_section_statement
,
5146 fill
, dot
, relax
, check_regions
);
5149 case lang_data_statement_enum
:
5151 unsigned int size
= 0;
5153 s
->data_statement
.output_offset
=
5154 dot
- output_section_statement
->bfd_section
->vma
;
5155 s
->data_statement
.output_section
=
5156 output_section_statement
->bfd_section
;
5158 /* We might refer to provided symbols in the expression, and
5159 need to mark them as needed. */
5160 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5162 switch (s
->data_statement
.type
)
5180 if (size
< TO_SIZE ((unsigned) 1))
5181 size
= TO_SIZE ((unsigned) 1);
5182 dot
+= TO_ADDR (size
);
5183 output_section_statement
->bfd_section
->size
5184 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5189 case lang_reloc_statement_enum
:
5193 s
->reloc_statement
.output_offset
=
5194 dot
- output_section_statement
->bfd_section
->vma
;
5195 s
->reloc_statement
.output_section
=
5196 output_section_statement
->bfd_section
;
5197 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5198 dot
+= TO_ADDR (size
);
5199 output_section_statement
->bfd_section
->size
5200 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5204 case lang_wild_statement_enum
:
5205 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5206 output_section_statement
,
5207 fill
, dot
, relax
, check_regions
);
5210 case lang_object_symbols_statement_enum
:
5211 link_info
.create_object_symbols_section
=
5212 output_section_statement
->bfd_section
;
5215 case lang_output_statement_enum
:
5216 case lang_target_statement_enum
:
5219 case lang_input_section_enum
:
5223 i
= s
->input_section
.section
;
5228 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5229 einfo (_("%P%F: can't relax section: %E\n"));
5233 dot
= size_input_section (prev
, output_section_statement
,
5238 case lang_input_statement_enum
:
5241 case lang_fill_statement_enum
:
5242 s
->fill_statement
.output_section
=
5243 output_section_statement
->bfd_section
;
5245 fill
= s
->fill_statement
.fill
;
5248 case lang_assignment_statement_enum
:
5250 bfd_vma newdot
= dot
;
5251 etree_type
*tree
= s
->assignment_statement
.exp
;
5253 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5255 exp_fold_tree (tree
,
5256 output_section_statement
->bfd_section
,
5259 if (expld
.dataseg
.relro
== exp_dataseg_relro_start
)
5261 if (!expld
.dataseg
.relro_start_stat
)
5262 expld
.dataseg
.relro_start_stat
= s
;
5265 ASSERT (expld
.dataseg
.relro_start_stat
== s
);
5268 else if (expld
.dataseg
.relro
== exp_dataseg_relro_end
)
5270 if (!expld
.dataseg
.relro_end_stat
)
5271 expld
.dataseg
.relro_end_stat
= s
;
5274 ASSERT (expld
.dataseg
.relro_end_stat
== s
);
5277 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5279 /* This symbol may be relative to this section. */
5280 if ((tree
->type
.node_class
== etree_provided
5281 || tree
->type
.node_class
== etree_assign
)
5282 && (tree
->assign
.dst
[0] != '.'
5283 || tree
->assign
.dst
[1] != '\0'))
5284 output_section_statement
->update_dot
= 1;
5286 if (!output_section_statement
->ignored
)
5288 if (output_section_statement
== abs_output_section
)
5290 /* If we don't have an output section, then just adjust
5291 the default memory address. */
5292 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5293 FALSE
)->current
= newdot
;
5295 else if (newdot
!= dot
)
5297 /* Insert a pad after this statement. We can't
5298 put the pad before when relaxing, in case the
5299 assignment references dot. */
5300 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5301 output_section_statement
->bfd_section
, dot
);
5303 /* Don't neuter the pad below when relaxing. */
5306 /* If dot is advanced, this implies that the section
5307 should have space allocated to it, unless the
5308 user has explicitly stated that the section
5309 should not be allocated. */
5310 if (output_section_statement
->sectype
!= noalloc_section
5311 && (output_section_statement
->sectype
!= noload_section
5312 || (bfd_get_flavour (link_info
.output_bfd
)
5313 == bfd_target_elf_flavour
)))
5314 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5321 case lang_padding_statement_enum
:
5322 /* If this is the first time lang_size_sections is called,
5323 we won't have any padding statements. If this is the
5324 second or later passes when relaxing, we should allow
5325 padding to shrink. If padding is needed on this pass, it
5326 will be added back in. */
5327 s
->padding_statement
.size
= 0;
5329 /* Make sure output_offset is valid. If relaxation shrinks
5330 the section and this pad isn't needed, it's possible to
5331 have output_offset larger than the final size of the
5332 section. bfd_set_section_contents will complain even for
5333 a pad size of zero. */
5334 s
->padding_statement
.output_offset
5335 = dot
- output_section_statement
->bfd_section
->vma
;
5338 case lang_group_statement_enum
:
5339 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5340 output_section_statement
,
5341 fill
, dot
, relax
, check_regions
);
5344 case lang_insert_statement_enum
:
5347 /* We can only get here when relaxing is turned on. */
5348 case lang_address_statement_enum
:
5355 prev
= &s
->header
.next
;
5360 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5361 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5362 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5363 segments. We are allowed an opportunity to override this decision. */
5366 ldlang_override_segment_assignment (struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
5367 bfd
* abfd ATTRIBUTE_UNUSED
,
5368 asection
* current_section
,
5369 asection
* previous_section
,
5370 bfd_boolean new_segment
)
5372 lang_output_section_statement_type
* cur
;
5373 lang_output_section_statement_type
* prev
;
5375 /* The checks below are only necessary when the BFD library has decided
5376 that the two sections ought to be placed into the same segment. */
5380 /* Paranoia checks. */
5381 if (current_section
== NULL
|| previous_section
== NULL
)
5384 /* If this flag is set, the target never wants code and non-code
5385 sections comingled in the same segment. */
5386 if (config
.separate_code
5387 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
5390 /* Find the memory regions associated with the two sections.
5391 We call lang_output_section_find() here rather than scanning the list
5392 of output sections looking for a matching section pointer because if
5393 we have a large number of sections then a hash lookup is faster. */
5394 cur
= lang_output_section_find (current_section
->name
);
5395 prev
= lang_output_section_find (previous_section
->name
);
5397 /* More paranoia. */
5398 if (cur
== NULL
|| prev
== NULL
)
5401 /* If the regions are different then force the sections to live in
5402 different segments. See the email thread starting at the following
5403 URL for the reasons why this is necessary:
5404 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5405 return cur
->region
!= prev
->region
;
5409 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5411 lang_statement_iteration
++;
5412 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5413 0, 0, relax
, check_regions
);
5417 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5419 expld
.phase
= lang_allocating_phase_enum
;
5420 expld
.dataseg
.phase
= exp_dataseg_none
;
5422 one_lang_size_sections_pass (relax
, check_regions
);
5423 if (expld
.dataseg
.phase
== exp_dataseg_end_seen
5424 && link_info
.relro
&& expld
.dataseg
.relro_end
)
5426 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
5427 to put expld.dataseg.relro_end on a (common) page boundary. */
5428 bfd_vma min_base
, relro_end
, maxpage
;
5430 expld
.dataseg
.phase
= exp_dataseg_relro_adjust
;
5431 maxpage
= expld
.dataseg
.maxpagesize
;
5432 /* MIN_BASE is the absolute minimum address we are allowed to start the
5433 read-write segment (byte before will be mapped read-only). */
5434 min_base
= (expld
.dataseg
.min_base
+ maxpage
- 1) & ~(maxpage
- 1);
5435 expld
.dataseg
.base
+= (-expld
.dataseg
.relro_end
5436 & (expld
.dataseg
.pagesize
- 1));
5437 /* Compute the expected PT_GNU_RELRO segment end. */
5438 relro_end
= ((expld
.dataseg
.relro_end
+ expld
.dataseg
.pagesize
- 1)
5439 & ~(expld
.dataseg
.pagesize
- 1));
5440 if (min_base
+ maxpage
< expld
.dataseg
.base
)
5442 expld
.dataseg
.base
-= maxpage
;
5443 relro_end
-= maxpage
;
5445 lang_reset_memory_regions ();
5446 one_lang_size_sections_pass (relax
, check_regions
);
5447 if (expld
.dataseg
.relro_end
> relro_end
)
5449 /* The alignment of sections between DATA_SEGMENT_ALIGN
5450 and DATA_SEGMENT_RELRO_END can cause excessive padding to
5451 be inserted at DATA_SEGMENT_RELRO_END. Try to start a
5452 bit lower so that the section alignments will fit in. */
5454 unsigned int max_alignment_power
= 0;
5456 /* Find maximum alignment power of sections between
5457 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
5458 for (sec
= link_info
.output_bfd
->sections
; sec
; sec
= sec
->next
)
5459 if (sec
->vma
>= expld
.dataseg
.base
5460 && sec
->vma
< expld
.dataseg
.relro_end
5461 && sec
->alignment_power
> max_alignment_power
)
5462 max_alignment_power
= sec
->alignment_power
;
5464 if (((bfd_vma
) 1 << max_alignment_power
) < expld
.dataseg
.pagesize
)
5466 /* Aligning the adjusted base guarantees the padding
5467 between sections won't change. This is better than
5468 simply subtracting 1 << max_alignment_power which is
5469 what we used to do here. */
5470 expld
.dataseg
.base
&= ~((1 << max_alignment_power
) - 1);
5471 lang_reset_memory_regions ();
5472 one_lang_size_sections_pass (relax
, check_regions
);
5475 link_info
.relro_start
= expld
.dataseg
.base
;
5476 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5478 else if (expld
.dataseg
.phase
== exp_dataseg_end_seen
)
5480 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5481 a page could be saved in the data segment. */
5482 bfd_vma first
, last
;
5484 first
= -expld
.dataseg
.base
& (expld
.dataseg
.pagesize
- 1);
5485 last
= expld
.dataseg
.end
& (expld
.dataseg
.pagesize
- 1);
5487 && ((expld
.dataseg
.base
& ~(expld
.dataseg
.pagesize
- 1))
5488 != (expld
.dataseg
.end
& ~(expld
.dataseg
.pagesize
- 1)))
5489 && first
+ last
<= expld
.dataseg
.pagesize
)
5491 expld
.dataseg
.phase
= exp_dataseg_adjust
;
5492 lang_reset_memory_regions ();
5493 one_lang_size_sections_pass (relax
, check_regions
);
5496 expld
.dataseg
.phase
= exp_dataseg_done
;
5499 expld
.dataseg
.phase
= exp_dataseg_done
;
5502 static lang_output_section_statement_type
*current_section
;
5503 static lang_assignment_statement_type
*current_assign
;
5504 static bfd_boolean prefer_next_section
;
5506 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5509 lang_do_assignments_1 (lang_statement_union_type
*s
,
5510 lang_output_section_statement_type
*current_os
,
5513 bfd_boolean
*found_end
)
5515 for (; s
!= NULL
; s
= s
->header
.next
)
5517 switch (s
->header
.type
)
5519 case lang_constructors_statement_enum
:
5520 dot
= lang_do_assignments_1 (constructor_list
.head
,
5521 current_os
, fill
, dot
, found_end
);
5524 case lang_output_section_statement_enum
:
5526 lang_output_section_statement_type
*os
;
5528 os
= &(s
->output_section_statement
);
5529 os
->after_end
= *found_end
;
5530 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
5532 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5534 current_section
= os
;
5535 prefer_next_section
= FALSE
;
5537 dot
= os
->bfd_section
->vma
;
5539 lang_do_assignments_1 (os
->children
.head
,
5540 os
, os
->fill
, dot
, found_end
);
5542 /* .tbss sections effectively have zero size. */
5543 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5544 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
5545 || link_info
.relocatable
)
5546 dot
+= TO_ADDR (os
->bfd_section
->size
);
5548 if (os
->update_dot_tree
!= NULL
)
5549 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5554 case lang_wild_statement_enum
:
5556 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
5557 current_os
, fill
, dot
, found_end
);
5560 case lang_object_symbols_statement_enum
:
5561 case lang_output_statement_enum
:
5562 case lang_target_statement_enum
:
5565 case lang_data_statement_enum
:
5566 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5567 if (expld
.result
.valid_p
)
5569 s
->data_statement
.value
= expld
.result
.value
;
5570 if (expld
.result
.section
!= NULL
)
5571 s
->data_statement
.value
+= expld
.result
.section
->vma
;
5574 einfo (_("%F%P: invalid data statement\n"));
5577 switch (s
->data_statement
.type
)
5595 if (size
< TO_SIZE ((unsigned) 1))
5596 size
= TO_SIZE ((unsigned) 1);
5597 dot
+= TO_ADDR (size
);
5601 case lang_reloc_statement_enum
:
5602 exp_fold_tree (s
->reloc_statement
.addend_exp
,
5603 bfd_abs_section_ptr
, &dot
);
5604 if (expld
.result
.valid_p
)
5605 s
->reloc_statement
.addend_value
= expld
.result
.value
;
5607 einfo (_("%F%P: invalid reloc statement\n"));
5608 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
5611 case lang_input_section_enum
:
5613 asection
*in
= s
->input_section
.section
;
5615 if ((in
->flags
& SEC_EXCLUDE
) == 0)
5616 dot
+= TO_ADDR (in
->size
);
5620 case lang_input_statement_enum
:
5623 case lang_fill_statement_enum
:
5624 fill
= s
->fill_statement
.fill
;
5627 case lang_assignment_statement_enum
:
5628 current_assign
= &s
->assignment_statement
;
5629 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
5631 const char *p
= current_assign
->exp
->assign
.dst
;
5633 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
5634 prefer_next_section
= TRUE
;
5638 if (strcmp (p
, "end") == 0)
5641 exp_fold_tree (s
->assignment_statement
.exp
,
5642 current_os
->bfd_section
,
5646 case lang_padding_statement_enum
:
5647 dot
+= TO_ADDR (s
->padding_statement
.size
);
5650 case lang_group_statement_enum
:
5651 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
5652 current_os
, fill
, dot
, found_end
);
5655 case lang_insert_statement_enum
:
5658 case lang_address_statement_enum
:
5670 lang_do_assignments (lang_phase_type phase
)
5672 bfd_boolean found_end
= FALSE
;
5674 current_section
= NULL
;
5675 prefer_next_section
= FALSE
;
5676 expld
.phase
= phase
;
5677 lang_statement_iteration
++;
5678 lang_do_assignments_1 (statement_list
.head
,
5679 abs_output_section
, NULL
, 0, &found_end
);
5682 /* For an assignment statement outside of an output section statement,
5683 choose the best of neighbouring output sections to use for values
5687 section_for_dot (void)
5691 /* Assignments belong to the previous output section, unless there
5692 has been an assignment to "dot", in which case following
5693 assignments belong to the next output section. (The assumption
5694 is that an assignment to "dot" is setting up the address for the
5695 next output section.) Except that past the assignment to "_end"
5696 we always associate with the previous section. This exception is
5697 for targets like SH that define an alloc .stack or other
5698 weirdness after non-alloc sections. */
5699 if (current_section
== NULL
|| prefer_next_section
)
5701 lang_statement_union_type
*stmt
;
5702 lang_output_section_statement_type
*os
;
5704 for (stmt
= (lang_statement_union_type
*) current_assign
;
5706 stmt
= stmt
->header
.next
)
5707 if (stmt
->header
.type
== lang_output_section_statement_enum
)
5710 os
= &stmt
->output_section_statement
;
5713 && (os
->bfd_section
== NULL
5714 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
5715 || bfd_section_removed_from_list (link_info
.output_bfd
,
5719 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
5722 s
= os
->bfd_section
;
5724 s
= link_info
.output_bfd
->section_last
;
5726 && ((s
->flags
& SEC_ALLOC
) == 0
5727 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
5732 return bfd_abs_section_ptr
;
5736 s
= current_section
->bfd_section
;
5738 /* The section may have been stripped. */
5740 && ((s
->flags
& SEC_EXCLUDE
) != 0
5741 || (s
->flags
& SEC_ALLOC
) == 0
5742 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
5743 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
5746 s
= link_info
.output_bfd
->sections
;
5748 && ((s
->flags
& SEC_ALLOC
) == 0
5749 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
5754 return bfd_abs_section_ptr
;
5757 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5758 operator .startof. (section_name), it produces an undefined symbol
5759 .startof.section_name. Similarly, when it sees
5760 .sizeof. (section_name), it produces an undefined symbol
5761 .sizeof.section_name. For all the output sections, we look for
5762 such symbols, and set them to the correct value. */
5765 lang_set_startof (void)
5769 if (link_info
.relocatable
)
5772 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5774 const char *secname
;
5776 struct bfd_link_hash_entry
*h
;
5778 secname
= bfd_get_section_name (link_info
.output_bfd
, s
);
5779 buf
= (char *) xmalloc (10 + strlen (secname
));
5781 sprintf (buf
, ".startof.%s", secname
);
5782 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5783 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5785 h
->type
= bfd_link_hash_defined
;
5787 h
->u
.def
.section
= s
;
5790 sprintf (buf
, ".sizeof.%s", secname
);
5791 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5792 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5794 h
->type
= bfd_link_hash_defined
;
5795 h
->u
.def
.value
= TO_ADDR (s
->size
);
5796 h
->u
.def
.section
= bfd_abs_section_ptr
;
5806 struct bfd_link_hash_entry
*h
;
5809 if ((link_info
.relocatable
&& !link_info
.gc_sections
)
5810 || (link_info
.shared
&& !link_info
.executable
))
5811 warn
= entry_from_cmdline
;
5815 /* Force the user to specify a root when generating a relocatable with
5817 if (link_info
.gc_sections
&& link_info
.relocatable
5818 && !(entry_from_cmdline
|| undef_from_cmdline
))
5819 einfo (_("%P%F: gc-sections requires either an entry or "
5820 "an undefined symbol\n"));
5822 if (entry_symbol
.name
== NULL
)
5824 /* No entry has been specified. Look for the default entry, but
5825 don't warn if we don't find it. */
5826 entry_symbol
.name
= entry_symbol_default
;
5830 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
5831 FALSE
, FALSE
, TRUE
);
5833 && (h
->type
== bfd_link_hash_defined
5834 || h
->type
== bfd_link_hash_defweak
)
5835 && h
->u
.def
.section
->output_section
!= NULL
)
5839 val
= (h
->u
.def
.value
5840 + bfd_get_section_vma (link_info
.output_bfd
,
5841 h
->u
.def
.section
->output_section
)
5842 + h
->u
.def
.section
->output_offset
);
5843 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5844 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
5851 /* We couldn't find the entry symbol. Try parsing it as a
5853 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
5856 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5857 einfo (_("%P%F: can't set start address\n"));
5863 /* Can't find the entry symbol, and it's not a number. Use
5864 the first address in the text section. */
5865 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
5869 einfo (_("%P: warning: cannot find entry symbol %s;"
5870 " defaulting to %V\n"),
5872 bfd_get_section_vma (link_info
.output_bfd
, ts
));
5873 if (!(bfd_set_start_address
5874 (link_info
.output_bfd
,
5875 bfd_get_section_vma (link_info
.output_bfd
, ts
))))
5876 einfo (_("%P%F: can't set start address\n"));
5881 einfo (_("%P: warning: cannot find entry symbol %s;"
5882 " not setting start address\n"),
5889 /* This is a small function used when we want to ignore errors from
5893 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
5895 /* Don't do anything. */
5898 /* Check that the architecture of all the input files is compatible
5899 with the output file. Also call the backend to let it do any
5900 other checking that is needed. */
5905 lang_statement_union_type
*file
;
5907 const bfd_arch_info_type
*compatible
;
5909 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
5911 #ifdef ENABLE_PLUGINS
5912 /* Don't check format of files claimed by plugin. */
5913 if (file
->input_statement
.flags
.claimed
)
5915 #endif /* ENABLE_PLUGINS */
5916 input_bfd
= file
->input_statement
.the_bfd
;
5918 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
5919 command_line
.accept_unknown_input_arch
);
5921 /* In general it is not possible to perform a relocatable
5922 link between differing object formats when the input
5923 file has relocations, because the relocations in the
5924 input format may not have equivalent representations in
5925 the output format (and besides BFD does not translate
5926 relocs for other link purposes than a final link). */
5927 if ((link_info
.relocatable
|| link_info
.emitrelocations
)
5928 && (compatible
== NULL
5929 || (bfd_get_flavour (input_bfd
)
5930 != bfd_get_flavour (link_info
.output_bfd
)))
5931 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
5933 einfo (_("%P%F: Relocatable linking with relocations from"
5934 " format %s (%B) to format %s (%B) is not supported\n"),
5935 bfd_get_target (input_bfd
), input_bfd
,
5936 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
5937 /* einfo with %F exits. */
5940 if (compatible
== NULL
)
5942 if (command_line
.warn_mismatch
)
5943 einfo (_("%P%X: %s architecture of input file `%B'"
5944 " is incompatible with %s output\n"),
5945 bfd_printable_name (input_bfd
), input_bfd
,
5946 bfd_printable_name (link_info
.output_bfd
));
5948 else if (bfd_count_sections (input_bfd
))
5950 /* If the input bfd has no contents, it shouldn't set the
5951 private data of the output bfd. */
5953 bfd_error_handler_type pfn
= NULL
;
5955 /* If we aren't supposed to warn about mismatched input
5956 files, temporarily set the BFD error handler to a
5957 function which will do nothing. We still want to call
5958 bfd_merge_private_bfd_data, since it may set up
5959 information which is needed in the output file. */
5960 if (! command_line
.warn_mismatch
)
5961 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
5962 if (! bfd_merge_private_bfd_data (input_bfd
, link_info
.output_bfd
))
5964 if (command_line
.warn_mismatch
)
5965 einfo (_("%P%X: failed to merge target specific data"
5966 " of file %B\n"), input_bfd
);
5968 if (! command_line
.warn_mismatch
)
5969 bfd_set_error_handler (pfn
);
5974 /* Look through all the global common symbols and attach them to the
5975 correct section. The -sort-common command line switch may be used
5976 to roughly sort the entries by alignment. */
5981 if (command_line
.inhibit_common_definition
)
5983 if (link_info
.relocatable
5984 && ! command_line
.force_common_definition
)
5987 if (! config
.sort_common
)
5988 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
5993 if (config
.sort_common
== sort_descending
)
5995 for (power
= 4; power
> 0; power
--)
5996 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5999 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6003 for (power
= 0; power
<= 4; power
++)
6004 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6006 power
= (unsigned int) -1;
6007 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6012 /* Place one common symbol in the correct section. */
6015 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6017 unsigned int power_of_two
;
6021 if (h
->type
!= bfd_link_hash_common
)
6025 power_of_two
= h
->u
.c
.p
->alignment_power
;
6027 if (config
.sort_common
== sort_descending
6028 && power_of_two
< *(unsigned int *) info
)
6030 else if (config
.sort_common
== sort_ascending
6031 && power_of_two
> *(unsigned int *) info
)
6034 section
= h
->u
.c
.p
->section
;
6035 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6036 einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
6039 if (config
.map_file
!= NULL
)
6041 static bfd_boolean header_printed
;
6046 if (! header_printed
)
6048 minfo (_("\nAllocating common symbols\n"));
6049 minfo (_("Common symbol size file\n\n"));
6050 header_printed
= TRUE
;
6053 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6054 DMGL_ANSI
| DMGL_PARAMS
);
6057 minfo ("%s", h
->root
.string
);
6058 len
= strlen (h
->root
.string
);
6063 len
= strlen (name
);
6079 if (size
<= 0xffffffff)
6080 sprintf (buf
, "%lx", (unsigned long) size
);
6082 sprintf_vma (buf
, size
);
6092 minfo ("%B\n", section
->owner
);
6098 /* Run through the input files and ensure that every input section has
6099 somewhere to go. If one is found without a destination then create
6100 an input request and place it into the statement tree. */
6103 lang_place_orphans (void)
6105 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6109 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6111 if (s
->output_section
== NULL
)
6113 /* This section of the file is not attached, root
6114 around for a sensible place for it to go. */
6116 if (file
->flags
.just_syms
)
6117 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
6118 else if ((s
->flags
& SEC_EXCLUDE
) != 0)
6119 s
->output_section
= bfd_abs_section_ptr
;
6120 else if (strcmp (s
->name
, "COMMON") == 0)
6122 /* This is a lonely common section which must have
6123 come from an archive. We attach to the section
6124 with the wildcard. */
6125 if (! link_info
.relocatable
6126 || command_line
.force_common_definition
)
6128 if (default_common_section
== NULL
)
6129 default_common_section
6130 = lang_output_section_statement_lookup (".bss", 0,
6132 lang_add_section (&default_common_section
->children
, s
,
6133 NULL
, default_common_section
);
6138 const char *name
= s
->name
;
6141 if (config
.unique_orphan_sections
6142 || unique_section_p (s
, NULL
))
6143 constraint
= SPECIAL
;
6145 if (!ldemul_place_orphan (s
, name
, constraint
))
6147 lang_output_section_statement_type
*os
;
6148 os
= lang_output_section_statement_lookup (name
,
6151 if (os
->addr_tree
== NULL
6152 && (link_info
.relocatable
6153 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6154 os
->addr_tree
= exp_intop (0);
6155 lang_add_section (&os
->children
, s
, NULL
, os
);
6164 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6166 flagword
*ptr_flags
;
6168 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6174 *ptr_flags
|= SEC_ALLOC
;
6178 *ptr_flags
|= SEC_READONLY
;
6182 *ptr_flags
|= SEC_DATA
;
6186 *ptr_flags
|= SEC_CODE
;
6191 *ptr_flags
|= SEC_LOAD
;
6195 einfo (_("%P%F: invalid syntax in flags\n"));
6202 /* Call a function on each input file. This function will be called
6203 on an archive, but not on the elements. */
6206 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6208 lang_input_statement_type
*f
;
6210 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
6212 f
= (lang_input_statement_type
*) f
->next_real_file
)
6216 /* Call a function on each file. The function will be called on all
6217 the elements of an archive which are included in the link, but will
6218 not be called on the archive file itself. */
6221 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6223 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6230 ldlang_add_file (lang_input_statement_type
*entry
)
6232 lang_statement_append (&file_chain
,
6233 (lang_statement_union_type
*) entry
,
6236 /* The BFD linker needs to have a list of all input BFDs involved in
6238 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
6239 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6241 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6242 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
6243 entry
->the_bfd
->usrdata
= entry
;
6244 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6246 /* Look through the sections and check for any which should not be
6247 included in the link. We need to do this now, so that we can
6248 notice when the backend linker tries to report multiple
6249 definition errors for symbols which are in sections we aren't
6250 going to link. FIXME: It might be better to entirely ignore
6251 symbols which are defined in sections which are going to be
6252 discarded. This would require modifying the backend linker for
6253 each backend which might set the SEC_LINK_ONCE flag. If we do
6254 this, we should probably handle SEC_EXCLUDE in the same way. */
6256 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6260 lang_add_output (const char *name
, int from_script
)
6262 /* Make -o on command line override OUTPUT in script. */
6263 if (!had_output_filename
|| !from_script
)
6265 output_filename
= name
;
6266 had_output_filename
= TRUE
;
6279 for (l
= 0; l
< 32; l
++)
6281 if (i
>= (unsigned int) x
)
6289 lang_output_section_statement_type
*
6290 lang_enter_output_section_statement (const char *output_section_statement_name
,
6291 etree_type
*address_exp
,
6292 enum section_type sectype
,
6294 etree_type
*subalign
,
6297 int align_with_input
)
6299 lang_output_section_statement_type
*os
;
6301 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6303 current_section
= os
;
6305 if (os
->addr_tree
== NULL
)
6307 os
->addr_tree
= address_exp
;
6309 os
->sectype
= sectype
;
6310 if (sectype
!= noload_section
)
6311 os
->flags
= SEC_NO_FLAGS
;
6313 os
->flags
= SEC_NEVER_LOAD
;
6314 os
->block_value
= 1;
6316 /* Make next things chain into subchain of this. */
6317 push_stat_ptr (&os
->children
);
6319 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
6320 if (os
->align_lma_with_input
&& align
!= NULL
)
6321 einfo (_("%F%P:%S: error: align with input and explicit align specified\n"), NULL
);
6323 os
->subsection_alignment
=
6324 topower (exp_get_value_int (subalign
, -1, "subsection alignment"));
6325 os
->section_alignment
=
6326 topower (exp_get_value_int (align
, -1, "section alignment"));
6328 os
->load_base
= ebase
;
6335 lang_output_statement_type
*new_stmt
;
6337 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6338 new_stmt
->name
= output_filename
;
6342 /* Reset the current counters in the regions. */
6345 lang_reset_memory_regions (void)
6347 lang_memory_region_type
*p
= lang_memory_region_list
;
6349 lang_output_section_statement_type
*os
;
6351 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
6353 p
->current
= p
->origin
;
6357 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6361 os
->processed_vma
= FALSE
;
6362 os
->processed_lma
= FALSE
;
6365 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6367 /* Save the last size for possible use by bfd_relax_section. */
6368 o
->rawsize
= o
->size
;
6373 /* Worker for lang_gc_sections_1. */
6376 gc_section_callback (lang_wild_statement_type
*ptr
,
6377 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6379 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
6380 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6381 void *data ATTRIBUTE_UNUSED
)
6383 /* If the wild pattern was marked KEEP, the member sections
6384 should be as well. */
6385 if (ptr
->keep_sections
)
6386 section
->flags
|= SEC_KEEP
;
6389 /* Iterate over sections marking them against GC. */
6392 lang_gc_sections_1 (lang_statement_union_type
*s
)
6394 for (; s
!= NULL
; s
= s
->header
.next
)
6396 switch (s
->header
.type
)
6398 case lang_wild_statement_enum
:
6399 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
6401 case lang_constructors_statement_enum
:
6402 lang_gc_sections_1 (constructor_list
.head
);
6404 case lang_output_section_statement_enum
:
6405 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
6407 case lang_group_statement_enum
:
6408 lang_gc_sections_1 (s
->group_statement
.children
.head
);
6417 lang_gc_sections (void)
6419 /* Keep all sections so marked in the link script. */
6421 lang_gc_sections_1 (statement_list
.head
);
6423 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6424 the special case of debug info. (See bfd/stabs.c)
6425 Twiddle the flag here, to simplify later linker code. */
6426 if (link_info
.relocatable
)
6428 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6431 #ifdef ENABLE_PLUGINS
6432 if (f
->flags
.claimed
)
6435 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6436 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
6437 sec
->flags
&= ~SEC_EXCLUDE
;
6441 if (link_info
.gc_sections
)
6442 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
6445 /* Worker for lang_find_relro_sections_1. */
6448 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
6449 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6451 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
6452 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6455 /* Discarded, excluded and ignored sections effectively have zero
6457 if (section
->output_section
!= NULL
6458 && section
->output_section
->owner
== link_info
.output_bfd
6459 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
6460 && !IGNORE_SECTION (section
)
6461 && section
->size
!= 0)
6463 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
6464 *has_relro_section
= TRUE
;
6468 /* Iterate over sections for relro sections. */
6471 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
6472 bfd_boolean
*has_relro_section
)
6474 if (*has_relro_section
)
6477 for (; s
!= NULL
; s
= s
->header
.next
)
6479 if (s
== expld
.dataseg
.relro_end_stat
)
6482 switch (s
->header
.type
)
6484 case lang_wild_statement_enum
:
6485 walk_wild (&s
->wild_statement
,
6486 find_relro_section_callback
,
6489 case lang_constructors_statement_enum
:
6490 lang_find_relro_sections_1 (constructor_list
.head
,
6493 case lang_output_section_statement_enum
:
6494 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
6497 case lang_group_statement_enum
:
6498 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
6508 lang_find_relro_sections (void)
6510 bfd_boolean has_relro_section
= FALSE
;
6512 /* Check all sections in the link script. */
6514 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
6515 &has_relro_section
);
6517 if (!has_relro_section
)
6518 link_info
.relro
= FALSE
;
6521 /* Relax all sections until bfd_relax_section gives up. */
6524 lang_relax_sections (bfd_boolean need_layout
)
6526 if (RELAXATION_ENABLED
)
6528 /* We may need more than one relaxation pass. */
6529 int i
= link_info
.relax_pass
;
6531 /* The backend can use it to determine the current pass. */
6532 link_info
.relax_pass
= 0;
6536 /* Keep relaxing until bfd_relax_section gives up. */
6537 bfd_boolean relax_again
;
6539 link_info
.relax_trip
= -1;
6542 link_info
.relax_trip
++;
6544 /* Note: pe-dll.c does something like this also. If you find
6545 you need to change this code, you probably need to change
6546 pe-dll.c also. DJ */
6548 /* Do all the assignments with our current guesses as to
6550 lang_do_assignments (lang_assigning_phase_enum
);
6552 /* We must do this after lang_do_assignments, because it uses
6554 lang_reset_memory_regions ();
6556 /* Perform another relax pass - this time we know where the
6557 globals are, so can make a better guess. */
6558 relax_again
= FALSE
;
6559 lang_size_sections (&relax_again
, FALSE
);
6561 while (relax_again
);
6563 link_info
.relax_pass
++;
6570 /* Final extra sizing to report errors. */
6571 lang_do_assignments (lang_assigning_phase_enum
);
6572 lang_reset_memory_regions ();
6573 lang_size_sections (NULL
, TRUE
);
6577 #ifdef ENABLE_PLUGINS
6578 /* Find the insert point for the plugin's replacement files. We
6579 place them after the first claimed real object file, or if the
6580 first claimed object is an archive member, after the last real
6581 object file immediately preceding the archive. In the event
6582 no objects have been claimed at all, we return the first dummy
6583 object file on the list as the insert point; that works, but
6584 the callee must be careful when relinking the file_chain as it
6585 is not actually on that chain, only the statement_list and the
6586 input_file list; in that case, the replacement files must be
6587 inserted at the head of the file_chain. */
6589 static lang_input_statement_type
*
6590 find_replacements_insert_point (void)
6592 lang_input_statement_type
*claim1
, *lastobject
;
6593 lastobject
= &input_file_chain
.head
->input_statement
;
6594 for (claim1
= &file_chain
.head
->input_statement
;
6596 claim1
= &claim1
->next
->input_statement
)
6598 if (claim1
->flags
.claimed
)
6599 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
6600 /* Update lastobject if this is a real object file. */
6601 if (claim1
->the_bfd
&& (claim1
->the_bfd
->my_archive
== NULL
))
6602 lastobject
= claim1
;
6604 /* No files were claimed by the plugin. Choose the last object
6605 file found on the list (maybe the first, dummy entry) as the
6610 /* Insert SRCLIST into DESTLIST after given element by chaining
6611 on FIELD as the next-pointer. (Counterintuitively does not need
6612 a pointer to the actual after-node itself, just its chain field.) */
6615 lang_list_insert_after (lang_statement_list_type
*destlist
,
6616 lang_statement_list_type
*srclist
,
6617 lang_statement_union_type
**field
)
6619 *(srclist
->tail
) = *field
;
6620 *field
= srclist
->head
;
6621 if (destlist
->tail
== field
)
6622 destlist
->tail
= srclist
->tail
;
6625 /* Detach new nodes added to DESTLIST since the time ORIGLIST
6626 was taken as a copy of it and leave them in ORIGLIST. */
6629 lang_list_remove_tail (lang_statement_list_type
*destlist
,
6630 lang_statement_list_type
*origlist
)
6632 union lang_statement_union
**savetail
;
6633 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
6634 ASSERT (origlist
->head
== destlist
->head
);
6635 savetail
= origlist
->tail
;
6636 origlist
->head
= *(savetail
);
6637 origlist
->tail
= destlist
->tail
;
6638 destlist
->tail
= savetail
;
6641 #endif /* ENABLE_PLUGINS */
6646 /* Finalize dynamic list. */
6647 if (link_info
.dynamic_list
)
6648 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
6650 current_target
= default_target
;
6652 /* Open the output file. */
6653 lang_for_each_statement (ldlang_open_output
);
6656 ldemul_create_output_section_statements ();
6658 /* Add to the hash table all undefineds on the command line. */
6659 lang_place_undefineds ();
6661 if (!bfd_section_already_linked_table_init ())
6662 einfo (_("%P%F: Failed to create hash table\n"));
6664 /* Create a bfd for each input file. */
6665 current_target
= default_target
;
6666 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
6668 #ifdef ENABLE_PLUGINS
6669 if (plugin_active_plugins_p ())
6671 lang_statement_list_type added
;
6672 lang_statement_list_type files
, inputfiles
;
6674 /* Now all files are read, let the plugin(s) decide if there
6675 are any more to be added to the link before we call the
6676 emulation's after_open hook. We create a private list of
6677 input statements for this purpose, which we will eventually
6678 insert into the global statment list after the first claimed
6681 /* We need to manipulate all three chains in synchrony. */
6683 inputfiles
= input_file_chain
;
6684 if (plugin_call_all_symbols_read ())
6685 einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
6686 plugin_error_plugin ());
6687 /* Open any newly added files, updating the file chains. */
6688 link_info
.loading_lto_outputs
= TRUE
;
6689 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
6690 /* Restore the global list pointer now they have all been added. */
6691 lang_list_remove_tail (stat_ptr
, &added
);
6692 /* And detach the fresh ends of the file lists. */
6693 lang_list_remove_tail (&file_chain
, &files
);
6694 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
6695 /* Were any new files added? */
6696 if (added
.head
!= NULL
)
6698 /* If so, we will insert them into the statement list immediately
6699 after the first input file that was claimed by the plugin. */
6700 plugin_insert
= find_replacements_insert_point ();
6701 /* If a plugin adds input files without having claimed any, we
6702 don't really have a good idea where to place them. Just putting
6703 them at the start or end of the list is liable to leave them
6704 outside the crtbegin...crtend range. */
6705 ASSERT (plugin_insert
!= NULL
);
6706 /* Splice the new statement list into the old one. */
6707 lang_list_insert_after (stat_ptr
, &added
,
6708 &plugin_insert
->header
.next
);
6709 /* Likewise for the file chains. */
6710 lang_list_insert_after (&input_file_chain
, &inputfiles
,
6711 &plugin_insert
->next_real_file
);
6712 /* We must be careful when relinking file_chain; we may need to
6713 insert the new files at the head of the list if the insert
6714 point chosen is the dummy first input file. */
6715 if (plugin_insert
->filename
)
6716 lang_list_insert_after (&file_chain
, &files
, &plugin_insert
->next
);
6718 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
6720 /* Rescan archives in case new undefined symbols have appeared. */
6721 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
6724 #endif /* ENABLE_PLUGINS */
6726 link_info
.gc_sym_list
= &entry_symbol
;
6727 if (entry_symbol
.name
== NULL
)
6728 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
6730 ldemul_after_open ();
6731 if (config
.map_file
!= NULL
)
6732 lang_print_asneeded ();
6734 bfd_section_already_linked_table_free ();
6736 /* Make sure that we're not mixing architectures. We call this
6737 after all the input files have been opened, but before we do any
6738 other processing, so that any operations merge_private_bfd_data
6739 does on the output file will be known during the rest of the
6743 /* Handle .exports instead of a version script if we're told to do so. */
6744 if (command_line
.version_exports_section
)
6745 lang_do_version_exports_section ();
6747 /* Build all sets based on the information gathered from the input
6749 ldctor_build_sets ();
6751 /* PR 13683: We must rerun the assignments prior to running garbage
6752 collection in order to make sure that all symbol aliases are resolved. */
6753 lang_do_assignments (lang_mark_phase_enum
);
6754 expld
.phase
= lang_first_phase_enum
;
6756 /* Remove unreferenced sections if asked to. */
6757 lang_gc_sections ();
6759 /* Size up the common data. */
6762 /* Update wild statements. */
6763 update_wild_statements (statement_list
.head
);
6765 /* Run through the contours of the script and attach input sections
6766 to the correct output sections. */
6767 lang_statement_iteration
++;
6768 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
6770 process_insert_statements ();
6772 /* Find any sections not attached explicitly and handle them. */
6773 lang_place_orphans ();
6775 if (! link_info
.relocatable
)
6779 /* Merge SEC_MERGE sections. This has to be done after GC of
6780 sections, so that GCed sections are not merged, but before
6781 assigning dynamic symbols, since removing whole input sections
6783 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
6785 /* Look for a text section and set the readonly attribute in it. */
6786 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
6790 if (config
.text_read_only
)
6791 found
->flags
|= SEC_READONLY
;
6793 found
->flags
&= ~SEC_READONLY
;
6797 /* Do anything special before sizing sections. This is where ELF
6798 and other back-ends size dynamic sections. */
6799 ldemul_before_allocation ();
6801 /* We must record the program headers before we try to fix the
6802 section positions, since they will affect SIZEOF_HEADERS. */
6803 lang_record_phdrs ();
6805 /* Check relro sections. */
6806 if (link_info
.relro
&& ! link_info
.relocatable
)
6807 lang_find_relro_sections ();
6809 /* Size up the sections. */
6810 lang_size_sections (NULL
, ! RELAXATION_ENABLED
);
6812 /* See if anything special should be done now we know how big
6813 everything is. This is where relaxation is done. */
6814 ldemul_after_allocation ();
6816 /* Fix any .startof. or .sizeof. symbols. */
6817 lang_set_startof ();
6819 /* Do all the assignments, now that we know the final resting places
6820 of all the symbols. */
6821 lang_do_assignments (lang_final_phase_enum
);
6825 /* Make sure that the section addresses make sense. */
6826 if (command_line
.check_section_addresses
)
6827 lang_check_section_addresses ();
6832 /* EXPORTED TO YACC */
6835 lang_add_wild (struct wildcard_spec
*filespec
,
6836 struct wildcard_list
*section_list
,
6837 bfd_boolean keep_sections
)
6839 struct wildcard_list
*curr
, *next
;
6840 lang_wild_statement_type
*new_stmt
;
6842 /* Reverse the list as the parser puts it back to front. */
6843 for (curr
= section_list
, section_list
= NULL
;
6845 section_list
= curr
, curr
= next
)
6847 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
6848 placed_commons
= TRUE
;
6851 curr
->next
= section_list
;
6854 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
6856 if (strcmp (filespec
->name
, "*") == 0)
6857 filespec
->name
= NULL
;
6858 else if (! wildcardp (filespec
->name
))
6859 lang_has_input_file
= TRUE
;
6862 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
6863 new_stmt
->filename
= NULL
;
6864 new_stmt
->filenames_sorted
= FALSE
;
6865 new_stmt
->section_flag_list
= NULL
;
6866 if (filespec
!= NULL
)
6868 new_stmt
->filename
= filespec
->name
;
6869 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
6870 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
6872 new_stmt
->section_list
= section_list
;
6873 new_stmt
->keep_sections
= keep_sections
;
6874 lang_list_init (&new_stmt
->children
);
6875 analyze_walk_wild_section_handler (new_stmt
);
6879 lang_section_start (const char *name
, etree_type
*address
,
6880 const segment_type
*segment
)
6882 lang_address_statement_type
*ad
;
6884 ad
= new_stat (lang_address_statement
, stat_ptr
);
6885 ad
->section_name
= name
;
6886 ad
->address
= address
;
6887 ad
->segment
= segment
;
6890 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
6891 because of a -e argument on the command line, or zero if this is
6892 called by ENTRY in a linker script. Command line arguments take
6896 lang_add_entry (const char *name
, bfd_boolean cmdline
)
6898 if (entry_symbol
.name
== NULL
6900 || ! entry_from_cmdline
)
6902 entry_symbol
.name
= name
;
6903 entry_from_cmdline
= cmdline
;
6907 /* Set the default start symbol to NAME. .em files should use this,
6908 not lang_add_entry, to override the use of "start" if neither the
6909 linker script nor the command line specifies an entry point. NAME
6910 must be permanently allocated. */
6912 lang_default_entry (const char *name
)
6914 entry_symbol_default
= name
;
6918 lang_add_target (const char *name
)
6920 lang_target_statement_type
*new_stmt
;
6922 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
6923 new_stmt
->target
= name
;
6927 lang_add_map (const char *name
)
6934 map_option_f
= TRUE
;
6942 lang_add_fill (fill_type
*fill
)
6944 lang_fill_statement_type
*new_stmt
;
6946 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
6947 new_stmt
->fill
= fill
;
6951 lang_add_data (int type
, union etree_union
*exp
)
6953 lang_data_statement_type
*new_stmt
;
6955 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
6956 new_stmt
->exp
= exp
;
6957 new_stmt
->type
= type
;
6960 /* Create a new reloc statement. RELOC is the BFD relocation type to
6961 generate. HOWTO is the corresponding howto structure (we could
6962 look this up, but the caller has already done so). SECTION is the
6963 section to generate a reloc against, or NAME is the name of the
6964 symbol to generate a reloc against. Exactly one of SECTION and
6965 NAME must be NULL. ADDEND is an expression for the addend. */
6968 lang_add_reloc (bfd_reloc_code_real_type reloc
,
6969 reloc_howto_type
*howto
,
6972 union etree_union
*addend
)
6974 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
6978 p
->section
= section
;
6980 p
->addend_exp
= addend
;
6982 p
->addend_value
= 0;
6983 p
->output_section
= NULL
;
6984 p
->output_offset
= 0;
6987 lang_assignment_statement_type
*
6988 lang_add_assignment (etree_type
*exp
)
6990 lang_assignment_statement_type
*new_stmt
;
6992 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
6993 new_stmt
->exp
= exp
;
6998 lang_add_attribute (enum statement_enum attribute
)
7000 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
7004 lang_startup (const char *name
)
7006 if (first_file
->filename
!= NULL
)
7008 einfo (_("%P%F: multiple STARTUP files\n"));
7010 first_file
->filename
= name
;
7011 first_file
->local_sym_name
= name
;
7012 first_file
->flags
.real
= TRUE
;
7016 lang_float (bfd_boolean maybe
)
7018 lang_float_flag
= maybe
;
7022 /* Work out the load- and run-time regions from a script statement, and
7023 store them in *LMA_REGION and *REGION respectively.
7025 MEMSPEC is the name of the run-time region, or the value of
7026 DEFAULT_MEMORY_REGION if the statement didn't specify one.
7027 LMA_MEMSPEC is the name of the load-time region, or null if the
7028 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
7029 had an explicit load address.
7031 It is an error to specify both a load region and a load address. */
7034 lang_get_regions (lang_memory_region_type
**region
,
7035 lang_memory_region_type
**lma_region
,
7036 const char *memspec
,
7037 const char *lma_memspec
,
7038 bfd_boolean have_lma
,
7039 bfd_boolean have_vma
)
7041 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
7043 /* If no runtime region or VMA has been specified, but the load region
7044 has been specified, then use the load region for the runtime region
7046 if (lma_memspec
!= NULL
7048 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
7049 *region
= *lma_region
;
7051 *region
= lang_memory_region_lookup (memspec
, FALSE
);
7053 if (have_lma
&& lma_memspec
!= 0)
7054 einfo (_("%X%P:%S: section has both a load address and a load region\n"),
7059 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
7060 lang_output_section_phdr_list
*phdrs
,
7061 const char *lma_memspec
)
7063 lang_get_regions (¤t_section
->region
,
7064 ¤t_section
->lma_region
,
7065 memspec
, lma_memspec
,
7066 current_section
->load_base
!= NULL
,
7067 current_section
->addr_tree
!= NULL
);
7069 /* If this section has no load region or base, but uses the same
7070 region as the previous section, then propagate the previous
7071 section's load region. */
7073 if (current_section
->lma_region
== NULL
7074 && current_section
->load_base
== NULL
7075 && current_section
->addr_tree
== NULL
7076 && current_section
->region
== current_section
->prev
->region
)
7077 current_section
->lma_region
= current_section
->prev
->lma_region
;
7079 current_section
->fill
= fill
;
7080 current_section
->phdrs
= phdrs
;
7085 lang_statement_append (lang_statement_list_type
*list
,
7086 lang_statement_union_type
*element
,
7087 lang_statement_union_type
**field
)
7089 *(list
->tail
) = element
;
7093 /* Set the output format type. -oformat overrides scripts. */
7096 lang_add_output_format (const char *format
,
7101 if (output_target
== NULL
|| !from_script
)
7103 if (command_line
.endian
== ENDIAN_BIG
7106 else if (command_line
.endian
== ENDIAN_LITTLE
7110 output_target
= format
;
7115 lang_add_insert (const char *where
, int is_before
)
7117 lang_insert_statement_type
*new_stmt
;
7119 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7120 new_stmt
->where
= where
;
7121 new_stmt
->is_before
= is_before
;
7122 saved_script_handle
= previous_script_handle
;
7125 /* Enter a group. This creates a new lang_group_statement, and sets
7126 stat_ptr to build new statements within the group. */
7129 lang_enter_group (void)
7131 lang_group_statement_type
*g
;
7133 g
= new_stat (lang_group_statement
, stat_ptr
);
7134 lang_list_init (&g
->children
);
7135 push_stat_ptr (&g
->children
);
7138 /* Leave a group. This just resets stat_ptr to start writing to the
7139 regular list of statements again. Note that this will not work if
7140 groups can occur inside anything else which can adjust stat_ptr,
7141 but currently they can't. */
7144 lang_leave_group (void)
7149 /* Add a new program header. This is called for each entry in a PHDRS
7150 command in a linker script. */
7153 lang_new_phdr (const char *name
,
7155 bfd_boolean filehdr
,
7160 struct lang_phdr
*n
, **pp
;
7163 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
7166 n
->type
= exp_get_value_int (type
, 0, "program header type");
7167 n
->filehdr
= filehdr
;
7172 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
7174 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7177 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
7179 einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported"
7180 " when prior PT_LOAD headers lack them\n"), NULL
);
7187 /* Record the program header information in the output BFD. FIXME: We
7188 should not be calling an ELF specific function here. */
7191 lang_record_phdrs (void)
7195 lang_output_section_phdr_list
*last
;
7196 struct lang_phdr
*l
;
7197 lang_output_section_statement_type
*os
;
7200 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
7203 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
7210 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7214 lang_output_section_phdr_list
*pl
;
7216 if (os
->constraint
< 0)
7224 if (os
->sectype
== noload_section
7225 || os
->bfd_section
== NULL
7226 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
7229 /* Don't add orphans to PT_INTERP header. */
7235 lang_output_section_statement_type
* tmp_os
;
7237 /* If we have not run across a section with a program
7238 header assigned to it yet, then scan forwards to find
7239 one. This prevents inconsistencies in the linker's
7240 behaviour when a script has specified just a single
7241 header and there are sections in that script which are
7242 not assigned to it, and which occur before the first
7243 use of that header. See here for more details:
7244 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
7245 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
7248 last
= tmp_os
->phdrs
;
7252 einfo (_("%F%P: no sections assigned to phdrs\n"));
7257 if (os
->bfd_section
== NULL
)
7260 for (; pl
!= NULL
; pl
= pl
->next
)
7262 if (strcmp (pl
->name
, l
->name
) == 0)
7267 secs
= (asection
**) xrealloc (secs
,
7268 alc
* sizeof (asection
*));
7270 secs
[c
] = os
->bfd_section
;
7277 if (l
->flags
== NULL
)
7280 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
7285 at
= exp_get_vma (l
->at
, 0, "phdr load address");
7287 if (! bfd_record_phdr (link_info
.output_bfd
, l
->type
,
7288 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
7289 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
7290 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
7295 /* Make sure all the phdr assignments succeeded. */
7296 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7300 lang_output_section_phdr_list
*pl
;
7302 if (os
->constraint
< 0
7303 || os
->bfd_section
== NULL
)
7306 for (pl
= os
->phdrs
;
7309 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
7310 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
7311 os
->name
, pl
->name
);
7315 /* Record a list of sections which may not be cross referenced. */
7318 lang_add_nocrossref (lang_nocrossref_type
*l
)
7320 struct lang_nocrossrefs
*n
;
7322 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
7323 n
->next
= nocrossref_list
;
7325 nocrossref_list
= n
;
7327 /* Set notice_all so that we get informed about all symbols. */
7328 link_info
.notice_all
= TRUE
;
7331 /* Overlay handling. We handle overlays with some static variables. */
7333 /* The overlay virtual address. */
7334 static etree_type
*overlay_vma
;
7335 /* And subsection alignment. */
7336 static etree_type
*overlay_subalign
;
7338 /* An expression for the maximum section size seen so far. */
7339 static etree_type
*overlay_max
;
7341 /* A list of all the sections in this overlay. */
7343 struct overlay_list
{
7344 struct overlay_list
*next
;
7345 lang_output_section_statement_type
*os
;
7348 static struct overlay_list
*overlay_list
;
7350 /* Start handling an overlay. */
7353 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
7355 /* The grammar should prevent nested overlays from occurring. */
7356 ASSERT (overlay_vma
== NULL
7357 && overlay_subalign
== NULL
7358 && overlay_max
== NULL
);
7360 overlay_vma
= vma_expr
;
7361 overlay_subalign
= subalign
;
7364 /* Start a section in an overlay. We handle this by calling
7365 lang_enter_output_section_statement with the correct VMA.
7366 lang_leave_overlay sets up the LMA and memory regions. */
7369 lang_enter_overlay_section (const char *name
)
7371 struct overlay_list
*n
;
7374 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
7375 0, overlay_subalign
, 0, 0, 0);
7377 /* If this is the first section, then base the VMA of future
7378 sections on this one. This will work correctly even if `.' is
7379 used in the addresses. */
7380 if (overlay_list
== NULL
)
7381 overlay_vma
= exp_nameop (ADDR
, name
);
7383 /* Remember the section. */
7384 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
7385 n
->os
= current_section
;
7386 n
->next
= overlay_list
;
7389 size
= exp_nameop (SIZEOF
, name
);
7391 /* Arrange to work out the maximum section end address. */
7392 if (overlay_max
== NULL
)
7395 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
7398 /* Finish a section in an overlay. There isn't any special to do
7402 lang_leave_overlay_section (fill_type
*fill
,
7403 lang_output_section_phdr_list
*phdrs
)
7410 name
= current_section
->name
;
7412 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
7413 region and that no load-time region has been specified. It doesn't
7414 really matter what we say here, since lang_leave_overlay will
7416 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
7418 /* Define the magic symbols. */
7420 clean
= (char *) xmalloc (strlen (name
) + 1);
7422 for (s1
= name
; *s1
!= '\0'; s1
++)
7423 if (ISALNUM (*s1
) || *s1
== '_')
7427 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
7428 sprintf (buf
, "__load_start_%s", clean
);
7429 lang_add_assignment (exp_provide (buf
,
7430 exp_nameop (LOADADDR
, name
),
7433 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
7434 sprintf (buf
, "__load_stop_%s", clean
);
7435 lang_add_assignment (exp_provide (buf
,
7437 exp_nameop (LOADADDR
, name
),
7438 exp_nameop (SIZEOF
, name
)),
7444 /* Finish an overlay. If there are any overlay wide settings, this
7445 looks through all the sections in the overlay and sets them. */
7448 lang_leave_overlay (etree_type
*lma_expr
,
7451 const char *memspec
,
7452 lang_output_section_phdr_list
*phdrs
,
7453 const char *lma_memspec
)
7455 lang_memory_region_type
*region
;
7456 lang_memory_region_type
*lma_region
;
7457 struct overlay_list
*l
;
7458 lang_nocrossref_type
*nocrossref
;
7460 lang_get_regions (®ion
, &lma_region
,
7461 memspec
, lma_memspec
,
7462 lma_expr
!= NULL
, FALSE
);
7466 /* After setting the size of the last section, set '.' to end of the
7468 if (overlay_list
!= NULL
)
7470 overlay_list
->os
->update_dot
= 1;
7471 overlay_list
->os
->update_dot_tree
7472 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
7478 struct overlay_list
*next
;
7480 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
7483 l
->os
->region
= region
;
7484 l
->os
->lma_region
= lma_region
;
7486 /* The first section has the load address specified in the
7487 OVERLAY statement. The rest are worked out from that.
7488 The base address is not needed (and should be null) if
7489 an LMA region was specified. */
7492 l
->os
->load_base
= lma_expr
;
7493 l
->os
->sectype
= normal_section
;
7495 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
7496 l
->os
->phdrs
= phdrs
;
7500 lang_nocrossref_type
*nc
;
7502 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
7503 nc
->name
= l
->os
->name
;
7504 nc
->next
= nocrossref
;
7513 if (nocrossref
!= NULL
)
7514 lang_add_nocrossref (nocrossref
);
7517 overlay_list
= NULL
;
7521 /* Version handling. This is only useful for ELF. */
7523 /* If PREV is NULL, return first version pattern matching particular symbol.
7524 If PREV is non-NULL, return first version pattern matching particular
7525 symbol after PREV (previously returned by lang_vers_match). */
7527 static struct bfd_elf_version_expr
*
7528 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
7529 struct bfd_elf_version_expr
*prev
,
7533 const char *cxx_sym
= sym
;
7534 const char *java_sym
= sym
;
7535 struct bfd_elf_version_expr
*expr
= NULL
;
7536 enum demangling_styles curr_style
;
7538 curr_style
= CURRENT_DEMANGLING_STYLE
;
7539 cplus_demangle_set_style (no_demangling
);
7540 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
7543 cplus_demangle_set_style (curr_style
);
7545 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7547 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
7548 DMGL_PARAMS
| DMGL_ANSI
);
7552 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7554 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
7559 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
7561 struct bfd_elf_version_expr e
;
7563 switch (prev
? prev
->mask
: 0)
7566 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
7569 expr
= (struct bfd_elf_version_expr
*)
7570 htab_find ((htab_t
) head
->htab
, &e
);
7571 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
7572 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
7578 case BFD_ELF_VERSION_C_TYPE
:
7579 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7581 e
.pattern
= cxx_sym
;
7582 expr
= (struct bfd_elf_version_expr
*)
7583 htab_find ((htab_t
) head
->htab
, &e
);
7584 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
7585 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7591 case BFD_ELF_VERSION_CXX_TYPE
:
7592 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7594 e
.pattern
= java_sym
;
7595 expr
= (struct bfd_elf_version_expr
*)
7596 htab_find ((htab_t
) head
->htab
, &e
);
7597 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
7598 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7609 /* Finally, try the wildcards. */
7610 if (prev
== NULL
|| prev
->literal
)
7611 expr
= head
->remaining
;
7614 for (; expr
; expr
= expr
->next
)
7621 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
7624 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7626 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7630 if (fnmatch (expr
->pattern
, s
, 0) == 0)
7636 free ((char *) c_sym
);
7638 free ((char *) cxx_sym
);
7639 if (java_sym
!= sym
)
7640 free ((char *) java_sym
);
7644 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7645 return a pointer to the symbol name with any backslash quotes removed. */
7648 realsymbol (const char *pattern
)
7651 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
7652 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
7654 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
7656 /* It is a glob pattern only if there is no preceding
7660 /* Remove the preceding backslash. */
7667 if (*p
== '?' || *p
== '*' || *p
== '[')
7674 backslash
= *p
== '\\';
7690 /* This is called for each variable name or match expression. NEW_NAME is
7691 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7692 pattern to be matched against symbol names. */
7694 struct bfd_elf_version_expr
*
7695 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
7696 const char *new_name
,
7698 bfd_boolean literal_p
)
7700 struct bfd_elf_version_expr
*ret
;
7702 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
7706 ret
->literal
= TRUE
;
7707 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
7708 if (ret
->pattern
== NULL
)
7710 ret
->pattern
= new_name
;
7711 ret
->literal
= FALSE
;
7714 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
7715 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7716 else if (strcasecmp (lang
, "C++") == 0)
7717 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
7718 else if (strcasecmp (lang
, "Java") == 0)
7719 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
7722 einfo (_("%X%P: unknown language `%s' in version information\n"),
7724 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7727 return ldemul_new_vers_pattern (ret
);
7730 /* This is called for each set of variable names and match
7733 struct bfd_elf_version_tree
*
7734 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
7735 struct bfd_elf_version_expr
*locals
)
7737 struct bfd_elf_version_tree
*ret
;
7739 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
7740 ret
->globals
.list
= globals
;
7741 ret
->locals
.list
= locals
;
7742 ret
->match
= lang_vers_match
;
7743 ret
->name_indx
= (unsigned int) -1;
7747 /* This static variable keeps track of version indices. */
7749 static int version_index
;
7752 version_expr_head_hash (const void *p
)
7754 const struct bfd_elf_version_expr
*e
=
7755 (const struct bfd_elf_version_expr
*) p
;
7757 return htab_hash_string (e
->pattern
);
7761 version_expr_head_eq (const void *p1
, const void *p2
)
7763 const struct bfd_elf_version_expr
*e1
=
7764 (const struct bfd_elf_version_expr
*) p1
;
7765 const struct bfd_elf_version_expr
*e2
=
7766 (const struct bfd_elf_version_expr
*) p2
;
7768 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
7772 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
7775 struct bfd_elf_version_expr
*e
, *next
;
7776 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
7778 for (e
= head
->list
; e
; e
= e
->next
)
7782 head
->mask
|= e
->mask
;
7787 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
7788 version_expr_head_eq
, NULL
);
7789 list_loc
= &head
->list
;
7790 remaining_loc
= &head
->remaining
;
7791 for (e
= head
->list
; e
; e
= next
)
7797 remaining_loc
= &e
->next
;
7801 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
7805 struct bfd_elf_version_expr
*e1
, *last
;
7807 e1
= (struct bfd_elf_version_expr
*) *loc
;
7811 if (e1
->mask
== e
->mask
)
7819 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
7823 /* This is a duplicate. */
7824 /* FIXME: Memory leak. Sometimes pattern is not
7825 xmalloced alone, but in larger chunk of memory. */
7826 /* free (e->pattern); */
7831 e
->next
= last
->next
;
7839 list_loc
= &e
->next
;
7843 *remaining_loc
= NULL
;
7844 *list_loc
= head
->remaining
;
7847 head
->remaining
= head
->list
;
7850 /* This is called when we know the name and dependencies of the
7854 lang_register_vers_node (const char *name
,
7855 struct bfd_elf_version_tree
*version
,
7856 struct bfd_elf_version_deps
*deps
)
7858 struct bfd_elf_version_tree
*t
, **pp
;
7859 struct bfd_elf_version_expr
*e1
;
7864 if (link_info
.version_info
!= NULL
7865 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
7867 einfo (_("%X%P: anonymous version tag cannot be combined"
7868 " with other version tags\n"));
7873 /* Make sure this node has a unique name. */
7874 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7875 if (strcmp (t
->name
, name
) == 0)
7876 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
7878 lang_finalize_version_expr_head (&version
->globals
);
7879 lang_finalize_version_expr_head (&version
->locals
);
7881 /* Check the global and local match names, and make sure there
7882 aren't any duplicates. */
7884 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
7886 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7888 struct bfd_elf_version_expr
*e2
;
7890 if (t
->locals
.htab
&& e1
->literal
)
7892 e2
= (struct bfd_elf_version_expr
*)
7893 htab_find ((htab_t
) t
->locals
.htab
, e1
);
7894 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
7896 if (e1
->mask
== e2
->mask
)
7897 einfo (_("%X%P: duplicate expression `%s'"
7898 " in version information\n"), e1
->pattern
);
7902 else if (!e1
->literal
)
7903 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7904 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7905 && e1
->mask
== e2
->mask
)
7906 einfo (_("%X%P: duplicate expression `%s'"
7907 " in version information\n"), e1
->pattern
);
7911 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
7913 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7915 struct bfd_elf_version_expr
*e2
;
7917 if (t
->globals
.htab
&& e1
->literal
)
7919 e2
= (struct bfd_elf_version_expr
*)
7920 htab_find ((htab_t
) t
->globals
.htab
, e1
);
7921 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
7923 if (e1
->mask
== e2
->mask
)
7924 einfo (_("%X%P: duplicate expression `%s'"
7925 " in version information\n"),
7930 else if (!e1
->literal
)
7931 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7932 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7933 && e1
->mask
== e2
->mask
)
7934 einfo (_("%X%P: duplicate expression `%s'"
7935 " in version information\n"), e1
->pattern
);
7939 version
->deps
= deps
;
7940 version
->name
= name
;
7941 if (name
[0] != '\0')
7944 version
->vernum
= version_index
;
7947 version
->vernum
= 0;
7949 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7954 /* This is called when we see a version dependency. */
7956 struct bfd_elf_version_deps
*
7957 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
7959 struct bfd_elf_version_deps
*ret
;
7960 struct bfd_elf_version_tree
*t
;
7962 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
7965 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7967 if (strcmp (t
->name
, name
) == 0)
7969 ret
->version_needed
= t
;
7974 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
7976 ret
->version_needed
= NULL
;
7981 lang_do_version_exports_section (void)
7983 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
7985 LANG_FOR_EACH_INPUT_STATEMENT (is
)
7987 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
7995 contents
= (char *) xmalloc (len
);
7996 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
7997 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
8000 while (p
< contents
+ len
)
8002 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
8003 p
= strchr (p
, '\0') + 1;
8006 /* Do not free the contents, as we used them creating the regex. */
8008 /* Do not include this section in the link. */
8009 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
8012 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
8013 lang_register_vers_node (command_line
.version_exports_section
,
8014 lang_new_vers_node (greg
, lreg
), NULL
);
8018 lang_add_unique (const char *name
)
8020 struct unique_sections
*ent
;
8022 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
8023 if (strcmp (ent
->name
, name
) == 0)
8026 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
8027 ent
->name
= xstrdup (name
);
8028 ent
->next
= unique_section_list
;
8029 unique_section_list
= ent
;
8032 /* Append the list of dynamic symbols to the existing one. */
8035 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
8037 if (link_info
.dynamic_list
)
8039 struct bfd_elf_version_expr
*tail
;
8040 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
8042 tail
->next
= link_info
.dynamic_list
->head
.list
;
8043 link_info
.dynamic_list
->head
.list
= dynamic
;
8047 struct bfd_elf_dynamic_list
*d
;
8049 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
8050 d
->head
.list
= dynamic
;
8051 d
->match
= lang_vers_match
;
8052 link_info
.dynamic_list
= d
;
8056 /* Append the list of C++ typeinfo dynamic symbols to the existing
8060 lang_append_dynamic_list_cpp_typeinfo (void)
8062 const char * symbols
[] =
8064 "typeinfo name for*",
8067 struct bfd_elf_version_expr
*dynamic
= NULL
;
8070 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8071 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8074 lang_append_dynamic_list (dynamic
);
8077 /* Append the list of C++ operator new and delete dynamic symbols to the
8081 lang_append_dynamic_list_cpp_new (void)
8083 const char * symbols
[] =
8088 struct bfd_elf_version_expr
*dynamic
= NULL
;
8091 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8092 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8095 lang_append_dynamic_list (dynamic
);
8098 /* Scan a space and/or comma separated string of features. */
8101 lang_ld_feature (char *str
)
8109 while (*p
== ',' || ISSPACE (*p
))
8114 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
8118 if (strcasecmp (p
, "SANE_EXPR") == 0)
8119 config
.sane_expr
= TRUE
;
8121 einfo (_("%X%P: unknown feature `%s'\n"), p
);