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 (!map_head_is_link_order
)
2416 asection
*s
= output
->bfd_section
->map_tail
.s
;
2417 output
->bfd_section
->map_tail
.s
= section
;
2418 section
->map_head
.s
= NULL
;
2419 section
->map_tail
.s
= s
;
2421 s
->map_head
.s
= section
;
2423 output
->bfd_section
->map_head
.s
= section
;
2426 /* Add a section reference to the list. */
2427 new_section
= new_stat (lang_input_section
, ptr
);
2428 new_section
->section
= section
;
2431 /* Handle wildcard sorting. This returns the lang_input_section which
2432 should follow the one we are going to create for SECTION and FILE,
2433 based on the sorting requirements of WILD. It returns NULL if the
2434 new section should just go at the end of the current list. */
2436 static lang_statement_union_type
*
2437 wild_sort (lang_wild_statement_type
*wild
,
2438 struct wildcard_list
*sec
,
2439 lang_input_statement_type
*file
,
2442 lang_statement_union_type
*l
;
2444 if (!wild
->filenames_sorted
2445 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2448 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2450 lang_input_section_type
*ls
;
2452 if (l
->header
.type
!= lang_input_section_enum
)
2454 ls
= &l
->input_section
;
2456 /* Sorting by filename takes precedence over sorting by section
2459 if (wild
->filenames_sorted
)
2461 const char *fn
, *ln
;
2465 /* The PE support for the .idata section as generated by
2466 dlltool assumes that files will be sorted by the name of
2467 the archive and then the name of the file within the
2470 if (file
->the_bfd
!= NULL
2471 && bfd_my_archive (file
->the_bfd
) != NULL
)
2473 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
2478 fn
= file
->filename
;
2482 if (bfd_my_archive (ls
->section
->owner
) != NULL
)
2484 ln
= bfd_get_filename (bfd_my_archive (ls
->section
->owner
));
2489 ln
= ls
->section
->owner
->filename
;
2493 i
= filename_cmp (fn
, ln
);
2502 fn
= file
->filename
;
2504 ln
= ls
->section
->owner
->filename
;
2506 i
= filename_cmp (fn
, ln
);
2514 /* Here either the files are not sorted by name, or we are
2515 looking at the sections for this file. */
2518 && sec
->spec
.sorted
!= none
2519 && sec
->spec
.sorted
!= by_none
)
2520 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2527 /* Expand a wild statement for a particular FILE. SECTION may be
2528 NULL, in which case it is a wild card. */
2531 output_section_callback (lang_wild_statement_type
*ptr
,
2532 struct wildcard_list
*sec
,
2534 struct flag_info
*sflag_info
,
2535 lang_input_statement_type
*file
,
2538 lang_statement_union_type
*before
;
2539 lang_output_section_statement_type
*os
;
2541 os
= (lang_output_section_statement_type
*) output
;
2543 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2544 if (unique_section_p (section
, os
))
2547 before
= wild_sort (ptr
, sec
, file
, section
);
2549 /* Here BEFORE points to the lang_input_section which
2550 should follow the one we are about to add. If BEFORE
2551 is NULL, then the section should just go at the end
2552 of the current list. */
2555 lang_add_section (&ptr
->children
, section
, sflag_info
, os
);
2558 lang_statement_list_type list
;
2559 lang_statement_union_type
**pp
;
2561 lang_list_init (&list
);
2562 lang_add_section (&list
, section
, sflag_info
, os
);
2564 /* If we are discarding the section, LIST.HEAD will
2566 if (list
.head
!= NULL
)
2568 ASSERT (list
.head
->header
.next
== NULL
);
2570 for (pp
= &ptr
->children
.head
;
2572 pp
= &(*pp
)->header
.next
)
2573 ASSERT (*pp
!= NULL
);
2575 list
.head
->header
.next
= *pp
;
2581 /* Check if all sections in a wild statement for a particular FILE
2585 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2586 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2588 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
2589 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2592 lang_output_section_statement_type
*os
;
2594 os
= (lang_output_section_statement_type
*) output
;
2596 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2597 if (unique_section_p (section
, os
))
2600 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2601 os
->all_input_readonly
= FALSE
;
2604 /* This is passed a file name which must have been seen already and
2605 added to the statement tree. We will see if it has been opened
2606 already and had its symbols read. If not then we'll read it. */
2608 static lang_input_statement_type
*
2609 lookup_name (const char *name
)
2611 lang_input_statement_type
*search
;
2613 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2615 search
= (lang_input_statement_type
*) search
->next_real_file
)
2617 /* Use the local_sym_name as the name of the file that has
2618 already been loaded as filename might have been transformed
2619 via the search directory lookup mechanism. */
2620 const char *filename
= search
->local_sym_name
;
2622 if (filename
!= NULL
2623 && filename_cmp (filename
, name
) == 0)
2628 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2629 default_target
, FALSE
);
2631 /* If we have already added this file, or this file is not real
2632 don't add this file. */
2633 if (search
->flags
.loaded
|| !search
->flags
.real
)
2636 if (! load_symbols (search
, NULL
))
2642 /* Save LIST as a list of libraries whose symbols should not be exported. */
2647 struct excluded_lib
*next
;
2649 static struct excluded_lib
*excluded_libs
;
2652 add_excluded_libs (const char *list
)
2654 const char *p
= list
, *end
;
2658 struct excluded_lib
*entry
;
2659 end
= strpbrk (p
, ",:");
2661 end
= p
+ strlen (p
);
2662 entry
= (struct excluded_lib
*) xmalloc (sizeof (*entry
));
2663 entry
->next
= excluded_libs
;
2664 entry
->name
= (char *) xmalloc (end
- p
+ 1);
2665 memcpy (entry
->name
, p
, end
- p
);
2666 entry
->name
[end
- p
] = '\0';
2667 excluded_libs
= entry
;
2675 check_excluded_libs (bfd
*abfd
)
2677 struct excluded_lib
*lib
= excluded_libs
;
2681 int len
= strlen (lib
->name
);
2682 const char *filename
= lbasename (abfd
->filename
);
2684 if (strcmp (lib
->name
, "ALL") == 0)
2686 abfd
->no_export
= TRUE
;
2690 if (filename_ncmp (lib
->name
, filename
, len
) == 0
2691 && (filename
[len
] == '\0'
2692 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2693 && filename
[len
+ 2] == '\0')))
2695 abfd
->no_export
= TRUE
;
2703 /* Get the symbols for an input file. */
2706 load_symbols (lang_input_statement_type
*entry
,
2707 lang_statement_list_type
*place
)
2711 if (entry
->flags
.loaded
)
2714 ldfile_open_file (entry
);
2716 /* Do not process further if the file was missing. */
2717 if (entry
->flags
.missing_file
)
2720 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
2721 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2724 struct lang_input_statement_flags save_flags
;
2727 err
= bfd_get_error ();
2729 /* See if the emulation has some special knowledge. */
2730 if (ldemul_unrecognized_file (entry
))
2733 if (err
== bfd_error_file_ambiguously_recognized
)
2737 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
2738 einfo (_("%B: matching formats:"), entry
->the_bfd
);
2739 for (p
= matching
; *p
!= NULL
; p
++)
2743 else if (err
!= bfd_error_file_not_recognized
2745 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
2747 bfd_close (entry
->the_bfd
);
2748 entry
->the_bfd
= NULL
;
2750 /* Try to interpret the file as a linker script. */
2751 save_flags
= input_flags
;
2752 ldfile_open_command_file (entry
->filename
);
2754 push_stat_ptr (place
);
2755 input_flags
.add_DT_NEEDED_for_regular
2756 = entry
->flags
.add_DT_NEEDED_for_regular
;
2757 input_flags
.add_DT_NEEDED_for_dynamic
2758 = entry
->flags
.add_DT_NEEDED_for_dynamic
;
2759 input_flags
.whole_archive
= entry
->flags
.whole_archive
;
2760 input_flags
.dynamic
= entry
->flags
.dynamic
;
2762 ldfile_assumed_script
= TRUE
;
2763 parser_input
= input_script
;
2765 ldfile_assumed_script
= FALSE
;
2767 /* missing_file is sticky. sysrooted will already have been
2768 restored when seeing EOF in yyparse, but no harm to restore
2770 save_flags
.missing_file
|= input_flags
.missing_file
;
2771 input_flags
= save_flags
;
2775 entry
->flags
.loaded
= TRUE
;
2780 if (ldemul_recognized_file (entry
))
2783 /* We don't call ldlang_add_file for an archive. Instead, the
2784 add_symbols entry point will call ldlang_add_file, via the
2785 add_archive_element callback, for each element of the archive
2787 switch (bfd_get_format (entry
->the_bfd
))
2793 if (!entry
->flags
.reload
)
2794 ldlang_add_file (entry
);
2795 if (trace_files
|| verbose
)
2796 info_msg ("%I\n", entry
);
2800 check_excluded_libs (entry
->the_bfd
);
2802 if (entry
->flags
.whole_archive
)
2805 bfd_boolean loaded
= TRUE
;
2810 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
2815 if (! bfd_check_format (member
, bfd_object
))
2817 einfo (_("%F%B: member %B in archive is not an object\n"),
2818 entry
->the_bfd
, member
);
2823 if (!(*link_info
.callbacks
2824 ->add_archive_element
) (&link_info
, member
,
2825 "--whole-archive", &subsbfd
))
2828 /* Potentially, the add_archive_element hook may have set a
2829 substitute BFD for us. */
2830 if (!bfd_link_add_symbols (subsbfd
, &link_info
))
2832 einfo (_("%F%B: error adding symbols: %E\n"), member
);
2837 entry
->flags
.loaded
= loaded
;
2843 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
2844 entry
->flags
.loaded
= TRUE
;
2846 einfo (_("%F%B: error adding symbols: %E\n"), entry
->the_bfd
);
2848 return entry
->flags
.loaded
;
2851 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2852 may be NULL, indicating that it is a wildcard. Separate
2853 lang_input_section statements are created for each part of the
2854 expansion; they are added after the wild statement S. OUTPUT is
2855 the output section. */
2858 wild (lang_wild_statement_type
*s
,
2859 const char *target ATTRIBUTE_UNUSED
,
2860 lang_output_section_statement_type
*output
)
2862 struct wildcard_list
*sec
;
2864 if (s
->handler_data
[0]
2865 && s
->handler_data
[0]->spec
.sorted
== by_name
2866 && !s
->filenames_sorted
)
2868 lang_section_bst_type
*tree
;
2870 walk_wild (s
, output_section_callback_fast
, output
);
2875 output_section_callback_tree_to_list (s
, tree
, output
);
2880 walk_wild (s
, output_section_callback
, output
);
2882 if (default_common_section
== NULL
)
2883 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
2884 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
2886 /* Remember the section that common is going to in case we
2887 later get something which doesn't know where to put it. */
2888 default_common_section
= output
;
2893 /* Return TRUE iff target is the sought target. */
2896 get_target (const bfd_target
*target
, void *data
)
2898 const char *sought
= (const char *) data
;
2900 return strcmp (target
->name
, sought
) == 0;
2903 /* Like strcpy() but convert to lower case as well. */
2906 stricpy (char *dest
, char *src
)
2910 while ((c
= *src
++) != 0)
2911 *dest
++ = TOLOWER (c
);
2916 /* Remove the first occurrence of needle (if any) in haystack
2920 strcut (char *haystack
, char *needle
)
2922 haystack
= strstr (haystack
, needle
);
2928 for (src
= haystack
+ strlen (needle
); *src
;)
2929 *haystack
++ = *src
++;
2935 /* Compare two target format name strings.
2936 Return a value indicating how "similar" they are. */
2939 name_compare (char *first
, char *second
)
2945 copy1
= (char *) xmalloc (strlen (first
) + 1);
2946 copy2
= (char *) xmalloc (strlen (second
) + 1);
2948 /* Convert the names to lower case. */
2949 stricpy (copy1
, first
);
2950 stricpy (copy2
, second
);
2952 /* Remove size and endian strings from the name. */
2953 strcut (copy1
, "big");
2954 strcut (copy1
, "little");
2955 strcut (copy2
, "big");
2956 strcut (copy2
, "little");
2958 /* Return a value based on how many characters match,
2959 starting from the beginning. If both strings are
2960 the same then return 10 * their length. */
2961 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
2962 if (copy1
[result
] == 0)
2974 /* Set by closest_target_match() below. */
2975 static const bfd_target
*winner
;
2977 /* Scan all the valid bfd targets looking for one that has the endianness
2978 requirement that was specified on the command line, and is the nearest
2979 match to the original output target. */
2982 closest_target_match (const bfd_target
*target
, void *data
)
2984 const bfd_target
*original
= (const bfd_target
*) data
;
2986 if (command_line
.endian
== ENDIAN_BIG
2987 && target
->byteorder
!= BFD_ENDIAN_BIG
)
2990 if (command_line
.endian
== ENDIAN_LITTLE
2991 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
2994 /* Must be the same flavour. */
2995 if (target
->flavour
!= original
->flavour
)
2998 /* Ignore generic big and little endian elf vectors. */
2999 if (strcmp (target
->name
, "elf32-big") == 0
3000 || strcmp (target
->name
, "elf64-big") == 0
3001 || strcmp (target
->name
, "elf32-little") == 0
3002 || strcmp (target
->name
, "elf64-little") == 0)
3005 /* If we have not found a potential winner yet, then record this one. */
3012 /* Oh dear, we now have two potential candidates for a successful match.
3013 Compare their names and choose the better one. */
3014 if (name_compare (target
->name
, original
->name
)
3015 > name_compare (winner
->name
, original
->name
))
3018 /* Keep on searching until wqe have checked them all. */
3022 /* Return the BFD target format of the first input file. */
3025 get_first_input_target (void)
3027 char *target
= NULL
;
3029 LANG_FOR_EACH_INPUT_STATEMENT (s
)
3031 if (s
->header
.type
== lang_input_statement_enum
3034 ldfile_open_file (s
);
3036 if (s
->the_bfd
!= NULL
3037 && bfd_check_format (s
->the_bfd
, bfd_object
))
3039 target
= bfd_get_target (s
->the_bfd
);
3051 lang_get_output_target (void)
3055 /* Has the user told us which output format to use? */
3056 if (output_target
!= NULL
)
3057 return output_target
;
3059 /* No - has the current target been set to something other than
3061 if (current_target
!= default_target
&& current_target
!= NULL
)
3062 return current_target
;
3064 /* No - can we determine the format of the first input file? */
3065 target
= get_first_input_target ();
3069 /* Failed - use the default output target. */
3070 return default_target
;
3073 /* Open the output file. */
3076 open_output (const char *name
)
3078 output_target
= lang_get_output_target ();
3080 /* Has the user requested a particular endianness on the command
3082 if (command_line
.endian
!= ENDIAN_UNSET
)
3084 const bfd_target
*target
;
3085 enum bfd_endian desired_endian
;
3087 /* Get the chosen target. */
3088 target
= bfd_search_for_target (get_target
, (void *) output_target
);
3090 /* If the target is not supported, we cannot do anything. */
3093 if (command_line
.endian
== ENDIAN_BIG
)
3094 desired_endian
= BFD_ENDIAN_BIG
;
3096 desired_endian
= BFD_ENDIAN_LITTLE
;
3098 /* See if the target has the wrong endianness. This should
3099 not happen if the linker script has provided big and
3100 little endian alternatives, but some scrips don't do
3102 if (target
->byteorder
!= desired_endian
)
3104 /* If it does, then see if the target provides
3105 an alternative with the correct endianness. */
3106 if (target
->alternative_target
!= NULL
3107 && (target
->alternative_target
->byteorder
== desired_endian
))
3108 output_target
= target
->alternative_target
->name
;
3111 /* Try to find a target as similar as possible to
3112 the default target, but which has the desired
3113 endian characteristic. */
3114 bfd_search_for_target (closest_target_match
,
3117 /* Oh dear - we could not find any targets that
3118 satisfy our requirements. */
3120 einfo (_("%P: warning: could not find any targets"
3121 " that match endianness requirement\n"));
3123 output_target
= winner
->name
;
3129 link_info
.output_bfd
= bfd_openw (name
, output_target
);
3131 if (link_info
.output_bfd
== NULL
)
3133 if (bfd_get_error () == bfd_error_invalid_target
)
3134 einfo (_("%P%F: target %s not found\n"), output_target
);
3136 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
3139 delete_output_file_on_failure
= TRUE
;
3141 if (! bfd_set_format (link_info
.output_bfd
, bfd_object
))
3142 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
3143 if (! bfd_set_arch_mach (link_info
.output_bfd
,
3144 ldfile_output_architecture
,
3145 ldfile_output_machine
))
3146 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
3148 link_info
.hash
= bfd_link_hash_table_create (link_info
.output_bfd
);
3149 if (link_info
.hash
== NULL
)
3150 einfo (_("%P%F: can not create hash table: %E\n"));
3152 bfd_set_gp_size (link_info
.output_bfd
, g_switch_value
);
3156 ldlang_open_output (lang_statement_union_type
*statement
)
3158 switch (statement
->header
.type
)
3160 case lang_output_statement_enum
:
3161 ASSERT (link_info
.output_bfd
== NULL
);
3162 open_output (statement
->output_statement
.name
);
3163 ldemul_set_output_arch ();
3164 if (config
.magic_demand_paged
&& !link_info
.relocatable
)
3165 link_info
.output_bfd
->flags
|= D_PAGED
;
3167 link_info
.output_bfd
->flags
&= ~D_PAGED
;
3168 if (config
.text_read_only
)
3169 link_info
.output_bfd
->flags
|= WP_TEXT
;
3171 link_info
.output_bfd
->flags
&= ~WP_TEXT
;
3172 if (link_info
.traditional_format
)
3173 link_info
.output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
3175 link_info
.output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
3178 case lang_target_statement_enum
:
3179 current_target
= statement
->target_statement
.target
;
3186 /* Convert between addresses in bytes and sizes in octets.
3187 For currently supported targets, octets_per_byte is always a power
3188 of two, so we can use shifts. */
3189 #define TO_ADDR(X) ((X) >> opb_shift)
3190 #define TO_SIZE(X) ((X) << opb_shift)
3192 /* Support the above. */
3193 static unsigned int opb_shift
= 0;
3198 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3199 ldfile_output_machine
);
3202 while ((x
& 1) == 0)
3210 /* Open all the input files. */
3214 OPEN_BFD_NORMAL
= 0,
3218 #ifdef ENABLE_PLUGINS
3219 static lang_input_statement_type
*plugin_insert
= NULL
;
3223 open_input_bfds (lang_statement_union_type
*s
, enum open_bfd_mode mode
)
3225 for (; s
!= NULL
; s
= s
->header
.next
)
3227 switch (s
->header
.type
)
3229 case lang_constructors_statement_enum
:
3230 open_input_bfds (constructor_list
.head
, mode
);
3232 case lang_output_section_statement_enum
:
3233 open_input_bfds (s
->output_section_statement
.children
.head
, mode
);
3235 case lang_wild_statement_enum
:
3236 /* Maybe we should load the file's symbols. */
3237 if ((mode
& OPEN_BFD_RESCAN
) == 0
3238 && s
->wild_statement
.filename
3239 && !wildcardp (s
->wild_statement
.filename
)
3240 && !archive_path (s
->wild_statement
.filename
))
3241 lookup_name (s
->wild_statement
.filename
);
3242 open_input_bfds (s
->wild_statement
.children
.head
, mode
);
3244 case lang_group_statement_enum
:
3246 struct bfd_link_hash_entry
*undefs
;
3248 /* We must continually search the entries in the group
3249 until no new symbols are added to the list of undefined
3254 undefs
= link_info
.hash
->undefs_tail
;
3255 open_input_bfds (s
->group_statement
.children
.head
,
3256 mode
| OPEN_BFD_FORCE
);
3258 while (undefs
!= link_info
.hash
->undefs_tail
);
3261 case lang_target_statement_enum
:
3262 current_target
= s
->target_statement
.target
;
3264 case lang_input_statement_enum
:
3265 if (s
->input_statement
.flags
.real
)
3267 lang_statement_union_type
**os_tail
;
3268 lang_statement_list_type add
;
3271 s
->input_statement
.target
= current_target
;
3273 /* If we are being called from within a group, and this
3274 is an archive which has already been searched, then
3275 force it to be researched unless the whole archive
3276 has been loaded already. Do the same for a rescan.
3277 Likewise reload --as-needed shared libs. */
3278 if (mode
!= OPEN_BFD_NORMAL
3279 #ifdef ENABLE_PLUGINS
3280 && ((mode
& OPEN_BFD_RESCAN
) == 0
3281 || plugin_insert
== NULL
)
3283 && s
->input_statement
.flags
.loaded
3284 && (abfd
= s
->input_statement
.the_bfd
) != NULL
3285 && ((bfd_get_format (abfd
) == bfd_archive
3286 && !s
->input_statement
.flags
.whole_archive
)
3287 || (bfd_get_format (abfd
) == bfd_object
3288 && ((abfd
->flags
) & DYNAMIC
) != 0
3289 && s
->input_statement
.flags
.add_DT_NEEDED_for_regular
3290 && bfd_get_flavour (abfd
) == bfd_target_elf_flavour
3291 && (elf_dyn_lib_class (abfd
) & DYN_AS_NEEDED
) != 0)))
3293 s
->input_statement
.flags
.loaded
= FALSE
;
3294 s
->input_statement
.flags
.reload
= TRUE
;
3297 os_tail
= lang_output_section_statement
.tail
;
3298 lang_list_init (&add
);
3300 if (! load_symbols (&s
->input_statement
, &add
))
3301 config
.make_executable
= FALSE
;
3303 if (add
.head
!= NULL
)
3305 /* If this was a script with output sections then
3306 tack any added statements on to the end of the
3307 list. This avoids having to reorder the output
3308 section statement list. Very likely the user
3309 forgot -T, and whatever we do here will not meet
3310 naive user expectations. */
3311 if (os_tail
!= lang_output_section_statement
.tail
)
3313 einfo (_("%P: warning: %s contains output sections;"
3314 " did you forget -T?\n"),
3315 s
->input_statement
.filename
);
3316 *stat_ptr
->tail
= add
.head
;
3317 stat_ptr
->tail
= add
.tail
;
3321 *add
.tail
= s
->header
.next
;
3322 s
->header
.next
= add
.head
;
3326 #ifdef ENABLE_PLUGINS
3327 /* If we have found the point at which a plugin added new
3328 files, clear plugin_insert to enable archive rescan. */
3329 if (&s
->input_statement
== plugin_insert
)
3330 plugin_insert
= NULL
;
3333 case lang_assignment_statement_enum
:
3334 if (s
->assignment_statement
.exp
->assign
.defsym
)
3335 /* This is from a --defsym on the command line. */
3336 exp_fold_tree_no_dot (s
->assignment_statement
.exp
);
3343 /* Exit if any of the files were missing. */
3344 if (input_flags
.missing_file
)
3348 /* New-function for the definedness hash table. */
3350 static struct bfd_hash_entry
*
3351 lang_definedness_newfunc (struct bfd_hash_entry
*entry
,
3352 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
3353 const char *name ATTRIBUTE_UNUSED
)
3355 struct lang_definedness_hash_entry
*ret
3356 = (struct lang_definedness_hash_entry
*) entry
;
3359 ret
= (struct lang_definedness_hash_entry
*)
3360 bfd_hash_allocate (table
, sizeof (struct lang_definedness_hash_entry
));
3363 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
3371 /* Called during processing of linker script script expressions.
3372 For symbols assigned in a linker script, return a struct describing
3373 where the symbol is defined relative to the current expression,
3374 otherwise return NULL. */
3376 struct lang_definedness_hash_entry
*
3377 lang_symbol_defined (const char *name
)
3379 return ((struct lang_definedness_hash_entry
*)
3380 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
));
3383 /* Update the definedness state of NAME. */
3386 lang_update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
3388 struct lang_definedness_hash_entry
*defentry
3389 = (struct lang_definedness_hash_entry
*)
3390 bfd_hash_lookup (&lang_definedness_table
, name
, TRUE
, FALSE
);
3392 if (defentry
== NULL
)
3393 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
3395 /* If the symbol was already defined, and not by a script, then it
3396 must be defined by an object file. */
3397 if (!defentry
->by_script
3398 && h
->type
!= bfd_link_hash_undefined
3399 && h
->type
!= bfd_link_hash_common
3400 && h
->type
!= bfd_link_hash_new
)
3401 defentry
->by_object
= 1;
3403 defentry
->by_script
= 1;
3404 defentry
->iteration
= lang_statement_iteration
;
3407 /* Add the supplied name to the symbol table as an undefined reference.
3408 This is a two step process as the symbol table doesn't even exist at
3409 the time the ld command line is processed. First we put the name
3410 on a list, then, once the output file has been opened, transfer the
3411 name to the symbol table. */
3413 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3415 #define ldlang_undef_chain_list_head entry_symbol.next
3418 ldlang_add_undef (const char *const name
, bfd_boolean cmdline
)
3420 ldlang_undef_chain_list_type
*new_undef
;
3422 undef_from_cmdline
= undef_from_cmdline
|| cmdline
;
3423 new_undef
= (ldlang_undef_chain_list_type
*) stat_alloc (sizeof (*new_undef
));
3424 new_undef
->next
= ldlang_undef_chain_list_head
;
3425 ldlang_undef_chain_list_head
= new_undef
;
3427 new_undef
->name
= xstrdup (name
);
3429 if (link_info
.output_bfd
!= NULL
)
3430 insert_undefined (new_undef
->name
);
3433 /* Insert NAME as undefined in the symbol table. */
3436 insert_undefined (const char *name
)
3438 struct bfd_link_hash_entry
*h
;
3440 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3442 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3443 if (h
->type
== bfd_link_hash_new
)
3445 h
->type
= bfd_link_hash_undefined
;
3446 h
->u
.undef
.abfd
= NULL
;
3447 bfd_link_add_undef (link_info
.hash
, h
);
3451 /* Run through the list of undefineds created above and place them
3452 into the linker hash table as undefined symbols belonging to the
3456 lang_place_undefineds (void)
3458 ldlang_undef_chain_list_type
*ptr
;
3460 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3461 insert_undefined (ptr
->name
);
3464 /* Check for all readonly or some readwrite sections. */
3467 check_input_sections
3468 (lang_statement_union_type
*s
,
3469 lang_output_section_statement_type
*output_section_statement
)
3471 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3473 switch (s
->header
.type
)
3475 case lang_wild_statement_enum
:
3476 walk_wild (&s
->wild_statement
, check_section_callback
,
3477 output_section_statement
);
3478 if (! output_section_statement
->all_input_readonly
)
3481 case lang_constructors_statement_enum
:
3482 check_input_sections (constructor_list
.head
,
3483 output_section_statement
);
3484 if (! output_section_statement
->all_input_readonly
)
3487 case lang_group_statement_enum
:
3488 check_input_sections (s
->group_statement
.children
.head
,
3489 output_section_statement
);
3490 if (! output_section_statement
->all_input_readonly
)
3499 /* Update wildcard statements if needed. */
3502 update_wild_statements (lang_statement_union_type
*s
)
3504 struct wildcard_list
*sec
;
3506 switch (sort_section
)
3516 for (; s
!= NULL
; s
= s
->header
.next
)
3518 switch (s
->header
.type
)
3523 case lang_wild_statement_enum
:
3524 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3527 switch (sec
->spec
.sorted
)
3530 sec
->spec
.sorted
= sort_section
;
3533 if (sort_section
== by_alignment
)
3534 sec
->spec
.sorted
= by_name_alignment
;
3537 if (sort_section
== by_name
)
3538 sec
->spec
.sorted
= by_alignment_name
;
3546 case lang_constructors_statement_enum
:
3547 update_wild_statements (constructor_list
.head
);
3550 case lang_output_section_statement_enum
:
3551 /* Don't sort .init/.fini sections. */
3552 if (strcmp (s
->output_section_statement
.name
, ".init") != 0
3553 && strcmp (s
->output_section_statement
.name
, ".fini") != 0)
3554 update_wild_statements
3555 (s
->output_section_statement
.children
.head
);
3558 case lang_group_statement_enum
:
3559 update_wild_statements (s
->group_statement
.children
.head
);
3567 /* Open input files and attach to output sections. */
3570 map_input_to_output_sections
3571 (lang_statement_union_type
*s
, const char *target
,
3572 lang_output_section_statement_type
*os
)
3574 for (; s
!= NULL
; s
= s
->header
.next
)
3576 lang_output_section_statement_type
*tos
;
3579 switch (s
->header
.type
)
3581 case lang_wild_statement_enum
:
3582 wild (&s
->wild_statement
, target
, os
);
3584 case lang_constructors_statement_enum
:
3585 map_input_to_output_sections (constructor_list
.head
,
3589 case lang_output_section_statement_enum
:
3590 tos
= &s
->output_section_statement
;
3591 if (tos
->constraint
!= 0)
3593 if (tos
->constraint
!= ONLY_IF_RW
3594 && tos
->constraint
!= ONLY_IF_RO
)
3596 tos
->all_input_readonly
= TRUE
;
3597 check_input_sections (tos
->children
.head
, tos
);
3598 if (tos
->all_input_readonly
!= (tos
->constraint
== ONLY_IF_RO
))
3600 tos
->constraint
= -1;
3604 map_input_to_output_sections (tos
->children
.head
,
3608 case lang_output_statement_enum
:
3610 case lang_target_statement_enum
:
3611 target
= s
->target_statement
.target
;
3613 case lang_group_statement_enum
:
3614 map_input_to_output_sections (s
->group_statement
.children
.head
,
3618 case lang_data_statement_enum
:
3619 /* Make sure that any sections mentioned in the expression
3621 exp_init_os (s
->data_statement
.exp
);
3622 /* The output section gets CONTENTS, ALLOC and LOAD, but
3623 these may be overridden by the script. */
3624 flags
= SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
;
3625 switch (os
->sectype
)
3627 case normal_section
:
3628 case overlay_section
:
3630 case noalloc_section
:
3631 flags
= SEC_HAS_CONTENTS
;
3633 case noload_section
:
3634 if (bfd_get_flavour (link_info
.output_bfd
)
3635 == bfd_target_elf_flavour
)
3636 flags
= SEC_NEVER_LOAD
| SEC_ALLOC
;
3638 flags
= SEC_NEVER_LOAD
| SEC_HAS_CONTENTS
;
3641 if (os
->bfd_section
== NULL
)
3642 init_os (os
, flags
);
3644 os
->bfd_section
->flags
|= flags
;
3646 case lang_input_section_enum
:
3648 case lang_fill_statement_enum
:
3649 case lang_object_symbols_statement_enum
:
3650 case lang_reloc_statement_enum
:
3651 case lang_padding_statement_enum
:
3652 case lang_input_statement_enum
:
3653 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3656 case lang_assignment_statement_enum
:
3657 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3660 /* Make sure that any sections mentioned in the assignment
3662 exp_init_os (s
->assignment_statement
.exp
);
3664 case lang_address_statement_enum
:
3665 /* Mark the specified section with the supplied address.
3666 If this section was actually a segment marker, then the
3667 directive is ignored if the linker script explicitly
3668 processed the segment marker. Originally, the linker
3669 treated segment directives (like -Ttext on the
3670 command-line) as section directives. We honor the
3671 section directive semantics for backwards compatibilty;
3672 linker scripts that do not specifically check for
3673 SEGMENT_START automatically get the old semantics. */
3674 if (!s
->address_statement
.segment
3675 || !s
->address_statement
.segment
->used
)
3677 const char *name
= s
->address_statement
.section_name
;
3679 /* Create the output section statement here so that
3680 orphans with a set address will be placed after other
3681 script sections. If we let the orphan placement code
3682 place them in amongst other sections then the address
3683 will affect following script sections, which is
3684 likely to surprise naive users. */
3685 tos
= lang_output_section_statement_lookup (name
, 0, TRUE
);
3686 tos
->addr_tree
= s
->address_statement
.address
;
3687 if (tos
->bfd_section
== NULL
)
3691 case lang_insert_statement_enum
:
3697 /* An insert statement snips out all the linker statements from the
3698 start of the list and places them after the output section
3699 statement specified by the insert. This operation is complicated
3700 by the fact that we keep a doubly linked list of output section
3701 statements as well as the singly linked list of all statements. */
3704 process_insert_statements (void)
3706 lang_statement_union_type
**s
;
3707 lang_output_section_statement_type
*first_os
= NULL
;
3708 lang_output_section_statement_type
*last_os
= NULL
;
3709 lang_output_section_statement_type
*os
;
3711 /* "start of list" is actually the statement immediately after
3712 the special abs_section output statement, so that it isn't
3714 s
= &lang_output_section_statement
.head
;
3715 while (*(s
= &(*s
)->header
.next
) != NULL
)
3717 if ((*s
)->header
.type
== lang_output_section_statement_enum
)
3719 /* Keep pointers to the first and last output section
3720 statement in the sequence we may be about to move. */
3721 os
= &(*s
)->output_section_statement
;
3723 ASSERT (last_os
== NULL
|| last_os
->next
== os
);
3726 /* Set constraint negative so that lang_output_section_find
3727 won't match this output section statement. At this
3728 stage in linking constraint has values in the range
3729 [-1, ONLY_IN_RW]. */
3730 last_os
->constraint
= -2 - last_os
->constraint
;
3731 if (first_os
== NULL
)
3734 else if ((*s
)->header
.type
== lang_insert_statement_enum
)
3736 lang_insert_statement_type
*i
= &(*s
)->insert_statement
;
3737 lang_output_section_statement_type
*where
;
3738 lang_statement_union_type
**ptr
;
3739 lang_statement_union_type
*first
;
3741 where
= lang_output_section_find (i
->where
);
3742 if (where
!= NULL
&& i
->is_before
)
3745 where
= where
->prev
;
3746 while (where
!= NULL
&& where
->constraint
< 0);
3750 einfo (_("%F%P: %s not found for insert\n"), i
->where
);
3754 /* Deal with reordering the output section statement list. */
3755 if (last_os
!= NULL
)
3757 asection
*first_sec
, *last_sec
;
3758 struct lang_output_section_statement_struct
**next
;
3760 /* Snip out the output sections we are moving. */
3761 first_os
->prev
->next
= last_os
->next
;
3762 if (last_os
->next
== NULL
)
3764 next
= &first_os
->prev
->next
;
3765 lang_output_section_statement
.tail
3766 = (lang_statement_union_type
**) next
;
3769 last_os
->next
->prev
= first_os
->prev
;
3770 /* Add them in at the new position. */
3771 last_os
->next
= where
->next
;
3772 if (where
->next
== NULL
)
3774 next
= &last_os
->next
;
3775 lang_output_section_statement
.tail
3776 = (lang_statement_union_type
**) next
;
3779 where
->next
->prev
= last_os
;
3780 first_os
->prev
= where
;
3781 where
->next
= first_os
;
3783 /* Move the bfd sections in the same way. */
3786 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3788 os
->constraint
= -2 - os
->constraint
;
3789 if (os
->bfd_section
!= NULL
3790 && os
->bfd_section
->owner
!= NULL
)
3792 last_sec
= os
->bfd_section
;
3793 if (first_sec
== NULL
)
3794 first_sec
= last_sec
;
3799 if (last_sec
!= NULL
)
3801 asection
*sec
= where
->bfd_section
;
3803 sec
= output_prev_sec_find (where
);
3805 /* The place we want to insert must come after the
3806 sections we are moving. So if we find no
3807 section or if the section is the same as our
3808 last section, then no move is needed. */
3809 if (sec
!= NULL
&& sec
!= last_sec
)
3811 /* Trim them off. */
3812 if (first_sec
->prev
!= NULL
)
3813 first_sec
->prev
->next
= last_sec
->next
;
3815 link_info
.output_bfd
->sections
= last_sec
->next
;
3816 if (last_sec
->next
!= NULL
)
3817 last_sec
->next
->prev
= first_sec
->prev
;
3819 link_info
.output_bfd
->section_last
= first_sec
->prev
;
3821 last_sec
->next
= sec
->next
;
3822 if (sec
->next
!= NULL
)
3823 sec
->next
->prev
= last_sec
;
3825 link_info
.output_bfd
->section_last
= last_sec
;
3826 first_sec
->prev
= sec
;
3827 sec
->next
= first_sec
;
3835 ptr
= insert_os_after (where
);
3836 /* Snip everything after the abs_section output statement we
3837 know is at the start of the list, up to and including
3838 the insert statement we are currently processing. */
3839 first
= lang_output_section_statement
.head
->header
.next
;
3840 lang_output_section_statement
.head
->header
.next
= (*s
)->header
.next
;
3841 /* Add them back where they belong. */
3844 statement_list
.tail
= s
;
3846 s
= &lang_output_section_statement
.head
;
3850 /* Undo constraint twiddling. */
3851 for (os
= first_os
; os
!= NULL
; os
= os
->next
)
3853 os
->constraint
= -2 - os
->constraint
;
3859 /* An output section might have been removed after its statement was
3860 added. For example, ldemul_before_allocation can remove dynamic
3861 sections if they turn out to be not needed. Clean them up here. */
3864 strip_excluded_output_sections (void)
3866 lang_output_section_statement_type
*os
;
3868 /* Run lang_size_sections (if not already done). */
3869 if (expld
.phase
!= lang_mark_phase_enum
)
3871 expld
.phase
= lang_mark_phase_enum
;
3872 expld
.dataseg
.phase
= exp_dataseg_none
;
3873 one_lang_size_sections_pass (NULL
, FALSE
);
3874 lang_reset_memory_regions ();
3877 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3881 asection
*output_section
;
3882 bfd_boolean exclude
;
3884 if (os
->constraint
< 0)
3887 output_section
= os
->bfd_section
;
3888 if (output_section
== NULL
)
3891 exclude
= (output_section
->rawsize
== 0
3892 && (output_section
->flags
& SEC_KEEP
) == 0
3893 && !bfd_section_removed_from_list (link_info
.output_bfd
,
3896 /* Some sections have not yet been sized, notably .gnu.version,
3897 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3898 input sections, so don't drop output sections that have such
3899 input sections unless they are also marked SEC_EXCLUDE. */
3900 if (exclude
&& output_section
->map_head
.s
!= NULL
)
3904 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
3905 if ((s
->flags
& SEC_EXCLUDE
) == 0
3906 && ((s
->flags
& SEC_LINKER_CREATED
) != 0
3907 || link_info
.emitrelocations
))
3916 /* We don't set bfd_section to NULL since bfd_section of the
3917 removed output section statement may still be used. */
3918 if (!os
->update_dot
)
3920 output_section
->flags
|= SEC_EXCLUDE
;
3921 bfd_section_list_remove (link_info
.output_bfd
, output_section
);
3922 link_info
.output_bfd
->section_count
--;
3927 /* Called from ldwrite to clear out asection.map_head and
3928 asection.map_tail for use as link_orders in ldwrite.
3929 FIXME: Except for sh64elf.em which starts creating link_orders in
3930 its after_allocation routine so needs to call it early. */
3933 lang_clear_os_map (void)
3935 lang_output_section_statement_type
*os
;
3937 if (map_head_is_link_order
)
3940 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3944 asection
*output_section
;
3946 if (os
->constraint
< 0)
3949 output_section
= os
->bfd_section
;
3950 if (output_section
== NULL
)
3953 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3954 output_section
->map_head
.link_order
= NULL
;
3955 output_section
->map_tail
.link_order
= NULL
;
3958 /* Stop future calls to lang_add_section from messing with map_head
3959 and map_tail link_order fields. */
3960 map_head_is_link_order
= TRUE
;
3964 print_output_section_statement
3965 (lang_output_section_statement_type
*output_section_statement
)
3967 asection
*section
= output_section_statement
->bfd_section
;
3970 if (output_section_statement
!= abs_output_section
)
3972 minfo ("\n%s", output_section_statement
->name
);
3974 if (section
!= NULL
)
3976 print_dot
= section
->vma
;
3978 len
= strlen (output_section_statement
->name
);
3979 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3984 while (len
< SECTION_NAME_MAP_LENGTH
)
3990 minfo ("0x%V %W", section
->vma
, section
->size
);
3992 if (section
->vma
!= section
->lma
)
3993 minfo (_(" load address 0x%V"), section
->lma
);
3995 if (output_section_statement
->update_dot_tree
!= NULL
)
3996 exp_fold_tree (output_section_statement
->update_dot_tree
,
3997 bfd_abs_section_ptr
, &print_dot
);
4003 print_statement_list (output_section_statement
->children
.head
,
4004 output_section_statement
);
4008 print_assignment (lang_assignment_statement_type
*assignment
,
4009 lang_output_section_statement_type
*output_section
)
4016 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4019 if (assignment
->exp
->type
.node_class
== etree_assert
)
4022 tree
= assignment
->exp
->assert_s
.child
;
4026 const char *dst
= assignment
->exp
->assign
.dst
;
4028 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
4030 expld
.assign_name
= dst
;
4031 tree
= assignment
->exp
->assign
.src
;
4034 osec
= output_section
->bfd_section
;
4036 osec
= bfd_abs_section_ptr
;
4037 exp_fold_tree (tree
, osec
, &print_dot
);
4038 if (expld
.result
.valid_p
)
4042 if (assignment
->exp
->type
.node_class
== etree_assert
4044 || expld
.assign_name
!= NULL
)
4046 value
= expld
.result
.value
;
4048 if (expld
.result
.section
!= NULL
)
4049 value
+= expld
.result
.section
->vma
;
4051 minfo ("0x%V", value
);
4057 struct bfd_link_hash_entry
*h
;
4059 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
4060 FALSE
, FALSE
, TRUE
);
4063 value
= h
->u
.def
.value
;
4064 value
+= h
->u
.def
.section
->output_section
->vma
;
4065 value
+= h
->u
.def
.section
->output_offset
;
4067 minfo ("[0x%V]", value
);
4070 minfo ("[unresolved]");
4080 expld
.assign_name
= NULL
;
4083 exp_print_tree (assignment
->exp
);
4088 print_input_statement (lang_input_statement_type
*statm
)
4090 if (statm
->filename
!= NULL
4091 && (statm
->the_bfd
== NULL
4092 || (statm
->the_bfd
->flags
& BFD_LINKER_CREATED
) == 0))
4093 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
4096 /* Print all symbols defined in a particular section. This is called
4097 via bfd_link_hash_traverse, or by print_all_symbols. */
4100 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
4102 asection
*sec
= (asection
*) ptr
;
4104 if ((hash_entry
->type
== bfd_link_hash_defined
4105 || hash_entry
->type
== bfd_link_hash_defweak
)
4106 && sec
== hash_entry
->u
.def
.section
)
4110 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4113 (hash_entry
->u
.def
.value
4114 + hash_entry
->u
.def
.section
->output_offset
4115 + hash_entry
->u
.def
.section
->output_section
->vma
));
4117 minfo (" %T\n", hash_entry
->root
.string
);
4124 hash_entry_addr_cmp (const void *a
, const void *b
)
4126 const struct bfd_link_hash_entry
*l
= *(const struct bfd_link_hash_entry
**)a
;
4127 const struct bfd_link_hash_entry
*r
= *(const struct bfd_link_hash_entry
**)b
;
4129 if (l
->u
.def
.value
< r
->u
.def
.value
)
4131 else if (l
->u
.def
.value
> r
->u
.def
.value
)
4138 print_all_symbols (asection
*sec
)
4140 input_section_userdata_type
*ud
4141 = (input_section_userdata_type
*) get_userdata (sec
);
4142 struct map_symbol_def
*def
;
4143 struct bfd_link_hash_entry
**entries
;
4149 *ud
->map_symbol_def_tail
= 0;
4151 /* Sort the symbols by address. */
4152 entries
= (struct bfd_link_hash_entry
**)
4153 obstack_alloc (&map_obstack
, ud
->map_symbol_def_count
* sizeof (*entries
));
4155 for (i
= 0, def
= ud
->map_symbol_def_head
; def
; def
= def
->next
, i
++)
4156 entries
[i
] = def
->entry
;
4158 qsort (entries
, ud
->map_symbol_def_count
, sizeof (*entries
),
4159 hash_entry_addr_cmp
);
4161 /* Print the symbols. */
4162 for (i
= 0; i
< ud
->map_symbol_def_count
; i
++)
4163 print_one_symbol (entries
[i
], sec
);
4165 obstack_free (&map_obstack
, entries
);
4168 /* Print information about an input section to the map file. */
4171 print_input_section (asection
*i
, bfd_boolean is_discarded
)
4173 bfd_size_type size
= i
->size
;
4180 minfo ("%s", i
->name
);
4182 len
= 1 + strlen (i
->name
);
4183 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
4188 while (len
< SECTION_NAME_MAP_LENGTH
)
4194 if (i
->output_section
!= NULL
4195 && i
->output_section
->owner
== link_info
.output_bfd
)
4196 addr
= i
->output_section
->vma
+ i
->output_offset
;
4204 minfo ("0x%V %W %B\n", addr
, TO_ADDR (size
), i
->owner
);
4206 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
4208 len
= SECTION_NAME_MAP_LENGTH
+ 3;
4220 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
4223 if (i
->output_section
!= NULL
4224 && i
->output_section
->owner
== link_info
.output_bfd
)
4226 if (link_info
.reduce_memory_overheads
)
4227 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
4229 print_all_symbols (i
);
4231 /* Update print_dot, but make sure that we do not move it
4232 backwards - this could happen if we have overlays and a
4233 later overlay is shorter than an earier one. */
4234 if (addr
+ TO_ADDR (size
) > print_dot
)
4235 print_dot
= addr
+ TO_ADDR (size
);
4240 print_fill_statement (lang_fill_statement_type
*fill
)
4244 fputs (" FILL mask 0x", config
.map_file
);
4245 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
4246 fprintf (config
.map_file
, "%02x", *p
);
4247 fputs ("\n", config
.map_file
);
4251 print_data_statement (lang_data_statement_type
*data
)
4259 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4262 addr
= data
->output_offset
;
4263 if (data
->output_section
!= NULL
)
4264 addr
+= data
->output_section
->vma
;
4292 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
4294 if (data
->exp
->type
.node_class
!= etree_value
)
4297 exp_print_tree (data
->exp
);
4302 print_dot
= addr
+ TO_ADDR (size
);
4305 /* Print an address statement. These are generated by options like
4309 print_address_statement (lang_address_statement_type
*address
)
4311 minfo (_("Address of section %s set to "), address
->section_name
);
4312 exp_print_tree (address
->address
);
4316 /* Print a reloc statement. */
4319 print_reloc_statement (lang_reloc_statement_type
*reloc
)
4326 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
4329 addr
= reloc
->output_offset
;
4330 if (reloc
->output_section
!= NULL
)
4331 addr
+= reloc
->output_section
->vma
;
4333 size
= bfd_get_reloc_size (reloc
->howto
);
4335 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
4337 if (reloc
->name
!= NULL
)
4338 minfo ("%s+", reloc
->name
);
4340 minfo ("%s+", reloc
->section
->name
);
4342 exp_print_tree (reloc
->addend_exp
);
4346 print_dot
= addr
+ TO_ADDR (size
);
4350 print_padding_statement (lang_padding_statement_type
*s
)
4358 len
= sizeof " *fill*" - 1;
4359 while (len
< SECTION_NAME_MAP_LENGTH
)
4365 addr
= s
->output_offset
;
4366 if (s
->output_section
!= NULL
)
4367 addr
+= s
->output_section
->vma
;
4368 minfo ("0x%V %W ", addr
, (bfd_vma
) s
->size
);
4370 if (s
->fill
->size
!= 0)
4374 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
4375 fprintf (config
.map_file
, "%02x", *p
);
4380 print_dot
= addr
+ TO_ADDR (s
->size
);
4384 print_wild_statement (lang_wild_statement_type
*w
,
4385 lang_output_section_statement_type
*os
)
4387 struct wildcard_list
*sec
;
4391 if (w
->filenames_sorted
)
4393 if (w
->filename
!= NULL
)
4394 minfo ("%s", w
->filename
);
4397 if (w
->filenames_sorted
)
4401 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
4403 if (sec
->spec
.sorted
)
4405 if (sec
->spec
.exclude_name_list
!= NULL
)
4408 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
4409 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
4410 minfo (" %s", tmp
->name
);
4413 if (sec
->spec
.name
!= NULL
)
4414 minfo ("%s", sec
->spec
.name
);
4417 if (sec
->spec
.sorted
)
4426 print_statement_list (w
->children
.head
, os
);
4429 /* Print a group statement. */
4432 print_group (lang_group_statement_type
*s
,
4433 lang_output_section_statement_type
*os
)
4435 fprintf (config
.map_file
, "START GROUP\n");
4436 print_statement_list (s
->children
.head
, os
);
4437 fprintf (config
.map_file
, "END GROUP\n");
4440 /* Print the list of statements in S.
4441 This can be called for any statement type. */
4444 print_statement_list (lang_statement_union_type
*s
,
4445 lang_output_section_statement_type
*os
)
4449 print_statement (s
, os
);
4454 /* Print the first statement in statement list S.
4455 This can be called for any statement type. */
4458 print_statement (lang_statement_union_type
*s
,
4459 lang_output_section_statement_type
*os
)
4461 switch (s
->header
.type
)
4464 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
4467 case lang_constructors_statement_enum
:
4468 if (constructor_list
.head
!= NULL
)
4470 if (constructors_sorted
)
4471 minfo (" SORT (CONSTRUCTORS)\n");
4473 minfo (" CONSTRUCTORS\n");
4474 print_statement_list (constructor_list
.head
, os
);
4477 case lang_wild_statement_enum
:
4478 print_wild_statement (&s
->wild_statement
, os
);
4480 case lang_address_statement_enum
:
4481 print_address_statement (&s
->address_statement
);
4483 case lang_object_symbols_statement_enum
:
4484 minfo (" CREATE_OBJECT_SYMBOLS\n");
4486 case lang_fill_statement_enum
:
4487 print_fill_statement (&s
->fill_statement
);
4489 case lang_data_statement_enum
:
4490 print_data_statement (&s
->data_statement
);
4492 case lang_reloc_statement_enum
:
4493 print_reloc_statement (&s
->reloc_statement
);
4495 case lang_input_section_enum
:
4496 print_input_section (s
->input_section
.section
, FALSE
);
4498 case lang_padding_statement_enum
:
4499 print_padding_statement (&s
->padding_statement
);
4501 case lang_output_section_statement_enum
:
4502 print_output_section_statement (&s
->output_section_statement
);
4504 case lang_assignment_statement_enum
:
4505 print_assignment (&s
->assignment_statement
, os
);
4507 case lang_target_statement_enum
:
4508 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
4510 case lang_output_statement_enum
:
4511 minfo ("OUTPUT(%s", s
->output_statement
.name
);
4512 if (output_target
!= NULL
)
4513 minfo (" %s", output_target
);
4516 case lang_input_statement_enum
:
4517 print_input_statement (&s
->input_statement
);
4519 case lang_group_statement_enum
:
4520 print_group (&s
->group_statement
, os
);
4522 case lang_insert_statement_enum
:
4523 minfo ("INSERT %s %s\n",
4524 s
->insert_statement
.is_before
? "BEFORE" : "AFTER",
4525 s
->insert_statement
.where
);
4531 print_statements (void)
4533 print_statement_list (statement_list
.head
, abs_output_section
);
4536 /* Print the first N statements in statement list S to STDERR.
4537 If N == 0, nothing is printed.
4538 If N < 0, the entire list is printed.
4539 Intended to be called from GDB. */
4542 dprint_statement (lang_statement_union_type
*s
, int n
)
4544 FILE *map_save
= config
.map_file
;
4546 config
.map_file
= stderr
;
4549 print_statement_list (s
, abs_output_section
);
4552 while (s
&& --n
>= 0)
4554 print_statement (s
, abs_output_section
);
4559 config
.map_file
= map_save
;
4563 insert_pad (lang_statement_union_type
**ptr
,
4565 bfd_size_type alignment_needed
,
4566 asection
*output_section
,
4569 static fill_type zero_fill
;
4570 lang_statement_union_type
*pad
= NULL
;
4572 if (ptr
!= &statement_list
.head
)
4573 pad
= ((lang_statement_union_type
*)
4574 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4576 && pad
->header
.type
== lang_padding_statement_enum
4577 && pad
->padding_statement
.output_section
== output_section
)
4579 /* Use the existing pad statement. */
4581 else if ((pad
= *ptr
) != NULL
4582 && pad
->header
.type
== lang_padding_statement_enum
4583 && pad
->padding_statement
.output_section
== output_section
)
4585 /* Use the existing pad statement. */
4589 /* Make a new padding statement, linked into existing chain. */
4590 pad
= (lang_statement_union_type
*)
4591 stat_alloc (sizeof (lang_padding_statement_type
));
4592 pad
->header
.next
= *ptr
;
4594 pad
->header
.type
= lang_padding_statement_enum
;
4595 pad
->padding_statement
.output_section
= output_section
;
4598 pad
->padding_statement
.fill
= fill
;
4600 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4601 pad
->padding_statement
.size
= alignment_needed
;
4602 output_section
->size
= TO_SIZE (dot
+ TO_ADDR (alignment_needed
)
4603 - output_section
->vma
);
4606 /* Work out how much this section will move the dot point. */
4610 (lang_statement_union_type
**this_ptr
,
4611 lang_output_section_statement_type
*output_section_statement
,
4615 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4616 asection
*i
= is
->section
;
4617 asection
*o
= output_section_statement
->bfd_section
;
4619 if (i
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4620 i
->output_offset
= i
->vma
- o
->vma
;
4621 else if ((i
->flags
& SEC_EXCLUDE
) != 0)
4622 i
->output_offset
= dot
- o
->vma
;
4625 bfd_size_type alignment_needed
;
4627 /* Align this section first to the input sections requirement,
4628 then to the output section's requirement. If this alignment
4629 is greater than any seen before, then record it too. Perform
4630 the alignment by inserting a magic 'padding' statement. */
4632 if (output_section_statement
->subsection_alignment
!= -1)
4633 i
->alignment_power
= output_section_statement
->subsection_alignment
;
4635 if (o
->alignment_power
< i
->alignment_power
)
4636 o
->alignment_power
= i
->alignment_power
;
4638 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4640 if (alignment_needed
!= 0)
4642 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4643 dot
+= alignment_needed
;
4646 /* Remember where in the output section this input section goes. */
4647 i
->output_offset
= dot
- o
->vma
;
4649 /* Mark how big the output section must be to contain this now. */
4650 dot
+= TO_ADDR (i
->size
);
4651 o
->size
= TO_SIZE (dot
- o
->vma
);
4658 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4660 const asection
*sec1
= *(const asection
**) arg1
;
4661 const asection
*sec2
= *(const asection
**) arg2
;
4663 if (bfd_section_lma (sec1
->owner
, sec1
)
4664 < bfd_section_lma (sec2
->owner
, sec2
))
4666 else if (bfd_section_lma (sec1
->owner
, sec1
)
4667 > bfd_section_lma (sec2
->owner
, sec2
))
4669 else if (sec1
->id
< sec2
->id
)
4671 else if (sec1
->id
> sec2
->id
)
4677 #define IGNORE_SECTION(s) \
4678 ((s->flags & SEC_ALLOC) == 0 \
4679 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4680 && (s->flags & SEC_LOAD) == 0))
4682 /* Check to see if any allocated sections overlap with other allocated
4683 sections. This can happen if a linker script specifies the output
4684 section addresses of the two sections. Also check whether any memory
4685 region has overflowed. */
4688 lang_check_section_addresses (void)
4691 asection
**sections
, **spp
;
4698 lang_memory_region_type
*m
;
4700 if (bfd_count_sections (link_info
.output_bfd
) <= 1)
4703 amt
= bfd_count_sections (link_info
.output_bfd
) * sizeof (asection
*);
4704 sections
= (asection
**) xmalloc (amt
);
4706 /* Scan all sections in the output list. */
4708 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4710 /* Only consider loadable sections with real contents. */
4711 if (!(s
->flags
& SEC_LOAD
)
4712 || !(s
->flags
& SEC_ALLOC
)
4716 sections
[count
] = s
;
4723 qsort (sections
, (size_t) count
, sizeof (asection
*),
4724 sort_sections_by_lma
);
4729 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4730 for (count
--; count
; count
--)
4732 /* We must check the sections' LMA addresses not their VMA
4733 addresses because overlay sections can have overlapping VMAs
4734 but they must have distinct LMAs. */
4740 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4742 /* Look for an overlap. We have sorted sections by lma, so we
4743 know that s_start >= p_start. Besides the obvious case of
4744 overlap when the current section starts before the previous
4745 one ends, we also must have overlap if the previous section
4746 wraps around the address space. */
4747 if (s_start
<= p_end
4749 einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),
4750 s
->name
, s_start
, s_end
, p
->name
, p_start
, p_end
);
4755 /* If any memory region has overflowed, report by how much.
4756 We do not issue this diagnostic for regions that had sections
4757 explicitly placed outside their bounds; os_region_check's
4758 diagnostics are adequate for that case.
4760 FIXME: It is conceivable that m->current - (m->origin + m->length)
4761 might overflow a 32-bit integer. There is, alas, no way to print
4762 a bfd_vma quantity in decimal. */
4763 for (m
= lang_memory_region_list
; m
; m
= m
->next
)
4764 if (m
->had_full_message
)
4765 einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4766 m
->name_list
.name
, (long)(m
->current
- (m
->origin
+ m
->length
)));
4770 /* Make sure the new address is within the region. We explicitly permit the
4771 current address to be at the exact end of the region when the address is
4772 non-zero, in case the region is at the end of addressable memory and the
4773 calculation wraps around. */
4776 os_region_check (lang_output_section_statement_type
*os
,
4777 lang_memory_region_type
*region
,
4781 if ((region
->current
< region
->origin
4782 || (region
->current
- region
->origin
> region
->length
))
4783 && ((region
->current
!= region
->origin
+ region
->length
)
4788 einfo (_("%X%P: address 0x%v of %B section `%s'"
4789 " is not within region `%s'\n"),
4791 os
->bfd_section
->owner
,
4792 os
->bfd_section
->name
,
4793 region
->name_list
.name
);
4795 else if (!region
->had_full_message
)
4797 region
->had_full_message
= TRUE
;
4799 einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4800 os
->bfd_section
->owner
,
4801 os
->bfd_section
->name
,
4802 region
->name_list
.name
);
4807 /* Set the sizes for all the output sections. */
4810 lang_size_sections_1
4811 (lang_statement_union_type
**prev
,
4812 lang_output_section_statement_type
*output_section_statement
,
4816 bfd_boolean check_regions
)
4818 lang_statement_union_type
*s
;
4820 /* Size up the sections from their constituent parts. */
4821 for (s
= *prev
; s
!= NULL
; s
= s
->header
.next
)
4823 switch (s
->header
.type
)
4825 case lang_output_section_statement_enum
:
4827 bfd_vma newdot
, after
, dotdelta
;
4828 lang_output_section_statement_type
*os
;
4829 lang_memory_region_type
*r
;
4830 int section_alignment
= 0;
4832 os
= &s
->output_section_statement
;
4833 if (os
->constraint
== -1)
4836 /* FIXME: We shouldn't need to zero section vmas for ld -r
4837 here, in lang_insert_orphan, or in the default linker scripts.
4838 This is covering for coff backend linker bugs. See PR6945. */
4839 if (os
->addr_tree
== NULL
4840 && link_info
.relocatable
4841 && (bfd_get_flavour (link_info
.output_bfd
)
4842 == bfd_target_coff_flavour
))
4843 os
->addr_tree
= exp_intop (0);
4844 if (os
->addr_tree
!= NULL
)
4846 os
->processed_vma
= FALSE
;
4847 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
4849 if (expld
.result
.valid_p
)
4851 dot
= expld
.result
.value
;
4852 if (expld
.result
.section
!= NULL
)
4853 dot
+= expld
.result
.section
->vma
;
4855 else if (expld
.phase
!= lang_mark_phase_enum
)
4856 einfo (_("%F%S: non constant or forward reference"
4857 " address expression for section %s\n"),
4858 os
->addr_tree
, os
->name
);
4861 if (os
->bfd_section
== NULL
)
4862 /* This section was removed or never actually created. */
4865 /* If this is a COFF shared library section, use the size and
4866 address from the input section. FIXME: This is COFF
4867 specific; it would be cleaner if there were some other way
4868 to do this, but nothing simple comes to mind. */
4869 if (((bfd_get_flavour (link_info
.output_bfd
)
4870 == bfd_target_ecoff_flavour
)
4871 || (bfd_get_flavour (link_info
.output_bfd
)
4872 == bfd_target_coff_flavour
))
4873 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
4877 if (os
->children
.head
== NULL
4878 || os
->children
.head
->header
.next
!= NULL
4879 || (os
->children
.head
->header
.type
4880 != lang_input_section_enum
))
4881 einfo (_("%P%X: Internal error on COFF shared library"
4882 " section %s\n"), os
->name
);
4884 input
= os
->children
.head
->input_section
.section
;
4885 bfd_set_section_vma (os
->bfd_section
->owner
,
4887 bfd_section_vma (input
->owner
, input
));
4888 os
->bfd_section
->size
= input
->size
;
4894 if (bfd_is_abs_section (os
->bfd_section
))
4896 /* No matter what happens, an abs section starts at zero. */
4897 ASSERT (os
->bfd_section
->vma
== 0);
4901 if (os
->addr_tree
== NULL
)
4903 /* No address specified for this section, get one
4904 from the region specification. */
4905 if (os
->region
== NULL
4906 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
4907 && os
->region
->name_list
.name
[0] == '*'
4908 && strcmp (os
->region
->name_list
.name
,
4909 DEFAULT_MEMORY_REGION
) == 0))
4911 os
->region
= lang_memory_default (os
->bfd_section
);
4914 /* If a loadable section is using the default memory
4915 region, and some non default memory regions were
4916 defined, issue an error message. */
4918 && !IGNORE_SECTION (os
->bfd_section
)
4919 && ! link_info
.relocatable
4921 && strcmp (os
->region
->name_list
.name
,
4922 DEFAULT_MEMORY_REGION
) == 0
4923 && lang_memory_region_list
!= NULL
4924 && (strcmp (lang_memory_region_list
->name_list
.name
,
4925 DEFAULT_MEMORY_REGION
) != 0
4926 || lang_memory_region_list
->next
!= NULL
)
4927 && expld
.phase
!= lang_mark_phase_enum
)
4929 /* By default this is an error rather than just a
4930 warning because if we allocate the section to the
4931 default memory region we can end up creating an
4932 excessively large binary, or even seg faulting when
4933 attempting to perform a negative seek. See
4934 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4935 for an example of this. This behaviour can be
4936 overridden by the using the --no-check-sections
4938 if (command_line
.check_section_addresses
)
4939 einfo (_("%P%F: error: no memory region specified"
4940 " for loadable section `%s'\n"),
4941 bfd_get_section_name (link_info
.output_bfd
,
4944 einfo (_("%P: warning: no memory region specified"
4945 " for loadable section `%s'\n"),
4946 bfd_get_section_name (link_info
.output_bfd
,
4950 newdot
= os
->region
->current
;
4951 section_alignment
= os
->bfd_section
->alignment_power
;
4954 section_alignment
= os
->section_alignment
;
4956 /* Align to what the section needs. */
4957 if (section_alignment
> 0)
4959 bfd_vma savedot
= newdot
;
4960 newdot
= align_power (newdot
, section_alignment
);
4962 dotdelta
= newdot
- savedot
;
4964 && (config
.warn_section_align
4965 || os
->addr_tree
!= NULL
)
4966 && expld
.phase
!= lang_mark_phase_enum
)
4967 einfo (_("%P: warning: changing start of section"
4968 " %s by %lu bytes\n"),
4969 os
->name
, (unsigned long) dotdelta
);
4972 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
4974 os
->bfd_section
->output_offset
= 0;
4977 lang_size_sections_1 (&os
->children
.head
, os
,
4978 os
->fill
, newdot
, relax
, check_regions
);
4980 os
->processed_vma
= TRUE
;
4982 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
4983 /* Except for some special linker created sections,
4984 no output section should change from zero size
4985 after strip_excluded_output_sections. A non-zero
4986 size on an ignored section indicates that some
4987 input section was not sized early enough. */
4988 ASSERT (os
->bfd_section
->size
== 0);
4991 dot
= os
->bfd_section
->vma
;
4993 /* Put the section within the requested block size, or
4994 align at the block boundary. */
4996 + TO_ADDR (os
->bfd_section
->size
)
4997 + os
->block_value
- 1)
4998 & - (bfd_vma
) os
->block_value
);
5000 os
->bfd_section
->size
= TO_SIZE (after
- os
->bfd_section
->vma
);
5003 /* Set section lma. */
5006 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
5010 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
5011 os
->bfd_section
->lma
= lma
;
5013 else if (os
->lma_region
!= NULL
)
5015 bfd_vma lma
= os
->lma_region
->current
;
5017 if (os
->align_lma_with_input
)
5021 /* When LMA_REGION is the same as REGION, align the LMA
5022 as we did for the VMA, possibly including alignment
5023 from the bfd section. If a different region, then
5024 only align according to the value in the output
5026 if (os
->lma_region
!= os
->region
)
5027 section_alignment
= os
->section_alignment
;
5028 if (section_alignment
> 0)
5029 lma
= align_power (lma
, section_alignment
);
5031 os
->bfd_section
->lma
= lma
;
5033 else if (r
->last_os
!= NULL
5034 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5039 last
= r
->last_os
->output_section_statement
.bfd_section
;
5041 /* A backwards move of dot should be accompanied by
5042 an explicit assignment to the section LMA (ie.
5043 os->load_base set) because backwards moves can
5044 create overlapping LMAs. */
5046 && os
->bfd_section
->size
!= 0
5047 && dot
+ os
->bfd_section
->size
<= last
->vma
)
5049 /* If dot moved backwards then leave lma equal to
5050 vma. This is the old default lma, which might
5051 just happen to work when the backwards move is
5052 sufficiently large. Nag if this changes anything,
5053 so people can fix their linker scripts. */
5055 if (last
->vma
!= last
->lma
)
5056 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
5061 /* If this is an overlay, set the current lma to that
5062 at the end of the previous section. */
5063 if (os
->sectype
== overlay_section
)
5064 lma
= last
->lma
+ last
->size
;
5066 /* Otherwise, keep the same lma to vma relationship
5067 as the previous section. */
5069 lma
= dot
+ last
->lma
- last
->vma
;
5071 if (section_alignment
> 0)
5072 lma
= align_power (lma
, section_alignment
);
5073 os
->bfd_section
->lma
= lma
;
5076 os
->processed_lma
= TRUE
;
5078 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
5081 /* Keep track of normal sections using the default
5082 lma region. We use this to set the lma for
5083 following sections. Overlays or other linker
5084 script assignment to lma might mean that the
5085 default lma == vma is incorrect.
5086 To avoid warnings about dot moving backwards when using
5087 -Ttext, don't start tracking sections until we find one
5088 of non-zero size or with lma set differently to vma. */
5089 if (((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5090 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0)
5091 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0
5092 && (os
->bfd_section
->size
!= 0
5093 || (r
->last_os
== NULL
5094 && os
->bfd_section
->vma
!= os
->bfd_section
->lma
)
5095 || (r
->last_os
!= NULL
5096 && dot
>= (r
->last_os
->output_section_statement
5097 .bfd_section
->vma
)))
5098 && os
->lma_region
== NULL
5099 && !link_info
.relocatable
)
5102 /* .tbss sections effectively have zero size. */
5103 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5104 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
5105 || link_info
.relocatable
)
5106 dotdelta
= TO_ADDR (os
->bfd_section
->size
);
5111 if (os
->update_dot_tree
!= 0)
5112 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5114 /* Update dot in the region ?
5115 We only do this if the section is going to be allocated,
5116 since unallocated sections do not contribute to the region's
5117 overall size in memory. */
5118 if (os
->region
!= NULL
5119 && (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
)))
5121 os
->region
->current
= dot
;
5124 /* Make sure the new address is within the region. */
5125 os_region_check (os
, os
->region
, os
->addr_tree
,
5126 os
->bfd_section
->vma
);
5128 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
5129 && ((os
->bfd_section
->flags
& SEC_LOAD
)
5130 || os
->align_lma_with_input
))
5132 os
->lma_region
->current
= os
->bfd_section
->lma
+ dotdelta
;
5135 os_region_check (os
, os
->lma_region
, NULL
,
5136 os
->bfd_section
->lma
);
5142 case lang_constructors_statement_enum
:
5143 dot
= lang_size_sections_1 (&constructor_list
.head
,
5144 output_section_statement
,
5145 fill
, dot
, relax
, check_regions
);
5148 case lang_data_statement_enum
:
5150 unsigned int size
= 0;
5152 s
->data_statement
.output_offset
=
5153 dot
- output_section_statement
->bfd_section
->vma
;
5154 s
->data_statement
.output_section
=
5155 output_section_statement
->bfd_section
;
5157 /* We might refer to provided symbols in the expression, and
5158 need to mark them as needed. */
5159 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5161 switch (s
->data_statement
.type
)
5179 if (size
< TO_SIZE ((unsigned) 1))
5180 size
= TO_SIZE ((unsigned) 1);
5181 dot
+= TO_ADDR (size
);
5182 output_section_statement
->bfd_section
->size
5183 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5188 case lang_reloc_statement_enum
:
5192 s
->reloc_statement
.output_offset
=
5193 dot
- output_section_statement
->bfd_section
->vma
;
5194 s
->reloc_statement
.output_section
=
5195 output_section_statement
->bfd_section
;
5196 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
5197 dot
+= TO_ADDR (size
);
5198 output_section_statement
->bfd_section
->size
5199 = TO_SIZE (dot
- output_section_statement
->bfd_section
->vma
);
5203 case lang_wild_statement_enum
:
5204 dot
= lang_size_sections_1 (&s
->wild_statement
.children
.head
,
5205 output_section_statement
,
5206 fill
, dot
, relax
, check_regions
);
5209 case lang_object_symbols_statement_enum
:
5210 link_info
.create_object_symbols_section
=
5211 output_section_statement
->bfd_section
;
5214 case lang_output_statement_enum
:
5215 case lang_target_statement_enum
:
5218 case lang_input_section_enum
:
5222 i
= s
->input_section
.section
;
5227 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
5228 einfo (_("%P%F: can't relax section: %E\n"));
5232 dot
= size_input_section (prev
, output_section_statement
,
5237 case lang_input_statement_enum
:
5240 case lang_fill_statement_enum
:
5241 s
->fill_statement
.output_section
=
5242 output_section_statement
->bfd_section
;
5244 fill
= s
->fill_statement
.fill
;
5247 case lang_assignment_statement_enum
:
5249 bfd_vma newdot
= dot
;
5250 etree_type
*tree
= s
->assignment_statement
.exp
;
5252 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5254 exp_fold_tree (tree
,
5255 output_section_statement
->bfd_section
,
5258 if (expld
.dataseg
.relro
== exp_dataseg_relro_start
)
5260 if (!expld
.dataseg
.relro_start_stat
)
5261 expld
.dataseg
.relro_start_stat
= s
;
5264 ASSERT (expld
.dataseg
.relro_start_stat
== s
);
5267 else if (expld
.dataseg
.relro
== exp_dataseg_relro_end
)
5269 if (!expld
.dataseg
.relro_end_stat
)
5270 expld
.dataseg
.relro_end_stat
= s
;
5273 ASSERT (expld
.dataseg
.relro_end_stat
== s
);
5276 expld
.dataseg
.relro
= exp_dataseg_relro_none
;
5278 /* This symbol may be relative to this section. */
5279 if ((tree
->type
.node_class
== etree_provided
5280 || tree
->type
.node_class
== etree_assign
)
5281 && (tree
->assign
.dst
[0] != '.'
5282 || tree
->assign
.dst
[1] != '\0'))
5283 output_section_statement
->update_dot
= 1;
5285 if (!output_section_statement
->ignored
)
5287 if (output_section_statement
== abs_output_section
)
5289 /* If we don't have an output section, then just adjust
5290 the default memory address. */
5291 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
5292 FALSE
)->current
= newdot
;
5294 else if (newdot
!= dot
)
5296 /* Insert a pad after this statement. We can't
5297 put the pad before when relaxing, in case the
5298 assignment references dot. */
5299 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
5300 output_section_statement
->bfd_section
, dot
);
5302 /* Don't neuter the pad below when relaxing. */
5305 /* If dot is advanced, this implies that the section
5306 should have space allocated to it, unless the
5307 user has explicitly stated that the section
5308 should not be allocated. */
5309 if (output_section_statement
->sectype
!= noalloc_section
5310 && (output_section_statement
->sectype
!= noload_section
5311 || (bfd_get_flavour (link_info
.output_bfd
)
5312 == bfd_target_elf_flavour
)))
5313 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
5320 case lang_padding_statement_enum
:
5321 /* If this is the first time lang_size_sections is called,
5322 we won't have any padding statements. If this is the
5323 second or later passes when relaxing, we should allow
5324 padding to shrink. If padding is needed on this pass, it
5325 will be added back in. */
5326 s
->padding_statement
.size
= 0;
5328 /* Make sure output_offset is valid. If relaxation shrinks
5329 the section and this pad isn't needed, it's possible to
5330 have output_offset larger than the final size of the
5331 section. bfd_set_section_contents will complain even for
5332 a pad size of zero. */
5333 s
->padding_statement
.output_offset
5334 = dot
- output_section_statement
->bfd_section
->vma
;
5337 case lang_group_statement_enum
:
5338 dot
= lang_size_sections_1 (&s
->group_statement
.children
.head
,
5339 output_section_statement
,
5340 fill
, dot
, relax
, check_regions
);
5343 case lang_insert_statement_enum
:
5346 /* We can only get here when relaxing is turned on. */
5347 case lang_address_statement_enum
:
5354 prev
= &s
->header
.next
;
5359 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5360 The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5361 CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5362 segments. We are allowed an opportunity to override this decision. */
5365 ldlang_override_segment_assignment (struct bfd_link_info
* info ATTRIBUTE_UNUSED
,
5366 bfd
* abfd ATTRIBUTE_UNUSED
,
5367 asection
* current_section
,
5368 asection
* previous_section
,
5369 bfd_boolean new_segment
)
5371 lang_output_section_statement_type
* cur
;
5372 lang_output_section_statement_type
* prev
;
5374 /* The checks below are only necessary when the BFD library has decided
5375 that the two sections ought to be placed into the same segment. */
5379 /* Paranoia checks. */
5380 if (current_section
== NULL
|| previous_section
== NULL
)
5383 /* If this flag is set, the target never wants code and non-code
5384 sections comingled in the same segment. */
5385 if (config
.separate_code
5386 && ((current_section
->flags
^ previous_section
->flags
) & SEC_CODE
))
5389 /* Find the memory regions associated with the two sections.
5390 We call lang_output_section_find() here rather than scanning the list
5391 of output sections looking for a matching section pointer because if
5392 we have a large number of sections then a hash lookup is faster. */
5393 cur
= lang_output_section_find (current_section
->name
);
5394 prev
= lang_output_section_find (previous_section
->name
);
5396 /* More paranoia. */
5397 if (cur
== NULL
|| prev
== NULL
)
5400 /* If the regions are different then force the sections to live in
5401 different segments. See the email thread starting at the following
5402 URL for the reasons why this is necessary:
5403 http://sourceware.org/ml/binutils/2007-02/msg00216.html */
5404 return cur
->region
!= prev
->region
;
5408 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
5410 lang_statement_iteration
++;
5411 lang_size_sections_1 (&statement_list
.head
, abs_output_section
,
5412 0, 0, relax
, check_regions
);
5416 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
5418 expld
.phase
= lang_allocating_phase_enum
;
5419 expld
.dataseg
.phase
= exp_dataseg_none
;
5421 one_lang_size_sections_pass (relax
, check_regions
);
5422 if (expld
.dataseg
.phase
== exp_dataseg_end_seen
5423 && link_info
.relro
&& expld
.dataseg
.relro_end
)
5425 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
5426 to put expld.dataseg.relro_end on a (common) page boundary. */
5427 bfd_vma min_base
, relro_end
, maxpage
;
5429 expld
.dataseg
.phase
= exp_dataseg_relro_adjust
;
5430 maxpage
= expld
.dataseg
.maxpagesize
;
5431 /* MIN_BASE is the absolute minimum address we are allowed to start the
5432 read-write segment (byte before will be mapped read-only). */
5433 min_base
= (expld
.dataseg
.min_base
+ maxpage
- 1) & ~(maxpage
- 1);
5434 expld
.dataseg
.base
+= (-expld
.dataseg
.relro_end
5435 & (expld
.dataseg
.pagesize
- 1));
5436 /* Compute the expected PT_GNU_RELRO segment end. */
5437 relro_end
= ((expld
.dataseg
.relro_end
+ expld
.dataseg
.pagesize
- 1)
5438 & ~(expld
.dataseg
.pagesize
- 1));
5439 if (min_base
+ maxpage
< expld
.dataseg
.base
)
5441 expld
.dataseg
.base
-= maxpage
;
5442 relro_end
-= maxpage
;
5444 lang_reset_memory_regions ();
5445 one_lang_size_sections_pass (relax
, check_regions
);
5446 if (expld
.dataseg
.relro_end
> relro_end
)
5448 /* The alignment of sections between DATA_SEGMENT_ALIGN
5449 and DATA_SEGMENT_RELRO_END can cause excessive padding to
5450 be inserted at DATA_SEGMENT_RELRO_END. Try to start a
5451 bit lower so that the section alignments will fit in. */
5453 unsigned int max_alignment_power
= 0;
5455 /* Find maximum alignment power of sections between
5456 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
5457 for (sec
= link_info
.output_bfd
->sections
; sec
; sec
= sec
->next
)
5458 if (sec
->vma
>= expld
.dataseg
.base
5459 && sec
->vma
< expld
.dataseg
.relro_end
5460 && sec
->alignment_power
> max_alignment_power
)
5461 max_alignment_power
= sec
->alignment_power
;
5463 if (((bfd_vma
) 1 << max_alignment_power
) < expld
.dataseg
.pagesize
)
5465 /* Aligning the adjusted base guarantees the padding
5466 between sections won't change. This is better than
5467 simply subtracting 1 << max_alignment_power which is
5468 what we used to do here. */
5469 expld
.dataseg
.base
&= ~((1 << max_alignment_power
) - 1);
5470 lang_reset_memory_regions ();
5471 one_lang_size_sections_pass (relax
, check_regions
);
5474 link_info
.relro_start
= expld
.dataseg
.base
;
5475 link_info
.relro_end
= expld
.dataseg
.relro_end
;
5477 else if (expld
.dataseg
.phase
== exp_dataseg_end_seen
)
5479 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5480 a page could be saved in the data segment. */
5481 bfd_vma first
, last
;
5483 first
= -expld
.dataseg
.base
& (expld
.dataseg
.pagesize
- 1);
5484 last
= expld
.dataseg
.end
& (expld
.dataseg
.pagesize
- 1);
5486 && ((expld
.dataseg
.base
& ~(expld
.dataseg
.pagesize
- 1))
5487 != (expld
.dataseg
.end
& ~(expld
.dataseg
.pagesize
- 1)))
5488 && first
+ last
<= expld
.dataseg
.pagesize
)
5490 expld
.dataseg
.phase
= exp_dataseg_adjust
;
5491 lang_reset_memory_regions ();
5492 one_lang_size_sections_pass (relax
, check_regions
);
5495 expld
.dataseg
.phase
= exp_dataseg_done
;
5498 expld
.dataseg
.phase
= exp_dataseg_done
;
5501 static lang_output_section_statement_type
*current_section
;
5502 static lang_assignment_statement_type
*current_assign
;
5503 static bfd_boolean prefer_next_section
;
5505 /* Worker function for lang_do_assignments. Recursiveness goes here. */
5508 lang_do_assignments_1 (lang_statement_union_type
*s
,
5509 lang_output_section_statement_type
*current_os
,
5512 bfd_boolean
*found_end
)
5514 for (; s
!= NULL
; s
= s
->header
.next
)
5516 switch (s
->header
.type
)
5518 case lang_constructors_statement_enum
:
5519 dot
= lang_do_assignments_1 (constructor_list
.head
,
5520 current_os
, fill
, dot
, found_end
);
5523 case lang_output_section_statement_enum
:
5525 lang_output_section_statement_type
*os
;
5527 os
= &(s
->output_section_statement
);
5528 os
->after_end
= *found_end
;
5529 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
5531 if ((os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
5533 current_section
= os
;
5534 prefer_next_section
= FALSE
;
5536 dot
= os
->bfd_section
->vma
;
5538 lang_do_assignments_1 (os
->children
.head
,
5539 os
, os
->fill
, dot
, found_end
);
5541 /* .tbss sections effectively have zero size. */
5542 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
5543 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
5544 || link_info
.relocatable
)
5545 dot
+= TO_ADDR (os
->bfd_section
->size
);
5547 if (os
->update_dot_tree
!= NULL
)
5548 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
5553 case lang_wild_statement_enum
:
5555 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
5556 current_os
, fill
, dot
, found_end
);
5559 case lang_object_symbols_statement_enum
:
5560 case lang_output_statement_enum
:
5561 case lang_target_statement_enum
:
5564 case lang_data_statement_enum
:
5565 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
5566 if (expld
.result
.valid_p
)
5568 s
->data_statement
.value
= expld
.result
.value
;
5569 if (expld
.result
.section
!= NULL
)
5570 s
->data_statement
.value
+= expld
.result
.section
->vma
;
5573 einfo (_("%F%P: invalid data statement\n"));
5576 switch (s
->data_statement
.type
)
5594 if (size
< TO_SIZE ((unsigned) 1))
5595 size
= TO_SIZE ((unsigned) 1);
5596 dot
+= TO_ADDR (size
);
5600 case lang_reloc_statement_enum
:
5601 exp_fold_tree (s
->reloc_statement
.addend_exp
,
5602 bfd_abs_section_ptr
, &dot
);
5603 if (expld
.result
.valid_p
)
5604 s
->reloc_statement
.addend_value
= expld
.result
.value
;
5606 einfo (_("%F%P: invalid reloc statement\n"));
5607 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
5610 case lang_input_section_enum
:
5612 asection
*in
= s
->input_section
.section
;
5614 if ((in
->flags
& SEC_EXCLUDE
) == 0)
5615 dot
+= TO_ADDR (in
->size
);
5619 case lang_input_statement_enum
:
5622 case lang_fill_statement_enum
:
5623 fill
= s
->fill_statement
.fill
;
5626 case lang_assignment_statement_enum
:
5627 current_assign
= &s
->assignment_statement
;
5628 if (current_assign
->exp
->type
.node_class
!= etree_assert
)
5630 const char *p
= current_assign
->exp
->assign
.dst
;
5632 if (current_os
== abs_output_section
&& p
[0] == '.' && p
[1] == 0)
5633 prefer_next_section
= TRUE
;
5637 if (strcmp (p
, "end") == 0)
5640 exp_fold_tree (s
->assignment_statement
.exp
,
5641 current_os
->bfd_section
,
5645 case lang_padding_statement_enum
:
5646 dot
+= TO_ADDR (s
->padding_statement
.size
);
5649 case lang_group_statement_enum
:
5650 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
5651 current_os
, fill
, dot
, found_end
);
5654 case lang_insert_statement_enum
:
5657 case lang_address_statement_enum
:
5669 lang_do_assignments (lang_phase_type phase
)
5671 bfd_boolean found_end
= FALSE
;
5673 current_section
= NULL
;
5674 prefer_next_section
= FALSE
;
5675 expld
.phase
= phase
;
5676 lang_statement_iteration
++;
5677 lang_do_assignments_1 (statement_list
.head
,
5678 abs_output_section
, NULL
, 0, &found_end
);
5681 /* For an assignment statement outside of an output section statement,
5682 choose the best of neighbouring output sections to use for values
5686 section_for_dot (void)
5690 /* Assignments belong to the previous output section, unless there
5691 has been an assignment to "dot", in which case following
5692 assignments belong to the next output section. (The assumption
5693 is that an assignment to "dot" is setting up the address for the
5694 next output section.) Except that past the assignment to "_end"
5695 we always associate with the previous section. This exception is
5696 for targets like SH that define an alloc .stack or other
5697 weirdness after non-alloc sections. */
5698 if (current_section
== NULL
|| prefer_next_section
)
5700 lang_statement_union_type
*stmt
;
5701 lang_output_section_statement_type
*os
;
5703 for (stmt
= (lang_statement_union_type
*) current_assign
;
5705 stmt
= stmt
->header
.next
)
5706 if (stmt
->header
.type
== lang_output_section_statement_enum
)
5709 os
= &stmt
->output_section_statement
;
5712 && (os
->bfd_section
== NULL
5713 || (os
->bfd_section
->flags
& SEC_EXCLUDE
) != 0
5714 || bfd_section_removed_from_list (link_info
.output_bfd
,
5718 if (current_section
== NULL
|| os
== NULL
|| !os
->after_end
)
5721 s
= os
->bfd_section
;
5723 s
= link_info
.output_bfd
->section_last
;
5725 && ((s
->flags
& SEC_ALLOC
) == 0
5726 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
5731 return bfd_abs_section_ptr
;
5735 s
= current_section
->bfd_section
;
5737 /* The section may have been stripped. */
5739 && ((s
->flags
& SEC_EXCLUDE
) != 0
5740 || (s
->flags
& SEC_ALLOC
) == 0
5741 || (s
->flags
& SEC_THREAD_LOCAL
) != 0
5742 || bfd_section_removed_from_list (link_info
.output_bfd
, s
)))
5745 s
= link_info
.output_bfd
->sections
;
5747 && ((s
->flags
& SEC_ALLOC
) == 0
5748 || (s
->flags
& SEC_THREAD_LOCAL
) != 0))
5753 return bfd_abs_section_ptr
;
5756 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
5757 operator .startof. (section_name), it produces an undefined symbol
5758 .startof.section_name. Similarly, when it sees
5759 .sizeof. (section_name), it produces an undefined symbol
5760 .sizeof.section_name. For all the output sections, we look for
5761 such symbols, and set them to the correct value. */
5764 lang_set_startof (void)
5768 if (link_info
.relocatable
)
5771 for (s
= link_info
.output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5773 const char *secname
;
5775 struct bfd_link_hash_entry
*h
;
5777 secname
= bfd_get_section_name (link_info
.output_bfd
, s
);
5778 buf
= (char *) xmalloc (10 + strlen (secname
));
5780 sprintf (buf
, ".startof.%s", secname
);
5781 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5782 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5784 h
->type
= bfd_link_hash_defined
;
5786 h
->u
.def
.section
= s
;
5789 sprintf (buf
, ".sizeof.%s", secname
);
5790 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
5791 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
5793 h
->type
= bfd_link_hash_defined
;
5794 h
->u
.def
.value
= TO_ADDR (s
->size
);
5795 h
->u
.def
.section
= bfd_abs_section_ptr
;
5805 struct bfd_link_hash_entry
*h
;
5808 if ((link_info
.relocatable
&& !link_info
.gc_sections
)
5809 || (link_info
.shared
&& !link_info
.executable
))
5810 warn
= entry_from_cmdline
;
5814 /* Force the user to specify a root when generating a relocatable with
5816 if (link_info
.gc_sections
&& link_info
.relocatable
5817 && !(entry_from_cmdline
|| undef_from_cmdline
))
5818 einfo (_("%P%F: gc-sections requires either an entry or "
5819 "an undefined symbol\n"));
5821 if (entry_symbol
.name
== NULL
)
5823 /* No entry has been specified. Look for the default entry, but
5824 don't warn if we don't find it. */
5825 entry_symbol
.name
= entry_symbol_default
;
5829 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
5830 FALSE
, FALSE
, TRUE
);
5832 && (h
->type
== bfd_link_hash_defined
5833 || h
->type
== bfd_link_hash_defweak
)
5834 && h
->u
.def
.section
->output_section
!= NULL
)
5838 val
= (h
->u
.def
.value
5839 + bfd_get_section_vma (link_info
.output_bfd
,
5840 h
->u
.def
.section
->output_section
)
5841 + h
->u
.def
.section
->output_offset
);
5842 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5843 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
5850 /* We couldn't find the entry symbol. Try parsing it as a
5852 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
5855 if (! bfd_set_start_address (link_info
.output_bfd
, val
))
5856 einfo (_("%P%F: can't set start address\n"));
5862 /* Can't find the entry symbol, and it's not a number. Use
5863 the first address in the text section. */
5864 ts
= bfd_get_section_by_name (link_info
.output_bfd
, entry_section
);
5868 einfo (_("%P: warning: cannot find entry symbol %s;"
5869 " defaulting to %V\n"),
5871 bfd_get_section_vma (link_info
.output_bfd
, ts
));
5872 if (!(bfd_set_start_address
5873 (link_info
.output_bfd
,
5874 bfd_get_section_vma (link_info
.output_bfd
, ts
))))
5875 einfo (_("%P%F: can't set start address\n"));
5880 einfo (_("%P: warning: cannot find entry symbol %s;"
5881 " not setting start address\n"),
5888 /* This is a small function used when we want to ignore errors from
5892 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
5894 /* Don't do anything. */
5897 /* Check that the architecture of all the input files is compatible
5898 with the output file. Also call the backend to let it do any
5899 other checking that is needed. */
5904 lang_statement_union_type
*file
;
5906 const bfd_arch_info_type
*compatible
;
5908 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
5910 #ifdef ENABLE_PLUGINS
5911 /* Don't check format of files claimed by plugin. */
5912 if (file
->input_statement
.flags
.claimed
)
5914 #endif /* ENABLE_PLUGINS */
5915 input_bfd
= file
->input_statement
.the_bfd
;
5917 = bfd_arch_get_compatible (input_bfd
, link_info
.output_bfd
,
5918 command_line
.accept_unknown_input_arch
);
5920 /* In general it is not possible to perform a relocatable
5921 link between differing object formats when the input
5922 file has relocations, because the relocations in the
5923 input format may not have equivalent representations in
5924 the output format (and besides BFD does not translate
5925 relocs for other link purposes than a final link). */
5926 if ((link_info
.relocatable
|| link_info
.emitrelocations
)
5927 && (compatible
== NULL
5928 || (bfd_get_flavour (input_bfd
)
5929 != bfd_get_flavour (link_info
.output_bfd
)))
5930 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
5932 einfo (_("%P%F: Relocatable linking with relocations from"
5933 " format %s (%B) to format %s (%B) is not supported\n"),
5934 bfd_get_target (input_bfd
), input_bfd
,
5935 bfd_get_target (link_info
.output_bfd
), link_info
.output_bfd
);
5936 /* einfo with %F exits. */
5939 if (compatible
== NULL
)
5941 if (command_line
.warn_mismatch
)
5942 einfo (_("%P%X: %s architecture of input file `%B'"
5943 " is incompatible with %s output\n"),
5944 bfd_printable_name (input_bfd
), input_bfd
,
5945 bfd_printable_name (link_info
.output_bfd
));
5947 else if (bfd_count_sections (input_bfd
))
5949 /* If the input bfd has no contents, it shouldn't set the
5950 private data of the output bfd. */
5952 bfd_error_handler_type pfn
= NULL
;
5954 /* If we aren't supposed to warn about mismatched input
5955 files, temporarily set the BFD error handler to a
5956 function which will do nothing. We still want to call
5957 bfd_merge_private_bfd_data, since it may set up
5958 information which is needed in the output file. */
5959 if (! command_line
.warn_mismatch
)
5960 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
5961 if (! bfd_merge_private_bfd_data (input_bfd
, link_info
.output_bfd
))
5963 if (command_line
.warn_mismatch
)
5964 einfo (_("%P%X: failed to merge target specific data"
5965 " of file %B\n"), input_bfd
);
5967 if (! command_line
.warn_mismatch
)
5968 bfd_set_error_handler (pfn
);
5973 /* Look through all the global common symbols and attach them to the
5974 correct section. The -sort-common command line switch may be used
5975 to roughly sort the entries by alignment. */
5980 if (command_line
.inhibit_common_definition
)
5982 if (link_info
.relocatable
5983 && ! command_line
.force_common_definition
)
5986 if (! config
.sort_common
)
5987 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
5992 if (config
.sort_common
== sort_descending
)
5994 for (power
= 4; power
> 0; power
--)
5995 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5998 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6002 for (power
= 0; power
<= 4; power
++)
6003 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6005 power
= (unsigned int) -1;
6006 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
6011 /* Place one common symbol in the correct section. */
6014 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
6016 unsigned int power_of_two
;
6020 if (h
->type
!= bfd_link_hash_common
)
6024 power_of_two
= h
->u
.c
.p
->alignment_power
;
6026 if (config
.sort_common
== sort_descending
6027 && power_of_two
< *(unsigned int *) info
)
6029 else if (config
.sort_common
== sort_ascending
6030 && power_of_two
> *(unsigned int *) info
)
6033 section
= h
->u
.c
.p
->section
;
6034 if (!bfd_define_common_symbol (link_info
.output_bfd
, &link_info
, h
))
6035 einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
6038 if (config
.map_file
!= NULL
)
6040 static bfd_boolean header_printed
;
6045 if (! header_printed
)
6047 minfo (_("\nAllocating common symbols\n"));
6048 minfo (_("Common symbol size file\n\n"));
6049 header_printed
= TRUE
;
6052 name
= bfd_demangle (link_info
.output_bfd
, h
->root
.string
,
6053 DMGL_ANSI
| DMGL_PARAMS
);
6056 minfo ("%s", h
->root
.string
);
6057 len
= strlen (h
->root
.string
);
6062 len
= strlen (name
);
6078 if (size
<= 0xffffffff)
6079 sprintf (buf
, "%lx", (unsigned long) size
);
6081 sprintf_vma (buf
, size
);
6091 minfo ("%B\n", section
->owner
);
6097 /* Run through the input files and ensure that every input section has
6098 somewhere to go. If one is found without a destination then create
6099 an input request and place it into the statement tree. */
6102 lang_place_orphans (void)
6104 LANG_FOR_EACH_INPUT_STATEMENT (file
)
6108 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
6110 if (s
->output_section
== NULL
)
6112 /* This section of the file is not attached, root
6113 around for a sensible place for it to go. */
6115 if (file
->flags
.just_syms
)
6116 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
6117 else if ((s
->flags
& SEC_EXCLUDE
) != 0)
6118 s
->output_section
= bfd_abs_section_ptr
;
6119 else if (strcmp (s
->name
, "COMMON") == 0)
6121 /* This is a lonely common section which must have
6122 come from an archive. We attach to the section
6123 with the wildcard. */
6124 if (! link_info
.relocatable
6125 || command_line
.force_common_definition
)
6127 if (default_common_section
== NULL
)
6128 default_common_section
6129 = lang_output_section_statement_lookup (".bss", 0,
6131 lang_add_section (&default_common_section
->children
, s
,
6132 NULL
, default_common_section
);
6137 const char *name
= s
->name
;
6140 if (config
.unique_orphan_sections
6141 || unique_section_p (s
, NULL
))
6142 constraint
= SPECIAL
;
6144 if (!ldemul_place_orphan (s
, name
, constraint
))
6146 lang_output_section_statement_type
*os
;
6147 os
= lang_output_section_statement_lookup (name
,
6150 if (os
->addr_tree
== NULL
6151 && (link_info
.relocatable
6152 || (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0))
6153 os
->addr_tree
= exp_intop (0);
6154 lang_add_section (&os
->children
, s
, NULL
, os
);
6163 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
6165 flagword
*ptr_flags
;
6167 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
6173 *ptr_flags
|= SEC_ALLOC
;
6177 *ptr_flags
|= SEC_READONLY
;
6181 *ptr_flags
|= SEC_DATA
;
6185 *ptr_flags
|= SEC_CODE
;
6190 *ptr_flags
|= SEC_LOAD
;
6194 einfo (_("%P%F: invalid syntax in flags\n"));
6201 /* Call a function on each input file. This function will be called
6202 on an archive, but not on the elements. */
6205 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
6207 lang_input_statement_type
*f
;
6209 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
6211 f
= (lang_input_statement_type
*) f
->next_real_file
)
6215 /* Call a function on each file. The function will be called on all
6216 the elements of an archive which are included in the link, but will
6217 not be called on the archive file itself. */
6220 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
6222 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6229 ldlang_add_file (lang_input_statement_type
*entry
)
6231 lang_statement_append (&file_chain
,
6232 (lang_statement_union_type
*) entry
,
6235 /* The BFD linker needs to have a list of all input BFDs involved in
6237 ASSERT (entry
->the_bfd
->link
.next
== NULL
);
6238 ASSERT (entry
->the_bfd
!= link_info
.output_bfd
);
6240 *link_info
.input_bfds_tail
= entry
->the_bfd
;
6241 link_info
.input_bfds_tail
= &entry
->the_bfd
->link
.next
;
6242 entry
->the_bfd
->usrdata
= entry
;
6243 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
6245 /* Look through the sections and check for any which should not be
6246 included in the link. We need to do this now, so that we can
6247 notice when the backend linker tries to report multiple
6248 definition errors for symbols which are in sections we aren't
6249 going to link. FIXME: It might be better to entirely ignore
6250 symbols which are defined in sections which are going to be
6251 discarded. This would require modifying the backend linker for
6252 each backend which might set the SEC_LINK_ONCE flag. If we do
6253 this, we should probably handle SEC_EXCLUDE in the same way. */
6255 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
6259 lang_add_output (const char *name
, int from_script
)
6261 /* Make -o on command line override OUTPUT in script. */
6262 if (!had_output_filename
|| !from_script
)
6264 output_filename
= name
;
6265 had_output_filename
= TRUE
;
6278 for (l
= 0; l
< 32; l
++)
6280 if (i
>= (unsigned int) x
)
6288 lang_output_section_statement_type
*
6289 lang_enter_output_section_statement (const char *output_section_statement_name
,
6290 etree_type
*address_exp
,
6291 enum section_type sectype
,
6293 etree_type
*subalign
,
6296 int align_with_input
)
6298 lang_output_section_statement_type
*os
;
6300 os
= lang_output_section_statement_lookup (output_section_statement_name
,
6302 current_section
= os
;
6304 if (os
->addr_tree
== NULL
)
6306 os
->addr_tree
= address_exp
;
6308 os
->sectype
= sectype
;
6309 if (sectype
!= noload_section
)
6310 os
->flags
= SEC_NO_FLAGS
;
6312 os
->flags
= SEC_NEVER_LOAD
;
6313 os
->block_value
= 1;
6315 /* Make next things chain into subchain of this. */
6316 push_stat_ptr (&os
->children
);
6318 os
->align_lma_with_input
= align_with_input
== ALIGN_WITH_INPUT
;
6319 if (os
->align_lma_with_input
&& align
!= NULL
)
6320 einfo (_("%F%P:%S: error: align with input and explicit align specified\n"), NULL
);
6322 os
->subsection_alignment
=
6323 topower (exp_get_value_int (subalign
, -1, "subsection alignment"));
6324 os
->section_alignment
=
6325 topower (exp_get_value_int (align
, -1, "section alignment"));
6327 os
->load_base
= ebase
;
6334 lang_output_statement_type
*new_stmt
;
6336 new_stmt
= new_stat (lang_output_statement
, stat_ptr
);
6337 new_stmt
->name
= output_filename
;
6341 /* Reset the current counters in the regions. */
6344 lang_reset_memory_regions (void)
6346 lang_memory_region_type
*p
= lang_memory_region_list
;
6348 lang_output_section_statement_type
*os
;
6350 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
6352 p
->current
= p
->origin
;
6356 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6360 os
->processed_vma
= FALSE
;
6361 os
->processed_lma
= FALSE
;
6364 for (o
= link_info
.output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
6366 /* Save the last size for possible use by bfd_relax_section. */
6367 o
->rawsize
= o
->size
;
6372 /* Worker for lang_gc_sections_1. */
6375 gc_section_callback (lang_wild_statement_type
*ptr
,
6376 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6378 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
6379 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6380 void *data ATTRIBUTE_UNUSED
)
6382 /* If the wild pattern was marked KEEP, the member sections
6383 should be as well. */
6384 if (ptr
->keep_sections
)
6385 section
->flags
|= SEC_KEEP
;
6388 /* Iterate over sections marking them against GC. */
6391 lang_gc_sections_1 (lang_statement_union_type
*s
)
6393 for (; s
!= NULL
; s
= s
->header
.next
)
6395 switch (s
->header
.type
)
6397 case lang_wild_statement_enum
:
6398 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
6400 case lang_constructors_statement_enum
:
6401 lang_gc_sections_1 (constructor_list
.head
);
6403 case lang_output_section_statement_enum
:
6404 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
6406 case lang_group_statement_enum
:
6407 lang_gc_sections_1 (s
->group_statement
.children
.head
);
6416 lang_gc_sections (void)
6418 /* Keep all sections so marked in the link script. */
6420 lang_gc_sections_1 (statement_list
.head
);
6422 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6423 the special case of debug info. (See bfd/stabs.c)
6424 Twiddle the flag here, to simplify later linker code. */
6425 if (link_info
.relocatable
)
6427 LANG_FOR_EACH_INPUT_STATEMENT (f
)
6430 #ifdef ENABLE_PLUGINS
6431 if (f
->flags
.claimed
)
6434 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
6435 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
6436 sec
->flags
&= ~SEC_EXCLUDE
;
6440 if (link_info
.gc_sections
)
6441 bfd_gc_sections (link_info
.output_bfd
, &link_info
);
6444 /* Worker for lang_find_relro_sections_1. */
6447 find_relro_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
6448 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
6450 struct flag_info
*sflag_info ATTRIBUTE_UNUSED
,
6451 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
6454 /* Discarded, excluded and ignored sections effectively have zero
6456 if (section
->output_section
!= NULL
6457 && section
->output_section
->owner
== link_info
.output_bfd
6458 && (section
->output_section
->flags
& SEC_EXCLUDE
) == 0
6459 && !IGNORE_SECTION (section
)
6460 && section
->size
!= 0)
6462 bfd_boolean
*has_relro_section
= (bfd_boolean
*) data
;
6463 *has_relro_section
= TRUE
;
6467 /* Iterate over sections for relro sections. */
6470 lang_find_relro_sections_1 (lang_statement_union_type
*s
,
6471 bfd_boolean
*has_relro_section
)
6473 if (*has_relro_section
)
6476 for (; s
!= NULL
; s
= s
->header
.next
)
6478 if (s
== expld
.dataseg
.relro_end_stat
)
6481 switch (s
->header
.type
)
6483 case lang_wild_statement_enum
:
6484 walk_wild (&s
->wild_statement
,
6485 find_relro_section_callback
,
6488 case lang_constructors_statement_enum
:
6489 lang_find_relro_sections_1 (constructor_list
.head
,
6492 case lang_output_section_statement_enum
:
6493 lang_find_relro_sections_1 (s
->output_section_statement
.children
.head
,
6496 case lang_group_statement_enum
:
6497 lang_find_relro_sections_1 (s
->group_statement
.children
.head
,
6507 lang_find_relro_sections (void)
6509 bfd_boolean has_relro_section
= FALSE
;
6511 /* Check all sections in the link script. */
6513 lang_find_relro_sections_1 (expld
.dataseg
.relro_start_stat
,
6514 &has_relro_section
);
6516 if (!has_relro_section
)
6517 link_info
.relro
= FALSE
;
6520 /* Relax all sections until bfd_relax_section gives up. */
6523 lang_relax_sections (bfd_boolean need_layout
)
6525 if (RELAXATION_ENABLED
)
6527 /* We may need more than one relaxation pass. */
6528 int i
= link_info
.relax_pass
;
6530 /* The backend can use it to determine the current pass. */
6531 link_info
.relax_pass
= 0;
6535 /* Keep relaxing until bfd_relax_section gives up. */
6536 bfd_boolean relax_again
;
6538 link_info
.relax_trip
= -1;
6541 link_info
.relax_trip
++;
6543 /* Note: pe-dll.c does something like this also. If you find
6544 you need to change this code, you probably need to change
6545 pe-dll.c also. DJ */
6547 /* Do all the assignments with our current guesses as to
6549 lang_do_assignments (lang_assigning_phase_enum
);
6551 /* We must do this after lang_do_assignments, because it uses
6553 lang_reset_memory_regions ();
6555 /* Perform another relax pass - this time we know where the
6556 globals are, so can make a better guess. */
6557 relax_again
= FALSE
;
6558 lang_size_sections (&relax_again
, FALSE
);
6560 while (relax_again
);
6562 link_info
.relax_pass
++;
6569 /* Final extra sizing to report errors. */
6570 lang_do_assignments (lang_assigning_phase_enum
);
6571 lang_reset_memory_regions ();
6572 lang_size_sections (NULL
, TRUE
);
6576 #ifdef ENABLE_PLUGINS
6577 /* Find the insert point for the plugin's replacement files. We
6578 place them after the first claimed real object file, or if the
6579 first claimed object is an archive member, after the last real
6580 object file immediately preceding the archive. In the event
6581 no objects have been claimed at all, we return the first dummy
6582 object file on the list as the insert point; that works, but
6583 the callee must be careful when relinking the file_chain as it
6584 is not actually on that chain, only the statement_list and the
6585 input_file list; in that case, the replacement files must be
6586 inserted at the head of the file_chain. */
6588 static lang_input_statement_type
*
6589 find_replacements_insert_point (void)
6591 lang_input_statement_type
*claim1
, *lastobject
;
6592 lastobject
= &input_file_chain
.head
->input_statement
;
6593 for (claim1
= &file_chain
.head
->input_statement
;
6595 claim1
= &claim1
->next
->input_statement
)
6597 if (claim1
->flags
.claimed
)
6598 return claim1
->flags
.claim_archive
? lastobject
: claim1
;
6599 /* Update lastobject if this is a real object file. */
6600 if (claim1
->the_bfd
&& (claim1
->the_bfd
->my_archive
== NULL
))
6601 lastobject
= claim1
;
6603 /* No files were claimed by the plugin. Choose the last object
6604 file found on the list (maybe the first, dummy entry) as the
6609 /* Insert SRCLIST into DESTLIST after given element by chaining
6610 on FIELD as the next-pointer. (Counterintuitively does not need
6611 a pointer to the actual after-node itself, just its chain field.) */
6614 lang_list_insert_after (lang_statement_list_type
*destlist
,
6615 lang_statement_list_type
*srclist
,
6616 lang_statement_union_type
**field
)
6618 *(srclist
->tail
) = *field
;
6619 *field
= srclist
->head
;
6620 if (destlist
->tail
== field
)
6621 destlist
->tail
= srclist
->tail
;
6624 /* Detach new nodes added to DESTLIST since the time ORIGLIST
6625 was taken as a copy of it and leave them in ORIGLIST. */
6628 lang_list_remove_tail (lang_statement_list_type
*destlist
,
6629 lang_statement_list_type
*origlist
)
6631 union lang_statement_union
**savetail
;
6632 /* Check that ORIGLIST really is an earlier state of DESTLIST. */
6633 ASSERT (origlist
->head
== destlist
->head
);
6634 savetail
= origlist
->tail
;
6635 origlist
->head
= *(savetail
);
6636 origlist
->tail
= destlist
->tail
;
6637 destlist
->tail
= savetail
;
6640 #endif /* ENABLE_PLUGINS */
6645 /* Finalize dynamic list. */
6646 if (link_info
.dynamic_list
)
6647 lang_finalize_version_expr_head (&link_info
.dynamic_list
->head
);
6649 current_target
= default_target
;
6651 /* Open the output file. */
6652 lang_for_each_statement (ldlang_open_output
);
6655 ldemul_create_output_section_statements ();
6657 /* Add to the hash table all undefineds on the command line. */
6658 lang_place_undefineds ();
6660 if (!bfd_section_already_linked_table_init ())
6661 einfo (_("%P%F: Failed to create hash table\n"));
6663 /* Create a bfd for each input file. */
6664 current_target
= default_target
;
6665 open_input_bfds (statement_list
.head
, OPEN_BFD_NORMAL
);
6667 #ifdef ENABLE_PLUGINS
6668 if (plugin_active_plugins_p ())
6670 lang_statement_list_type added
;
6671 lang_statement_list_type files
, inputfiles
;
6673 /* Now all files are read, let the plugin(s) decide if there
6674 are any more to be added to the link before we call the
6675 emulation's after_open hook. We create a private list of
6676 input statements for this purpose, which we will eventually
6677 insert into the global statment list after the first claimed
6680 /* We need to manipulate all three chains in synchrony. */
6682 inputfiles
= input_file_chain
;
6683 if (plugin_call_all_symbols_read ())
6684 einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
6685 plugin_error_plugin ());
6686 /* Open any newly added files, updating the file chains. */
6687 link_info
.loading_lto_outputs
= TRUE
;
6688 open_input_bfds (*added
.tail
, OPEN_BFD_NORMAL
);
6689 /* Restore the global list pointer now they have all been added. */
6690 lang_list_remove_tail (stat_ptr
, &added
);
6691 /* And detach the fresh ends of the file lists. */
6692 lang_list_remove_tail (&file_chain
, &files
);
6693 lang_list_remove_tail (&input_file_chain
, &inputfiles
);
6694 /* Were any new files added? */
6695 if (added
.head
!= NULL
)
6697 /* If so, we will insert them into the statement list immediately
6698 after the first input file that was claimed by the plugin. */
6699 plugin_insert
= find_replacements_insert_point ();
6700 /* If a plugin adds input files without having claimed any, we
6701 don't really have a good idea where to place them. Just putting
6702 them at the start or end of the list is liable to leave them
6703 outside the crtbegin...crtend range. */
6704 ASSERT (plugin_insert
!= NULL
);
6705 /* Splice the new statement list into the old one. */
6706 lang_list_insert_after (stat_ptr
, &added
,
6707 &plugin_insert
->header
.next
);
6708 /* Likewise for the file chains. */
6709 lang_list_insert_after (&input_file_chain
, &inputfiles
,
6710 &plugin_insert
->next_real_file
);
6711 /* We must be careful when relinking file_chain; we may need to
6712 insert the new files at the head of the list if the insert
6713 point chosen is the dummy first input file. */
6714 if (plugin_insert
->filename
)
6715 lang_list_insert_after (&file_chain
, &files
, &plugin_insert
->next
);
6717 lang_list_insert_after (&file_chain
, &files
, &file_chain
.head
);
6719 /* Rescan archives in case new undefined symbols have appeared. */
6720 open_input_bfds (statement_list
.head
, OPEN_BFD_RESCAN
);
6723 #endif /* ENABLE_PLUGINS */
6725 link_info
.gc_sym_list
= &entry_symbol
;
6726 if (entry_symbol
.name
== NULL
)
6727 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
6729 ldemul_after_open ();
6730 if (config
.map_file
!= NULL
)
6731 lang_print_asneeded ();
6733 bfd_section_already_linked_table_free ();
6735 /* Make sure that we're not mixing architectures. We call this
6736 after all the input files have been opened, but before we do any
6737 other processing, so that any operations merge_private_bfd_data
6738 does on the output file will be known during the rest of the
6742 /* Handle .exports instead of a version script if we're told to do so. */
6743 if (command_line
.version_exports_section
)
6744 lang_do_version_exports_section ();
6746 /* Build all sets based on the information gathered from the input
6748 ldctor_build_sets ();
6750 /* PR 13683: We must rerun the assignments prior to running garbage
6751 collection in order to make sure that all symbol aliases are resolved. */
6752 lang_do_assignments (lang_mark_phase_enum
);
6753 expld
.phase
= lang_first_phase_enum
;
6755 /* Remove unreferenced sections if asked to. */
6756 lang_gc_sections ();
6758 /* Size up the common data. */
6761 /* Update wild statements. */
6762 update_wild_statements (statement_list
.head
);
6764 /* Run through the contours of the script and attach input sections
6765 to the correct output sections. */
6766 lang_statement_iteration
++;
6767 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
6769 process_insert_statements ();
6771 /* Find any sections not attached explicitly and handle them. */
6772 lang_place_orphans ();
6774 if (! link_info
.relocatable
)
6778 /* Merge SEC_MERGE sections. This has to be done after GC of
6779 sections, so that GCed sections are not merged, but before
6780 assigning dynamic symbols, since removing whole input sections
6782 bfd_merge_sections (link_info
.output_bfd
, &link_info
);
6784 /* Look for a text section and set the readonly attribute in it. */
6785 found
= bfd_get_section_by_name (link_info
.output_bfd
, ".text");
6789 if (config
.text_read_only
)
6790 found
->flags
|= SEC_READONLY
;
6792 found
->flags
&= ~SEC_READONLY
;
6796 /* Do anything special before sizing sections. This is where ELF
6797 and other back-ends size dynamic sections. */
6798 ldemul_before_allocation ();
6800 /* We must record the program headers before we try to fix the
6801 section positions, since they will affect SIZEOF_HEADERS. */
6802 lang_record_phdrs ();
6804 /* Check relro sections. */
6805 if (link_info
.relro
&& ! link_info
.relocatable
)
6806 lang_find_relro_sections ();
6808 /* Size up the sections. */
6809 lang_size_sections (NULL
, ! RELAXATION_ENABLED
);
6811 /* See if anything special should be done now we know how big
6812 everything is. This is where relaxation is done. */
6813 ldemul_after_allocation ();
6815 /* Fix any .startof. or .sizeof. symbols. */
6816 lang_set_startof ();
6818 /* Do all the assignments, now that we know the final resting places
6819 of all the symbols. */
6820 lang_do_assignments (lang_final_phase_enum
);
6824 /* Make sure that the section addresses make sense. */
6825 if (command_line
.check_section_addresses
)
6826 lang_check_section_addresses ();
6831 /* EXPORTED TO YACC */
6834 lang_add_wild (struct wildcard_spec
*filespec
,
6835 struct wildcard_list
*section_list
,
6836 bfd_boolean keep_sections
)
6838 struct wildcard_list
*curr
, *next
;
6839 lang_wild_statement_type
*new_stmt
;
6841 /* Reverse the list as the parser puts it back to front. */
6842 for (curr
= section_list
, section_list
= NULL
;
6844 section_list
= curr
, curr
= next
)
6846 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
6847 placed_commons
= TRUE
;
6850 curr
->next
= section_list
;
6853 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
6855 if (strcmp (filespec
->name
, "*") == 0)
6856 filespec
->name
= NULL
;
6857 else if (! wildcardp (filespec
->name
))
6858 lang_has_input_file
= TRUE
;
6861 new_stmt
= new_stat (lang_wild_statement
, stat_ptr
);
6862 new_stmt
->filename
= NULL
;
6863 new_stmt
->filenames_sorted
= FALSE
;
6864 new_stmt
->section_flag_list
= NULL
;
6865 if (filespec
!= NULL
)
6867 new_stmt
->filename
= filespec
->name
;
6868 new_stmt
->filenames_sorted
= filespec
->sorted
== by_name
;
6869 new_stmt
->section_flag_list
= filespec
->section_flag_list
;
6871 new_stmt
->section_list
= section_list
;
6872 new_stmt
->keep_sections
= keep_sections
;
6873 lang_list_init (&new_stmt
->children
);
6874 analyze_walk_wild_section_handler (new_stmt
);
6878 lang_section_start (const char *name
, etree_type
*address
,
6879 const segment_type
*segment
)
6881 lang_address_statement_type
*ad
;
6883 ad
= new_stat (lang_address_statement
, stat_ptr
);
6884 ad
->section_name
= name
;
6885 ad
->address
= address
;
6886 ad
->segment
= segment
;
6889 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
6890 because of a -e argument on the command line, or zero if this is
6891 called by ENTRY in a linker script. Command line arguments take
6895 lang_add_entry (const char *name
, bfd_boolean cmdline
)
6897 if (entry_symbol
.name
== NULL
6899 || ! entry_from_cmdline
)
6901 entry_symbol
.name
= name
;
6902 entry_from_cmdline
= cmdline
;
6906 /* Set the default start symbol to NAME. .em files should use this,
6907 not lang_add_entry, to override the use of "start" if neither the
6908 linker script nor the command line specifies an entry point. NAME
6909 must be permanently allocated. */
6911 lang_default_entry (const char *name
)
6913 entry_symbol_default
= name
;
6917 lang_add_target (const char *name
)
6919 lang_target_statement_type
*new_stmt
;
6921 new_stmt
= new_stat (lang_target_statement
, stat_ptr
);
6922 new_stmt
->target
= name
;
6926 lang_add_map (const char *name
)
6933 map_option_f
= TRUE
;
6941 lang_add_fill (fill_type
*fill
)
6943 lang_fill_statement_type
*new_stmt
;
6945 new_stmt
= new_stat (lang_fill_statement
, stat_ptr
);
6946 new_stmt
->fill
= fill
;
6950 lang_add_data (int type
, union etree_union
*exp
)
6952 lang_data_statement_type
*new_stmt
;
6954 new_stmt
= new_stat (lang_data_statement
, stat_ptr
);
6955 new_stmt
->exp
= exp
;
6956 new_stmt
->type
= type
;
6959 /* Create a new reloc statement. RELOC is the BFD relocation type to
6960 generate. HOWTO is the corresponding howto structure (we could
6961 look this up, but the caller has already done so). SECTION is the
6962 section to generate a reloc against, or NAME is the name of the
6963 symbol to generate a reloc against. Exactly one of SECTION and
6964 NAME must be NULL. ADDEND is an expression for the addend. */
6967 lang_add_reloc (bfd_reloc_code_real_type reloc
,
6968 reloc_howto_type
*howto
,
6971 union etree_union
*addend
)
6973 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
6977 p
->section
= section
;
6979 p
->addend_exp
= addend
;
6981 p
->addend_value
= 0;
6982 p
->output_section
= NULL
;
6983 p
->output_offset
= 0;
6986 lang_assignment_statement_type
*
6987 lang_add_assignment (etree_type
*exp
)
6989 lang_assignment_statement_type
*new_stmt
;
6991 new_stmt
= new_stat (lang_assignment_statement
, stat_ptr
);
6992 new_stmt
->exp
= exp
;
6997 lang_add_attribute (enum statement_enum attribute
)
6999 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
7003 lang_startup (const char *name
)
7005 if (first_file
->filename
!= NULL
)
7007 einfo (_("%P%F: multiple STARTUP files\n"));
7009 first_file
->filename
= name
;
7010 first_file
->local_sym_name
= name
;
7011 first_file
->flags
.real
= TRUE
;
7015 lang_float (bfd_boolean maybe
)
7017 lang_float_flag
= maybe
;
7021 /* Work out the load- and run-time regions from a script statement, and
7022 store them in *LMA_REGION and *REGION respectively.
7024 MEMSPEC is the name of the run-time region, or the value of
7025 DEFAULT_MEMORY_REGION if the statement didn't specify one.
7026 LMA_MEMSPEC is the name of the load-time region, or null if the
7027 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
7028 had an explicit load address.
7030 It is an error to specify both a load region and a load address. */
7033 lang_get_regions (lang_memory_region_type
**region
,
7034 lang_memory_region_type
**lma_region
,
7035 const char *memspec
,
7036 const char *lma_memspec
,
7037 bfd_boolean have_lma
,
7038 bfd_boolean have_vma
)
7040 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
7042 /* If no runtime region or VMA has been specified, but the load region
7043 has been specified, then use the load region for the runtime region
7045 if (lma_memspec
!= NULL
7047 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
7048 *region
= *lma_region
;
7050 *region
= lang_memory_region_lookup (memspec
, FALSE
);
7052 if (have_lma
&& lma_memspec
!= 0)
7053 einfo (_("%X%P:%S: section has both a load address and a load region\n"),
7058 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
7059 lang_output_section_phdr_list
*phdrs
,
7060 const char *lma_memspec
)
7062 lang_get_regions (¤t_section
->region
,
7063 ¤t_section
->lma_region
,
7064 memspec
, lma_memspec
,
7065 current_section
->load_base
!= NULL
,
7066 current_section
->addr_tree
!= NULL
);
7068 /* If this section has no load region or base, but uses the same
7069 region as the previous section, then propagate the previous
7070 section's load region. */
7072 if (current_section
->lma_region
== NULL
7073 && current_section
->load_base
== NULL
7074 && current_section
->addr_tree
== NULL
7075 && current_section
->region
== current_section
->prev
->region
)
7076 current_section
->lma_region
= current_section
->prev
->lma_region
;
7078 current_section
->fill
= fill
;
7079 current_section
->phdrs
= phdrs
;
7084 lang_statement_append (lang_statement_list_type
*list
,
7085 lang_statement_union_type
*element
,
7086 lang_statement_union_type
**field
)
7088 *(list
->tail
) = element
;
7092 /* Set the output format type. -oformat overrides scripts. */
7095 lang_add_output_format (const char *format
,
7100 if (output_target
== NULL
|| !from_script
)
7102 if (command_line
.endian
== ENDIAN_BIG
7105 else if (command_line
.endian
== ENDIAN_LITTLE
7109 output_target
= format
;
7114 lang_add_insert (const char *where
, int is_before
)
7116 lang_insert_statement_type
*new_stmt
;
7118 new_stmt
= new_stat (lang_insert_statement
, stat_ptr
);
7119 new_stmt
->where
= where
;
7120 new_stmt
->is_before
= is_before
;
7121 saved_script_handle
= previous_script_handle
;
7124 /* Enter a group. This creates a new lang_group_statement, and sets
7125 stat_ptr to build new statements within the group. */
7128 lang_enter_group (void)
7130 lang_group_statement_type
*g
;
7132 g
= new_stat (lang_group_statement
, stat_ptr
);
7133 lang_list_init (&g
->children
);
7134 push_stat_ptr (&g
->children
);
7137 /* Leave a group. This just resets stat_ptr to start writing to the
7138 regular list of statements again. Note that this will not work if
7139 groups can occur inside anything else which can adjust stat_ptr,
7140 but currently they can't. */
7143 lang_leave_group (void)
7148 /* Add a new program header. This is called for each entry in a PHDRS
7149 command in a linker script. */
7152 lang_new_phdr (const char *name
,
7154 bfd_boolean filehdr
,
7159 struct lang_phdr
*n
, **pp
;
7162 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
7165 n
->type
= exp_get_value_int (type
, 0, "program header type");
7166 n
->filehdr
= filehdr
;
7171 hdrs
= n
->type
== 1 && (phdrs
|| filehdr
);
7173 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7176 && !((*pp
)->filehdr
|| (*pp
)->phdrs
))
7178 einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported"
7179 " when prior PT_LOAD headers lack them\n"), NULL
);
7186 /* Record the program header information in the output BFD. FIXME: We
7187 should not be calling an ELF specific function here. */
7190 lang_record_phdrs (void)
7194 lang_output_section_phdr_list
*last
;
7195 struct lang_phdr
*l
;
7196 lang_output_section_statement_type
*os
;
7199 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
7202 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
7209 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7213 lang_output_section_phdr_list
*pl
;
7215 if (os
->constraint
< 0)
7223 if (os
->sectype
== noload_section
7224 || os
->bfd_section
== NULL
7225 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
7228 /* Don't add orphans to PT_INTERP header. */
7234 lang_output_section_statement_type
* tmp_os
;
7236 /* If we have not run across a section with a program
7237 header assigned to it yet, then scan forwards to find
7238 one. This prevents inconsistencies in the linker's
7239 behaviour when a script has specified just a single
7240 header and there are sections in that script which are
7241 not assigned to it, and which occur before the first
7242 use of that header. See here for more details:
7243 http://sourceware.org/ml/binutils/2007-02/msg00291.html */
7244 for (tmp_os
= os
; tmp_os
; tmp_os
= tmp_os
->next
)
7247 last
= tmp_os
->phdrs
;
7251 einfo (_("%F%P: no sections assigned to phdrs\n"));
7256 if (os
->bfd_section
== NULL
)
7259 for (; pl
!= NULL
; pl
= pl
->next
)
7261 if (strcmp (pl
->name
, l
->name
) == 0)
7266 secs
= (asection
**) xrealloc (secs
,
7267 alc
* sizeof (asection
*));
7269 secs
[c
] = os
->bfd_section
;
7276 if (l
->flags
== NULL
)
7279 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
7284 at
= exp_get_vma (l
->at
, 0, "phdr load address");
7286 if (! bfd_record_phdr (link_info
.output_bfd
, l
->type
,
7287 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
7288 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
7289 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
7294 /* Make sure all the phdr assignments succeeded. */
7295 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
7299 lang_output_section_phdr_list
*pl
;
7301 if (os
->constraint
< 0
7302 || os
->bfd_section
== NULL
)
7305 for (pl
= os
->phdrs
;
7308 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
7309 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
7310 os
->name
, pl
->name
);
7314 /* Record a list of sections which may not be cross referenced. */
7317 lang_add_nocrossref (lang_nocrossref_type
*l
)
7319 struct lang_nocrossrefs
*n
;
7321 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
7322 n
->next
= nocrossref_list
;
7324 nocrossref_list
= n
;
7326 /* Set notice_all so that we get informed about all symbols. */
7327 link_info
.notice_all
= TRUE
;
7330 /* Overlay handling. We handle overlays with some static variables. */
7332 /* The overlay virtual address. */
7333 static etree_type
*overlay_vma
;
7334 /* And subsection alignment. */
7335 static etree_type
*overlay_subalign
;
7337 /* An expression for the maximum section size seen so far. */
7338 static etree_type
*overlay_max
;
7340 /* A list of all the sections in this overlay. */
7342 struct overlay_list
{
7343 struct overlay_list
*next
;
7344 lang_output_section_statement_type
*os
;
7347 static struct overlay_list
*overlay_list
;
7349 /* Start handling an overlay. */
7352 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
7354 /* The grammar should prevent nested overlays from occurring. */
7355 ASSERT (overlay_vma
== NULL
7356 && overlay_subalign
== NULL
7357 && overlay_max
== NULL
);
7359 overlay_vma
= vma_expr
;
7360 overlay_subalign
= subalign
;
7363 /* Start a section in an overlay. We handle this by calling
7364 lang_enter_output_section_statement with the correct VMA.
7365 lang_leave_overlay sets up the LMA and memory regions. */
7368 lang_enter_overlay_section (const char *name
)
7370 struct overlay_list
*n
;
7373 lang_enter_output_section_statement (name
, overlay_vma
, overlay_section
,
7374 0, overlay_subalign
, 0, 0, 0);
7376 /* If this is the first section, then base the VMA of future
7377 sections on this one. This will work correctly even if `.' is
7378 used in the addresses. */
7379 if (overlay_list
== NULL
)
7380 overlay_vma
= exp_nameop (ADDR
, name
);
7382 /* Remember the section. */
7383 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
7384 n
->os
= current_section
;
7385 n
->next
= overlay_list
;
7388 size
= exp_nameop (SIZEOF
, name
);
7390 /* Arrange to work out the maximum section end address. */
7391 if (overlay_max
== NULL
)
7394 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
7397 /* Finish a section in an overlay. There isn't any special to do
7401 lang_leave_overlay_section (fill_type
*fill
,
7402 lang_output_section_phdr_list
*phdrs
)
7409 name
= current_section
->name
;
7411 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
7412 region and that no load-time region has been specified. It doesn't
7413 really matter what we say here, since lang_leave_overlay will
7415 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
7417 /* Define the magic symbols. */
7419 clean
= (char *) xmalloc (strlen (name
) + 1);
7421 for (s1
= name
; *s1
!= '\0'; s1
++)
7422 if (ISALNUM (*s1
) || *s1
== '_')
7426 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_start_");
7427 sprintf (buf
, "__load_start_%s", clean
);
7428 lang_add_assignment (exp_provide (buf
,
7429 exp_nameop (LOADADDR
, name
),
7432 buf
= (char *) xmalloc (strlen (clean
) + sizeof "__load_stop_");
7433 sprintf (buf
, "__load_stop_%s", clean
);
7434 lang_add_assignment (exp_provide (buf
,
7436 exp_nameop (LOADADDR
, name
),
7437 exp_nameop (SIZEOF
, name
)),
7443 /* Finish an overlay. If there are any overlay wide settings, this
7444 looks through all the sections in the overlay and sets them. */
7447 lang_leave_overlay (etree_type
*lma_expr
,
7450 const char *memspec
,
7451 lang_output_section_phdr_list
*phdrs
,
7452 const char *lma_memspec
)
7454 lang_memory_region_type
*region
;
7455 lang_memory_region_type
*lma_region
;
7456 struct overlay_list
*l
;
7457 lang_nocrossref_type
*nocrossref
;
7459 lang_get_regions (®ion
, &lma_region
,
7460 memspec
, lma_memspec
,
7461 lma_expr
!= NULL
, FALSE
);
7465 /* After setting the size of the last section, set '.' to end of the
7467 if (overlay_list
!= NULL
)
7469 overlay_list
->os
->update_dot
= 1;
7470 overlay_list
->os
->update_dot_tree
7471 = exp_assign (".", exp_binop ('+', overlay_vma
, overlay_max
), FALSE
);
7477 struct overlay_list
*next
;
7479 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
7482 l
->os
->region
= region
;
7483 l
->os
->lma_region
= lma_region
;
7485 /* The first section has the load address specified in the
7486 OVERLAY statement. The rest are worked out from that.
7487 The base address is not needed (and should be null) if
7488 an LMA region was specified. */
7491 l
->os
->load_base
= lma_expr
;
7492 l
->os
->sectype
= normal_section
;
7494 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
7495 l
->os
->phdrs
= phdrs
;
7499 lang_nocrossref_type
*nc
;
7501 nc
= (lang_nocrossref_type
*) xmalloc (sizeof *nc
);
7502 nc
->name
= l
->os
->name
;
7503 nc
->next
= nocrossref
;
7512 if (nocrossref
!= NULL
)
7513 lang_add_nocrossref (nocrossref
);
7516 overlay_list
= NULL
;
7520 /* Version handling. This is only useful for ELF. */
7522 /* If PREV is NULL, return first version pattern matching particular symbol.
7523 If PREV is non-NULL, return first version pattern matching particular
7524 symbol after PREV (previously returned by lang_vers_match). */
7526 static struct bfd_elf_version_expr
*
7527 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
7528 struct bfd_elf_version_expr
*prev
,
7532 const char *cxx_sym
= sym
;
7533 const char *java_sym
= sym
;
7534 struct bfd_elf_version_expr
*expr
= NULL
;
7535 enum demangling_styles curr_style
;
7537 curr_style
= CURRENT_DEMANGLING_STYLE
;
7538 cplus_demangle_set_style (no_demangling
);
7539 c_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_NO_OPTS
);
7542 cplus_demangle_set_style (curr_style
);
7544 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7546 cxx_sym
= bfd_demangle (link_info
.output_bfd
, sym
,
7547 DMGL_PARAMS
| DMGL_ANSI
);
7551 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7553 java_sym
= bfd_demangle (link_info
.output_bfd
, sym
, DMGL_JAVA
);
7558 if (head
->htab
&& (prev
== NULL
|| prev
->literal
))
7560 struct bfd_elf_version_expr e
;
7562 switch (prev
? prev
->mask
: 0)
7565 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
7568 expr
= (struct bfd_elf_version_expr
*)
7569 htab_find ((htab_t
) head
->htab
, &e
);
7570 while (expr
&& strcmp (expr
->pattern
, c_sym
) == 0)
7571 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
7577 case BFD_ELF_VERSION_C_TYPE
:
7578 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
7580 e
.pattern
= cxx_sym
;
7581 expr
= (struct bfd_elf_version_expr
*)
7582 htab_find ((htab_t
) head
->htab
, &e
);
7583 while (expr
&& strcmp (expr
->pattern
, cxx_sym
) == 0)
7584 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7590 case BFD_ELF_VERSION_CXX_TYPE
:
7591 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
7593 e
.pattern
= java_sym
;
7594 expr
= (struct bfd_elf_version_expr
*)
7595 htab_find ((htab_t
) head
->htab
, &e
);
7596 while (expr
&& strcmp (expr
->pattern
, java_sym
) == 0)
7597 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7608 /* Finally, try the wildcards. */
7609 if (prev
== NULL
|| prev
->literal
)
7610 expr
= head
->remaining
;
7613 for (; expr
; expr
= expr
->next
)
7620 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
7623 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
7625 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
7629 if (fnmatch (expr
->pattern
, s
, 0) == 0)
7635 free ((char *) c_sym
);
7637 free ((char *) cxx_sym
);
7638 if (java_sym
!= sym
)
7639 free ((char *) java_sym
);
7643 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7644 return a pointer to the symbol name with any backslash quotes removed. */
7647 realsymbol (const char *pattern
)
7650 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
7651 char *s
, *symbol
= (char *) xmalloc (strlen (pattern
) + 1);
7653 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
7655 /* It is a glob pattern only if there is no preceding
7659 /* Remove the preceding backslash. */
7666 if (*p
== '?' || *p
== '*' || *p
== '[')
7673 backslash
= *p
== '\\';
7689 /* This is called for each variable name or match expression. NEW_NAME is
7690 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7691 pattern to be matched against symbol names. */
7693 struct bfd_elf_version_expr
*
7694 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
7695 const char *new_name
,
7697 bfd_boolean literal_p
)
7699 struct bfd_elf_version_expr
*ret
;
7701 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
7705 ret
->literal
= TRUE
;
7706 ret
->pattern
= literal_p
? new_name
: realsymbol (new_name
);
7707 if (ret
->pattern
== NULL
)
7709 ret
->pattern
= new_name
;
7710 ret
->literal
= FALSE
;
7713 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
7714 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7715 else if (strcasecmp (lang
, "C++") == 0)
7716 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
7717 else if (strcasecmp (lang
, "Java") == 0)
7718 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
7721 einfo (_("%X%P: unknown language `%s' in version information\n"),
7723 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
7726 return ldemul_new_vers_pattern (ret
);
7729 /* This is called for each set of variable names and match
7732 struct bfd_elf_version_tree
*
7733 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
7734 struct bfd_elf_version_expr
*locals
)
7736 struct bfd_elf_version_tree
*ret
;
7738 ret
= (struct bfd_elf_version_tree
*) xcalloc (1, sizeof *ret
);
7739 ret
->globals
.list
= globals
;
7740 ret
->locals
.list
= locals
;
7741 ret
->match
= lang_vers_match
;
7742 ret
->name_indx
= (unsigned int) -1;
7746 /* This static variable keeps track of version indices. */
7748 static int version_index
;
7751 version_expr_head_hash (const void *p
)
7753 const struct bfd_elf_version_expr
*e
=
7754 (const struct bfd_elf_version_expr
*) p
;
7756 return htab_hash_string (e
->pattern
);
7760 version_expr_head_eq (const void *p1
, const void *p2
)
7762 const struct bfd_elf_version_expr
*e1
=
7763 (const struct bfd_elf_version_expr
*) p1
;
7764 const struct bfd_elf_version_expr
*e2
=
7765 (const struct bfd_elf_version_expr
*) p2
;
7767 return strcmp (e1
->pattern
, e2
->pattern
) == 0;
7771 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
7774 struct bfd_elf_version_expr
*e
, *next
;
7775 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
7777 for (e
= head
->list
; e
; e
= e
->next
)
7781 head
->mask
|= e
->mask
;
7786 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
7787 version_expr_head_eq
, NULL
);
7788 list_loc
= &head
->list
;
7789 remaining_loc
= &head
->remaining
;
7790 for (e
= head
->list
; e
; e
= next
)
7796 remaining_loc
= &e
->next
;
7800 void **loc
= htab_find_slot ((htab_t
) head
->htab
, e
, INSERT
);
7804 struct bfd_elf_version_expr
*e1
, *last
;
7806 e1
= (struct bfd_elf_version_expr
*) *loc
;
7810 if (e1
->mask
== e
->mask
)
7818 while (e1
&& strcmp (e1
->pattern
, e
->pattern
) == 0);
7822 /* This is a duplicate. */
7823 /* FIXME: Memory leak. Sometimes pattern is not
7824 xmalloced alone, but in larger chunk of memory. */
7825 /* free (e->pattern); */
7830 e
->next
= last
->next
;
7838 list_loc
= &e
->next
;
7842 *remaining_loc
= NULL
;
7843 *list_loc
= head
->remaining
;
7846 head
->remaining
= head
->list
;
7849 /* This is called when we know the name and dependencies of the
7853 lang_register_vers_node (const char *name
,
7854 struct bfd_elf_version_tree
*version
,
7855 struct bfd_elf_version_deps
*deps
)
7857 struct bfd_elf_version_tree
*t
, **pp
;
7858 struct bfd_elf_version_expr
*e1
;
7863 if (link_info
.version_info
!= NULL
7864 && (name
[0] == '\0' || link_info
.version_info
->name
[0] == '\0'))
7866 einfo (_("%X%P: anonymous version tag cannot be combined"
7867 " with other version tags\n"));
7872 /* Make sure this node has a unique name. */
7873 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7874 if (strcmp (t
->name
, name
) == 0)
7875 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
7877 lang_finalize_version_expr_head (&version
->globals
);
7878 lang_finalize_version_expr_head (&version
->locals
);
7880 /* Check the global and local match names, and make sure there
7881 aren't any duplicates. */
7883 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
7885 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7887 struct bfd_elf_version_expr
*e2
;
7889 if (t
->locals
.htab
&& e1
->literal
)
7891 e2
= (struct bfd_elf_version_expr
*)
7892 htab_find ((htab_t
) t
->locals
.htab
, e1
);
7893 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
7895 if (e1
->mask
== e2
->mask
)
7896 einfo (_("%X%P: duplicate expression `%s'"
7897 " in version information\n"), e1
->pattern
);
7901 else if (!e1
->literal
)
7902 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7903 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7904 && e1
->mask
== e2
->mask
)
7905 einfo (_("%X%P: duplicate expression `%s'"
7906 " in version information\n"), e1
->pattern
);
7910 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
7912 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7914 struct bfd_elf_version_expr
*e2
;
7916 if (t
->globals
.htab
&& e1
->literal
)
7918 e2
= (struct bfd_elf_version_expr
*)
7919 htab_find ((htab_t
) t
->globals
.htab
, e1
);
7920 while (e2
&& strcmp (e1
->pattern
, e2
->pattern
) == 0)
7922 if (e1
->mask
== e2
->mask
)
7923 einfo (_("%X%P: duplicate expression `%s'"
7924 " in version information\n"),
7929 else if (!e1
->literal
)
7930 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
7931 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
7932 && e1
->mask
== e2
->mask
)
7933 einfo (_("%X%P: duplicate expression `%s'"
7934 " in version information\n"), e1
->pattern
);
7938 version
->deps
= deps
;
7939 version
->name
= name
;
7940 if (name
[0] != '\0')
7943 version
->vernum
= version_index
;
7946 version
->vernum
= 0;
7948 for (pp
= &link_info
.version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
7953 /* This is called when we see a version dependency. */
7955 struct bfd_elf_version_deps
*
7956 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
7958 struct bfd_elf_version_deps
*ret
;
7959 struct bfd_elf_version_tree
*t
;
7961 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
7964 for (t
= link_info
.version_info
; t
!= NULL
; t
= t
->next
)
7966 if (strcmp (t
->name
, name
) == 0)
7968 ret
->version_needed
= t
;
7973 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
7975 ret
->version_needed
= NULL
;
7980 lang_do_version_exports_section (void)
7982 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
7984 LANG_FOR_EACH_INPUT_STATEMENT (is
)
7986 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
7994 contents
= (char *) xmalloc (len
);
7995 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
7996 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
7999 while (p
< contents
+ len
)
8001 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
8002 p
= strchr (p
, '\0') + 1;
8005 /* Do not free the contents, as we used them creating the regex. */
8007 /* Do not include this section in the link. */
8008 sec
->flags
|= SEC_EXCLUDE
| SEC_KEEP
;
8011 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
8012 lang_register_vers_node (command_line
.version_exports_section
,
8013 lang_new_vers_node (greg
, lreg
), NULL
);
8017 lang_add_unique (const char *name
)
8019 struct unique_sections
*ent
;
8021 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
8022 if (strcmp (ent
->name
, name
) == 0)
8025 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
8026 ent
->name
= xstrdup (name
);
8027 ent
->next
= unique_section_list
;
8028 unique_section_list
= ent
;
8031 /* Append the list of dynamic symbols to the existing one. */
8034 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
8036 if (link_info
.dynamic_list
)
8038 struct bfd_elf_version_expr
*tail
;
8039 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
8041 tail
->next
= link_info
.dynamic_list
->head
.list
;
8042 link_info
.dynamic_list
->head
.list
= dynamic
;
8046 struct bfd_elf_dynamic_list
*d
;
8048 d
= (struct bfd_elf_dynamic_list
*) xcalloc (1, sizeof *d
);
8049 d
->head
.list
= dynamic
;
8050 d
->match
= lang_vers_match
;
8051 link_info
.dynamic_list
= d
;
8055 /* Append the list of C++ typeinfo dynamic symbols to the existing
8059 lang_append_dynamic_list_cpp_typeinfo (void)
8061 const char * symbols
[] =
8063 "typeinfo name for*",
8066 struct bfd_elf_version_expr
*dynamic
= NULL
;
8069 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8070 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8073 lang_append_dynamic_list (dynamic
);
8076 /* Append the list of C++ operator new and delete dynamic symbols to the
8080 lang_append_dynamic_list_cpp_new (void)
8082 const char * symbols
[] =
8087 struct bfd_elf_version_expr
*dynamic
= NULL
;
8090 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
8091 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
8094 lang_append_dynamic_list (dynamic
);
8097 /* Scan a space and/or comma separated string of features. */
8100 lang_ld_feature (char *str
)
8108 while (*p
== ',' || ISSPACE (*p
))
8113 while (*q
&& *q
!= ',' && !ISSPACE (*q
))
8117 if (strcasecmp (p
, "SANE_EXPR") == 0)
8118 config
.sane_expr
= TRUE
;
8120 einfo (_("%X%P: unknown feature `%s'\n"), p
);