1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006
4 Free Software Foundation, Inc.
6 This file is part of GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
25 #include "libiberty.h"
26 #include "safe-ctype.h"
45 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
48 /* Locals variables. */
49 static struct obstack stat_obstack
;
50 static struct obstack map_obstack
;
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
54 static const char *startup_file
;
55 static lang_statement_list_type input_file_chain
;
56 static bfd_boolean placed_commons
= FALSE
;
57 static bfd_boolean stripped_excluded_sections
= FALSE
;
58 static lang_output_section_statement_type
*default_common_section
;
59 static bfd_boolean map_option_f
;
60 static bfd_vma print_dot
;
61 static lang_input_statement_type
*first_file
;
62 static const char *current_target
;
63 static const char *output_target
;
64 static lang_statement_list_type statement_list
;
65 static struct bfd_hash_table lang_definedness_table
;
67 /* Forward declarations. */
68 static void exp_init_os (etree_type
*);
69 static void init_map_userdata (bfd
*, asection
*, void *);
70 static lang_input_statement_type
*lookup_name (const char *);
71 static bfd_boolean
load_symbols (lang_input_statement_type
*,
72 lang_statement_list_type
*);
73 static struct bfd_hash_entry
*lang_definedness_newfunc
74 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
75 static void insert_undefined (const char *);
76 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
77 static void print_statement (lang_statement_union_type
*,
78 lang_output_section_statement_type
*);
79 static void print_statement_list (lang_statement_union_type
*,
80 lang_output_section_statement_type
*);
81 static void print_statements (void);
82 static void print_input_section (asection
*);
83 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
84 static void lang_record_phdrs (void);
85 static void lang_do_version_exports_section (void);
86 static void lang_finalize_version_expr_head
87 (struct bfd_elf_version_expr_head
*);
89 /* Exported variables. */
90 lang_output_section_statement_type
*abs_output_section
;
91 lang_statement_list_type lang_output_section_statement
;
92 lang_statement_list_type
*stat_ptr
= &statement_list
;
93 lang_statement_list_type file_chain
= { NULL
, NULL
};
94 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
95 static const char *entry_symbol_default
= "start";
96 const char *entry_section
= ".text";
97 bfd_boolean entry_from_cmdline
;
98 bfd_boolean lang_has_input_file
= FALSE
;
99 bfd_boolean had_output_filename
= FALSE
;
100 bfd_boolean lang_float_flag
= FALSE
;
101 bfd_boolean delete_output_file_on_failure
= FALSE
;
102 struct lang_phdr
*lang_phdr_list
;
103 struct lang_nocrossrefs
*nocrossref_list
;
104 static struct unique_sections
*unique_section_list
;
105 static bfd_boolean ldlang_sysrooted_script
= FALSE
;
107 /* Functions that traverse the linker script and might evaluate
108 DEFINED() need to increment this. */
109 int lang_statement_iteration
= 0;
111 etree_type
*base
; /* Relocation base - or null */
113 /* Return TRUE if the PATTERN argument is a wildcard pattern.
114 Although backslashes are treated specially if a pattern contains
115 wildcards, we do not consider the mere presence of a backslash to
116 be enough to cause the pattern to be treated as a wildcard.
117 That lets us handle DOS filenames more naturally. */
118 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
120 #define new_stat(x, y) \
121 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
123 #define outside_section_address(q) \
124 ((q)->output_offset + (q)->output_section->vma)
126 #define outside_symbol_address(q) \
127 ((q)->value + outside_section_address (q->section))
129 #define SECTION_NAME_MAP_LENGTH (16)
132 stat_alloc (size_t size
)
134 return obstack_alloc (&stat_obstack
, size
);
138 unique_section_p (const asection
*sec
)
140 struct unique_sections
*unam
;
143 if (link_info
.relocatable
144 && sec
->owner
!= NULL
145 && bfd_is_group_section (sec
->owner
, sec
))
149 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
150 if (wildcardp (unam
->name
)
151 ? fnmatch (unam
->name
, secnam
, 0) == 0
152 : strcmp (unam
->name
, secnam
) == 0)
160 /* Generic traversal routines for finding matching sections. */
162 /* Try processing a section against a wildcard. This just calls
163 the callback unless the filename exclusion list is present
164 and excludes the file. It's hardly ever present so this
165 function is very fast. */
168 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
169 lang_input_statement_type
*file
,
171 struct wildcard_list
*sec
,
175 bfd_boolean skip
= FALSE
;
176 struct name_list
*list_tmp
;
178 /* Don't process sections from files which were
180 for (list_tmp
= sec
->spec
.exclude_name_list
;
182 list_tmp
= list_tmp
->next
)
184 bfd_boolean is_wildcard
= wildcardp (list_tmp
->name
);
186 skip
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
188 skip
= strcmp (list_tmp
->name
, file
->filename
) == 0;
190 /* If this file is part of an archive, and the archive is
191 excluded, exclude this file. */
192 if (! skip
&& file
->the_bfd
!= NULL
193 && file
->the_bfd
->my_archive
!= NULL
194 && file
->the_bfd
->my_archive
->filename
!= NULL
)
197 skip
= fnmatch (list_tmp
->name
,
198 file
->the_bfd
->my_archive
->filename
,
201 skip
= strcmp (list_tmp
->name
,
202 file
->the_bfd
->my_archive
->filename
) == 0;
210 (*callback
) (ptr
, sec
, s
, file
, data
);
213 /* Lowest common denominator routine that can handle everything correctly,
217 walk_wild_section_general (lang_wild_statement_type
*ptr
,
218 lang_input_statement_type
*file
,
223 struct wildcard_list
*sec
;
225 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
227 sec
= ptr
->section_list
;
229 (*callback
) (ptr
, sec
, s
, file
, data
);
233 bfd_boolean skip
= FALSE
;
235 if (sec
->spec
.name
!= NULL
)
237 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
239 if (wildcardp (sec
->spec
.name
))
240 skip
= fnmatch (sec
->spec
.name
, sname
, 0) != 0;
242 skip
= strcmp (sec
->spec
.name
, sname
) != 0;
246 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
253 /* Routines to find a single section given its name. If there's more
254 than one section with that name, we report that. */
258 asection
*found_section
;
259 bfd_boolean multiple_sections_found
;
260 } section_iterator_callback_data
;
263 section_iterator_callback (bfd
*bfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
265 section_iterator_callback_data
*d
= data
;
267 if (d
->found_section
!= NULL
)
269 d
->multiple_sections_found
= TRUE
;
273 d
->found_section
= s
;
278 find_section (lang_input_statement_type
*file
,
279 struct wildcard_list
*sec
,
280 bfd_boolean
*multiple_sections_found
)
282 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
284 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
285 section_iterator_callback
, &cb_data
);
286 *multiple_sections_found
= cb_data
.multiple_sections_found
;
287 return cb_data
.found_section
;
290 /* Code for handling simple wildcards without going through fnmatch,
291 which can be expensive because of charset translations etc. */
293 /* A simple wild is a literal string followed by a single '*',
294 where the literal part is at least 4 characters long. */
297 is_simple_wild (const char *name
)
299 size_t len
= strcspn (name
, "*?[");
300 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
304 match_simple_wild (const char *pattern
, const char *name
)
306 /* The first four characters of the pattern are guaranteed valid
307 non-wildcard characters. So we can go faster. */
308 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
309 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
314 while (*pattern
!= '*')
315 if (*name
++ != *pattern
++)
321 /* Compare sections ASEC and BSEC according to SORT. */
324 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
333 case by_alignment_name
:
334 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
335 - bfd_section_alignment (asec
->owner
, asec
));
341 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
342 bfd_get_section_name (bsec
->owner
, bsec
));
345 case by_name_alignment
:
346 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
347 bfd_get_section_name (bsec
->owner
, bsec
));
353 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
354 - bfd_section_alignment (asec
->owner
, asec
));
361 /* Build a Binary Search Tree to sort sections, unlike insertion sort
362 used in wild_sort(). BST is considerably faster if the number of
363 of sections are large. */
365 static lang_section_bst_type
**
366 wild_sort_fast (lang_wild_statement_type
*wild
,
367 struct wildcard_list
*sec
,
368 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
371 lang_section_bst_type
**tree
;
374 if (!wild
->filenames_sorted
375 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
377 /* Append at the right end of tree. */
379 tree
= &((*tree
)->right
);
385 /* Find the correct node to append this section. */
386 if (compare_section (sec
->spec
.sorted
, section
, (*tree
)->section
) < 0)
387 tree
= &((*tree
)->left
);
389 tree
= &((*tree
)->right
);
395 /* Use wild_sort_fast to build a BST to sort sections. */
398 output_section_callback_fast (lang_wild_statement_type
*ptr
,
399 struct wildcard_list
*sec
,
401 lang_input_statement_type
*file
,
402 void *output ATTRIBUTE_UNUSED
)
404 lang_section_bst_type
*node
;
405 lang_section_bst_type
**tree
;
407 if (unique_section_p (section
))
410 node
= xmalloc (sizeof (lang_section_bst_type
));
413 node
->section
= section
;
415 tree
= wild_sort_fast (ptr
, sec
, file
, section
);
420 /* Convert a sorted sections' BST back to list form. */
423 output_section_callback_tree_to_list (lang_wild_statement_type
*ptr
,
424 lang_section_bst_type
*tree
,
428 output_section_callback_tree_to_list (ptr
, tree
->left
, output
);
430 lang_add_section (&ptr
->children
, tree
->section
,
431 (lang_output_section_statement_type
*) output
);
434 output_section_callback_tree_to_list (ptr
, tree
->right
, output
);
439 /* Specialized, optimized routines for handling different kinds of
443 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
444 lang_input_statement_type
*file
,
448 /* We can just do a hash lookup for the section with the right name.
449 But if that lookup discovers more than one section with the name
450 (should be rare), we fall back to the general algorithm because
451 we would otherwise have to sort the sections to make sure they
452 get processed in the bfd's order. */
453 bfd_boolean multiple_sections_found
;
454 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
455 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
457 if (multiple_sections_found
)
458 walk_wild_section_general (ptr
, file
, callback
, data
);
460 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
464 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
465 lang_input_statement_type
*file
,
470 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
472 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
474 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
475 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
478 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
483 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
484 lang_input_statement_type
*file
,
489 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
490 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
491 bfd_boolean multiple_sections_found
;
492 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
494 if (multiple_sections_found
)
496 walk_wild_section_general (ptr
, file
, callback
, data
);
500 /* Note that if the section was not found, s0 is NULL and
501 we'll simply never succeed the s == s0 test below. */
502 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
504 /* Recall that in this code path, a section cannot satisfy more
505 than one spec, so if s == s0 then it cannot match
508 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
511 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
512 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
515 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
522 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
523 lang_input_statement_type
*file
,
528 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
529 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
530 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
531 bfd_boolean multiple_sections_found
;
532 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
534 if (multiple_sections_found
)
536 walk_wild_section_general (ptr
, file
, callback
, data
);
540 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
543 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
546 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
547 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
550 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
553 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
555 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
563 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
564 lang_input_statement_type
*file
,
569 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
570 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
571 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
572 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
573 bfd_boolean multiple_sections_found
;
574 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
576 if (multiple_sections_found
)
578 walk_wild_section_general (ptr
, file
, callback
, data
);
582 s1
= find_section (file
, sec1
, &multiple_sections_found
);
583 if (multiple_sections_found
)
585 walk_wild_section_general (ptr
, file
, callback
, data
);
589 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
592 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
595 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
598 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
599 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
603 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
607 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
609 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
617 walk_wild_section (lang_wild_statement_type
*ptr
,
618 lang_input_statement_type
*file
,
622 if (file
->just_syms_flag
)
625 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
628 /* Returns TRUE when name1 is a wildcard spec that might match
629 something name2 can match. We're conservative: we return FALSE
630 only if the prefixes of name1 and name2 are different up to the
631 first wildcard character. */
634 wild_spec_can_overlap (const char *name1
, const char *name2
)
636 size_t prefix1_len
= strcspn (name1
, "?*[");
637 size_t prefix2_len
= strcspn (name2
, "?*[");
638 size_t min_prefix_len
;
640 /* Note that if there is no wildcard character, then we treat the
641 terminating 0 as part of the prefix. Thus ".text" won't match
642 ".text." or ".text.*", for example. */
643 if (name1
[prefix1_len
] == '\0')
645 if (name2
[prefix2_len
] == '\0')
648 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
650 return memcmp (name1
, name2
, min_prefix_len
) == 0;
653 /* Select specialized code to handle various kinds of wildcard
657 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
660 int wild_name_count
= 0;
661 struct wildcard_list
*sec
;
665 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
666 ptr
->handler_data
[0] = NULL
;
667 ptr
->handler_data
[1] = NULL
;
668 ptr
->handler_data
[2] = NULL
;
669 ptr
->handler_data
[3] = NULL
;
672 /* Count how many wildcard_specs there are, and how many of those
673 actually use wildcards in the name. Also, bail out if any of the
674 wildcard names are NULL. (Can this actually happen?
675 walk_wild_section used to test for it.) And bail out if any
676 of the wildcards are more complex than a simple string
677 ending in a single '*'. */
678 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
681 if (sec
->spec
.name
== NULL
)
683 if (wildcardp (sec
->spec
.name
))
686 if (!is_simple_wild (sec
->spec
.name
))
691 /* The zero-spec case would be easy to optimize but it doesn't
692 happen in practice. Likewise, more than 4 specs doesn't
693 happen in practice. */
694 if (sec_count
== 0 || sec_count
> 4)
697 /* Check that no two specs can match the same section. */
698 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
700 struct wildcard_list
*sec2
;
701 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
703 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
708 signature
= (sec_count
<< 8) + wild_name_count
;
712 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
715 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
718 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
721 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
724 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
730 /* Now fill the data array with pointers to the specs, first the
731 specs with non-wildcard names, then the specs with wildcard
732 names. It's OK to process the specs in different order from the
733 given order, because we've already determined that no section
734 will match more than one spec. */
736 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
737 if (!wildcardp (sec
->spec
.name
))
738 ptr
->handler_data
[data_counter
++] = sec
;
739 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
740 if (wildcardp (sec
->spec
.name
))
741 ptr
->handler_data
[data_counter
++] = sec
;
744 /* Handle a wild statement for a single file F. */
747 walk_wild_file (lang_wild_statement_type
*s
,
748 lang_input_statement_type
*f
,
752 if (f
->the_bfd
== NULL
753 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
754 walk_wild_section (s
, f
, callback
, data
);
759 /* This is an archive file. We must map each member of the
760 archive separately. */
761 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
762 while (member
!= NULL
)
764 /* When lookup_name is called, it will call the add_symbols
765 entry point for the archive. For each element of the
766 archive which is included, BFD will call ldlang_add_file,
767 which will set the usrdata field of the member to the
768 lang_input_statement. */
769 if (member
->usrdata
!= NULL
)
771 walk_wild_section (s
, member
->usrdata
, callback
, data
);
774 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
780 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
782 const char *file_spec
= s
->filename
;
784 if (file_spec
== NULL
)
786 /* Perform the iteration over all files in the list. */
787 LANG_FOR_EACH_INPUT_STATEMENT (f
)
789 walk_wild_file (s
, f
, callback
, data
);
792 else if (wildcardp (file_spec
))
794 LANG_FOR_EACH_INPUT_STATEMENT (f
)
796 if (fnmatch (file_spec
, f
->filename
, 0) == 0)
797 walk_wild_file (s
, f
, callback
, data
);
802 lang_input_statement_type
*f
;
804 /* Perform the iteration over a single file. */
805 f
= lookup_name (file_spec
);
807 walk_wild_file (s
, f
, callback
, data
);
811 /* lang_for_each_statement walks the parse tree and calls the provided
812 function for each node. */
815 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
816 lang_statement_union_type
*s
)
818 for (; s
!= NULL
; s
= s
->header
.next
)
822 switch (s
->header
.type
)
824 case lang_constructors_statement_enum
:
825 lang_for_each_statement_worker (func
, constructor_list
.head
);
827 case lang_output_section_statement_enum
:
828 lang_for_each_statement_worker
829 (func
, s
->output_section_statement
.children
.head
);
831 case lang_wild_statement_enum
:
832 lang_for_each_statement_worker (func
,
833 s
->wild_statement
.children
.head
);
835 case lang_group_statement_enum
:
836 lang_for_each_statement_worker (func
,
837 s
->group_statement
.children
.head
);
839 case lang_data_statement_enum
:
840 case lang_reloc_statement_enum
:
841 case lang_object_symbols_statement_enum
:
842 case lang_output_statement_enum
:
843 case lang_target_statement_enum
:
844 case lang_input_section_enum
:
845 case lang_input_statement_enum
:
846 case lang_assignment_statement_enum
:
847 case lang_padding_statement_enum
:
848 case lang_address_statement_enum
:
849 case lang_fill_statement_enum
:
859 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
861 lang_for_each_statement_worker (func
, statement_list
.head
);
864 /*----------------------------------------------------------------------*/
867 lang_list_init (lang_statement_list_type
*list
)
870 list
->tail
= &list
->head
;
873 /* Build a new statement node for the parse tree. */
875 static lang_statement_union_type
*
876 new_statement (enum statement_enum type
,
878 lang_statement_list_type
*list
)
880 lang_statement_union_type
*new;
882 new = stat_alloc (size
);
883 new->header
.type
= type
;
884 new->header
.next
= NULL
;
885 lang_statement_append (list
, new, &new->header
.next
);
889 /* Build a new input file node for the language. There are several
890 ways in which we treat an input file, eg, we only look at symbols,
891 or prefix it with a -l etc.
893 We can be supplied with requests for input files more than once;
894 they may, for example be split over several lines like foo.o(.text)
895 foo.o(.data) etc, so when asked for a file we check that we haven't
896 got it already so we don't duplicate the bfd. */
898 static lang_input_statement_type
*
899 new_afile (const char *name
,
900 lang_input_file_enum_type file_type
,
902 bfd_boolean add_to_list
)
904 lang_input_statement_type
*p
;
907 p
= new_stat (lang_input_statement
, stat_ptr
);
910 p
= stat_alloc (sizeof (lang_input_statement_type
));
911 p
->header
.type
= lang_input_statement_enum
;
912 p
->header
.next
= NULL
;
915 lang_has_input_file
= TRUE
;
917 p
->sysrooted
= FALSE
;
920 case lang_input_file_is_symbols_only_enum
:
922 p
->is_archive
= FALSE
;
924 p
->local_sym_name
= name
;
925 p
->just_syms_flag
= TRUE
;
926 p
->search_dirs_flag
= FALSE
;
928 case lang_input_file_is_fake_enum
:
930 p
->is_archive
= FALSE
;
932 p
->local_sym_name
= name
;
933 p
->just_syms_flag
= FALSE
;
934 p
->search_dirs_flag
= FALSE
;
936 case lang_input_file_is_l_enum
:
937 p
->is_archive
= TRUE
;
940 p
->local_sym_name
= concat ("-l", name
, NULL
);
941 p
->just_syms_flag
= FALSE
;
942 p
->search_dirs_flag
= TRUE
;
944 case lang_input_file_is_marker_enum
:
946 p
->is_archive
= FALSE
;
948 p
->local_sym_name
= name
;
949 p
->just_syms_flag
= FALSE
;
950 p
->search_dirs_flag
= TRUE
;
952 case lang_input_file_is_search_file_enum
:
953 p
->sysrooted
= ldlang_sysrooted_script
;
955 p
->is_archive
= FALSE
;
957 p
->local_sym_name
= name
;
958 p
->just_syms_flag
= FALSE
;
959 p
->search_dirs_flag
= TRUE
;
961 case lang_input_file_is_file_enum
:
963 p
->is_archive
= FALSE
;
965 p
->local_sym_name
= name
;
966 p
->just_syms_flag
= FALSE
;
967 p
->search_dirs_flag
= FALSE
;
974 p
->next_real_file
= NULL
;
977 p
->dynamic
= config
.dynamic_link
;
978 p
->add_needed
= add_needed
;
979 p
->as_needed
= as_needed
;
980 p
->whole_archive
= whole_archive
;
982 lang_statement_append (&input_file_chain
,
983 (lang_statement_union_type
*) p
,
988 lang_input_statement_type
*
989 lang_add_input_file (const char *name
,
990 lang_input_file_enum_type file_type
,
993 lang_has_input_file
= TRUE
;
994 return new_afile (name
, file_type
, target
, TRUE
);
997 struct out_section_hash_entry
999 struct bfd_hash_entry root
;
1000 lang_statement_union_type s
;
1003 /* The hash table. */
1005 static struct bfd_hash_table output_section_statement_table
;
1007 /* Support routines for the hash table used by lang_output_section_find,
1008 initialize the table, fill in an entry and remove the table. */
1010 static struct bfd_hash_entry
*
1011 output_section_statement_newfunc (struct bfd_hash_entry
*entry
,
1012 struct bfd_hash_table
*table
,
1015 lang_output_section_statement_type
**nextp
;
1016 struct out_section_hash_entry
*ret
;
1020 entry
= bfd_hash_allocate (table
, sizeof (*ret
));
1025 entry
= bfd_hash_newfunc (entry
, table
, string
);
1029 ret
= (struct out_section_hash_entry
*) entry
;
1030 memset (&ret
->s
, 0, sizeof (ret
->s
));
1031 ret
->s
.header
.type
= lang_output_section_statement_enum
;
1032 ret
->s
.output_section_statement
.subsection_alignment
= -1;
1033 ret
->s
.output_section_statement
.section_alignment
= -1;
1034 ret
->s
.output_section_statement
.block_value
= 1;
1035 lang_list_init (&ret
->s
.output_section_statement
.children
);
1036 lang_statement_append (stat_ptr
, &ret
->s
, &ret
->s
.header
.next
);
1038 /* For every output section statement added to the list, except the
1039 first one, lang_output_section_statement.tail points to the "next"
1040 field of the last element of the list. */
1041 if (lang_output_section_statement
.head
!= NULL
)
1042 ret
->s
.output_section_statement
.prev
1043 = ((lang_output_section_statement_type
*)
1044 ((char *) lang_output_section_statement
.tail
1045 - offsetof (lang_output_section_statement_type
, next
)));
1047 /* GCC's strict aliasing rules prevent us from just casting the
1048 address, so we store the pointer in a variable and cast that
1050 nextp
= &ret
->s
.output_section_statement
.next
;
1051 lang_statement_append (&lang_output_section_statement
,
1053 (lang_statement_union_type
**) nextp
);
1058 output_section_statement_table_init (void)
1060 if (!bfd_hash_table_init_n (&output_section_statement_table
,
1061 output_section_statement_newfunc
,
1062 sizeof (struct out_section_hash_entry
),
1064 einfo (_("%P%F: can not create hash table: %E\n"));
1068 output_section_statement_table_free (void)
1070 bfd_hash_table_free (&output_section_statement_table
);
1073 /* Build enough state so that the parser can build its tree. */
1078 obstack_begin (&stat_obstack
, 1000);
1080 stat_ptr
= &statement_list
;
1082 output_section_statement_table_init ();
1084 lang_list_init (stat_ptr
);
1086 lang_list_init (&input_file_chain
);
1087 lang_list_init (&lang_output_section_statement
);
1088 lang_list_init (&file_chain
);
1089 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
1091 abs_output_section
=
1092 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
1094 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
1096 /* The value "3" is ad-hoc, somewhat related to the expected number of
1097 DEFINED expressions in a linker script. For most default linker
1098 scripts, there are none. Why a hash table then? Well, it's somewhat
1099 simpler to re-use working machinery than using a linked list in terms
1100 of code-complexity here in ld, besides the initialization which just
1101 looks like other code here. */
1102 if (!bfd_hash_table_init_n (&lang_definedness_table
,
1103 lang_definedness_newfunc
,
1104 sizeof (struct lang_definedness_hash_entry
),
1106 einfo (_("%P%F: can not create hash table: %E\n"));
1112 output_section_statement_table_free ();
1115 /*----------------------------------------------------------------------
1116 A region is an area of memory declared with the
1117 MEMORY { name:org=exp, len=exp ... }
1120 We maintain a list of all the regions here.
1122 If no regions are specified in the script, then the default is used
1123 which is created when looked up to be the entire data space.
1125 If create is true we are creating a region inside a MEMORY block.
1126 In this case it is probably an error to create a region that has
1127 already been created. If we are not inside a MEMORY block it is
1128 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1129 and so we issue a warning. */
1131 static lang_memory_region_type
*lang_memory_region_list
;
1132 static lang_memory_region_type
**lang_memory_region_list_tail
1133 = &lang_memory_region_list
;
1135 lang_memory_region_type
*
1136 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
1138 lang_memory_region_type
*p
;
1139 lang_memory_region_type
*new;
1141 /* NAME is NULL for LMA memspecs if no region was specified. */
1145 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1146 if (strcmp (p
->name
, name
) == 0)
1149 einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
1154 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
1155 einfo (_("%P:%S: warning: memory region %s not declared\n"), name
);
1157 new = stat_alloc (sizeof (lang_memory_region_type
));
1159 new->name
= xstrdup (name
);
1162 new->length
= ~(bfd_size_type
) 0;
1164 new->last_os
= NULL
;
1167 new->had_full_message
= FALSE
;
1169 *lang_memory_region_list_tail
= new;
1170 lang_memory_region_list_tail
= &new->next
;
1175 static lang_memory_region_type
*
1176 lang_memory_default (asection
*section
)
1178 lang_memory_region_type
*p
;
1180 flagword sec_flags
= section
->flags
;
1182 /* Override SEC_DATA to mean a writable section. */
1183 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
1184 sec_flags
|= SEC_DATA
;
1186 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
1188 if ((p
->flags
& sec_flags
) != 0
1189 && (p
->not_flags
& sec_flags
) == 0)
1194 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
1197 lang_output_section_statement_type
*
1198 lang_output_section_find (const char *const name
)
1200 struct out_section_hash_entry
*entry
;
1203 entry
= ((struct out_section_hash_entry
*)
1204 bfd_hash_lookup (&output_section_statement_table
, name
,
1209 hash
= entry
->root
.hash
;
1212 if (entry
->s
.output_section_statement
.constraint
!= -1)
1213 return &entry
->s
.output_section_statement
;
1214 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1216 while (entry
!= NULL
1217 && entry
->root
.hash
== hash
1218 && strcmp (name
, entry
->s
.output_section_statement
.name
) == 0);
1223 static lang_output_section_statement_type
*
1224 lang_output_section_statement_lookup_1 (const char *const name
, int constraint
)
1226 struct out_section_hash_entry
*entry
;
1227 struct out_section_hash_entry
*last_ent
;
1230 entry
= ((struct out_section_hash_entry
*)
1231 bfd_hash_lookup (&output_section_statement_table
, name
,
1235 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1239 if (entry
->s
.output_section_statement
.name
!= NULL
)
1241 /* We have a section of this name, but it might not have the correct
1243 hash
= entry
->root
.hash
;
1246 if (entry
->s
.output_section_statement
.constraint
!= -1
1248 || (constraint
== entry
->s
.output_section_statement
.constraint
1249 && constraint
!= SPECIAL
)))
1250 return &entry
->s
.output_section_statement
;
1252 entry
= (struct out_section_hash_entry
*) entry
->root
.next
;
1254 while (entry
!= NULL
1255 && entry
->root
.hash
== hash
1256 && strcmp (name
, entry
->s
.output_section_statement
.name
) == 0);
1259 = ((struct out_section_hash_entry
*)
1260 output_section_statement_newfunc (NULL
,
1261 &output_section_statement_table
,
1265 einfo (_("%P%F: failed creating section `%s': %E\n"), name
);
1268 entry
->root
= last_ent
->root
;
1269 last_ent
->root
.next
= &entry
->root
;
1272 entry
->s
.output_section_statement
.name
= name
;
1273 entry
->s
.output_section_statement
.constraint
= constraint
;
1274 return &entry
->s
.output_section_statement
;
1277 lang_output_section_statement_type
*
1278 lang_output_section_statement_lookup (const char *const name
)
1280 return lang_output_section_statement_lookup_1 (name
, 0);
1283 /* A variant of lang_output_section_find used by place_orphan.
1284 Returns the output statement that should precede a new output
1285 statement for SEC. If an exact match is found on certain flags,
1288 lang_output_section_statement_type
*
1289 lang_output_section_find_by_flags (const asection
*sec
,
1290 lang_output_section_statement_type
**exact
,
1291 lang_match_sec_type_func match_type
)
1293 lang_output_section_statement_type
*first
, *look
, *found
;
1296 /* We know the first statement on this list is *ABS*. May as well
1298 first
= &lang_output_section_statement
.head
->output_section_statement
;
1299 first
= first
->next
;
1301 /* First try for an exact match. */
1303 for (look
= first
; look
; look
= look
->next
)
1305 flags
= look
->flags
;
1306 if (look
->bfd_section
!= NULL
)
1308 flags
= look
->bfd_section
->flags
;
1309 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1313 flags
^= sec
->flags
;
1314 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1315 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1325 if (sec
->flags
& SEC_CODE
)
1327 /* Try for a rw code section. */
1328 for (look
= first
; look
; look
= look
->next
)
1330 flags
= look
->flags
;
1331 if (look
->bfd_section
!= NULL
)
1333 flags
= look
->bfd_section
->flags
;
1334 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1338 flags
^= sec
->flags
;
1339 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1340 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1344 else if (sec
->flags
& (SEC_READONLY
| SEC_THREAD_LOCAL
))
1346 /* .rodata can go after .text, .sdata2 after .rodata. */
1347 for (look
= first
; look
; look
= look
->next
)
1349 flags
= look
->flags
;
1350 if (look
->bfd_section
!= NULL
)
1352 flags
= look
->bfd_section
->flags
;
1353 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1357 flags
^= sec
->flags
;
1358 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1360 && !(look
->flags
& (SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1364 else if (sec
->flags
& SEC_SMALL_DATA
)
1366 /* .sdata goes after .data, .sbss after .sdata. */
1367 for (look
= first
; look
; look
= look
->next
)
1369 flags
= look
->flags
;
1370 if (look
->bfd_section
!= NULL
)
1372 flags
= look
->bfd_section
->flags
;
1373 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1377 flags
^= sec
->flags
;
1378 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1379 | SEC_THREAD_LOCAL
))
1380 || ((look
->flags
& SEC_SMALL_DATA
)
1381 && !(sec
->flags
& SEC_HAS_CONTENTS
)))
1385 else if (sec
->flags
& SEC_HAS_CONTENTS
)
1387 /* .data goes after .rodata. */
1388 for (look
= first
; look
; look
= look
->next
)
1390 flags
= look
->flags
;
1391 if (look
->bfd_section
!= NULL
)
1393 flags
= look
->bfd_section
->flags
;
1394 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1398 flags
^= sec
->flags
;
1399 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1400 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1406 /* .bss goes last. */
1407 for (look
= first
; look
; look
= look
->next
)
1409 flags
= look
->flags
;
1410 if (look
->bfd_section
!= NULL
)
1412 flags
= look
->bfd_section
->flags
;
1413 if (match_type
&& !match_type (output_bfd
, look
->bfd_section
,
1417 flags
^= sec
->flags
;
1418 if (!(flags
& SEC_ALLOC
))
1423 if (found
|| !match_type
)
1426 return lang_output_section_find_by_flags (sec
, NULL
, NULL
);
1429 /* Find the last output section before given output statement.
1430 Used by place_orphan. */
1433 output_prev_sec_find (lang_output_section_statement_type
*os
)
1435 lang_output_section_statement_type
*lookup
;
1437 for (lookup
= os
->prev
; lookup
!= NULL
; lookup
= lookup
->prev
)
1439 if (lookup
->constraint
== -1)
1442 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1443 return lookup
->bfd_section
;
1449 lang_output_section_statement_type
*
1450 lang_insert_orphan (asection
*s
,
1451 const char *secname
,
1452 lang_output_section_statement_type
*after
,
1453 struct orphan_save
*place
,
1454 etree_type
*address
,
1455 lang_statement_list_type
*add_child
)
1457 lang_statement_list_type
*old
;
1458 lang_statement_list_type add
;
1460 lang_output_section_statement_type
*os
;
1461 lang_output_section_statement_type
**os_tail
;
1463 /* Start building a list of statements for this section.
1464 First save the current statement pointer. */
1467 /* If we have found an appropriate place for the output section
1468 statements for this orphan, add them to our own private list,
1469 inserting them later into the global statement list. */
1473 lang_list_init (stat_ptr
);
1477 if (config
.build_constructors
)
1479 /* If the name of the section is representable in C, then create
1480 symbols to mark the start and the end of the section. */
1481 for (ps
= secname
; *ps
!= '\0'; ps
++)
1482 if (! ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
1487 etree_type
*e_align
;
1489 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__start_" + 1);
1490 symname
[0] = bfd_get_symbol_leading_char (output_bfd
);
1491 sprintf (symname
+ (symname
[0] != 0), "__start_%s", secname
);
1492 e_align
= exp_unop (ALIGN_K
,
1493 exp_intop ((bfd_vma
) 1 << s
->alignment_power
));
1494 lang_add_assignment (exp_assop ('=', ".", e_align
));
1495 lang_add_assignment (exp_assop ('=', symname
,
1496 exp_nameop (NAME
, ".")));
1500 if (link_info
.relocatable
|| (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1501 address
= exp_intop (0);
1503 os_tail
= ((lang_output_section_statement_type
**)
1504 lang_output_section_statement
.tail
);
1505 os
= lang_enter_output_section_statement (secname
, address
, 0, NULL
, NULL
,
1508 if (add_child
== NULL
)
1509 add_child
= &os
->children
;
1510 lang_add_section (add_child
, s
, os
);
1512 lang_leave_output_section_statement (0, "*default*", NULL
, NULL
);
1514 if (config
.build_constructors
&& *ps
== '\0')
1518 /* lang_leave_ouput_section_statement resets stat_ptr.
1519 Put stat_ptr back where we want it. */
1523 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__stop_" + 1);
1524 symname
[0] = bfd_get_symbol_leading_char (output_bfd
);
1525 sprintf (symname
+ (symname
[0] != 0), "__stop_%s", secname
);
1526 lang_add_assignment (exp_assop ('=', symname
,
1527 exp_nameop (NAME
, ".")));
1530 /* Restore the global list pointer. */
1534 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1536 asection
*snew
, *as
;
1538 snew
= os
->bfd_section
;
1540 /* Shuffle the bfd section list to make the output file look
1541 neater. This is really only cosmetic. */
1542 if (place
->section
== NULL
1543 && after
!= (&lang_output_section_statement
.head
1544 ->output_section_statement
))
1546 asection
*bfd_section
= after
->bfd_section
;
1548 /* If the output statement hasn't been used to place any input
1549 sections (and thus doesn't have an output bfd_section),
1550 look for the closest prior output statement having an
1552 if (bfd_section
== NULL
)
1553 bfd_section
= output_prev_sec_find (after
);
1555 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1556 place
->section
= &bfd_section
->next
;
1559 if (place
->section
== NULL
)
1560 place
->section
= &output_bfd
->sections
;
1562 as
= *place
->section
;
1566 /* Put the section at the end of the list. */
1568 /* Unlink the section. */
1569 bfd_section_list_remove (output_bfd
, snew
);
1571 /* Now tack it back on in the right place. */
1572 bfd_section_list_append (output_bfd
, snew
);
1574 else if (as
!= snew
&& as
->prev
!= snew
)
1576 /* Unlink the section. */
1577 bfd_section_list_remove (output_bfd
, snew
);
1579 /* Now tack it back on in the right place. */
1580 bfd_section_list_insert_before (output_bfd
, as
, snew
);
1583 /* Save the end of this list. Further ophans of this type will
1584 follow the one we've just added. */
1585 place
->section
= &snew
->next
;
1587 /* The following is non-cosmetic. We try to put the output
1588 statements in some sort of reasonable order here, because they
1589 determine the final load addresses of the orphan sections.
1590 In addition, placing output statements in the wrong order may
1591 require extra segments. For instance, given a typical
1592 situation of all read-only sections placed in one segment and
1593 following that a segment containing all the read-write
1594 sections, we wouldn't want to place an orphan read/write
1595 section before or amongst the read-only ones. */
1596 if (add
.head
!= NULL
)
1598 lang_output_section_statement_type
*newly_added_os
;
1600 if (place
->stmt
== NULL
)
1602 lang_statement_union_type
**where
;
1603 lang_statement_union_type
**assign
= NULL
;
1604 bfd_boolean ignore_first
;
1606 /* Look for a suitable place for the new statement list.
1607 The idea is to skip over anything that might be inside
1608 a SECTIONS {} statement in a script, before we find
1609 another output_section_statement. Assignments to "dot"
1610 before an output section statement are assumed to
1611 belong to it. An exception to this rule is made for
1612 the first assignment to dot, otherwise we might put an
1613 orphan before . = . + SIZEOF_HEADERS or similar
1614 assignments that set the initial address. */
1616 ignore_first
= after
== (&lang_output_section_statement
.head
1617 ->output_section_statement
);
1618 for (where
= &after
->header
.next
;
1620 where
= &(*where
)->header
.next
)
1622 switch ((*where
)->header
.type
)
1624 case lang_assignment_statement_enum
:
1627 lang_assignment_statement_type
*ass
;
1628 ass
= &(*where
)->assignment_statement
;
1629 if (ass
->exp
->type
.node_class
!= etree_assert
1630 && ass
->exp
->assign
.dst
[0] == '.'
1631 && ass
->exp
->assign
.dst
[1] == 0
1635 ignore_first
= FALSE
;
1637 case lang_wild_statement_enum
:
1638 case lang_input_section_enum
:
1639 case lang_object_symbols_statement_enum
:
1640 case lang_fill_statement_enum
:
1641 case lang_data_statement_enum
:
1642 case lang_reloc_statement_enum
:
1643 case lang_padding_statement_enum
:
1644 case lang_constructors_statement_enum
:
1647 case lang_output_section_statement_enum
:
1650 case lang_input_statement_enum
:
1651 case lang_address_statement_enum
:
1652 case lang_target_statement_enum
:
1653 case lang_output_statement_enum
:
1654 case lang_group_statement_enum
:
1655 case lang_afile_asection_pair_statement_enum
:
1664 place
->os_tail
= &after
->next
;
1668 /* Put it after the last orphan statement we added. */
1669 *add
.tail
= *place
->stmt
;
1670 *place
->stmt
= add
.head
;
1673 /* Fix the global list pointer if we happened to tack our
1674 new list at the tail. */
1675 if (*old
->tail
== add
.head
)
1676 old
->tail
= add
.tail
;
1678 /* Save the end of this list. */
1679 place
->stmt
= add
.tail
;
1681 /* Do the same for the list of output section statements. */
1682 newly_added_os
= *os_tail
;
1684 newly_added_os
->prev
= (lang_output_section_statement_type
*)
1685 ((char *) place
->os_tail
1686 - offsetof (lang_output_section_statement_type
, next
));
1687 newly_added_os
->next
= *place
->os_tail
;
1688 if (newly_added_os
->next
!= NULL
)
1689 newly_added_os
->next
->prev
= newly_added_os
;
1690 *place
->os_tail
= newly_added_os
;
1691 place
->os_tail
= &newly_added_os
->next
;
1693 /* Fixing the global list pointer here is a little different.
1694 We added to the list in lang_enter_output_section_statement,
1695 trimmed off the new output_section_statment above when
1696 assigning *os_tail = NULL, but possibly added it back in
1697 the same place when assigning *place->os_tail. */
1698 if (*os_tail
== NULL
)
1699 lang_output_section_statement
.tail
1700 = (lang_statement_union_type
**) os_tail
;
1707 lang_map_flags (flagword flag
)
1709 if (flag
& SEC_ALLOC
)
1712 if (flag
& SEC_CODE
)
1715 if (flag
& SEC_READONLY
)
1718 if (flag
& SEC_DATA
)
1721 if (flag
& SEC_LOAD
)
1728 lang_memory_region_type
*m
;
1729 bfd_boolean dis_header_printed
= FALSE
;
1732 LANG_FOR_EACH_INPUT_STATEMENT (file
)
1736 if ((file
->the_bfd
->flags
& (BFD_LINKER_CREATED
| DYNAMIC
)) != 0
1737 || file
->just_syms_flag
)
1740 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
1741 if (s
->output_section
== NULL
1742 || s
->output_section
->owner
!= output_bfd
)
1744 if (! dis_header_printed
)
1746 fprintf (config
.map_file
, _("\nDiscarded input sections\n\n"));
1747 dis_header_printed
= TRUE
;
1750 print_input_section (s
);
1754 minfo (_("\nMemory Configuration\n\n"));
1755 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
1756 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1758 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
1763 fprintf (config
.map_file
, "%-16s ", m
->name
);
1765 sprintf_vma (buf
, m
->origin
);
1766 minfo ("0x%s ", buf
);
1774 minfo ("0x%V", m
->length
);
1775 if (m
->flags
|| m
->not_flags
)
1783 lang_map_flags (m
->flags
);
1789 lang_map_flags (m
->not_flags
);
1796 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
1798 if (! command_line
.reduce_memory_overheads
)
1800 obstack_begin (&map_obstack
, 1000);
1801 for (p
= link_info
.input_bfds
; p
!= (bfd
*) NULL
; p
= p
->link_next
)
1802 bfd_map_over_sections (p
, init_map_userdata
, 0);
1803 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
1805 print_statements ();
1809 init_map_userdata (abfd
, sec
, data
)
1810 bfd
*abfd ATTRIBUTE_UNUSED
;
1812 void *data ATTRIBUTE_UNUSED
;
1814 fat_section_userdata_type
*new_data
1815 = ((fat_section_userdata_type
*) (stat_alloc
1816 (sizeof (fat_section_userdata_type
))));
1818 ASSERT (get_userdata (sec
) == NULL
);
1819 get_userdata (sec
) = new_data
;
1820 new_data
->map_symbol_def_tail
= &new_data
->map_symbol_def_head
;
1824 sort_def_symbol (hash_entry
, info
)
1825 struct bfd_link_hash_entry
*hash_entry
;
1826 void *info ATTRIBUTE_UNUSED
;
1828 if (hash_entry
->type
== bfd_link_hash_defined
1829 || hash_entry
->type
== bfd_link_hash_defweak
)
1831 struct fat_user_section_struct
*ud
;
1832 struct map_symbol_def
*def
;
1834 ud
= get_userdata (hash_entry
->u
.def
.section
);
1837 /* ??? What do we have to do to initialize this beforehand? */
1838 /* The first time we get here is bfd_abs_section... */
1839 init_map_userdata (0, hash_entry
->u
.def
.section
, 0);
1840 ud
= get_userdata (hash_entry
->u
.def
.section
);
1842 else if (!ud
->map_symbol_def_tail
)
1843 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
1845 def
= obstack_alloc (&map_obstack
, sizeof *def
);
1846 def
->entry
= hash_entry
;
1847 *(ud
->map_symbol_def_tail
) = def
;
1848 ud
->map_symbol_def_tail
= &def
->next
;
1853 /* Initialize an output section. */
1856 init_os (lang_output_section_statement_type
*s
, asection
*isec
,
1859 if (s
->bfd_section
!= NULL
)
1862 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
1863 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
1865 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
1866 if (s
->bfd_section
== NULL
)
1867 s
->bfd_section
= bfd_make_section_with_flags (output_bfd
, s
->name
,
1869 if (s
->bfd_section
== NULL
)
1871 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
1872 output_bfd
->xvec
->name
, s
->name
);
1874 s
->bfd_section
->output_section
= s
->bfd_section
;
1875 s
->bfd_section
->output_offset
= 0;
1877 if (!command_line
.reduce_memory_overheads
)
1879 fat_section_userdata_type
*new
1880 = stat_alloc (sizeof (fat_section_userdata_type
));
1881 memset (new, 0, sizeof (fat_section_userdata_type
));
1882 get_userdata (s
->bfd_section
) = new;
1885 /* If there is a base address, make sure that any sections it might
1886 mention are initialized. */
1887 if (s
->addr_tree
!= NULL
)
1888 exp_init_os (s
->addr_tree
);
1890 if (s
->load_base
!= NULL
)
1891 exp_init_os (s
->load_base
);
1893 /* If supplied an alignment, set it. */
1894 if (s
->section_alignment
!= -1)
1895 s
->bfd_section
->alignment_power
= s
->section_alignment
;
1898 bfd_init_private_section_data (isec
->owner
, isec
,
1899 output_bfd
, s
->bfd_section
,
1903 /* Make sure that all output sections mentioned in an expression are
1907 exp_init_os (etree_type
*exp
)
1909 switch (exp
->type
.node_class
)
1913 exp_init_os (exp
->assign
.src
);
1917 exp_init_os (exp
->binary
.lhs
);
1918 exp_init_os (exp
->binary
.rhs
);
1922 exp_init_os (exp
->trinary
.cond
);
1923 exp_init_os (exp
->trinary
.lhs
);
1924 exp_init_os (exp
->trinary
.rhs
);
1928 exp_init_os (exp
->assert_s
.child
);
1932 exp_init_os (exp
->unary
.child
);
1936 switch (exp
->type
.node_code
)
1942 lang_output_section_statement_type
*os
;
1944 os
= lang_output_section_find (exp
->name
.name
);
1945 if (os
!= NULL
&& os
->bfd_section
== NULL
)
1946 init_os (os
, NULL
, 0);
1957 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
1959 lang_input_statement_type
*entry
= data
;
1961 /* If we are only reading symbols from this object, then we want to
1962 discard all sections. */
1963 if (entry
->just_syms_flag
)
1965 bfd_link_just_syms (abfd
, sec
, &link_info
);
1969 if (!(abfd
->flags
& DYNAMIC
))
1970 bfd_section_already_linked (abfd
, sec
);
1973 /* The wild routines.
1975 These expand statements like *(.text) and foo.o to a list of
1976 explicit actions, like foo.o(.text), bar.o(.text) and
1977 foo.o(.text, .data). */
1979 /* Add SECTION to the output section OUTPUT. Do this by creating a
1980 lang_input_section statement which is placed at PTR. FILE is the
1981 input file which holds SECTION. */
1984 lang_add_section (lang_statement_list_type
*ptr
,
1986 lang_output_section_statement_type
*output
)
1988 flagword flags
= section
->flags
;
1989 bfd_boolean discard
;
1991 /* Discard sections marked with SEC_EXCLUDE. */
1992 discard
= (flags
& SEC_EXCLUDE
) != 0;
1994 /* Discard input sections which are assigned to a section named
1995 DISCARD_SECTION_NAME. */
1996 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1999 /* Discard debugging sections if we are stripping debugging
2001 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
2002 && (flags
& SEC_DEBUGGING
) != 0)
2007 if (section
->output_section
== NULL
)
2009 /* This prevents future calls from assigning this section. */
2010 section
->output_section
= bfd_abs_section_ptr
;
2015 if (section
->output_section
== NULL
)
2018 lang_input_section_type
*new;
2021 flags
= section
->flags
;
2023 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2024 to an output section, because we want to be able to include a
2025 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2026 section (I don't know why we want to do this, but we do).
2027 build_link_order in ldwrite.c handles this case by turning
2028 the embedded SEC_NEVER_LOAD section into a fill. */
2030 flags
&= ~ SEC_NEVER_LOAD
;
2032 switch (output
->sectype
)
2034 case normal_section
:
2036 case noalloc_section
:
2037 flags
&= ~SEC_ALLOC
;
2039 case noload_section
:
2041 flags
|= SEC_NEVER_LOAD
;
2045 if (output
->bfd_section
== NULL
)
2046 init_os (output
, section
, flags
);
2048 first
= ! output
->bfd_section
->linker_has_input
;
2049 output
->bfd_section
->linker_has_input
= 1;
2051 if (!link_info
.relocatable
2052 && !stripped_excluded_sections
)
2054 asection
*s
= output
->bfd_section
->map_tail
.s
;
2055 output
->bfd_section
->map_tail
.s
= section
;
2056 section
->map_head
.s
= NULL
;
2057 section
->map_tail
.s
= s
;
2059 s
->map_head
.s
= section
;
2061 output
->bfd_section
->map_head
.s
= section
;
2064 /* Add a section reference to the list. */
2065 new = new_stat (lang_input_section
, ptr
);
2067 new->section
= section
;
2068 section
->output_section
= output
->bfd_section
;
2070 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2071 already been processed. One reason to do this is that on pe
2072 format targets, .text$foo sections go into .text and it's odd
2073 to see .text with SEC_LINK_ONCE set. */
2075 if (! link_info
.relocatable
)
2076 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
2078 /* If this is not the first input section, and the SEC_READONLY
2079 flag is not currently set, then don't set it just because the
2080 input section has it set. */
2082 if (! first
&& (output
->bfd_section
->flags
& SEC_READONLY
) == 0)
2083 flags
&= ~ SEC_READONLY
;
2085 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2087 && ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
2088 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
2089 || ((flags
& SEC_MERGE
)
2090 && output
->bfd_section
->entsize
!= section
->entsize
)))
2092 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2093 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
2096 output
->bfd_section
->flags
|= flags
;
2098 if (flags
& SEC_MERGE
)
2099 output
->bfd_section
->entsize
= section
->entsize
;
2101 /* If SEC_READONLY is not set in the input section, then clear
2102 it from the output section. */
2103 if ((section
->flags
& SEC_READONLY
) == 0)
2104 output
->bfd_section
->flags
&= ~SEC_READONLY
;
2106 /* Copy over SEC_SMALL_DATA. */
2107 if (section
->flags
& SEC_SMALL_DATA
)
2108 output
->bfd_section
->flags
|= SEC_SMALL_DATA
;
2110 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
2111 output
->bfd_section
->alignment_power
= section
->alignment_power
;
2113 if (bfd_get_arch (section
->owner
) == bfd_arch_tic54x
2114 && (section
->flags
& SEC_TIC54X_BLOCK
) != 0)
2116 output
->bfd_section
->flags
|= SEC_TIC54X_BLOCK
;
2117 /* FIXME: This value should really be obtained from the bfd... */
2118 output
->block_value
= 128;
2123 /* Handle wildcard sorting. This returns the lang_input_section which
2124 should follow the one we are going to create for SECTION and FILE,
2125 based on the sorting requirements of WILD. It returns NULL if the
2126 new section should just go at the end of the current list. */
2128 static lang_statement_union_type
*
2129 wild_sort (lang_wild_statement_type
*wild
,
2130 struct wildcard_list
*sec
,
2131 lang_input_statement_type
*file
,
2134 const char *section_name
;
2135 lang_statement_union_type
*l
;
2137 if (!wild
->filenames_sorted
2138 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
2141 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
2142 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
2144 lang_input_section_type
*ls
;
2146 if (l
->header
.type
!= lang_input_section_enum
)
2148 ls
= &l
->input_section
;
2150 /* Sorting by filename takes precedence over sorting by section
2153 if (wild
->filenames_sorted
)
2155 const char *fn
, *ln
;
2159 /* The PE support for the .idata section as generated by
2160 dlltool assumes that files will be sorted by the name of
2161 the archive and then the name of the file within the
2164 if (file
->the_bfd
!= NULL
2165 && bfd_my_archive (file
->the_bfd
) != NULL
)
2167 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
2172 fn
= file
->filename
;
2176 if (bfd_my_archive (ls
->section
->owner
) != NULL
)
2178 ln
= bfd_get_filename (bfd_my_archive (ls
->section
->owner
));
2183 ln
= ls
->section
->owner
->filename
;
2187 i
= strcmp (fn
, ln
);
2196 fn
= file
->filename
;
2198 ln
= ls
->section
->owner
->filename
;
2200 i
= strcmp (fn
, ln
);
2208 /* Here either the files are not sorted by name, or we are
2209 looking at the sections for this file. */
2211 if (sec
!= NULL
&& sec
->spec
.sorted
!= none
)
2212 if (compare_section (sec
->spec
.sorted
, section
, ls
->section
) < 0)
2219 /* Expand a wild statement for a particular FILE. SECTION may be
2220 NULL, in which case it is a wild card. */
2223 output_section_callback (lang_wild_statement_type
*ptr
,
2224 struct wildcard_list
*sec
,
2226 lang_input_statement_type
*file
,
2229 lang_statement_union_type
*before
;
2231 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2232 if (unique_section_p (section
))
2235 before
= wild_sort (ptr
, sec
, file
, section
);
2237 /* Here BEFORE points to the lang_input_section which
2238 should follow the one we are about to add. If BEFORE
2239 is NULL, then the section should just go at the end
2240 of the current list. */
2243 lang_add_section (&ptr
->children
, section
,
2244 (lang_output_section_statement_type
*) output
);
2247 lang_statement_list_type list
;
2248 lang_statement_union_type
**pp
;
2250 lang_list_init (&list
);
2251 lang_add_section (&list
, section
,
2252 (lang_output_section_statement_type
*) output
);
2254 /* If we are discarding the section, LIST.HEAD will
2256 if (list
.head
!= NULL
)
2258 ASSERT (list
.head
->header
.next
== NULL
);
2260 for (pp
= &ptr
->children
.head
;
2262 pp
= &(*pp
)->header
.next
)
2263 ASSERT (*pp
!= NULL
);
2265 list
.head
->header
.next
= *pp
;
2271 /* Check if all sections in a wild statement for a particular FILE
2275 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2276 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2278 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2281 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2282 if (unique_section_p (section
))
2285 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2286 ((lang_output_section_statement_type
*) data
)->all_input_readonly
= FALSE
;
2289 /* This is passed a file name which must have been seen already and
2290 added to the statement tree. We will see if it has been opened
2291 already and had its symbols read. If not then we'll read it. */
2293 static lang_input_statement_type
*
2294 lookup_name (const char *name
)
2296 lang_input_statement_type
*search
;
2298 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2300 search
= (lang_input_statement_type
*) search
->next_real_file
)
2302 /* Use the local_sym_name as the name of the file that has
2303 already been loaded as filename might have been transformed
2304 via the search directory lookup mechanism. */
2305 const char *filename
= search
->local_sym_name
;
2307 if (filename
!= NULL
2308 && strcmp (filename
, name
) == 0)
2313 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2314 default_target
, FALSE
);
2316 /* If we have already added this file, or this file is not real
2317 don't add this file. */
2318 if (search
->loaded
|| !search
->real
)
2321 if (! load_symbols (search
, NULL
))
2327 /* Save LIST as a list of libraries whose symbols should not be exported. */
2332 struct excluded_lib
*next
;
2334 static struct excluded_lib
*excluded_libs
;
2337 add_excluded_libs (const char *list
)
2339 const char *p
= list
, *end
;
2343 struct excluded_lib
*entry
;
2344 end
= strpbrk (p
, ",:");
2346 end
= p
+ strlen (p
);
2347 entry
= xmalloc (sizeof (*entry
));
2348 entry
->next
= excluded_libs
;
2349 entry
->name
= xmalloc (end
- p
+ 1);
2350 memcpy (entry
->name
, p
, end
- p
);
2351 entry
->name
[end
- p
] = '\0';
2352 excluded_libs
= entry
;
2360 check_excluded_libs (bfd
*abfd
)
2362 struct excluded_lib
*lib
= excluded_libs
;
2366 int len
= strlen (lib
->name
);
2367 const char *filename
= lbasename (abfd
->filename
);
2369 if (strcmp (lib
->name
, "ALL") == 0)
2371 abfd
->no_export
= TRUE
;
2375 if (strncmp (lib
->name
, filename
, len
) == 0
2376 && (filename
[len
] == '\0'
2377 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2378 && filename
[len
+ 2] == '\0')))
2380 abfd
->no_export
= TRUE
;
2388 /* Get the symbols for an input file. */
2391 load_symbols (lang_input_statement_type
*entry
,
2392 lang_statement_list_type
*place
)
2399 ldfile_open_file (entry
);
2401 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
2402 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2405 lang_statement_list_type
*hold
;
2406 bfd_boolean bad_load
= TRUE
;
2407 bfd_boolean save_ldlang_sysrooted_script
;
2408 bfd_boolean save_as_needed
, save_add_needed
;
2410 err
= bfd_get_error ();
2412 /* See if the emulation has some special knowledge. */
2413 if (ldemul_unrecognized_file (entry
))
2416 if (err
== bfd_error_file_ambiguously_recognized
)
2420 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
2421 einfo (_("%B: matching formats:"), entry
->the_bfd
);
2422 for (p
= matching
; *p
!= NULL
; p
++)
2426 else if (err
!= bfd_error_file_not_recognized
2428 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
2432 bfd_close (entry
->the_bfd
);
2433 entry
->the_bfd
= NULL
;
2435 /* Try to interpret the file as a linker script. */
2436 ldfile_open_command_file (entry
->filename
);
2440 save_ldlang_sysrooted_script
= ldlang_sysrooted_script
;
2441 ldlang_sysrooted_script
= entry
->sysrooted
;
2442 save_as_needed
= as_needed
;
2443 as_needed
= entry
->as_needed
;
2444 save_add_needed
= add_needed
;
2445 add_needed
= entry
->add_needed
;
2447 ldfile_assumed_script
= TRUE
;
2448 parser_input
= input_script
;
2449 /* We want to use the same -Bdynamic/-Bstatic as the one for
2451 config
.dynamic_link
= entry
->dynamic
;
2453 ldfile_assumed_script
= FALSE
;
2455 ldlang_sysrooted_script
= save_ldlang_sysrooted_script
;
2456 as_needed
= save_as_needed
;
2457 add_needed
= save_add_needed
;
2463 if (ldemul_recognized_file (entry
))
2466 /* We don't call ldlang_add_file for an archive. Instead, the
2467 add_symbols entry point will call ldlang_add_file, via the
2468 add_archive_element callback, for each element of the archive
2470 switch (bfd_get_format (entry
->the_bfd
))
2476 ldlang_add_file (entry
);
2477 if (trace_files
|| trace_file_tries
)
2478 info_msg ("%I\n", entry
);
2482 check_excluded_libs (entry
->the_bfd
);
2484 if (entry
->whole_archive
)
2487 bfd_boolean loaded
= TRUE
;
2491 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
2496 if (! bfd_check_format (member
, bfd_object
))
2498 einfo (_("%F%B: member %B in archive is not an object\n"),
2499 entry
->the_bfd
, member
);
2503 if (! ((*link_info
.callbacks
->add_archive_element
)
2504 (&link_info
, member
, "--whole-archive")))
2507 if (! bfd_link_add_symbols (member
, &link_info
))
2509 einfo (_("%F%B: could not read symbols: %E\n"), member
);
2514 entry
->loaded
= loaded
;
2520 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
2521 entry
->loaded
= TRUE
;
2523 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
2525 return entry
->loaded
;
2528 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2529 may be NULL, indicating that it is a wildcard. Separate
2530 lang_input_section statements are created for each part of the
2531 expansion; they are added after the wild statement S. OUTPUT is
2532 the output section. */
2535 wild (lang_wild_statement_type
*s
,
2536 const char *target ATTRIBUTE_UNUSED
,
2537 lang_output_section_statement_type
*output
)
2539 struct wildcard_list
*sec
;
2541 if (s
->handler_data
[0]
2542 && s
->handler_data
[0]->spec
.sorted
== by_name
2543 && !s
->filenames_sorted
)
2545 lang_section_bst_type
*tree
;
2547 walk_wild (s
, output_section_callback_fast
, output
);
2552 output_section_callback_tree_to_list (s
, tree
, output
);
2557 walk_wild (s
, output_section_callback
, output
);
2559 if (default_common_section
== NULL
)
2560 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
2561 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
2563 /* Remember the section that common is going to in case we
2564 later get something which doesn't know where to put it. */
2565 default_common_section
= output
;
2570 /* Return TRUE iff target is the sought target. */
2573 get_target (const bfd_target
*target
, void *data
)
2575 const char *sought
= data
;
2577 return strcmp (target
->name
, sought
) == 0;
2580 /* Like strcpy() but convert to lower case as well. */
2583 stricpy (char *dest
, char *src
)
2587 while ((c
= *src
++) != 0)
2588 *dest
++ = TOLOWER (c
);
2593 /* Remove the first occurrence of needle (if any) in haystack
2597 strcut (char *haystack
, char *needle
)
2599 haystack
= strstr (haystack
, needle
);
2605 for (src
= haystack
+ strlen (needle
); *src
;)
2606 *haystack
++ = *src
++;
2612 /* Compare two target format name strings.
2613 Return a value indicating how "similar" they are. */
2616 name_compare (char *first
, char *second
)
2622 copy1
= xmalloc (strlen (first
) + 1);
2623 copy2
= xmalloc (strlen (second
) + 1);
2625 /* Convert the names to lower case. */
2626 stricpy (copy1
, first
);
2627 stricpy (copy2
, second
);
2629 /* Remove size and endian strings from the name. */
2630 strcut (copy1
, "big");
2631 strcut (copy1
, "little");
2632 strcut (copy2
, "big");
2633 strcut (copy2
, "little");
2635 /* Return a value based on how many characters match,
2636 starting from the beginning. If both strings are
2637 the same then return 10 * their length. */
2638 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
2639 if (copy1
[result
] == 0)
2651 /* Set by closest_target_match() below. */
2652 static const bfd_target
*winner
;
2654 /* Scan all the valid bfd targets looking for one that has the endianness
2655 requirement that was specified on the command line, and is the nearest
2656 match to the original output target. */
2659 closest_target_match (const bfd_target
*target
, void *data
)
2661 const bfd_target
*original
= data
;
2663 if (command_line
.endian
== ENDIAN_BIG
2664 && target
->byteorder
!= BFD_ENDIAN_BIG
)
2667 if (command_line
.endian
== ENDIAN_LITTLE
2668 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
2671 /* Must be the same flavour. */
2672 if (target
->flavour
!= original
->flavour
)
2675 /* If we have not found a potential winner yet, then record this one. */
2682 /* Oh dear, we now have two potential candidates for a successful match.
2683 Compare their names and choose the better one. */
2684 if (name_compare (target
->name
, original
->name
)
2685 > name_compare (winner
->name
, original
->name
))
2688 /* Keep on searching until wqe have checked them all. */
2692 /* Return the BFD target format of the first input file. */
2695 get_first_input_target (void)
2697 char *target
= NULL
;
2699 LANG_FOR_EACH_INPUT_STATEMENT (s
)
2701 if (s
->header
.type
== lang_input_statement_enum
2704 ldfile_open_file (s
);
2706 if (s
->the_bfd
!= NULL
2707 && bfd_check_format (s
->the_bfd
, bfd_object
))
2709 target
= bfd_get_target (s
->the_bfd
);
2721 lang_get_output_target (void)
2725 /* Has the user told us which output format to use? */
2726 if (output_target
!= NULL
)
2727 return output_target
;
2729 /* No - has the current target been set to something other than
2731 if (current_target
!= default_target
)
2732 return current_target
;
2734 /* No - can we determine the format of the first input file? */
2735 target
= get_first_input_target ();
2739 /* Failed - use the default output target. */
2740 return default_target
;
2743 /* Open the output file. */
2746 open_output (const char *name
)
2750 output_target
= lang_get_output_target ();
2752 /* Has the user requested a particular endianness on the command
2754 if (command_line
.endian
!= ENDIAN_UNSET
)
2756 const bfd_target
*target
;
2757 enum bfd_endian desired_endian
;
2759 /* Get the chosen target. */
2760 target
= bfd_search_for_target (get_target
, (void *) output_target
);
2762 /* If the target is not supported, we cannot do anything. */
2765 if (command_line
.endian
== ENDIAN_BIG
)
2766 desired_endian
= BFD_ENDIAN_BIG
;
2768 desired_endian
= BFD_ENDIAN_LITTLE
;
2770 /* See if the target has the wrong endianness. This should
2771 not happen if the linker script has provided big and
2772 little endian alternatives, but some scrips don't do
2774 if (target
->byteorder
!= desired_endian
)
2776 /* If it does, then see if the target provides
2777 an alternative with the correct endianness. */
2778 if (target
->alternative_target
!= NULL
2779 && (target
->alternative_target
->byteorder
== desired_endian
))
2780 output_target
= target
->alternative_target
->name
;
2783 /* Try to find a target as similar as possible to
2784 the default target, but which has the desired
2785 endian characteristic. */
2786 bfd_search_for_target (closest_target_match
,
2789 /* Oh dear - we could not find any targets that
2790 satisfy our requirements. */
2792 einfo (_("%P: warning: could not find any targets"
2793 " that match endianness requirement\n"));
2795 output_target
= winner
->name
;
2801 output
= bfd_openw (name
, output_target
);
2805 if (bfd_get_error () == bfd_error_invalid_target
)
2806 einfo (_("%P%F: target %s not found\n"), output_target
);
2808 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
2811 delete_output_file_on_failure
= TRUE
;
2813 if (! bfd_set_format (output
, bfd_object
))
2814 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
2815 if (! bfd_set_arch_mach (output
,
2816 ldfile_output_architecture
,
2817 ldfile_output_machine
))
2818 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
2820 link_info
.hash
= bfd_link_hash_table_create (output
);
2821 if (link_info
.hash
== NULL
)
2822 einfo (_("%P%F: can not create hash table: %E\n"));
2824 bfd_set_gp_size (output
, g_switch_value
);
2829 ldlang_open_output (lang_statement_union_type
*statement
)
2831 switch (statement
->header
.type
)
2833 case lang_output_statement_enum
:
2834 ASSERT (output_bfd
== NULL
);
2835 output_bfd
= open_output (statement
->output_statement
.name
);
2836 ldemul_set_output_arch ();
2837 if (config
.magic_demand_paged
&& !link_info
.relocatable
)
2838 output_bfd
->flags
|= D_PAGED
;
2840 output_bfd
->flags
&= ~D_PAGED
;
2841 if (config
.text_read_only
)
2842 output_bfd
->flags
|= WP_TEXT
;
2844 output_bfd
->flags
&= ~WP_TEXT
;
2845 if (link_info
.traditional_format
)
2846 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
2848 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
2851 case lang_target_statement_enum
:
2852 current_target
= statement
->target_statement
.target
;
2859 /* Convert between addresses in bytes and sizes in octets.
2860 For currently supported targets, octets_per_byte is always a power
2861 of two, so we can use shifts. */
2862 #define TO_ADDR(X) ((X) >> opb_shift)
2863 #define TO_SIZE(X) ((X) << opb_shift)
2865 /* Support the above. */
2866 static unsigned int opb_shift
= 0;
2871 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2872 ldfile_output_machine
);
2875 while ((x
& 1) == 0)
2883 /* Open all the input files. */
2886 open_input_bfds (lang_statement_union_type
*s
, bfd_boolean force
)
2888 for (; s
!= NULL
; s
= s
->header
.next
)
2890 switch (s
->header
.type
)
2892 case lang_constructors_statement_enum
:
2893 open_input_bfds (constructor_list
.head
, force
);
2895 case lang_output_section_statement_enum
:
2896 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
2898 case lang_wild_statement_enum
:
2899 /* Maybe we should load the file's symbols. */
2900 if (s
->wild_statement
.filename
2901 && ! wildcardp (s
->wild_statement
.filename
))
2902 lookup_name (s
->wild_statement
.filename
);
2903 open_input_bfds (s
->wild_statement
.children
.head
, force
);
2905 case lang_group_statement_enum
:
2907 struct bfd_link_hash_entry
*undefs
;
2909 /* We must continually search the entries in the group
2910 until no new symbols are added to the list of undefined
2915 undefs
= link_info
.hash
->undefs_tail
;
2916 open_input_bfds (s
->group_statement
.children
.head
, TRUE
);
2918 while (undefs
!= link_info
.hash
->undefs_tail
);
2921 case lang_target_statement_enum
:
2922 current_target
= s
->target_statement
.target
;
2924 case lang_input_statement_enum
:
2925 if (s
->input_statement
.real
)
2927 lang_statement_list_type add
;
2929 s
->input_statement
.target
= current_target
;
2931 /* If we are being called from within a group, and this
2932 is an archive which has already been searched, then
2933 force it to be researched unless the whole archive
2934 has been loaded already. */
2936 && !s
->input_statement
.whole_archive
2937 && s
->input_statement
.loaded
2938 && bfd_check_format (s
->input_statement
.the_bfd
,
2940 s
->input_statement
.loaded
= FALSE
;
2942 lang_list_init (&add
);
2944 if (! load_symbols (&s
->input_statement
, &add
))
2945 config
.make_executable
= FALSE
;
2947 if (add
.head
!= NULL
)
2949 *add
.tail
= s
->header
.next
;
2950 s
->header
.next
= add
.head
;
2960 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
2963 lang_track_definedness (const char *name
)
2965 if (bfd_hash_lookup (&lang_definedness_table
, name
, TRUE
, FALSE
) == NULL
)
2966 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
2969 /* New-function for the definedness hash table. */
2971 static struct bfd_hash_entry
*
2972 lang_definedness_newfunc (struct bfd_hash_entry
*entry
,
2973 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
2974 const char *name ATTRIBUTE_UNUSED
)
2976 struct lang_definedness_hash_entry
*ret
2977 = (struct lang_definedness_hash_entry
*) entry
;
2980 ret
= (struct lang_definedness_hash_entry
*)
2981 bfd_hash_allocate (table
, sizeof (struct lang_definedness_hash_entry
));
2984 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
2986 ret
->iteration
= -1;
2990 /* Return the iteration when the definition of NAME was last updated. A
2991 value of -1 means that the symbol is not defined in the linker script
2992 or the command line, but may be defined in the linker symbol table. */
2995 lang_symbol_definition_iteration (const char *name
)
2997 struct lang_definedness_hash_entry
*defentry
2998 = (struct lang_definedness_hash_entry
*)
2999 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
3001 /* We've already created this one on the presence of DEFINED in the
3002 script, so it can't be NULL unless something is borked elsewhere in
3004 if (defentry
== NULL
)
3007 return defentry
->iteration
;
3010 /* Update the definedness state of NAME. */
3013 lang_update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
3015 struct lang_definedness_hash_entry
*defentry
3016 = (struct lang_definedness_hash_entry
*)
3017 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
3019 /* We don't keep track of symbols not tested with DEFINED. */
3020 if (defentry
== NULL
)
3023 /* If the symbol was already defined, and not from an earlier statement
3024 iteration, don't update the definedness iteration, because that'd
3025 make the symbol seem defined in the linker script at this point, and
3026 it wasn't; it was defined in some object. If we do anyway, DEFINED
3027 would start to yield false before this point and the construct "sym =
3028 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3030 if (h
->type
!= bfd_link_hash_undefined
3031 && h
->type
!= bfd_link_hash_common
3032 && h
->type
!= bfd_link_hash_new
3033 && defentry
->iteration
== -1)
3036 defentry
->iteration
= lang_statement_iteration
;
3039 /* Add the supplied name to the symbol table as an undefined reference.
3040 This is a two step process as the symbol table doesn't even exist at
3041 the time the ld command line is processed. First we put the name
3042 on a list, then, once the output file has been opened, transfer the
3043 name to the symbol table. */
3045 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
3047 #define ldlang_undef_chain_list_head entry_symbol.next
3050 ldlang_add_undef (const char *const name
)
3052 ldlang_undef_chain_list_type
*new =
3053 stat_alloc (sizeof (ldlang_undef_chain_list_type
));
3055 new->next
= ldlang_undef_chain_list_head
;
3056 ldlang_undef_chain_list_head
= new;
3058 new->name
= xstrdup (name
);
3060 if (output_bfd
!= NULL
)
3061 insert_undefined (new->name
);
3064 /* Insert NAME as undefined in the symbol table. */
3067 insert_undefined (const char *name
)
3069 struct bfd_link_hash_entry
*h
;
3071 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
3073 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3074 if (h
->type
== bfd_link_hash_new
)
3076 h
->type
= bfd_link_hash_undefined
;
3077 h
->u
.undef
.abfd
= NULL
;
3078 bfd_link_add_undef (link_info
.hash
, h
);
3082 /* Run through the list of undefineds created above and place them
3083 into the linker hash table as undefined symbols belonging to the
3087 lang_place_undefineds (void)
3089 ldlang_undef_chain_list_type
*ptr
;
3091 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
3092 insert_undefined (ptr
->name
);
3095 /* Check for all readonly or some readwrite sections. */
3098 check_input_sections
3099 (lang_statement_union_type
*s
,
3100 lang_output_section_statement_type
*output_section_statement
)
3102 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3104 switch (s
->header
.type
)
3106 case lang_wild_statement_enum
:
3107 walk_wild (&s
->wild_statement
, check_section_callback
,
3108 output_section_statement
);
3109 if (! output_section_statement
->all_input_readonly
)
3112 case lang_constructors_statement_enum
:
3113 check_input_sections (constructor_list
.head
,
3114 output_section_statement
);
3115 if (! output_section_statement
->all_input_readonly
)
3118 case lang_group_statement_enum
:
3119 check_input_sections (s
->group_statement
.children
.head
,
3120 output_section_statement
);
3121 if (! output_section_statement
->all_input_readonly
)
3130 /* Update wildcard statements if needed. */
3133 update_wild_statements (lang_statement_union_type
*s
)
3135 struct wildcard_list
*sec
;
3137 switch (sort_section
)
3147 for (; s
!= NULL
; s
= s
->header
.next
)
3149 switch (s
->header
.type
)
3154 case lang_wild_statement_enum
:
3155 sec
= s
->wild_statement
.section_list
;
3156 for (sec
= s
->wild_statement
.section_list
; sec
!= NULL
;
3159 switch (sec
->spec
.sorted
)
3162 sec
->spec
.sorted
= sort_section
;
3165 if (sort_section
== by_alignment
)
3166 sec
->spec
.sorted
= by_name_alignment
;
3169 if (sort_section
== by_name
)
3170 sec
->spec
.sorted
= by_alignment_name
;
3178 case lang_constructors_statement_enum
:
3179 update_wild_statements (constructor_list
.head
);
3182 case lang_output_section_statement_enum
:
3183 update_wild_statements
3184 (s
->output_section_statement
.children
.head
);
3187 case lang_group_statement_enum
:
3188 update_wild_statements (s
->group_statement
.children
.head
);
3196 /* Open input files and attach to output sections. */
3199 map_input_to_output_sections
3200 (lang_statement_union_type
*s
, const char *target
,
3201 lang_output_section_statement_type
*os
)
3205 for (; s
!= NULL
; s
= s
->header
.next
)
3207 switch (s
->header
.type
)
3209 case lang_wild_statement_enum
:
3210 wild (&s
->wild_statement
, target
, os
);
3212 case lang_constructors_statement_enum
:
3213 map_input_to_output_sections (constructor_list
.head
,
3217 case lang_output_section_statement_enum
:
3218 if (s
->output_section_statement
.constraint
)
3220 if (s
->output_section_statement
.constraint
!= ONLY_IF_RW
3221 && s
->output_section_statement
.constraint
!= ONLY_IF_RO
)
3223 s
->output_section_statement
.all_input_readonly
= TRUE
;
3224 check_input_sections (s
->output_section_statement
.children
.head
,
3225 &s
->output_section_statement
);
3226 if ((s
->output_section_statement
.all_input_readonly
3227 && s
->output_section_statement
.constraint
== ONLY_IF_RW
)
3228 || (!s
->output_section_statement
.all_input_readonly
3229 && s
->output_section_statement
.constraint
== ONLY_IF_RO
))
3231 s
->output_section_statement
.constraint
= -1;
3236 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
3238 &s
->output_section_statement
);
3240 case lang_output_statement_enum
:
3242 case lang_target_statement_enum
:
3243 target
= s
->target_statement
.target
;
3245 case lang_group_statement_enum
:
3246 map_input_to_output_sections (s
->group_statement
.children
.head
,
3250 case lang_data_statement_enum
:
3251 /* Make sure that any sections mentioned in the expression
3253 exp_init_os (s
->data_statement
.exp
);
3254 flags
= SEC_HAS_CONTENTS
;
3255 /* The output section gets contents, and then we inspect for
3256 any flags set in the input script which override any ALLOC. */
3257 if (!(os
->flags
& SEC_NEVER_LOAD
))
3258 flags
|= SEC_ALLOC
| SEC_LOAD
;
3259 if (os
->bfd_section
== NULL
)
3260 init_os (os
, NULL
, flags
);
3262 os
->bfd_section
->flags
|= flags
;
3264 case lang_input_section_enum
:
3266 case lang_fill_statement_enum
:
3267 case lang_object_symbols_statement_enum
:
3268 case lang_reloc_statement_enum
:
3269 case lang_padding_statement_enum
:
3270 case lang_input_statement_enum
:
3271 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3272 init_os (os
, NULL
, 0);
3274 case lang_assignment_statement_enum
:
3275 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3276 init_os (os
, NULL
, 0);
3278 /* Make sure that any sections mentioned in the assignment
3280 exp_init_os (s
->assignment_statement
.exp
);
3282 case lang_afile_asection_pair_statement_enum
:
3285 case lang_address_statement_enum
:
3286 /* Mark the specified section with the supplied address.
3288 If this section was actually a segment marker, then the
3289 directive is ignored if the linker script explicitly
3290 processed the segment marker. Originally, the linker
3291 treated segment directives (like -Ttext on the
3292 command-line) as section directives. We honor the
3293 section directive semantics for backwards compatibilty;
3294 linker scripts that do not specifically check for
3295 SEGMENT_START automatically get the old semantics. */
3296 if (!s
->address_statement
.segment
3297 || !s
->address_statement
.segment
->used
)
3299 lang_output_section_statement_type
*aos
3300 = (lang_output_section_statement_lookup
3301 (s
->address_statement
.section_name
));
3303 if (aos
->bfd_section
== NULL
)
3304 init_os (aos
, NULL
, 0);
3305 aos
->addr_tree
= s
->address_statement
.address
;
3312 /* An output section might have been removed after its statement was
3313 added. For example, ldemul_before_allocation can remove dynamic
3314 sections if they turn out to be not needed. Clean them up here. */
3317 strip_excluded_output_sections (void)
3319 lang_output_section_statement_type
*os
;
3321 /* Run lang_size_sections (if not already done). */
3322 if (expld
.phase
!= lang_mark_phase_enum
)
3324 expld
.phase
= lang_mark_phase_enum
;
3325 expld
.dataseg
.phase
= exp_dataseg_none
;
3326 one_lang_size_sections_pass (NULL
, FALSE
);
3327 lang_reset_memory_regions ();
3330 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3334 asection
*output_section
;
3335 bfd_boolean exclude
;
3337 if (os
->constraint
== -1)
3340 output_section
= os
->bfd_section
;
3341 if (output_section
== NULL
)
3344 exclude
= (output_section
->rawsize
== 0
3345 && !os
->section_relative_symbol
3346 && (output_section
->flags
& SEC_KEEP
) == 0
3347 && !bfd_section_removed_from_list (output_bfd
,
3350 /* Some sections have not yet been sized, notably .gnu.version,
3351 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3352 input sections, so don't drop output sections that have such
3353 input sections unless they are also marked SEC_EXCLUDE. */
3354 if (exclude
&& output_section
->map_head
.s
!= NULL
)
3358 for (s
= output_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
3359 if ((s
->flags
& SEC_LINKER_CREATED
) != 0
3360 && (s
->flags
& SEC_EXCLUDE
) == 0)
3367 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3368 output_section
->map_head
.link_order
= NULL
;
3369 output_section
->map_tail
.link_order
= NULL
;
3373 /* We don't set bfd_section to NULL since bfd_section of the
3374 removed output section statement may still be used. */
3376 output_section
->flags
|= SEC_EXCLUDE
;
3377 bfd_section_list_remove (output_bfd
, output_section
);
3378 output_bfd
->section_count
--;
3382 /* Stop future calls to lang_add_section from messing with map_head
3383 and map_tail link_order fields. */
3384 stripped_excluded_sections
= TRUE
;
3388 print_output_section_statement
3389 (lang_output_section_statement_type
*output_section_statement
)
3391 asection
*section
= output_section_statement
->bfd_section
;
3394 if (output_section_statement
!= abs_output_section
)
3396 minfo ("\n%s", output_section_statement
->name
);
3398 if (section
!= NULL
)
3400 print_dot
= section
->vma
;
3402 len
= strlen (output_section_statement
->name
);
3403 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3408 while (len
< SECTION_NAME_MAP_LENGTH
)
3414 minfo ("0x%V %W", section
->vma
, section
->size
);
3416 if (output_section_statement
->load_base
!= NULL
)
3420 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
3422 minfo (_(" load address 0x%V"), addr
);
3429 print_statement_list (output_section_statement
->children
.head
,
3430 output_section_statement
);
3433 /* Scan for the use of the destination in the right hand side
3434 of an expression. In such cases we will not compute the
3435 correct expression, since the value of DST that is used on
3436 the right hand side will be its final value, not its value
3437 just before this expression is evaluated. */
3440 scan_for_self_assignment (const char * dst
, etree_type
* rhs
)
3442 if (rhs
== NULL
|| dst
== NULL
)
3445 switch (rhs
->type
.node_class
)
3448 return scan_for_self_assignment (dst
, rhs
->binary
.lhs
)
3449 || scan_for_self_assignment (dst
, rhs
->binary
.rhs
);
3452 return scan_for_self_assignment (dst
, rhs
->trinary
.lhs
)
3453 || scan_for_self_assignment (dst
, rhs
->trinary
.rhs
);
3456 case etree_provided
:
3458 if (strcmp (dst
, rhs
->assign
.dst
) == 0)
3460 return scan_for_self_assignment (dst
, rhs
->assign
.src
);
3463 return scan_for_self_assignment (dst
, rhs
->unary
.child
);
3467 return strcmp (dst
, rhs
->value
.str
) == 0;
3472 return strcmp (dst
, rhs
->name
.name
) == 0;
3484 print_assignment (lang_assignment_statement_type
*assignment
,
3485 lang_output_section_statement_type
*output_section
)
3489 bfd_boolean computation_is_valid
= TRUE
;
3492 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3495 if (assignment
->exp
->type
.node_class
== etree_assert
)
3498 tree
= assignment
->exp
->assert_s
.child
;
3499 computation_is_valid
= TRUE
;
3503 const char *dst
= assignment
->exp
->assign
.dst
;
3505 is_dot
= (dst
[0] == '.' && dst
[1] == 0);
3506 tree
= assignment
->exp
->assign
.src
;
3507 computation_is_valid
= is_dot
|| (scan_for_self_assignment (dst
, tree
) == FALSE
);
3510 exp_fold_tree (tree
, output_section
->bfd_section
, &print_dot
);
3511 if (expld
.result
.valid_p
)
3515 if (computation_is_valid
)
3517 value
= expld
.result
.value
;
3519 if (expld
.result
.section
)
3520 value
+= expld
.result
.section
->vma
;
3522 minfo ("0x%V", value
);
3528 struct bfd_link_hash_entry
*h
;
3530 h
= bfd_link_hash_lookup (link_info
.hash
, assignment
->exp
->assign
.dst
,
3531 FALSE
, FALSE
, TRUE
);
3534 value
= h
->u
.def
.value
;
3536 if (expld
.result
.section
)
3537 value
+= expld
.result
.section
->vma
;
3539 minfo ("[0x%V]", value
);
3542 minfo ("[unresolved]");
3554 exp_print_tree (assignment
->exp
);
3559 print_input_statement (lang_input_statement_type
*statm
)
3561 if (statm
->filename
!= NULL
)
3563 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
3567 /* Print all symbols defined in a particular section. This is called
3568 via bfd_link_hash_traverse, or by print_all_symbols. */
3571 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
3573 asection
*sec
= ptr
;
3575 if ((hash_entry
->type
== bfd_link_hash_defined
3576 || hash_entry
->type
== bfd_link_hash_defweak
)
3577 && sec
== hash_entry
->u
.def
.section
)
3581 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3584 (hash_entry
->u
.def
.value
3585 + hash_entry
->u
.def
.section
->output_offset
3586 + hash_entry
->u
.def
.section
->output_section
->vma
));
3588 minfo (" %T\n", hash_entry
->root
.string
);
3595 print_all_symbols (asection
*sec
)
3597 struct fat_user_section_struct
*ud
= get_userdata (sec
);
3598 struct map_symbol_def
*def
;
3603 *ud
->map_symbol_def_tail
= 0;
3604 for (def
= ud
->map_symbol_def_head
; def
; def
= def
->next
)
3605 print_one_symbol (def
->entry
, sec
);
3608 /* Print information about an input section to the map file. */
3611 print_input_section (asection
*i
)
3613 bfd_size_type size
= i
->size
;
3620 minfo ("%s", i
->name
);
3622 len
= 1 + strlen (i
->name
);
3623 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3628 while (len
< SECTION_NAME_MAP_LENGTH
)
3634 if (i
->output_section
!= NULL
&& i
->output_section
->owner
== output_bfd
)
3635 addr
= i
->output_section
->vma
+ i
->output_offset
;
3642 minfo ("0x%V %W %B\n", addr
, TO_ADDR (size
), i
->owner
);
3644 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
3646 len
= SECTION_NAME_MAP_LENGTH
+ 3;
3658 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
3661 if (i
->output_section
!= NULL
&& i
->output_section
->owner
== output_bfd
)
3663 if (command_line
.reduce_memory_overheads
)
3664 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
3666 print_all_symbols (i
);
3668 print_dot
= addr
+ TO_ADDR (size
);
3673 print_fill_statement (lang_fill_statement_type
*fill
)
3677 fputs (" FILL mask 0x", config
.map_file
);
3678 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
3679 fprintf (config
.map_file
, "%02x", *p
);
3680 fputs ("\n", config
.map_file
);
3684 print_data_statement (lang_data_statement_type
*data
)
3692 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3695 addr
= data
->output_offset
;
3696 if (data
->output_section
!= NULL
)
3697 addr
+= data
->output_section
->vma
;
3725 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
3727 if (data
->exp
->type
.node_class
!= etree_value
)
3730 exp_print_tree (data
->exp
);
3735 print_dot
= addr
+ TO_ADDR (size
);
3738 /* Print an address statement. These are generated by options like
3742 print_address_statement (lang_address_statement_type
*address
)
3744 minfo (_("Address of section %s set to "), address
->section_name
);
3745 exp_print_tree (address
->address
);
3749 /* Print a reloc statement. */
3752 print_reloc_statement (lang_reloc_statement_type
*reloc
)
3759 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3762 addr
= reloc
->output_offset
;
3763 if (reloc
->output_section
!= NULL
)
3764 addr
+= reloc
->output_section
->vma
;
3766 size
= bfd_get_reloc_size (reloc
->howto
);
3768 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
3770 if (reloc
->name
!= NULL
)
3771 minfo ("%s+", reloc
->name
);
3773 minfo ("%s+", reloc
->section
->name
);
3775 exp_print_tree (reloc
->addend_exp
);
3779 print_dot
= addr
+ TO_ADDR (size
);
3783 print_padding_statement (lang_padding_statement_type
*s
)
3791 len
= sizeof " *fill*" - 1;
3792 while (len
< SECTION_NAME_MAP_LENGTH
)
3798 addr
= s
->output_offset
;
3799 if (s
->output_section
!= NULL
)
3800 addr
+= s
->output_section
->vma
;
3801 minfo ("0x%V %W ", addr
, (bfd_vma
) s
->size
);
3803 if (s
->fill
->size
!= 0)
3807 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
3808 fprintf (config
.map_file
, "%02x", *p
);
3813 print_dot
= addr
+ TO_ADDR (s
->size
);
3817 print_wild_statement (lang_wild_statement_type
*w
,
3818 lang_output_section_statement_type
*os
)
3820 struct wildcard_list
*sec
;
3824 if (w
->filenames_sorted
)
3826 if (w
->filename
!= NULL
)
3827 minfo ("%s", w
->filename
);
3830 if (w
->filenames_sorted
)
3834 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
3836 if (sec
->spec
.sorted
)
3838 if (sec
->spec
.exclude_name_list
!= NULL
)
3841 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
3842 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
3843 minfo (" %s", tmp
->name
);
3846 if (sec
->spec
.name
!= NULL
)
3847 minfo ("%s", sec
->spec
.name
);
3850 if (sec
->spec
.sorted
)
3859 print_statement_list (w
->children
.head
, os
);
3862 /* Print a group statement. */
3865 print_group (lang_group_statement_type
*s
,
3866 lang_output_section_statement_type
*os
)
3868 fprintf (config
.map_file
, "START GROUP\n");
3869 print_statement_list (s
->children
.head
, os
);
3870 fprintf (config
.map_file
, "END GROUP\n");
3873 /* Print the list of statements in S.
3874 This can be called for any statement type. */
3877 print_statement_list (lang_statement_union_type
*s
,
3878 lang_output_section_statement_type
*os
)
3882 print_statement (s
, os
);
3887 /* Print the first statement in statement list S.
3888 This can be called for any statement type. */
3891 print_statement (lang_statement_union_type
*s
,
3892 lang_output_section_statement_type
*os
)
3894 switch (s
->header
.type
)
3897 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
3900 case lang_constructors_statement_enum
:
3901 if (constructor_list
.head
!= NULL
)
3903 if (constructors_sorted
)
3904 minfo (" SORT (CONSTRUCTORS)\n");
3906 minfo (" CONSTRUCTORS\n");
3907 print_statement_list (constructor_list
.head
, os
);
3910 case lang_wild_statement_enum
:
3911 print_wild_statement (&s
->wild_statement
, os
);
3913 case lang_address_statement_enum
:
3914 print_address_statement (&s
->address_statement
);
3916 case lang_object_symbols_statement_enum
:
3917 minfo (" CREATE_OBJECT_SYMBOLS\n");
3919 case lang_fill_statement_enum
:
3920 print_fill_statement (&s
->fill_statement
);
3922 case lang_data_statement_enum
:
3923 print_data_statement (&s
->data_statement
);
3925 case lang_reloc_statement_enum
:
3926 print_reloc_statement (&s
->reloc_statement
);
3928 case lang_input_section_enum
:
3929 print_input_section (s
->input_section
.section
);
3931 case lang_padding_statement_enum
:
3932 print_padding_statement (&s
->padding_statement
);
3934 case lang_output_section_statement_enum
:
3935 print_output_section_statement (&s
->output_section_statement
);
3937 case lang_assignment_statement_enum
:
3938 print_assignment (&s
->assignment_statement
, os
);
3940 case lang_target_statement_enum
:
3941 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
3943 case lang_output_statement_enum
:
3944 minfo ("OUTPUT(%s", s
->output_statement
.name
);
3945 if (output_target
!= NULL
)
3946 minfo (" %s", output_target
);
3949 case lang_input_statement_enum
:
3950 print_input_statement (&s
->input_statement
);
3952 case lang_group_statement_enum
:
3953 print_group (&s
->group_statement
, os
);
3955 case lang_afile_asection_pair_statement_enum
:
3962 print_statements (void)
3964 print_statement_list (statement_list
.head
, abs_output_section
);
3967 /* Print the first N statements in statement list S to STDERR.
3968 If N == 0, nothing is printed.
3969 If N < 0, the entire list is printed.
3970 Intended to be called from GDB. */
3973 dprint_statement (lang_statement_union_type
*s
, int n
)
3975 FILE *map_save
= config
.map_file
;
3977 config
.map_file
= stderr
;
3980 print_statement_list (s
, abs_output_section
);
3983 while (s
&& --n
>= 0)
3985 print_statement (s
, abs_output_section
);
3990 config
.map_file
= map_save
;
3994 insert_pad (lang_statement_union_type
**ptr
,
3996 unsigned int alignment_needed
,
3997 asection
*output_section
,
4000 static fill_type zero_fill
= { 1, { 0 } };
4001 lang_statement_union_type
*pad
= NULL
;
4003 if (ptr
!= &statement_list
.head
)
4004 pad
= ((lang_statement_union_type
*)
4005 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
4007 && pad
->header
.type
== lang_padding_statement_enum
4008 && pad
->padding_statement
.output_section
== output_section
)
4010 /* Use the existing pad statement. */
4012 else if ((pad
= *ptr
) != NULL
4013 && pad
->header
.type
== lang_padding_statement_enum
4014 && pad
->padding_statement
.output_section
== output_section
)
4016 /* Use the existing pad statement. */
4020 /* Make a new padding statement, linked into existing chain. */
4021 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
4022 pad
->header
.next
= *ptr
;
4024 pad
->header
.type
= lang_padding_statement_enum
;
4025 pad
->padding_statement
.output_section
= output_section
;
4028 pad
->padding_statement
.fill
= fill
;
4030 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
4031 pad
->padding_statement
.size
= alignment_needed
;
4032 output_section
->size
+= alignment_needed
;
4035 /* Work out how much this section will move the dot point. */
4039 (lang_statement_union_type
**this_ptr
,
4040 lang_output_section_statement_type
*output_section_statement
,
4044 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
4045 asection
*i
= is
->section
;
4047 if (!((lang_input_statement_type
*) i
->owner
->usrdata
)->just_syms_flag
4048 && (i
->flags
& SEC_EXCLUDE
) == 0)
4050 unsigned int alignment_needed
;
4053 /* Align this section first to the input sections requirement,
4054 then to the output section's requirement. If this alignment
4055 is greater than any seen before, then record it too. Perform
4056 the alignment by inserting a magic 'padding' statement. */
4058 if (output_section_statement
->subsection_alignment
!= -1)
4059 i
->alignment_power
= output_section_statement
->subsection_alignment
;
4061 o
= output_section_statement
->bfd_section
;
4062 if (o
->alignment_power
< i
->alignment_power
)
4063 o
->alignment_power
= i
->alignment_power
;
4065 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
4067 if (alignment_needed
!= 0)
4069 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
4070 dot
+= alignment_needed
;
4073 /* Remember where in the output section this input section goes. */
4075 i
->output_offset
= dot
- o
->vma
;
4077 /* Mark how big the output section must be to contain this now. */
4078 dot
+= TO_ADDR (i
->size
);
4079 o
->size
= TO_SIZE (dot
- o
->vma
);
4083 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
4090 sort_sections_by_lma (const void *arg1
, const void *arg2
)
4092 const asection
*sec1
= *(const asection
**) arg1
;
4093 const asection
*sec2
= *(const asection
**) arg2
;
4095 if (bfd_section_lma (sec1
->owner
, sec1
)
4096 < bfd_section_lma (sec2
->owner
, sec2
))
4098 else if (bfd_section_lma (sec1
->owner
, sec1
)
4099 > bfd_section_lma (sec2
->owner
, sec2
))
4105 #define IGNORE_SECTION(s) \
4106 ((s->flags & SEC_NEVER_LOAD) != 0 \
4107 || (s->flags & SEC_ALLOC) == 0 \
4108 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
4109 && (s->flags & SEC_LOAD) == 0))
4111 /* Check to see if any allocated sections overlap with other allocated
4112 sections. This can happen if a linker script specifies the output
4113 section addresses of the two sections. */
4116 lang_check_section_addresses (void)
4119 asection
**sections
, **spp
;
4127 if (bfd_count_sections (output_bfd
) <= 1)
4130 amt
= bfd_count_sections (output_bfd
) * sizeof (asection
*);
4131 sections
= xmalloc (amt
);
4133 /* Scan all sections in the output list. */
4135 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4137 /* Only consider loadable sections with real contents. */
4138 if (IGNORE_SECTION (s
) || s
->size
== 0)
4141 sections
[count
] = s
;
4148 qsort (sections
, (size_t) count
, sizeof (asection
*),
4149 sort_sections_by_lma
);
4153 s_start
= bfd_section_lma (output_bfd
, s
);
4154 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4155 for (count
--; count
; count
--)
4157 /* We must check the sections' LMA addresses not their VMA
4158 addresses because overlay sections can have overlapping VMAs
4159 but they must have distinct LMAs. */
4164 s_start
= bfd_section_lma (output_bfd
, s
);
4165 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
4167 /* Look for an overlap. */
4168 if (s_end
>= os_start
&& s_start
<= os_end
)
4169 einfo (_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
4170 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
4176 /* Make sure the new address is within the region. We explicitly permit the
4177 current address to be at the exact end of the region when the address is
4178 non-zero, in case the region is at the end of addressable memory and the
4179 calculation wraps around. */
4182 os_region_check (lang_output_section_statement_type
*os
,
4183 lang_memory_region_type
*region
,
4187 if ((region
->current
< region
->origin
4188 || (region
->current
- region
->origin
> region
->length
))
4189 && ((region
->current
!= region
->origin
+ region
->length
)
4194 einfo (_("%X%P: address 0x%v of %B section %s"
4195 " is not within region %s\n"),
4197 os
->bfd_section
->owner
,
4198 os
->bfd_section
->name
,
4203 einfo (_("%X%P: region %s is full (%B section %s)\n"),
4205 os
->bfd_section
->owner
,
4206 os
->bfd_section
->name
);
4208 /* Reset the region pointer. */
4209 region
->current
= region
->origin
;
4213 /* Set the sizes for all the output sections. */
4216 lang_size_sections_1
4217 (lang_statement_union_type
*s
,
4218 lang_output_section_statement_type
*output_section_statement
,
4219 lang_statement_union_type
**prev
,
4223 bfd_boolean check_regions
)
4225 /* Size up the sections from their constituent parts. */
4226 for (; s
!= NULL
; s
= s
->header
.next
)
4228 switch (s
->header
.type
)
4230 case lang_output_section_statement_enum
:
4232 bfd_vma newdot
, after
;
4233 lang_output_section_statement_type
*os
;
4234 lang_memory_region_type
*r
;
4236 os
= &s
->output_section_statement
;
4237 if (os
->addr_tree
!= NULL
)
4239 os
->processed_vma
= FALSE
;
4240 exp_fold_tree (os
->addr_tree
, bfd_abs_section_ptr
, &dot
);
4242 if (!expld
.result
.valid_p
4243 && expld
.phase
!= lang_mark_phase_enum
)
4244 einfo (_("%F%S: non constant or forward reference"
4245 " address expression for section %s\n"),
4248 dot
= expld
.result
.value
+ expld
.result
.section
->vma
;
4251 if (os
->bfd_section
== NULL
)
4252 /* This section was removed or never actually created. */
4255 /* If this is a COFF shared library section, use the size and
4256 address from the input section. FIXME: This is COFF
4257 specific; it would be cleaner if there were some other way
4258 to do this, but nothing simple comes to mind. */
4259 if ((bfd_get_flavour (output_bfd
) == bfd_target_ecoff_flavour
4260 || bfd_get_flavour (output_bfd
) == bfd_target_coff_flavour
)
4261 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
4265 if (os
->children
.head
== NULL
4266 || os
->children
.head
->header
.next
!= NULL
4267 || (os
->children
.head
->header
.type
4268 != lang_input_section_enum
))
4269 einfo (_("%P%X: Internal error on COFF shared library"
4270 " section %s\n"), os
->name
);
4272 input
= os
->children
.head
->input_section
.section
;
4273 bfd_set_section_vma (os
->bfd_section
->owner
,
4275 bfd_section_vma (input
->owner
, input
));
4276 os
->bfd_section
->size
= input
->size
;
4281 if (bfd_is_abs_section (os
->bfd_section
))
4283 /* No matter what happens, an abs section starts at zero. */
4284 ASSERT (os
->bfd_section
->vma
== 0);
4290 if (os
->addr_tree
== NULL
)
4292 /* No address specified for this section, get one
4293 from the region specification. */
4294 if (os
->region
== NULL
4295 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
4296 && os
->region
->name
[0] == '*'
4297 && strcmp (os
->region
->name
,
4298 DEFAULT_MEMORY_REGION
) == 0))
4300 os
->region
= lang_memory_default (os
->bfd_section
);
4303 /* If a loadable section is using the default memory
4304 region, and some non default memory regions were
4305 defined, issue an error message. */
4307 && !IGNORE_SECTION (os
->bfd_section
)
4308 && ! link_info
.relocatable
4310 && strcmp (os
->region
->name
,
4311 DEFAULT_MEMORY_REGION
) == 0
4312 && lang_memory_region_list
!= NULL
4313 && (strcmp (lang_memory_region_list
->name
,
4314 DEFAULT_MEMORY_REGION
) != 0
4315 || lang_memory_region_list
->next
!= NULL
)
4316 && expld
.phase
!= lang_mark_phase_enum
)
4318 /* By default this is an error rather than just a
4319 warning because if we allocate the section to the
4320 default memory region we can end up creating an
4321 excessively large binary, or even seg faulting when
4322 attempting to perform a negative seek. See
4323 sources.redhat.com/ml/binutils/2003-04/msg00423.html
4324 for an example of this. This behaviour can be
4325 overridden by the using the --no-check-sections
4327 if (command_line
.check_section_addresses
)
4328 einfo (_("%P%F: error: no memory region specified"
4329 " for loadable section `%s'\n"),
4330 bfd_get_section_name (output_bfd
,
4333 einfo (_("%P: warning: no memory region specified"
4334 " for loadable section `%s'\n"),
4335 bfd_get_section_name (output_bfd
,
4339 newdot
= os
->region
->current
;
4340 align
= os
->bfd_section
->alignment_power
;
4343 align
= os
->section_alignment
;
4345 /* Align to what the section needs. */
4348 bfd_vma savedot
= newdot
;
4349 newdot
= align_power (newdot
, align
);
4351 if (newdot
!= savedot
4352 && (config
.warn_section_align
4353 || os
->addr_tree
!= NULL
)
4354 && expld
.phase
!= lang_mark_phase_enum
)
4355 einfo (_("%P: warning: changing start of section"
4356 " %s by %lu bytes\n"),
4357 os
->name
, (unsigned long) (newdot
- savedot
));
4360 bfd_set_section_vma (0, os
->bfd_section
, newdot
);
4362 os
->bfd_section
->output_offset
= 0;
4365 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
4366 os
->fill
, newdot
, relax
, check_regions
);
4368 os
->processed_vma
= TRUE
;
4370 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
4372 if (os
->bfd_section
->size
> 0)
4374 /* PR ld/3107: Do not abort when a buggy linker script
4375 causes a non-empty section to be discarded. */
4376 if (bfd_is_abs_section (os
->bfd_section
))
4377 einfo (_("%P%X: internal error: attempting to take the size of the non-section *ABS*\n"));
4379 einfo (_("%P: warning: discarding non-empty, well known section %A\n"),
4385 dot
= os
->bfd_section
->vma
;
4387 /* Put the section within the requested block size, or
4388 align at the block boundary. */
4390 + TO_ADDR (os
->bfd_section
->size
)
4391 + os
->block_value
- 1)
4392 & - (bfd_vma
) os
->block_value
);
4394 os
->bfd_section
->size
= TO_SIZE (after
- os
->bfd_section
->vma
);
4397 /* Set section lma. */
4400 r
= lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
4404 bfd_vma lma
= exp_get_abs_int (os
->load_base
, 0, "load base");
4405 os
->bfd_section
->lma
= lma
;
4407 else if (os
->region
!= NULL
4408 && os
->lma_region
!= NULL
4409 && os
->lma_region
!= os
->region
)
4411 bfd_vma lma
= os
->lma_region
->current
;
4413 if (os
->section_alignment
!= -1)
4414 lma
= align_power (lma
, os
->section_alignment
);
4415 os
->bfd_section
->lma
= lma
;
4417 else if (r
->last_os
!= NULL
4418 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0)
4423 last
= r
->last_os
->output_section_statement
.bfd_section
;
4425 /* A backwards move of dot should be accompanied by
4426 an explicit assignment to the section LMA (ie.
4427 os->load_base set) because backwards moves normally
4428 create overlapping LMAs. */
4429 if (dot
< last
->vma
)
4431 einfo (_("%P: warning: dot moved backwards before `%s'\n"),
4434 /* If dot moved backwards then leave lma equal to
4435 vma. This is the old default lma, which might
4436 just happen to work when the backwards move is
4437 sufficiently large. Nag anyway, so people fix
4438 their linker scripts. */
4442 /* If the current vma overlaps the previous section,
4443 then set the current lma to that at the end of
4444 the previous section. The previous section was
4445 probably an overlay. */
4446 if ((dot
>= last
->vma
4447 && dot
< last
->vma
+ last
->size
)
4448 || (last
->vma
>= dot
4449 && last
->vma
< dot
+ os
->bfd_section
->size
))
4450 lma
= last
->lma
+ last
->size
;
4452 /* Otherwise, keep the same lma to vma relationship
4453 as the previous section. */
4455 lma
= dot
+ last
->lma
- last
->vma
;
4457 if (os
->section_alignment
!= -1)
4458 lma
= align_power (lma
, os
->section_alignment
);
4459 os
->bfd_section
->lma
= lma
;
4462 os
->processed_lma
= TRUE
;
4464 if (bfd_is_abs_section (os
->bfd_section
) || os
->ignored
)
4467 /* Keep track of normal sections using the default
4468 lma region. We use this to set the lma for
4469 following sections. Overlays or other linker
4470 script assignment to lma might mean that the
4471 default lma == vma is incorrect.
4472 To avoid warnings about dot moving backwards when using
4473 -Ttext, don't start tracking sections until we find one
4474 of non-zero size or with lma set differently to vma. */
4475 if (((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
4476 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0)
4477 && (os
->bfd_section
->flags
& SEC_ALLOC
) != 0
4478 && (os
->bfd_section
->size
!= 0
4479 || os
->bfd_section
->vma
!= os
->bfd_section
->lma
4480 || r
->last_os
!= NULL
)
4481 && os
->lma_region
== NULL
4482 && !link_info
.relocatable
)
4485 /* .tbss sections effectively have zero size. */
4486 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
4487 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
4488 || link_info
.relocatable
)
4489 dot
+= TO_ADDR (os
->bfd_section
->size
);
4491 if (os
->update_dot_tree
!= 0)
4492 exp_fold_tree (os
->update_dot_tree
, bfd_abs_section_ptr
, &dot
);
4494 /* Update dot in the region ?
4495 We only do this if the section is going to be allocated,
4496 since unallocated sections do not contribute to the region's
4497 overall size in memory.
4499 If the SEC_NEVER_LOAD bit is not set, it will affect the
4500 addresses of sections after it. We have to update
4502 if (os
->region
!= NULL
4503 && ((os
->bfd_section
->flags
& SEC_NEVER_LOAD
) == 0
4504 || (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))))
4506 os
->region
->current
= dot
;
4509 /* Make sure the new address is within the region. */
4510 os_region_check (os
, os
->region
, os
->addr_tree
,
4511 os
->bfd_section
->vma
);
4513 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
)
4515 os
->lma_region
->current
4516 = os
->bfd_section
->lma
+ TO_ADDR (os
->bfd_section
->size
);
4519 os_region_check (os
, os
->lma_region
, NULL
,
4520 os
->bfd_section
->lma
);
4526 case lang_constructors_statement_enum
:
4527 dot
= lang_size_sections_1 (constructor_list
.head
,
4528 output_section_statement
,
4529 &s
->wild_statement
.children
.head
,
4530 fill
, dot
, relax
, check_regions
);
4533 case lang_data_statement_enum
:
4535 unsigned int size
= 0;
4537 s
->data_statement
.output_offset
=
4538 dot
- output_section_statement
->bfd_section
->vma
;
4539 s
->data_statement
.output_section
=
4540 output_section_statement
->bfd_section
;
4542 /* We might refer to provided symbols in the expression, and
4543 need to mark them as needed. */
4544 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
4546 switch (s
->data_statement
.type
)
4564 if (size
< TO_SIZE ((unsigned) 1))
4565 size
= TO_SIZE ((unsigned) 1);
4566 dot
+= TO_ADDR (size
);
4567 output_section_statement
->bfd_section
->size
+= size
;
4571 case lang_reloc_statement_enum
:
4575 s
->reloc_statement
.output_offset
=
4576 dot
- output_section_statement
->bfd_section
->vma
;
4577 s
->reloc_statement
.output_section
=
4578 output_section_statement
->bfd_section
;
4579 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
4580 dot
+= TO_ADDR (size
);
4581 output_section_statement
->bfd_section
->size
+= size
;
4585 case lang_wild_statement_enum
:
4586 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
4587 output_section_statement
,
4588 &s
->wild_statement
.children
.head
,
4589 fill
, dot
, relax
, check_regions
);
4592 case lang_object_symbols_statement_enum
:
4593 link_info
.create_object_symbols_section
=
4594 output_section_statement
->bfd_section
;
4597 case lang_output_statement_enum
:
4598 case lang_target_statement_enum
:
4601 case lang_input_section_enum
:
4605 i
= (*prev
)->input_section
.section
;
4610 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
4611 einfo (_("%P%F: can't relax section: %E\n"));
4615 dot
= size_input_section (prev
, output_section_statement
,
4616 output_section_statement
->fill
, dot
);
4620 case lang_input_statement_enum
:
4623 case lang_fill_statement_enum
:
4624 s
->fill_statement
.output_section
=
4625 output_section_statement
->bfd_section
;
4627 fill
= s
->fill_statement
.fill
;
4630 case lang_assignment_statement_enum
:
4632 bfd_vma newdot
= dot
;
4633 etree_type
*tree
= s
->assignment_statement
.exp
;
4635 exp_fold_tree (tree
,
4636 output_section_statement
->bfd_section
,
4639 /* This symbol is relative to this section. */
4640 if ((tree
->type
.node_class
== etree_provided
4641 || tree
->type
.node_class
== etree_assign
)
4642 && (tree
->assign
.dst
[0] != '.'
4643 || tree
->assign
.dst
[1] != '\0'))
4644 output_section_statement
->section_relative_symbol
= 1;
4646 if (!output_section_statement
->ignored
)
4648 if (output_section_statement
== abs_output_section
)
4650 /* If we don't have an output section, then just adjust
4651 the default memory address. */
4652 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
4653 FALSE
)->current
= newdot
;
4655 else if (newdot
!= dot
)
4657 /* Insert a pad after this statement. We can't
4658 put the pad before when relaxing, in case the
4659 assignment references dot. */
4660 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
4661 output_section_statement
->bfd_section
, dot
);
4663 /* Don't neuter the pad below when relaxing. */
4666 /* If dot is advanced, this implies that the section
4667 should have space allocated to it, unless the
4668 user has explicitly stated that the section
4669 should never be loaded. */
4670 if (!(output_section_statement
->flags
4671 & (SEC_NEVER_LOAD
| SEC_ALLOC
)))
4672 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
4679 case lang_padding_statement_enum
:
4680 /* If this is the first time lang_size_sections is called,
4681 we won't have any padding statements. If this is the
4682 second or later passes when relaxing, we should allow
4683 padding to shrink. If padding is needed on this pass, it
4684 will be added back in. */
4685 s
->padding_statement
.size
= 0;
4687 /* Make sure output_offset is valid. If relaxation shrinks
4688 the section and this pad isn't needed, it's possible to
4689 have output_offset larger than the final size of the
4690 section. bfd_set_section_contents will complain even for
4691 a pad size of zero. */
4692 s
->padding_statement
.output_offset
4693 = dot
- output_section_statement
->bfd_section
->vma
;
4696 case lang_group_statement_enum
:
4697 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
4698 output_section_statement
,
4699 &s
->group_statement
.children
.head
,
4700 fill
, dot
, relax
, check_regions
);
4707 /* We can only get here when relaxing is turned on. */
4708 case lang_address_statement_enum
:
4711 prev
= &s
->header
.next
;
4717 one_lang_size_sections_pass (bfd_boolean
*relax
, bfd_boolean check_regions
)
4719 lang_statement_iteration
++;
4720 lang_size_sections_1 (statement_list
.head
, abs_output_section
,
4721 &statement_list
.head
, 0, 0, relax
, check_regions
);
4725 lang_size_sections (bfd_boolean
*relax
, bfd_boolean check_regions
)
4727 expld
.phase
= lang_allocating_phase_enum
;
4728 expld
.dataseg
.phase
= exp_dataseg_none
;
4730 one_lang_size_sections_pass (relax
, check_regions
);
4731 if (expld
.dataseg
.phase
== exp_dataseg_end_seen
4732 && link_info
.relro
&& expld
.dataseg
.relro_end
)
4734 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
4735 to put expld.dataseg.relro on a (common) page boundary. */
4736 bfd_vma old_min_base
, relro_end
, maxpage
;
4738 expld
.dataseg
.phase
= exp_dataseg_relro_adjust
;
4739 old_min_base
= expld
.dataseg
.min_base
;
4740 maxpage
= expld
.dataseg
.maxpagesize
;
4741 expld
.dataseg
.base
+= (-expld
.dataseg
.relro_end
4742 & (expld
.dataseg
.pagesize
- 1));
4743 /* Compute the expected PT_GNU_RELRO segment end. */
4744 relro_end
= (expld
.dataseg
.relro_end
+ expld
.dataseg
.pagesize
- 1)
4745 & ~(expld
.dataseg
.pagesize
- 1);
4746 if (old_min_base
+ maxpage
< expld
.dataseg
.base
)
4748 expld
.dataseg
.base
-= maxpage
;
4749 relro_end
-= maxpage
;
4751 lang_reset_memory_regions ();
4752 one_lang_size_sections_pass (relax
, check_regions
);
4753 if (expld
.dataseg
.relro_end
> relro_end
)
4755 /* The alignment of sections between DATA_SEGMENT_ALIGN
4756 and DATA_SEGMENT_RELRO_END caused huge padding to be
4757 inserted at DATA_SEGMENT_RELRO_END. Try some other base. */
4759 unsigned int max_alignment_power
= 0;
4761 /* Find maximum alignment power of sections between
4762 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
4763 for (sec
= output_bfd
->sections
; sec
; sec
= sec
->next
)
4764 if (sec
->vma
>= expld
.dataseg
.base
4765 && sec
->vma
< expld
.dataseg
.relro_end
4766 && sec
->alignment_power
> max_alignment_power
)
4767 max_alignment_power
= sec
->alignment_power
;
4769 if (((bfd_vma
) 1 << max_alignment_power
) < expld
.dataseg
.pagesize
)
4771 if (expld
.dataseg
.base
- (1 << max_alignment_power
)
4773 expld
.dataseg
.base
+= expld
.dataseg
.pagesize
;
4774 expld
.dataseg
.base
-= (1 << max_alignment_power
);
4775 lang_reset_memory_regions ();
4776 one_lang_size_sections_pass (relax
, check_regions
);
4779 link_info
.relro_start
= expld
.dataseg
.base
;
4780 link_info
.relro_end
= expld
.dataseg
.relro_end
;
4782 else if (expld
.dataseg
.phase
== exp_dataseg_end_seen
)
4784 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
4785 a page could be saved in the data segment. */
4786 bfd_vma first
, last
;
4788 first
= -expld
.dataseg
.base
& (expld
.dataseg
.pagesize
- 1);
4789 last
= expld
.dataseg
.end
& (expld
.dataseg
.pagesize
- 1);
4791 && ((expld
.dataseg
.base
& ~(expld
.dataseg
.pagesize
- 1))
4792 != (expld
.dataseg
.end
& ~(expld
.dataseg
.pagesize
- 1)))
4793 && first
+ last
<= expld
.dataseg
.pagesize
)
4795 expld
.dataseg
.phase
= exp_dataseg_adjust
;
4796 lang_reset_memory_regions ();
4797 one_lang_size_sections_pass (relax
, check_regions
);
4801 expld
.phase
= lang_final_phase_enum
;
4804 /* Worker function for lang_do_assignments. Recursiveness goes here. */
4807 lang_do_assignments_1 (lang_statement_union_type
*s
,
4808 lang_output_section_statement_type
*current_os
,
4812 for (; s
!= NULL
; s
= s
->header
.next
)
4814 switch (s
->header
.type
)
4816 case lang_constructors_statement_enum
:
4817 dot
= lang_do_assignments_1 (constructor_list
.head
,
4818 current_os
, fill
, dot
);
4821 case lang_output_section_statement_enum
:
4823 lang_output_section_statement_type
*os
;
4825 os
= &(s
->output_section_statement
);
4826 if (os
->bfd_section
!= NULL
&& !os
->ignored
)
4828 dot
= os
->bfd_section
->vma
;
4830 lang_do_assignments_1 (os
->children
.head
, os
, os
->fill
, dot
);
4832 /* .tbss sections effectively have zero size. */
4833 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
4834 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
4835 || link_info
.relocatable
)
4836 dot
+= TO_ADDR (os
->bfd_section
->size
);
4841 case lang_wild_statement_enum
:
4843 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
4844 current_os
, fill
, dot
);
4847 case lang_object_symbols_statement_enum
:
4848 case lang_output_statement_enum
:
4849 case lang_target_statement_enum
:
4852 case lang_data_statement_enum
:
4853 exp_fold_tree (s
->data_statement
.exp
, bfd_abs_section_ptr
, &dot
);
4854 if (expld
.result
.valid_p
)
4855 s
->data_statement
.value
= (expld
.result
.value
4856 + expld
.result
.section
->vma
);
4858 einfo (_("%F%P: invalid data statement\n"));
4861 switch (s
->data_statement
.type
)
4879 if (size
< TO_SIZE ((unsigned) 1))
4880 size
= TO_SIZE ((unsigned) 1);
4881 dot
+= TO_ADDR (size
);
4885 case lang_reloc_statement_enum
:
4886 exp_fold_tree (s
->reloc_statement
.addend_exp
,
4887 bfd_abs_section_ptr
, &dot
);
4888 if (expld
.result
.valid_p
)
4889 s
->reloc_statement
.addend_value
= expld
.result
.value
;
4891 einfo (_("%F%P: invalid reloc statement\n"));
4892 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
4895 case lang_input_section_enum
:
4897 asection
*in
= s
->input_section
.section
;
4899 if ((in
->flags
& SEC_EXCLUDE
) == 0)
4900 dot
+= TO_ADDR (in
->size
);
4904 case lang_input_statement_enum
:
4907 case lang_fill_statement_enum
:
4908 fill
= s
->fill_statement
.fill
;
4911 case lang_assignment_statement_enum
:
4912 exp_fold_tree (s
->assignment_statement
.exp
,
4913 current_os
->bfd_section
,
4917 case lang_padding_statement_enum
:
4918 dot
+= TO_ADDR (s
->padding_statement
.size
);
4921 case lang_group_statement_enum
:
4922 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
4923 current_os
, fill
, dot
);
4930 case lang_address_statement_enum
:
4938 lang_do_assignments (void)
4940 lang_statement_iteration
++;
4941 lang_do_assignments_1 (statement_list
.head
, abs_output_section
, NULL
, 0);
4944 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
4945 operator .startof. (section_name), it produces an undefined symbol
4946 .startof.section_name. Similarly, when it sees
4947 .sizeof. (section_name), it produces an undefined symbol
4948 .sizeof.section_name. For all the output sections, we look for
4949 such symbols, and set them to the correct value. */
4952 lang_set_startof (void)
4956 if (link_info
.relocatable
)
4959 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4961 const char *secname
;
4963 struct bfd_link_hash_entry
*h
;
4965 secname
= bfd_get_section_name (output_bfd
, s
);
4966 buf
= xmalloc (10 + strlen (secname
));
4968 sprintf (buf
, ".startof.%s", secname
);
4969 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
4970 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
4972 h
->type
= bfd_link_hash_defined
;
4973 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
4974 h
->u
.def
.section
= bfd_abs_section_ptr
;
4977 sprintf (buf
, ".sizeof.%s", secname
);
4978 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
4979 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
4981 h
->type
= bfd_link_hash_defined
;
4982 h
->u
.def
.value
= TO_ADDR (s
->size
);
4983 h
->u
.def
.section
= bfd_abs_section_ptr
;
4993 struct bfd_link_hash_entry
*h
;
4996 if (link_info
.relocatable
|| link_info
.shared
)
5001 if (entry_symbol
.name
== NULL
)
5003 /* No entry has been specified. Look for the default entry, but
5004 don't warn if we don't find it. */
5005 entry_symbol
.name
= entry_symbol_default
;
5009 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
5010 FALSE
, FALSE
, TRUE
);
5012 && (h
->type
== bfd_link_hash_defined
5013 || h
->type
== bfd_link_hash_defweak
)
5014 && h
->u
.def
.section
->output_section
!= NULL
)
5018 val
= (h
->u
.def
.value
5019 + bfd_get_section_vma (output_bfd
,
5020 h
->u
.def
.section
->output_section
)
5021 + h
->u
.def
.section
->output_offset
);
5022 if (! bfd_set_start_address (output_bfd
, val
))
5023 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
5030 /* We couldn't find the entry symbol. Try parsing it as a
5032 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
5035 if (! bfd_set_start_address (output_bfd
, val
))
5036 einfo (_("%P%F: can't set start address\n"));
5042 /* Can't find the entry symbol, and it's not a number. Use
5043 the first address in the text section. */
5044 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
5048 einfo (_("%P: warning: cannot find entry symbol %s;"
5049 " defaulting to %V\n"),
5051 bfd_get_section_vma (output_bfd
, ts
));
5052 if (! bfd_set_start_address (output_bfd
,
5053 bfd_get_section_vma (output_bfd
,
5055 einfo (_("%P%F: can't set start address\n"));
5060 einfo (_("%P: warning: cannot find entry symbol %s;"
5061 " not setting start address\n"),
5067 /* Don't bfd_hash_table_free (&lang_definedness_table);
5068 map file output may result in a call of lang_track_definedness. */
5071 /* This is a small function used when we want to ignore errors from
5075 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
5077 /* Don't do anything. */
5080 /* Check that the architecture of all the input files is compatible
5081 with the output file. Also call the backend to let it do any
5082 other checking that is needed. */
5087 lang_statement_union_type
*file
;
5089 const bfd_arch_info_type
*compatible
;
5091 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
5093 input_bfd
= file
->input_statement
.the_bfd
;
5095 = bfd_arch_get_compatible (input_bfd
, output_bfd
,
5096 command_line
.accept_unknown_input_arch
);
5098 /* In general it is not possible to perform a relocatable
5099 link between differing object formats when the input
5100 file has relocations, because the relocations in the
5101 input format may not have equivalent representations in
5102 the output format (and besides BFD does not translate
5103 relocs for other link purposes than a final link). */
5104 if ((link_info
.relocatable
|| link_info
.emitrelocations
)
5105 && (compatible
== NULL
5106 || bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
5107 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
5109 einfo (_("%P%F: Relocatable linking with relocations from"
5110 " format %s (%B) to format %s (%B) is not supported\n"),
5111 bfd_get_target (input_bfd
), input_bfd
,
5112 bfd_get_target (output_bfd
), output_bfd
);
5113 /* einfo with %F exits. */
5116 if (compatible
== NULL
)
5118 if (command_line
.warn_mismatch
)
5119 einfo (_("%P: warning: %s architecture of input file `%B'"
5120 " is incompatible with %s output\n"),
5121 bfd_printable_name (input_bfd
), input_bfd
,
5122 bfd_printable_name (output_bfd
));
5124 else if (bfd_count_sections (input_bfd
))
5126 /* If the input bfd has no contents, it shouldn't set the
5127 private data of the output bfd. */
5129 bfd_error_handler_type pfn
= NULL
;
5131 /* If we aren't supposed to warn about mismatched input
5132 files, temporarily set the BFD error handler to a
5133 function which will do nothing. We still want to call
5134 bfd_merge_private_bfd_data, since it may set up
5135 information which is needed in the output file. */
5136 if (! command_line
.warn_mismatch
)
5137 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
5138 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
5140 if (command_line
.warn_mismatch
)
5141 einfo (_("%P%X: failed to merge target specific data"
5142 " of file %B\n"), input_bfd
);
5144 if (! command_line
.warn_mismatch
)
5145 bfd_set_error_handler (pfn
);
5150 /* Look through all the global common symbols and attach them to the
5151 correct section. The -sort-common command line switch may be used
5152 to roughly sort the entries by size. */
5157 if (command_line
.inhibit_common_definition
)
5159 if (link_info
.relocatable
5160 && ! command_line
.force_common_definition
)
5163 if (! config
.sort_common
)
5164 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
5169 for (power
= 4; power
>= 0; power
--)
5170 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
5174 /* Place one common symbol in the correct section. */
5177 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
5179 unsigned int power_of_two
;
5183 if (h
->type
!= bfd_link_hash_common
)
5187 power_of_two
= h
->u
.c
.p
->alignment_power
;
5189 if (config
.sort_common
5190 && power_of_two
< (unsigned int) *(int *) info
)
5193 section
= h
->u
.c
.p
->section
;
5195 /* Increase the size of the section to align the common sym. */
5196 section
->size
+= ((bfd_vma
) 1 << (power_of_two
+ opb_shift
)) - 1;
5197 section
->size
&= (- (bfd_vma
) 1 << (power_of_two
+ opb_shift
));
5199 /* Adjust the alignment if necessary. */
5200 if (power_of_two
> section
->alignment_power
)
5201 section
->alignment_power
= power_of_two
;
5203 /* Change the symbol from common to defined. */
5204 h
->type
= bfd_link_hash_defined
;
5205 h
->u
.def
.section
= section
;
5206 h
->u
.def
.value
= section
->size
;
5208 /* Increase the size of the section. */
5209 section
->size
+= size
;
5211 /* Make sure the section is allocated in memory, and make sure that
5212 it is no longer a common section. */
5213 section
->flags
|= SEC_ALLOC
;
5214 section
->flags
&= ~SEC_IS_COMMON
;
5216 if (config
.map_file
!= NULL
)
5218 static bfd_boolean header_printed
;
5223 if (! header_printed
)
5225 minfo (_("\nAllocating common symbols\n"));
5226 minfo (_("Common symbol size file\n\n"));
5227 header_printed
= TRUE
;
5230 name
= demangle (h
->root
.string
);
5232 len
= strlen (name
);
5247 if (size
<= 0xffffffff)
5248 sprintf (buf
, "%lx", (unsigned long) size
);
5250 sprintf_vma (buf
, size
);
5260 minfo ("%B\n", section
->owner
);
5266 /* Run through the input files and ensure that every input section has
5267 somewhere to go. If one is found without a destination then create
5268 an input request and place it into the statement tree. */
5271 lang_place_orphans (void)
5273 LANG_FOR_EACH_INPUT_STATEMENT (file
)
5277 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
5279 if (s
->output_section
== NULL
)
5281 /* This section of the file is not attached, root
5282 around for a sensible place for it to go. */
5284 if (file
->just_syms_flag
)
5285 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
5286 else if ((s
->flags
& SEC_EXCLUDE
) != 0)
5287 s
->output_section
= bfd_abs_section_ptr
;
5288 else if (strcmp (s
->name
, "COMMON") == 0)
5290 /* This is a lonely common section which must have
5291 come from an archive. We attach to the section
5292 with the wildcard. */
5293 if (! link_info
.relocatable
5294 || command_line
.force_common_definition
)
5296 if (default_common_section
== NULL
)
5298 default_common_section
=
5299 lang_output_section_statement_lookup (".bss");
5302 lang_add_section (&default_common_section
->children
, s
,
5303 default_common_section
);
5306 else if (ldemul_place_orphan (s
))
5310 lang_output_section_statement_type
*os
;
5312 os
= lang_output_section_statement_lookup (s
->name
);
5313 lang_add_section (&os
->children
, s
, os
);
5321 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
5323 flagword
*ptr_flags
;
5325 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
5331 *ptr_flags
|= SEC_ALLOC
;
5335 *ptr_flags
|= SEC_READONLY
;
5339 *ptr_flags
|= SEC_DATA
;
5343 *ptr_flags
|= SEC_CODE
;
5348 *ptr_flags
|= SEC_LOAD
;
5352 einfo (_("%P%F: invalid syntax in flags\n"));
5359 /* Call a function on each input file. This function will be called
5360 on an archive, but not on the elements. */
5363 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
5365 lang_input_statement_type
*f
;
5367 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
5369 f
= (lang_input_statement_type
*) f
->next_real_file
)
5373 /* Call a function on each file. The function will be called on all
5374 the elements of an archive which are included in the link, but will
5375 not be called on the archive file itself. */
5378 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
5380 LANG_FOR_EACH_INPUT_STATEMENT (f
)
5387 ldlang_add_file (lang_input_statement_type
*entry
)
5391 lang_statement_append (&file_chain
,
5392 (lang_statement_union_type
*) entry
,
5395 /* The BFD linker needs to have a list of all input BFDs involved in
5397 ASSERT (entry
->the_bfd
->link_next
== NULL
);
5398 ASSERT (entry
->the_bfd
!= output_bfd
);
5399 for (pp
= &link_info
.input_bfds
; *pp
!= NULL
; pp
= &(*pp
)->link_next
)
5401 *pp
= entry
->the_bfd
;
5402 entry
->the_bfd
->usrdata
= entry
;
5403 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
5405 /* Look through the sections and check for any which should not be
5406 included in the link. We need to do this now, so that we can
5407 notice when the backend linker tries to report multiple
5408 definition errors for symbols which are in sections we aren't
5409 going to link. FIXME: It might be better to entirely ignore
5410 symbols which are defined in sections which are going to be
5411 discarded. This would require modifying the backend linker for
5412 each backend which might set the SEC_LINK_ONCE flag. If we do
5413 this, we should probably handle SEC_EXCLUDE in the same way. */
5415 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
5419 lang_add_output (const char *name
, int from_script
)
5421 /* Make -o on command line override OUTPUT in script. */
5422 if (!had_output_filename
|| !from_script
)
5424 output_filename
= name
;
5425 had_output_filename
= TRUE
;
5429 static lang_output_section_statement_type
*current_section
;
5440 for (l
= 0; l
< 32; l
++)
5442 if (i
>= (unsigned int) x
)
5450 lang_output_section_statement_type
*
5451 lang_enter_output_section_statement (const char *output_section_statement_name
,
5452 etree_type
*address_exp
,
5453 enum section_type sectype
,
5455 etree_type
*subalign
,
5459 lang_output_section_statement_type
*os
;
5461 os
= lang_output_section_statement_lookup_1 (output_section_statement_name
,
5463 current_section
= os
;
5465 /* Make next things chain into subchain of this. */
5467 if (os
->addr_tree
== NULL
)
5469 os
->addr_tree
= address_exp
;
5471 os
->sectype
= sectype
;
5472 if (sectype
!= noload_section
)
5473 os
->flags
= SEC_NO_FLAGS
;
5475 os
->flags
= SEC_NEVER_LOAD
;
5476 os
->block_value
= 1;
5477 stat_ptr
= &os
->children
;
5479 os
->subsection_alignment
=
5480 topower (exp_get_value_int (subalign
, -1, "subsection alignment"));
5481 os
->section_alignment
=
5482 topower (exp_get_value_int (align
, -1, "section alignment"));
5484 os
->load_base
= ebase
;
5491 lang_output_statement_type
*new;
5493 new = new_stat (lang_output_statement
, stat_ptr
);
5494 new->name
= output_filename
;
5497 /* Reset the current counters in the regions. */
5500 lang_reset_memory_regions (void)
5502 lang_memory_region_type
*p
= lang_memory_region_list
;
5504 lang_output_section_statement_type
*os
;
5506 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
5508 p
->current
= p
->origin
;
5512 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
5516 os
->processed_vma
= FALSE
;
5517 os
->processed_lma
= FALSE
;
5520 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5522 /* Save the last size for possible use by bfd_relax_section. */
5523 o
->rawsize
= o
->size
;
5528 /* Worker for lang_gc_sections_1. */
5531 gc_section_callback (lang_wild_statement_type
*ptr
,
5532 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
5534 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
5535 void *data ATTRIBUTE_UNUSED
)
5537 /* If the wild pattern was marked KEEP, the member sections
5538 should be as well. */
5539 if (ptr
->keep_sections
)
5540 section
->flags
|= SEC_KEEP
;
5543 /* Iterate over sections marking them against GC. */
5546 lang_gc_sections_1 (lang_statement_union_type
*s
)
5548 for (; s
!= NULL
; s
= s
->header
.next
)
5550 switch (s
->header
.type
)
5552 case lang_wild_statement_enum
:
5553 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
5555 case lang_constructors_statement_enum
:
5556 lang_gc_sections_1 (constructor_list
.head
);
5558 case lang_output_section_statement_enum
:
5559 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
5561 case lang_group_statement_enum
:
5562 lang_gc_sections_1 (s
->group_statement
.children
.head
);
5571 lang_gc_sections (void)
5573 struct bfd_link_hash_entry
*h
;
5574 ldlang_undef_chain_list_type
*ulist
;
5576 /* Keep all sections so marked in the link script. */
5578 lang_gc_sections_1 (statement_list
.head
);
5580 /* Keep all sections containing symbols undefined on the command-line,
5581 and the section containing the entry symbol. */
5583 for (ulist
= link_info
.gc_sym_list
; ulist
; ulist
= ulist
->next
)
5585 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
5586 FALSE
, FALSE
, FALSE
);
5589 && (h
->type
== bfd_link_hash_defined
5590 || h
->type
== bfd_link_hash_defweak
)
5591 && ! bfd_is_abs_section (h
->u
.def
.section
))
5593 h
->u
.def
.section
->flags
|= SEC_KEEP
;
5597 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
5598 the special case of debug info. (See bfd/stabs.c)
5599 Twiddle the flag here, to simplify later linker code. */
5600 if (link_info
.relocatable
)
5602 LANG_FOR_EACH_INPUT_STATEMENT (f
)
5605 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5606 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
5607 sec
->flags
&= ~SEC_EXCLUDE
;
5611 if (link_info
.gc_sections
)
5612 bfd_gc_sections (output_bfd
, &link_info
);
5615 /* Relax all sections until bfd_relax_section gives up. */
5618 relax_sections (void)
5620 /* Keep relaxing until bfd_relax_section gives up. */
5621 bfd_boolean relax_again
;
5625 relax_again
= FALSE
;
5627 /* Note: pe-dll.c does something like this also. If you find
5628 you need to change this code, you probably need to change
5629 pe-dll.c also. DJ */
5631 /* Do all the assignments with our current guesses as to
5633 lang_do_assignments ();
5635 /* We must do this after lang_do_assignments, because it uses
5637 lang_reset_memory_regions ();
5639 /* Perform another relax pass - this time we know where the
5640 globals are, so can make a better guess. */
5641 lang_size_sections (&relax_again
, FALSE
);
5643 while (relax_again
);
5649 /* Finalize dynamic list. */
5650 if (link_info
.dynamic
)
5651 lang_finalize_version_expr_head (&link_info
.dynamic
->head
);
5653 current_target
= default_target
;
5655 /* Open the output file. */
5656 lang_for_each_statement (ldlang_open_output
);
5659 ldemul_create_output_section_statements ();
5661 /* Add to the hash table all undefineds on the command line. */
5662 lang_place_undefineds ();
5664 if (!bfd_section_already_linked_table_init ())
5665 einfo (_("%P%F: Failed to create hash table\n"));
5667 /* Create a bfd for each input file. */
5668 current_target
= default_target
;
5669 open_input_bfds (statement_list
.head
, FALSE
);
5671 link_info
.gc_sym_list
= &entry_symbol
;
5672 if (entry_symbol
.name
== NULL
)
5673 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
5675 ldemul_after_open ();
5677 bfd_section_already_linked_table_free ();
5679 /* Make sure that we're not mixing architectures. We call this
5680 after all the input files have been opened, but before we do any
5681 other processing, so that any operations merge_private_bfd_data
5682 does on the output file will be known during the rest of the
5686 /* Handle .exports instead of a version script if we're told to do so. */
5687 if (command_line
.version_exports_section
)
5688 lang_do_version_exports_section ();
5690 /* Build all sets based on the information gathered from the input
5692 ldctor_build_sets ();
5694 /* Remove unreferenced sections if asked to. */
5695 lang_gc_sections ();
5697 /* Size up the common data. */
5700 /* Update wild statements. */
5701 update_wild_statements (statement_list
.head
);
5703 /* Run through the contours of the script and attach input sections
5704 to the correct output sections. */
5705 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
5707 /* Find any sections not attached explicitly and handle them. */
5708 lang_place_orphans ();
5710 if (! link_info
.relocatable
)
5714 /* Merge SEC_MERGE sections. This has to be done after GC of
5715 sections, so that GCed sections are not merged, but before
5716 assigning dynamic symbols, since removing whole input sections
5718 bfd_merge_sections (output_bfd
, &link_info
);
5720 /* Look for a text section and set the readonly attribute in it. */
5721 found
= bfd_get_section_by_name (output_bfd
, ".text");
5725 if (config
.text_read_only
)
5726 found
->flags
|= SEC_READONLY
;
5728 found
->flags
&= ~SEC_READONLY
;
5732 /* Do anything special before sizing sections. This is where ELF
5733 and other back-ends size dynamic sections. */
5734 ldemul_before_allocation ();
5736 /* We must record the program headers before we try to fix the
5737 section positions, since they will affect SIZEOF_HEADERS. */
5738 lang_record_phdrs ();
5740 /* Size up the sections. */
5741 lang_size_sections (NULL
, !command_line
.relax
);
5743 /* Now run around and relax if we can. */
5744 if (command_line
.relax
)
5746 /* We may need more than one relaxation pass. */
5747 int i
= link_info
.relax_pass
;
5749 /* The backend can use it to determine the current pass. */
5750 link_info
.relax_pass
= 0;
5755 link_info
.relax_pass
++;
5758 /* Final extra sizing to report errors. */
5759 lang_do_assignments ();
5760 lang_reset_memory_regions ();
5761 lang_size_sections (NULL
, TRUE
);
5764 /* See if anything special should be done now we know how big
5766 ldemul_after_allocation ();
5768 /* Fix any .startof. or .sizeof. symbols. */
5769 lang_set_startof ();
5771 /* Do all the assignments, now that we know the final resting places
5772 of all the symbols. */
5774 lang_do_assignments ();
5778 /* Make sure that the section addresses make sense. */
5779 if (! link_info
.relocatable
5780 && command_line
.check_section_addresses
)
5781 lang_check_section_addresses ();
5786 /* EXPORTED TO YACC */
5789 lang_add_wild (struct wildcard_spec
*filespec
,
5790 struct wildcard_list
*section_list
,
5791 bfd_boolean keep_sections
)
5793 struct wildcard_list
*curr
, *next
;
5794 lang_wild_statement_type
*new;
5796 /* Reverse the list as the parser puts it back to front. */
5797 for (curr
= section_list
, section_list
= NULL
;
5799 section_list
= curr
, curr
= next
)
5801 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
5802 placed_commons
= TRUE
;
5805 curr
->next
= section_list
;
5808 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
5810 if (strcmp (filespec
->name
, "*") == 0)
5811 filespec
->name
= NULL
;
5812 else if (! wildcardp (filespec
->name
))
5813 lang_has_input_file
= TRUE
;
5816 new = new_stat (lang_wild_statement
, stat_ptr
);
5817 new->filename
= NULL
;
5818 new->filenames_sorted
= FALSE
;
5819 if (filespec
!= NULL
)
5821 new->filename
= filespec
->name
;
5822 new->filenames_sorted
= filespec
->sorted
== by_name
;
5824 new->section_list
= section_list
;
5825 new->keep_sections
= keep_sections
;
5826 lang_list_init (&new->children
);
5827 analyze_walk_wild_section_handler (new);
5831 lang_section_start (const char *name
, etree_type
*address
,
5832 const segment_type
*segment
)
5834 lang_address_statement_type
*ad
;
5836 ad
= new_stat (lang_address_statement
, stat_ptr
);
5837 ad
->section_name
= name
;
5838 ad
->address
= address
;
5839 ad
->segment
= segment
;
5842 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
5843 because of a -e argument on the command line, or zero if this is
5844 called by ENTRY in a linker script. Command line arguments take
5848 lang_add_entry (const char *name
, bfd_boolean cmdline
)
5850 if (entry_symbol
.name
== NULL
5852 || ! entry_from_cmdline
)
5854 entry_symbol
.name
= name
;
5855 entry_from_cmdline
= cmdline
;
5859 /* Set the default start symbol to NAME. .em files should use this,
5860 not lang_add_entry, to override the use of "start" if neither the
5861 linker script nor the command line specifies an entry point. NAME
5862 must be permanently allocated. */
5864 lang_default_entry (const char *name
)
5866 entry_symbol_default
= name
;
5870 lang_add_target (const char *name
)
5872 lang_target_statement_type
*new;
5874 new = new_stat (lang_target_statement
, stat_ptr
);
5879 lang_add_map (const char *name
)
5886 map_option_f
= TRUE
;
5894 lang_add_fill (fill_type
*fill
)
5896 lang_fill_statement_type
*new;
5898 new = new_stat (lang_fill_statement
, stat_ptr
);
5903 lang_add_data (int type
, union etree_union
*exp
)
5905 lang_data_statement_type
*new;
5907 new = new_stat (lang_data_statement
, stat_ptr
);
5912 /* Create a new reloc statement. RELOC is the BFD relocation type to
5913 generate. HOWTO is the corresponding howto structure (we could
5914 look this up, but the caller has already done so). SECTION is the
5915 section to generate a reloc against, or NAME is the name of the
5916 symbol to generate a reloc against. Exactly one of SECTION and
5917 NAME must be NULL. ADDEND is an expression for the addend. */
5920 lang_add_reloc (bfd_reloc_code_real_type reloc
,
5921 reloc_howto_type
*howto
,
5924 union etree_union
*addend
)
5926 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
5930 p
->section
= section
;
5932 p
->addend_exp
= addend
;
5934 p
->addend_value
= 0;
5935 p
->output_section
= NULL
;
5936 p
->output_offset
= 0;
5939 lang_assignment_statement_type
*
5940 lang_add_assignment (etree_type
*exp
)
5942 lang_assignment_statement_type
*new;
5944 new = new_stat (lang_assignment_statement
, stat_ptr
);
5950 lang_add_attribute (enum statement_enum attribute
)
5952 new_statement (attribute
, sizeof (lang_statement_header_type
), stat_ptr
);
5956 lang_startup (const char *name
)
5958 if (startup_file
!= NULL
)
5960 einfo (_("%P%F: multiple STARTUP files\n"));
5962 first_file
->filename
= name
;
5963 first_file
->local_sym_name
= name
;
5964 first_file
->real
= TRUE
;
5966 startup_file
= name
;
5970 lang_float (bfd_boolean maybe
)
5972 lang_float_flag
= maybe
;
5976 /* Work out the load- and run-time regions from a script statement, and
5977 store them in *LMA_REGION and *REGION respectively.
5979 MEMSPEC is the name of the run-time region, or the value of
5980 DEFAULT_MEMORY_REGION if the statement didn't specify one.
5981 LMA_MEMSPEC is the name of the load-time region, or null if the
5982 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
5983 had an explicit load address.
5985 It is an error to specify both a load region and a load address. */
5988 lang_get_regions (lang_memory_region_type
**region
,
5989 lang_memory_region_type
**lma_region
,
5990 const char *memspec
,
5991 const char *lma_memspec
,
5992 bfd_boolean have_lma
,
5993 bfd_boolean have_vma
)
5995 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
5997 /* If no runtime region or VMA has been specified, but the load region
5998 has been specified, then use the load region for the runtime region
6000 if (lma_memspec
!= NULL
6002 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
6003 *region
= *lma_region
;
6005 *region
= lang_memory_region_lookup (memspec
, FALSE
);
6007 if (have_lma
&& lma_memspec
!= 0)
6008 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
6012 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
6013 lang_output_section_phdr_list
*phdrs
,
6014 const char *lma_memspec
)
6016 lang_get_regions (¤t_section
->region
,
6017 ¤t_section
->lma_region
,
6018 memspec
, lma_memspec
,
6019 current_section
->load_base
!= NULL
,
6020 current_section
->addr_tree
!= NULL
);
6021 current_section
->fill
= fill
;
6022 current_section
->phdrs
= phdrs
;
6023 stat_ptr
= &statement_list
;
6026 /* Create an absolute symbol with the given name with the value of the
6027 address of first byte of the section named.
6029 If the symbol already exists, then do nothing. */
6032 lang_abs_symbol_at_beginning_of (const char *secname
, const char *name
)
6034 struct bfd_link_hash_entry
*h
;
6036 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
6038 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6040 if (h
->type
== bfd_link_hash_new
6041 || h
->type
== bfd_link_hash_undefined
)
6045 h
->type
= bfd_link_hash_defined
;
6047 sec
= bfd_get_section_by_name (output_bfd
, secname
);
6051 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
6053 h
->u
.def
.section
= bfd_abs_section_ptr
;
6057 /* Create an absolute symbol with the given name with the value of the
6058 address of the first byte after the end of the section named.
6060 If the symbol already exists, then do nothing. */
6063 lang_abs_symbol_at_end_of (const char *secname
, const char *name
)
6065 struct bfd_link_hash_entry
*h
;
6067 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
6069 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6071 if (h
->type
== bfd_link_hash_new
6072 || h
->type
== bfd_link_hash_undefined
)
6076 h
->type
= bfd_link_hash_defined
;
6078 sec
= bfd_get_section_by_name (output_bfd
, secname
);
6082 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
6083 + TO_ADDR (sec
->size
));
6085 h
->u
.def
.section
= bfd_abs_section_ptr
;
6090 lang_statement_append (lang_statement_list_type
*list
,
6091 lang_statement_union_type
*element
,
6092 lang_statement_union_type
**field
)
6094 *(list
->tail
) = element
;
6098 /* Set the output format type. -oformat overrides scripts. */
6101 lang_add_output_format (const char *format
,
6106 if (output_target
== NULL
|| !from_script
)
6108 if (command_line
.endian
== ENDIAN_BIG
6111 else if (command_line
.endian
== ENDIAN_LITTLE
6115 output_target
= format
;
6119 /* Enter a group. This creates a new lang_group_statement, and sets
6120 stat_ptr to build new statements within the group. */
6123 lang_enter_group (void)
6125 lang_group_statement_type
*g
;
6127 g
= new_stat (lang_group_statement
, stat_ptr
);
6128 lang_list_init (&g
->children
);
6129 stat_ptr
= &g
->children
;
6132 /* Leave a group. This just resets stat_ptr to start writing to the
6133 regular list of statements again. Note that this will not work if
6134 groups can occur inside anything else which can adjust stat_ptr,
6135 but currently they can't. */
6138 lang_leave_group (void)
6140 stat_ptr
= &statement_list
;
6143 /* Add a new program header. This is called for each entry in a PHDRS
6144 command in a linker script. */
6147 lang_new_phdr (const char *name
,
6149 bfd_boolean filehdr
,
6154 struct lang_phdr
*n
, **pp
;
6156 n
= stat_alloc (sizeof (struct lang_phdr
));
6159 n
->type
= exp_get_value_int (type
, 0, "program header type");
6160 n
->filehdr
= filehdr
;
6165 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
6170 /* Record the program header information in the output BFD. FIXME: We
6171 should not be calling an ELF specific function here. */
6174 lang_record_phdrs (void)
6178 lang_output_section_phdr_list
*last
;
6179 struct lang_phdr
*l
;
6180 lang_output_section_statement_type
*os
;
6183 secs
= xmalloc (alc
* sizeof (asection
*));
6185 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
6192 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6196 lang_output_section_phdr_list
*pl
;
6198 if (os
->constraint
== -1)
6206 if (os
->sectype
== noload_section
6207 || os
->bfd_section
== NULL
6208 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
6213 if (os
->bfd_section
== NULL
)
6216 for (; pl
!= NULL
; pl
= pl
->next
)
6218 if (strcmp (pl
->name
, l
->name
) == 0)
6223 secs
= xrealloc (secs
, alc
* sizeof (asection
*));
6225 secs
[c
] = os
->bfd_section
;
6232 if (l
->flags
== NULL
)
6235 flags
= exp_get_vma (l
->flags
, 0, "phdr flags");
6240 at
= exp_get_vma (l
->at
, 0, "phdr load address");
6242 if (! bfd_record_phdr (output_bfd
, l
->type
,
6243 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
6244 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
6245 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
6250 /* Make sure all the phdr assignments succeeded. */
6251 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
6255 lang_output_section_phdr_list
*pl
;
6257 if (os
->constraint
== -1
6258 || os
->bfd_section
== NULL
)
6261 for (pl
= os
->phdrs
;
6264 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
6265 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
6266 os
->name
, pl
->name
);
6270 /* Record a list of sections which may not be cross referenced. */
6273 lang_add_nocrossref (lang_nocrossref_type
*l
)
6275 struct lang_nocrossrefs
*n
;
6277 n
= xmalloc (sizeof *n
);
6278 n
->next
= nocrossref_list
;
6280 nocrossref_list
= n
;
6282 /* Set notice_all so that we get informed about all symbols. */
6283 link_info
.notice_all
= TRUE
;
6286 /* Overlay handling. We handle overlays with some static variables. */
6288 /* The overlay virtual address. */
6289 static etree_type
*overlay_vma
;
6290 /* And subsection alignment. */
6291 static etree_type
*overlay_subalign
;
6293 /* An expression for the maximum section size seen so far. */
6294 static etree_type
*overlay_max
;
6296 /* A list of all the sections in this overlay. */
6298 struct overlay_list
{
6299 struct overlay_list
*next
;
6300 lang_output_section_statement_type
*os
;
6303 static struct overlay_list
*overlay_list
;
6305 /* Start handling an overlay. */
6308 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
6310 /* The grammar should prevent nested overlays from occurring. */
6311 ASSERT (overlay_vma
== NULL
6312 && overlay_subalign
== NULL
6313 && overlay_max
== NULL
);
6315 overlay_vma
= vma_expr
;
6316 overlay_subalign
= subalign
;
6319 /* Start a section in an overlay. We handle this by calling
6320 lang_enter_output_section_statement with the correct VMA.
6321 lang_leave_overlay sets up the LMA and memory regions. */
6324 lang_enter_overlay_section (const char *name
)
6326 struct overlay_list
*n
;
6329 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
6330 0, overlay_subalign
, 0, 0);
6332 /* If this is the first section, then base the VMA of future
6333 sections on this one. This will work correctly even if `.' is
6334 used in the addresses. */
6335 if (overlay_list
== NULL
)
6336 overlay_vma
= exp_nameop (ADDR
, name
);
6338 /* Remember the section. */
6339 n
= xmalloc (sizeof *n
);
6340 n
->os
= current_section
;
6341 n
->next
= overlay_list
;
6344 size
= exp_nameop (SIZEOF
, name
);
6346 /* Arrange to work out the maximum section end address. */
6347 if (overlay_max
== NULL
)
6350 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
6353 /* Finish a section in an overlay. There isn't any special to do
6357 lang_leave_overlay_section (fill_type
*fill
,
6358 lang_output_section_phdr_list
*phdrs
)
6365 name
= current_section
->name
;
6367 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
6368 region and that no load-time region has been specified. It doesn't
6369 really matter what we say here, since lang_leave_overlay will
6371 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
6373 /* Define the magic symbols. */
6375 clean
= xmalloc (strlen (name
) + 1);
6377 for (s1
= name
; *s1
!= '\0'; s1
++)
6378 if (ISALNUM (*s1
) || *s1
== '_')
6382 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
6383 sprintf (buf
, "__load_start_%s", clean
);
6384 lang_add_assignment (exp_assop ('=', buf
,
6385 exp_nameop (LOADADDR
, name
)));
6387 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
6388 sprintf (buf
, "__load_stop_%s", clean
);
6389 lang_add_assignment (exp_assop ('=', buf
,
6391 exp_nameop (LOADADDR
, name
),
6392 exp_nameop (SIZEOF
, name
))));
6397 /* Finish an overlay. If there are any overlay wide settings, this
6398 looks through all the sections in the overlay and sets them. */
6401 lang_leave_overlay (etree_type
*lma_expr
,
6404 const char *memspec
,
6405 lang_output_section_phdr_list
*phdrs
,
6406 const char *lma_memspec
)
6408 lang_memory_region_type
*region
;
6409 lang_memory_region_type
*lma_region
;
6410 struct overlay_list
*l
;
6411 lang_nocrossref_type
*nocrossref
;
6413 lang_get_regions (®ion
, &lma_region
,
6414 memspec
, lma_memspec
,
6415 lma_expr
!= NULL
, FALSE
);
6419 /* After setting the size of the last section, set '.' to end of the
6421 if (overlay_list
!= NULL
)
6422 overlay_list
->os
->update_dot_tree
6423 = exp_assop ('=', ".", exp_binop ('+', overlay_vma
, overlay_max
));
6428 struct overlay_list
*next
;
6430 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
6433 l
->os
->region
= region
;
6434 l
->os
->lma_region
= lma_region
;
6436 /* The first section has the load address specified in the
6437 OVERLAY statement. The rest are worked out from that.
6438 The base address is not needed (and should be null) if
6439 an LMA region was specified. */
6441 l
->os
->load_base
= lma_expr
;
6443 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
6444 l
->os
->phdrs
= phdrs
;
6448 lang_nocrossref_type
*nc
;
6450 nc
= xmalloc (sizeof *nc
);
6451 nc
->name
= l
->os
->name
;
6452 nc
->next
= nocrossref
;
6461 if (nocrossref
!= NULL
)
6462 lang_add_nocrossref (nocrossref
);
6465 overlay_list
= NULL
;
6469 /* Version handling. This is only useful for ELF. */
6471 /* This global variable holds the version tree that we build. */
6473 struct bfd_elf_version_tree
*lang_elf_version_info
;
6475 /* If PREV is NULL, return first version pattern matching particular symbol.
6476 If PREV is non-NULL, return first version pattern matching particular
6477 symbol after PREV (previously returned by lang_vers_match). */
6479 static struct bfd_elf_version_expr
*
6480 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
6481 struct bfd_elf_version_expr
*prev
,
6484 const char *cxx_sym
= sym
;
6485 const char *java_sym
= sym
;
6486 struct bfd_elf_version_expr
*expr
= NULL
;
6488 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
6490 cxx_sym
= cplus_demangle (sym
, DMGL_PARAMS
| DMGL_ANSI
);
6494 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
6496 java_sym
= cplus_demangle (sym
, DMGL_JAVA
);
6501 if (head
->htab
&& (prev
== NULL
|| prev
->symbol
))
6503 struct bfd_elf_version_expr e
;
6505 switch (prev
? prev
->mask
: 0)
6508 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
6511 expr
= htab_find (head
->htab
, &e
);
6512 while (expr
&& strcmp (expr
->symbol
, sym
) == 0)
6513 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
6519 case BFD_ELF_VERSION_C_TYPE
:
6520 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
6523 expr
= htab_find (head
->htab
, &e
);
6524 while (expr
&& strcmp (expr
->symbol
, cxx_sym
) == 0)
6525 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
6531 case BFD_ELF_VERSION_CXX_TYPE
:
6532 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
6534 e
.symbol
= java_sym
;
6535 expr
= htab_find (head
->htab
, &e
);
6536 while (expr
&& strcmp (expr
->symbol
, java_sym
) == 0)
6537 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
6548 /* Finally, try the wildcards. */
6549 if (prev
== NULL
|| prev
->symbol
)
6550 expr
= head
->remaining
;
6553 for (; expr
; expr
= expr
->next
)
6560 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
6563 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
6565 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
6569 if (fnmatch (expr
->pattern
, s
, 0) == 0)
6575 free ((char *) cxx_sym
);
6576 if (java_sym
!= sym
)
6577 free ((char *) java_sym
);
6581 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
6582 return a string pointing to the symbol name. */
6585 realsymbol (const char *pattern
)
6588 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
6589 char *s
, *symbol
= xmalloc (strlen (pattern
) + 1);
6591 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
6593 /* It is a glob pattern only if there is no preceding
6595 if (! backslash
&& (*p
== '?' || *p
== '*' || *p
== '['))
6603 /* Remove the preceding backslash. */
6610 backslash
= *p
== '\\';
6625 /* This is called for each variable name or match expression. NEW is
6626 the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
6627 pattern to be matched against symbol names. */
6629 struct bfd_elf_version_expr
*
6630 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
6633 bfd_boolean literal_p
)
6635 struct bfd_elf_version_expr
*ret
;
6637 ret
= xmalloc (sizeof *ret
);
6639 ret
->pattern
= literal_p
? NULL
: new;
6642 ret
->symbol
= literal_p
? new : realsymbol (new);
6644 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
6645 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
6646 else if (strcasecmp (lang
, "C++") == 0)
6647 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
6648 else if (strcasecmp (lang
, "Java") == 0)
6649 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
6652 einfo (_("%X%P: unknown language `%s' in version information\n"),
6654 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
6657 return ldemul_new_vers_pattern (ret
);
6660 /* This is called for each set of variable names and match
6663 struct bfd_elf_version_tree
*
6664 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
6665 struct bfd_elf_version_expr
*locals
)
6667 struct bfd_elf_version_tree
*ret
;
6669 ret
= xcalloc (1, sizeof *ret
);
6670 ret
->globals
.list
= globals
;
6671 ret
->locals
.list
= locals
;
6672 ret
->match
= lang_vers_match
;
6673 ret
->name_indx
= (unsigned int) -1;
6677 /* This static variable keeps track of version indices. */
6679 static int version_index
;
6682 version_expr_head_hash (const void *p
)
6684 const struct bfd_elf_version_expr
*e
= p
;
6686 return htab_hash_string (e
->symbol
);
6690 version_expr_head_eq (const void *p1
, const void *p2
)
6692 const struct bfd_elf_version_expr
*e1
= p1
;
6693 const struct bfd_elf_version_expr
*e2
= p2
;
6695 return strcmp (e1
->symbol
, e2
->symbol
) == 0;
6699 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
6702 struct bfd_elf_version_expr
*e
, *next
;
6703 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
6705 for (e
= head
->list
; e
; e
= e
->next
)
6709 head
->mask
|= e
->mask
;
6714 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
6715 version_expr_head_eq
, NULL
);
6716 list_loc
= &head
->list
;
6717 remaining_loc
= &head
->remaining
;
6718 for (e
= head
->list
; e
; e
= next
)
6724 remaining_loc
= &e
->next
;
6728 void **loc
= htab_find_slot (head
->htab
, e
, INSERT
);
6732 struct bfd_elf_version_expr
*e1
, *last
;
6738 if (e1
->mask
== e
->mask
)
6746 while (e1
&& strcmp (e1
->symbol
, e
->symbol
) == 0);
6750 /* This is a duplicate. */
6751 /* FIXME: Memory leak. Sometimes pattern is not
6752 xmalloced alone, but in larger chunk of memory. */
6753 /* free (e->symbol); */
6758 e
->next
= last
->next
;
6766 list_loc
= &e
->next
;
6770 *remaining_loc
= NULL
;
6771 *list_loc
= head
->remaining
;
6774 head
->remaining
= head
->list
;
6777 /* This is called when we know the name and dependencies of the
6781 lang_register_vers_node (const char *name
,
6782 struct bfd_elf_version_tree
*version
,
6783 struct bfd_elf_version_deps
*deps
)
6785 struct bfd_elf_version_tree
*t
, **pp
;
6786 struct bfd_elf_version_expr
*e1
;
6791 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
6792 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
6794 einfo (_("%X%P: anonymous version tag cannot be combined"
6795 " with other version tags\n"));
6800 /* Make sure this node has a unique name. */
6801 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6802 if (strcmp (t
->name
, name
) == 0)
6803 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
6805 lang_finalize_version_expr_head (&version
->globals
);
6806 lang_finalize_version_expr_head (&version
->locals
);
6808 /* Check the global and local match names, and make sure there
6809 aren't any duplicates. */
6811 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
6813 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6815 struct bfd_elf_version_expr
*e2
;
6817 if (t
->locals
.htab
&& e1
->symbol
)
6819 e2
= htab_find (t
->locals
.htab
, e1
);
6820 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
6822 if (e1
->mask
== e2
->mask
)
6823 einfo (_("%X%P: duplicate expression `%s'"
6824 " in version information\n"), e1
->symbol
);
6828 else if (!e1
->symbol
)
6829 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
6830 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
6831 && e1
->mask
== e2
->mask
)
6832 einfo (_("%X%P: duplicate expression `%s'"
6833 " in version information\n"), e1
->pattern
);
6837 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
6839 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6841 struct bfd_elf_version_expr
*e2
;
6843 if (t
->globals
.htab
&& e1
->symbol
)
6845 e2
= htab_find (t
->globals
.htab
, e1
);
6846 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
6848 if (e1
->mask
== e2
->mask
)
6849 einfo (_("%X%P: duplicate expression `%s'"
6850 " in version information\n"),
6855 else if (!e1
->symbol
)
6856 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
6857 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
6858 && e1
->mask
== e2
->mask
)
6859 einfo (_("%X%P: duplicate expression `%s'"
6860 " in version information\n"), e1
->pattern
);
6864 version
->deps
= deps
;
6865 version
->name
= name
;
6866 if (name
[0] != '\0')
6869 version
->vernum
= version_index
;
6872 version
->vernum
= 0;
6874 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
6879 /* This is called when we see a version dependency. */
6881 struct bfd_elf_version_deps
*
6882 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
6884 struct bfd_elf_version_deps
*ret
;
6885 struct bfd_elf_version_tree
*t
;
6887 ret
= xmalloc (sizeof *ret
);
6890 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6892 if (strcmp (t
->name
, name
) == 0)
6894 ret
->version_needed
= t
;
6899 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
6905 lang_do_version_exports_section (void)
6907 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
6909 LANG_FOR_EACH_INPUT_STATEMENT (is
)
6911 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
6919 contents
= xmalloc (len
);
6920 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
6921 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
6924 while (p
< contents
+ len
)
6926 greg
= lang_new_vers_pattern (greg
, p
, NULL
, FALSE
);
6927 p
= strchr (p
, '\0') + 1;
6930 /* Do not free the contents, as we used them creating the regex. */
6932 /* Do not include this section in the link. */
6933 sec
->flags
|= SEC_EXCLUDE
;
6936 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
, FALSE
);
6937 lang_register_vers_node (command_line
.version_exports_section
,
6938 lang_new_vers_node (greg
, lreg
), NULL
);
6942 lang_add_unique (const char *name
)
6944 struct unique_sections
*ent
;
6946 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
6947 if (strcmp (ent
->name
, name
) == 0)
6950 ent
= xmalloc (sizeof *ent
);
6951 ent
->name
= xstrdup (name
);
6952 ent
->next
= unique_section_list
;
6953 unique_section_list
= ent
;
6956 /* Append the list of dynamic symbols to the existing one. */
6959 lang_append_dynamic_list (struct bfd_elf_version_expr
*dynamic
)
6961 if (link_info
.dynamic
)
6963 struct bfd_elf_version_expr
*tail
;
6964 for (tail
= dynamic
; tail
->next
!= NULL
; tail
= tail
->next
)
6966 tail
->next
= link_info
.dynamic
->head
.list
;
6967 link_info
.dynamic
->head
.list
= dynamic
;
6971 struct bfd_elf_dynamic_list
*d
;
6973 d
= xcalloc (1, sizeof *d
);
6974 d
->head
.list
= dynamic
;
6975 d
->match
= lang_vers_match
;
6976 link_info
.dynamic
= d
;
6980 /* Append the list of C++ typeinfo dynamic symbols to the existing
6984 lang_append_dynamic_list_cpp_typeinfo (void)
6986 const char * symbols
[] =
6988 "typeinfo name for*",
6991 struct bfd_elf_version_expr
*dynamic
= NULL
;
6994 for (i
= 0; i
< ARRAY_SIZE (symbols
); i
++)
6995 dynamic
= lang_new_vers_pattern (dynamic
, symbols
[i
], "C++",
6998 lang_append_dynamic_list (dynamic
);