1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005
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, 59 Temple Place - Suite 330, 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 lang_phdr
*lang_phdr_list
;
66 static struct bfd_hash_table lang_definedness_table
;
68 /* Forward declarations. */
69 static void exp_init_os (etree_type
*);
70 static void init_map_userdata (bfd
*, asection
*, void *);
71 static lang_input_statement_type
*lookup_name (const char *);
72 static bfd_boolean
load_symbols (lang_input_statement_type
*,
73 lang_statement_list_type
*);
74 static struct bfd_hash_entry
*lang_definedness_newfunc
75 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
76 static void insert_undefined (const char *);
77 static void print_all_symbols (asection
*);
78 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
79 static void print_statement (lang_statement_union_type
*,
80 lang_output_section_statement_type
*);
81 static void print_statement_list (lang_statement_union_type
*,
82 lang_output_section_statement_type
*);
83 static void print_statements (void);
84 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
85 static void lang_record_phdrs (void);
86 static void lang_do_version_exports_section (void);
88 /* Exported variables. */
89 lang_output_section_statement_type
*abs_output_section
;
90 lang_statement_list_type lang_output_section_statement
;
91 lang_statement_list_type
*stat_ptr
= &statement_list
;
92 lang_statement_list_type file_chain
= { NULL
, NULL
};
93 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
94 const char *entry_section
= ".text";
95 bfd_boolean entry_from_cmdline
;
96 bfd_boolean lang_has_input_file
= FALSE
;
97 bfd_boolean had_output_filename
= FALSE
;
98 bfd_boolean lang_float_flag
= FALSE
;
99 bfd_boolean delete_output_file_on_failure
= FALSE
;
100 struct lang_nocrossrefs
*nocrossref_list
;
101 static struct unique_sections
*unique_section_list
;
102 static bfd_boolean ldlang_sysrooted_script
= FALSE
;
103 int lang_statement_iteration
= 0;
105 etree_type
*base
; /* Relocation base - or null */
107 /* Return TRUE if the PATTERN argument is a wildcard pattern.
108 Although backslashes are treated specially if a pattern contains
109 wildcards, we do not consider the mere presence of a backslash to
110 be enough to cause the pattern to be treated as a wildcard.
111 That lets us handle DOS filenames more naturally. */
112 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
114 #define new_stat(x, y) \
115 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
117 #define outside_section_address(q) \
118 ((q)->output_offset + (q)->output_section->vma)
120 #define outside_symbol_address(q) \
121 ((q)->value + outside_section_address (q->section))
123 #define SECTION_NAME_MAP_LENGTH (16)
126 stat_alloc (size_t size
)
128 return obstack_alloc (&stat_obstack
, size
);
132 unique_section_p (const asection
*sec
)
134 struct unique_sections
*unam
;
137 if (link_info
.relocatable
138 && sec
->owner
!= NULL
139 && bfd_is_group_section (sec
->owner
, sec
))
143 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
144 if (wildcardp (unam
->name
)
145 ? fnmatch (unam
->name
, secnam
, 0) == 0
146 : strcmp (unam
->name
, secnam
) == 0)
154 /* Generic traversal routines for finding matching sections. */
156 /* Try processing a section against a wildcard. This just calls
157 the callback unless the filename exclusion list is present
158 and excludes the file. It's hardly ever present so this
159 function is very fast. */
162 walk_wild_consider_section (lang_wild_statement_type
*ptr
,
163 lang_input_statement_type
*file
,
165 struct wildcard_list
*sec
,
169 bfd_boolean skip
= FALSE
;
170 struct name_list
*list_tmp
;
172 /* Don't process sections from files which were
174 for (list_tmp
= sec
->spec
.exclude_name_list
;
176 list_tmp
= list_tmp
->next
)
178 bfd_boolean is_wildcard
= wildcardp (list_tmp
->name
);
180 skip
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
182 skip
= strcmp (list_tmp
->name
, file
->filename
) == 0;
184 /* If this file is part of an archive, and the archive is
185 excluded, exclude this file. */
186 if (! skip
&& file
->the_bfd
!= NULL
187 && file
->the_bfd
->my_archive
!= NULL
188 && file
->the_bfd
->my_archive
->filename
!= NULL
)
191 skip
= fnmatch (list_tmp
->name
,
192 file
->the_bfd
->my_archive
->filename
,
195 skip
= strcmp (list_tmp
->name
,
196 file
->the_bfd
->my_archive
->filename
) == 0;
204 (*callback
) (ptr
, sec
, s
, file
, data
);
207 /* Lowest common denominator routine that can handle everything correctly,
211 walk_wild_section_general (lang_wild_statement_type
*ptr
,
212 lang_input_statement_type
*file
,
217 struct wildcard_list
*sec
;
219 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
221 sec
= ptr
->section_list
;
223 (*callback
) (ptr
, sec
, s
, file
, data
);
227 bfd_boolean skip
= FALSE
;
229 if (sec
->spec
.name
!= NULL
)
231 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
233 if (wildcardp (sec
->spec
.name
))
234 skip
= fnmatch (sec
->spec
.name
, sname
, 0) != 0;
236 skip
= strcmp (sec
->spec
.name
, sname
) != 0;
240 walk_wild_consider_section (ptr
, file
, s
, sec
, callback
, data
);
247 /* Routines to find a single section given its name. If there's more
248 than one section with that name, we report that. */
252 asection
*found_section
;
253 bfd_boolean multiple_sections_found
;
254 } section_iterator_callback_data
;
257 section_iterator_callback (bfd
*bfd ATTRIBUTE_UNUSED
, asection
*s
, void *data
)
259 section_iterator_callback_data
*d
= data
;
261 if (d
->found_section
!= NULL
)
263 d
->multiple_sections_found
= TRUE
;
267 d
->found_section
= s
;
272 find_section (lang_input_statement_type
*file
,
273 struct wildcard_list
*sec
,
274 bfd_boolean
*multiple_sections_found
)
276 section_iterator_callback_data cb_data
= { NULL
, FALSE
};
278 bfd_get_section_by_name_if (file
->the_bfd
, sec
->spec
.name
,
279 section_iterator_callback
, &cb_data
);
280 *multiple_sections_found
= cb_data
.multiple_sections_found
;
281 return cb_data
.found_section
;
284 /* Code for handling simple wildcards without going through fnmatch,
285 which can be expensive because of charset translations etc. */
287 /* A simple wild is a literal string followed by a single '*',
288 where the literal part is at least 4 characters long. */
291 is_simple_wild (const char *name
)
293 size_t len
= strcspn (name
, "*?[");
294 return len
>= 4 && name
[len
] == '*' && name
[len
+ 1] == '\0';
298 match_simple_wild (const char *pattern
, const char *name
)
300 /* The first four characters of the pattern are guaranteed valid
301 non-wildcard characters. So we can go faster. */
302 if (pattern
[0] != name
[0] || pattern
[1] != name
[1]
303 || pattern
[2] != name
[2] || pattern
[3] != name
[3])
308 while (*pattern
!= '*')
309 if (*name
++ != *pattern
++)
315 /* Specialized, optimized routines for handling different kinds of
319 walk_wild_section_specs1_wild0 (lang_wild_statement_type
*ptr
,
320 lang_input_statement_type
*file
,
324 /* We can just do a hash lookup for the section with the right name.
325 But if that lookup discovers more than one section with the name
326 (should be rare), we fall back to the general algorithm because
327 we would otherwise have to sort the sections to make sure they
328 get processed in the bfd's order. */
329 bfd_boolean multiple_sections_found
;
330 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
331 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
333 if (multiple_sections_found
)
334 walk_wild_section_general (ptr
, file
, callback
, data
);
336 walk_wild_consider_section (ptr
, file
, s0
, sec0
, callback
, data
);
340 walk_wild_section_specs1_wild1 (lang_wild_statement_type
*ptr
,
341 lang_input_statement_type
*file
,
346 struct wildcard_list
*wildsec0
= ptr
->handler_data
[0];
348 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
350 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
351 bfd_boolean skip
= !match_simple_wild (wildsec0
->spec
.name
, sname
);
354 walk_wild_consider_section (ptr
, file
, s
, wildsec0
, callback
, data
);
359 walk_wild_section_specs2_wild1 (lang_wild_statement_type
*ptr
,
360 lang_input_statement_type
*file
,
365 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
366 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
367 bfd_boolean multiple_sections_found
;
368 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
370 if (multiple_sections_found
)
372 walk_wild_section_general (ptr
, file
, callback
, data
);
376 /* Note that if the section was not found, s0 is NULL and
377 we'll simply never succeed the s == s0 test below. */
378 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
380 /* Recall that in this code path, a section cannot satisfy more
381 than one spec, so if s == s0 then it cannot match
384 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
387 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
388 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
391 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
,
398 walk_wild_section_specs3_wild2 (lang_wild_statement_type
*ptr
,
399 lang_input_statement_type
*file
,
404 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
405 struct wildcard_list
*wildsec1
= ptr
->handler_data
[1];
406 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
407 bfd_boolean multiple_sections_found
;
408 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
);
410 if (multiple_sections_found
)
412 walk_wild_section_general (ptr
, file
, callback
, data
);
416 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
419 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
422 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
423 bfd_boolean skip
= !match_simple_wild (wildsec1
->spec
.name
, sname
);
426 walk_wild_consider_section (ptr
, file
, s
, wildsec1
, callback
, data
);
429 skip
= !match_simple_wild (wildsec2
->spec
.name
, sname
);
431 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
439 walk_wild_section_specs4_wild2 (lang_wild_statement_type
*ptr
,
440 lang_input_statement_type
*file
,
445 struct wildcard_list
*sec0
= ptr
->handler_data
[0];
446 struct wildcard_list
*sec1
= ptr
->handler_data
[1];
447 struct wildcard_list
*wildsec2
= ptr
->handler_data
[2];
448 struct wildcard_list
*wildsec3
= ptr
->handler_data
[3];
449 bfd_boolean multiple_sections_found
;
450 asection
*s0
= find_section (file
, sec0
, &multiple_sections_found
), *s1
;
452 if (multiple_sections_found
)
454 walk_wild_section_general (ptr
, file
, callback
, data
);
458 s1
= find_section (file
, sec1
, &multiple_sections_found
);
459 if (multiple_sections_found
)
461 walk_wild_section_general (ptr
, file
, callback
, data
);
465 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
468 walk_wild_consider_section (ptr
, file
, s
, sec0
, callback
, data
);
471 walk_wild_consider_section (ptr
, file
, s
, sec1
, callback
, data
);
474 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
475 bfd_boolean skip
= !match_simple_wild (wildsec2
->spec
.name
,
479 walk_wild_consider_section (ptr
, file
, s
, wildsec2
, callback
,
483 skip
= !match_simple_wild (wildsec3
->spec
.name
, sname
);
485 walk_wild_consider_section (ptr
, file
, s
, wildsec3
,
493 walk_wild_section (lang_wild_statement_type
*ptr
,
494 lang_input_statement_type
*file
,
498 if (file
->just_syms_flag
)
501 (*ptr
->walk_wild_section_handler
) (ptr
, file
, callback
, data
);
504 /* Returns TRUE when name1 is a wildcard spec that might match
505 something name2 can match. We're conservative: we return FALSE
506 only if the prefixes of name1 and name2 are different up to the
507 first wildcard character. */
510 wild_spec_can_overlap (const char *name1
, const char *name2
)
512 size_t prefix1_len
= strcspn (name1
, "?*[");
513 size_t prefix2_len
= strcspn (name2
, "?*[");
514 size_t min_prefix_len
;
516 /* Note that if there is no wildcard character, then we treat the
517 terminating 0 as part of the prefix. Thus ".text" won't match
518 ".text." or ".text.*", for example. */
519 if (name1
[prefix1_len
] == '\0')
521 if (name2
[prefix2_len
] == '\0')
524 min_prefix_len
= prefix1_len
< prefix2_len
? prefix1_len
: prefix2_len
;
526 return memcmp (name1
, name2
, min_prefix_len
) == 0;
529 /* Select specialized code to handle various kinds of wildcard
533 analyze_walk_wild_section_handler (lang_wild_statement_type
*ptr
)
536 int wild_name_count
= 0;
537 struct wildcard_list
*sec
;
541 ptr
->walk_wild_section_handler
= walk_wild_section_general
;
543 /* Count how many wildcard_specs there are, and how many of those
544 actually use wildcards in the name. Also, bail out if any of the
545 wildcard names are NULL. (Can this actually happen?
546 walk_wild_section used to test for it.) And bail out if any
547 of the wildcards are more complex than a simple string
548 ending in a single '*'. */
549 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
552 if (sec
->spec
.name
== NULL
)
554 if (wildcardp (sec
->spec
.name
))
557 if (!is_simple_wild (sec
->spec
.name
))
562 /* The zero-spec case would be easy to optimize but it doesn't
563 happen in practice. Likewise, more than 4 specs doesn't
564 happen in practice. */
565 if (sec_count
== 0 || sec_count
> 4)
568 /* Check that no two specs can match the same section. */
569 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
571 struct wildcard_list
*sec2
;
572 for (sec2
= sec
->next
; sec2
!= NULL
; sec2
= sec2
->next
)
574 if (wild_spec_can_overlap (sec
->spec
.name
, sec2
->spec
.name
))
579 signature
= (sec_count
<< 8) + wild_name_count
;
583 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild0
;
586 ptr
->walk_wild_section_handler
= walk_wild_section_specs1_wild1
;
589 ptr
->walk_wild_section_handler
= walk_wild_section_specs2_wild1
;
592 ptr
->walk_wild_section_handler
= walk_wild_section_specs3_wild2
;
595 ptr
->walk_wild_section_handler
= walk_wild_section_specs4_wild2
;
601 /* Now fill the data array with pointers to the specs, first the
602 specs with non-wildcard names, then the specs with wildcard
603 names. It's OK to process the specs in different order from the
604 given order, because we've already determined that no section
605 will match more than one spec. */
607 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
608 if (!wildcardp (sec
->spec
.name
))
609 ptr
->handler_data
[data_counter
++] = sec
;
610 for (sec
= ptr
->section_list
; sec
!= NULL
; sec
= sec
->next
)
611 if (wildcardp (sec
->spec
.name
))
612 ptr
->handler_data
[data_counter
++] = sec
;
615 /* Handle a wild statement for a single file F. */
618 walk_wild_file (lang_wild_statement_type
*s
,
619 lang_input_statement_type
*f
,
623 if (f
->the_bfd
== NULL
624 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
625 walk_wild_section (s
, f
, callback
, data
);
630 /* This is an archive file. We must map each member of the
631 archive separately. */
632 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
633 while (member
!= NULL
)
635 /* When lookup_name is called, it will call the add_symbols
636 entry point for the archive. For each element of the
637 archive which is included, BFD will call ldlang_add_file,
638 which will set the usrdata field of the member to the
639 lang_input_statement. */
640 if (member
->usrdata
!= NULL
)
642 walk_wild_section (s
, member
->usrdata
, callback
, data
);
645 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
651 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
653 const char *file_spec
= s
->filename
;
655 if (file_spec
== NULL
)
657 /* Perform the iteration over all files in the list. */
658 LANG_FOR_EACH_INPUT_STATEMENT (f
)
660 walk_wild_file (s
, f
, callback
, data
);
663 else if (wildcardp (file_spec
))
665 LANG_FOR_EACH_INPUT_STATEMENT (f
)
667 if (fnmatch (file_spec
, f
->filename
, FNM_FILE_NAME
) == 0)
668 walk_wild_file (s
, f
, callback
, data
);
673 lang_input_statement_type
*f
;
675 /* Perform the iteration over a single file. */
676 f
= lookup_name (file_spec
);
678 walk_wild_file (s
, f
, callback
, data
);
682 /* lang_for_each_statement walks the parse tree and calls the provided
683 function for each node. */
686 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
687 lang_statement_union_type
*s
)
689 for (; s
!= NULL
; s
= s
->header
.next
)
693 switch (s
->header
.type
)
695 case lang_constructors_statement_enum
:
696 lang_for_each_statement_worker (func
, constructor_list
.head
);
698 case lang_output_section_statement_enum
:
699 lang_for_each_statement_worker
700 (func
, s
->output_section_statement
.children
.head
);
702 case lang_wild_statement_enum
:
703 lang_for_each_statement_worker (func
,
704 s
->wild_statement
.children
.head
);
706 case lang_group_statement_enum
:
707 lang_for_each_statement_worker (func
,
708 s
->group_statement
.children
.head
);
710 case lang_data_statement_enum
:
711 case lang_reloc_statement_enum
:
712 case lang_object_symbols_statement_enum
:
713 case lang_output_statement_enum
:
714 case lang_target_statement_enum
:
715 case lang_input_section_enum
:
716 case lang_input_statement_enum
:
717 case lang_assignment_statement_enum
:
718 case lang_padding_statement_enum
:
719 case lang_address_statement_enum
:
720 case lang_fill_statement_enum
:
730 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
732 lang_for_each_statement_worker (func
, statement_list
.head
);
735 /*----------------------------------------------------------------------*/
738 lang_list_init (lang_statement_list_type
*list
)
741 list
->tail
= &list
->head
;
744 /* Build a new statement node for the parse tree. */
746 static lang_statement_union_type
*
747 new_statement (enum statement_enum type
,
749 lang_statement_list_type
*list
)
751 lang_statement_union_type
*new;
753 new = stat_alloc (size
);
754 new->header
.type
= type
;
755 new->header
.next
= NULL
;
756 lang_statement_append (list
, new, &new->header
.next
);
760 /* Build a new input file node for the language. There are several
761 ways in which we treat an input file, eg, we only look at symbols,
762 or prefix it with a -l etc.
764 We can be supplied with requests for input files more than once;
765 they may, for example be split over several lines like foo.o(.text)
766 foo.o(.data) etc, so when asked for a file we check that we haven't
767 got it already so we don't duplicate the bfd. */
769 static lang_input_statement_type
*
770 new_afile (const char *name
,
771 lang_input_file_enum_type file_type
,
773 bfd_boolean add_to_list
)
775 lang_input_statement_type
*p
;
778 p
= new_stat (lang_input_statement
, stat_ptr
);
781 p
= stat_alloc (sizeof (lang_input_statement_type
));
782 p
->header
.next
= NULL
;
785 lang_has_input_file
= TRUE
;
787 p
->sysrooted
= FALSE
;
790 case lang_input_file_is_symbols_only_enum
:
792 p
->is_archive
= FALSE
;
794 p
->local_sym_name
= name
;
795 p
->just_syms_flag
= TRUE
;
796 p
->search_dirs_flag
= FALSE
;
798 case lang_input_file_is_fake_enum
:
800 p
->is_archive
= FALSE
;
802 p
->local_sym_name
= name
;
803 p
->just_syms_flag
= FALSE
;
804 p
->search_dirs_flag
= FALSE
;
806 case lang_input_file_is_l_enum
:
807 p
->is_archive
= TRUE
;
810 p
->local_sym_name
= concat ("-l", name
, NULL
);
811 p
->just_syms_flag
= FALSE
;
812 p
->search_dirs_flag
= TRUE
;
814 case lang_input_file_is_marker_enum
:
816 p
->is_archive
= FALSE
;
818 p
->local_sym_name
= name
;
819 p
->just_syms_flag
= FALSE
;
820 p
->search_dirs_flag
= TRUE
;
822 case lang_input_file_is_search_file_enum
:
823 p
->sysrooted
= ldlang_sysrooted_script
;
825 p
->is_archive
= FALSE
;
827 p
->local_sym_name
= name
;
828 p
->just_syms_flag
= FALSE
;
829 p
->search_dirs_flag
= TRUE
;
831 case lang_input_file_is_file_enum
:
833 p
->is_archive
= FALSE
;
835 p
->local_sym_name
= name
;
836 p
->just_syms_flag
= FALSE
;
837 p
->search_dirs_flag
= FALSE
;
844 p
->next_real_file
= NULL
;
847 p
->dynamic
= config
.dynamic_link
;
848 p
->add_needed
= add_needed
;
849 p
->as_needed
= as_needed
;
850 p
->whole_archive
= whole_archive
;
852 lang_statement_append (&input_file_chain
,
853 (lang_statement_union_type
*) p
,
858 lang_input_statement_type
*
859 lang_add_input_file (const char *name
,
860 lang_input_file_enum_type file_type
,
863 lang_has_input_file
= TRUE
;
864 return new_afile (name
, file_type
, target
, TRUE
);
867 /* Build enough state so that the parser can build its tree. */
872 obstack_begin (&stat_obstack
, 1000);
874 stat_ptr
= &statement_list
;
876 lang_list_init (stat_ptr
);
878 lang_list_init (&input_file_chain
);
879 lang_list_init (&lang_output_section_statement
);
880 lang_list_init (&file_chain
);
881 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
884 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
886 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
888 /* The value "3" is ad-hoc, somewhat related to the expected number of
889 DEFINED expressions in a linker script. For most default linker
890 scripts, there are none. Why a hash table then? Well, it's somewhat
891 simpler to re-use working machinery than using a linked list in terms
892 of code-complexity here in ld, besides the initialization which just
893 looks like other code here. */
894 if (!bfd_hash_table_init_n (&lang_definedness_table
,
895 lang_definedness_newfunc
, 3))
896 einfo (_("%P%F: out of memory during initialization"));
898 /* Callers of exp_fold_tree need to increment this. */
899 lang_statement_iteration
= 0;
902 /*----------------------------------------------------------------------
903 A region is an area of memory declared with the
904 MEMORY { name:org=exp, len=exp ... }
907 We maintain a list of all the regions here.
909 If no regions are specified in the script, then the default is used
910 which is created when looked up to be the entire data space.
912 If create is true we are creating a region inside a MEMORY block.
913 In this case it is probably an error to create a region that has
914 already been created. If we are not inside a MEMORY block it is
915 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
916 and so we issue a warning. */
918 static lang_memory_region_type
*lang_memory_region_list
;
919 static lang_memory_region_type
**lang_memory_region_list_tail
920 = &lang_memory_region_list
;
922 lang_memory_region_type
*
923 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
925 lang_memory_region_type
*p
;
926 lang_memory_region_type
*new;
928 /* NAME is NULL for LMA memspecs if no region was specified. */
932 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
933 if (strcmp (p
->name
, name
) == 0)
936 einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
941 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
942 einfo (_("%P:%S: warning: memory region %s not declared\n"), name
);
944 new = stat_alloc (sizeof (lang_memory_region_type
));
946 new->name
= xstrdup (name
);
949 *lang_memory_region_list_tail
= new;
950 lang_memory_region_list_tail
= &new->next
;
954 new->length
= ~(bfd_size_type
) 0;
956 new->had_full_message
= FALSE
;
961 static lang_memory_region_type
*
962 lang_memory_default (asection
*section
)
964 lang_memory_region_type
*p
;
966 flagword sec_flags
= section
->flags
;
968 /* Override SEC_DATA to mean a writable section. */
969 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
970 sec_flags
|= SEC_DATA
;
972 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
974 if ((p
->flags
& sec_flags
) != 0
975 && (p
->not_flags
& sec_flags
) == 0)
980 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
983 static lang_output_section_statement_type
*
984 lang_output_section_find_1 (const char *const name
, int constraint
)
986 lang_output_section_statement_type
*lookup
;
988 for (lookup
= &lang_output_section_statement
.head
->output_section_statement
;
990 lookup
= lookup
->next
)
992 if (strcmp (name
, lookup
->name
) == 0
993 && lookup
->constraint
!= -1
994 && (constraint
== 0 || constraint
== lookup
->constraint
))
1000 lang_output_section_statement_type
*
1001 lang_output_section_find (const char *const name
)
1003 return lang_output_section_find_1 (name
, 0);
1006 static lang_output_section_statement_type
*
1007 lang_output_section_statement_lookup_1 (const char *const name
, int constraint
)
1009 lang_output_section_statement_type
*lookup
;
1011 lookup
= lang_output_section_find_1 (name
, constraint
);
1014 lookup
= new_stat (lang_output_section_statement
, stat_ptr
);
1015 lookup
->region
= NULL
;
1016 lookup
->lma_region
= NULL
;
1018 lookup
->block_value
= 1;
1019 lookup
->name
= name
;
1021 lookup
->next
= NULL
;
1022 lookup
->bfd_section
= NULL
;
1023 lookup
->processed
= 0;
1024 lookup
->constraint
= constraint
;
1025 lookup
->sectype
= normal_section
;
1026 lookup
->addr_tree
= NULL
;
1027 lang_list_init (&lookup
->children
);
1029 lookup
->memspec
= NULL
;
1031 lookup
->subsection_alignment
= -1;
1032 lookup
->section_alignment
= -1;
1033 lookup
->load_base
= NULL
;
1034 lookup
->update_dot_tree
= NULL
;
1035 lookup
->phdrs
= NULL
;
1037 lang_statement_append (&lang_output_section_statement
,
1038 (lang_statement_union_type
*) lookup
,
1039 (lang_statement_union_type
**) &lookup
->next
);
1044 lang_output_section_statement_type
*
1045 lang_output_section_statement_lookup (const char *const name
)
1047 return lang_output_section_statement_lookup_1 (name
, 0);
1050 /* A variant of lang_output_section_find used by place_orphan.
1051 Returns the output statement that should precede a new output
1052 statement for SEC. If an exact match is found on certain flags,
1055 lang_output_section_statement_type
*
1056 lang_output_section_find_by_flags (const asection
*sec
,
1057 lang_output_section_statement_type
**exact
)
1059 lang_output_section_statement_type
*first
, *look
, *found
;
1062 /* We know the first statement on this list is *ABS*. May as well
1064 first
= &lang_output_section_statement
.head
->output_section_statement
;
1065 first
= first
->next
;
1067 /* First try for an exact match. */
1069 for (look
= first
; look
; look
= look
->next
)
1071 flags
= look
->flags
;
1072 if (look
->bfd_section
!= NULL
)
1073 flags
= look
->bfd_section
->flags
;
1074 flags
^= sec
->flags
;
1075 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
1076 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1085 if (sec
->flags
& SEC_CODE
)
1087 /* Try for a rw code section. */
1088 for (look
= first
; look
; look
= look
->next
)
1090 flags
= look
->flags
;
1091 if (look
->bfd_section
!= NULL
)
1092 flags
= look
->bfd_section
->flags
;
1093 flags
^= sec
->flags
;
1094 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1095 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1101 if (sec
->flags
& (SEC_READONLY
| SEC_THREAD_LOCAL
))
1103 /* .rodata can go after .text, .sdata2 after .rodata. */
1104 for (look
= first
; look
; look
= look
->next
)
1106 flags
= look
->flags
;
1107 if (look
->bfd_section
!= NULL
)
1108 flags
= look
->bfd_section
->flags
;
1109 flags
^= sec
->flags
;
1110 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1112 && !(look
->flags
& (SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1118 if (sec
->flags
& SEC_SMALL_DATA
)
1120 /* .sdata goes after .data, .sbss after .sdata. */
1121 for (look
= first
; look
; look
= look
->next
)
1123 flags
= look
->flags
;
1124 if (look
->bfd_section
!= NULL
)
1125 flags
= look
->bfd_section
->flags
;
1126 flags
^= sec
->flags
;
1127 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1128 | SEC_THREAD_LOCAL
))
1129 || ((look
->flags
& SEC_SMALL_DATA
)
1130 && !(sec
->flags
& SEC_HAS_CONTENTS
)))
1136 if (sec
->flags
& SEC_HAS_CONTENTS
)
1138 /* .data goes after .rodata. */
1139 for (look
= first
; look
; look
= look
->next
)
1141 flags
= look
->flags
;
1142 if (look
->bfd_section
!= NULL
)
1143 flags
= look
->bfd_section
->flags
;
1144 flags
^= sec
->flags
;
1145 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
1146 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
1152 /* .bss goes last. */
1153 for (look
= first
; look
; look
= look
->next
)
1155 flags
= look
->flags
;
1156 if (look
->bfd_section
!= NULL
)
1157 flags
= look
->bfd_section
->flags
;
1158 flags
^= sec
->flags
;
1159 if (!(flags
& SEC_ALLOC
))
1166 /* Find the last output section before given output statement.
1167 Used by place_orphan. */
1170 output_prev_sec_find (lang_output_section_statement_type
*os
)
1172 asection
*s
= (asection
*) NULL
;
1173 lang_output_section_statement_type
*lookup
;
1175 for (lookup
= &lang_output_section_statement
.head
->output_section_statement
;
1177 lookup
= lookup
->next
)
1179 if (lookup
->constraint
== -1)
1184 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
1185 s
= lookup
->bfd_section
;
1191 lang_output_section_statement_type
*
1192 lang_insert_orphan (lang_input_statement_type
*file
,
1194 const char *secname
,
1195 lang_output_section_statement_type
*after
,
1196 struct orphan_save
*place
,
1197 etree_type
*address
,
1198 lang_statement_list_type
*add_child
)
1200 lang_statement_list_type
*old
;
1201 lang_statement_list_type add
;
1203 etree_type
*load_base
;
1204 lang_output_section_statement_type
*os
;
1205 lang_output_section_statement_type
**os_tail
;
1207 /* Start building a list of statements for this section.
1208 First save the current statement pointer. */
1211 /* If we have found an appropriate place for the output section
1212 statements for this orphan, add them to our own private list,
1213 inserting them later into the global statement list. */
1217 lang_list_init (stat_ptr
);
1221 if (config
.build_constructors
)
1223 /* If the name of the section is representable in C, then create
1224 symbols to mark the start and the end of the section. */
1225 for (ps
= secname
; *ps
!= '\0'; ps
++)
1226 if (! ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
1231 etree_type
*e_align
;
1233 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__start_" + 1);
1234 symname
[0] = bfd_get_symbol_leading_char (output_bfd
);
1235 sprintf (symname
+ (symname
[0] != 0), "__start_%s", secname
);
1236 e_align
= exp_unop (ALIGN_K
,
1237 exp_intop ((bfd_vma
) 1 << s
->alignment_power
));
1238 lang_add_assignment (exp_assop ('=', ".", e_align
));
1239 lang_add_assignment (exp_assop ('=', symname
,
1240 exp_nameop (NAME
, ".")));
1244 if (link_info
.relocatable
|| (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
1245 address
= exp_intop (0);
1248 if (after
!= NULL
&& after
->load_base
!= NULL
)
1250 etree_type
*lma_from_vma
;
1251 lma_from_vma
= exp_binop ('-', after
->load_base
,
1252 exp_nameop (ADDR
, after
->name
));
1253 load_base
= exp_binop ('+', lma_from_vma
,
1254 exp_nameop (ADDR
, secname
));
1257 os_tail
= ((lang_output_section_statement_type
**)
1258 lang_output_section_statement
.tail
);
1259 os
= lang_enter_output_section_statement (secname
, address
, 0, NULL
, NULL
,
1262 if (add_child
== NULL
)
1263 add_child
= &os
->children
;
1264 lang_add_section (add_child
, s
, os
, file
);
1266 lang_leave_output_section_statement (0, "*default*", NULL
, NULL
);
1268 if (config
.build_constructors
&& *ps
== '\0')
1272 /* lang_leave_ouput_section_statement resets stat_ptr.
1273 Put stat_ptr back where we want it. */
1277 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__stop_" + 1);
1278 symname
[0] = bfd_get_symbol_leading_char (output_bfd
);
1279 sprintf (symname
+ (symname
[0] != 0), "__stop_%s", secname
);
1280 lang_add_assignment (exp_assop ('=', symname
,
1281 exp_nameop (NAME
, ".")));
1284 /* Restore the global list pointer. */
1288 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
1290 asection
*snew
, *as
;
1292 snew
= os
->bfd_section
;
1294 /* Shuffle the bfd section list to make the output file look
1295 neater. This is really only cosmetic. */
1296 if (place
->section
== NULL
1297 && after
!= (&lang_output_section_statement
.head
1298 ->output_section_statement
))
1300 asection
*bfd_section
= after
->bfd_section
;
1302 /* If the output statement hasn't been used to place any input
1303 sections (and thus doesn't have an output bfd_section),
1304 look for the closest prior output statement having an
1306 if (bfd_section
== NULL
)
1307 bfd_section
= output_prev_sec_find (after
);
1309 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
1310 place
->section
= &bfd_section
->next
;
1313 if (place
->section
== NULL
)
1314 place
->section
= &output_bfd
->sections
;
1316 as
= *place
->section
;
1317 if (as
!= snew
&& as
->prev
!= snew
)
1319 /* Unlink the section. */
1320 bfd_section_list_remove (output_bfd
, snew
);
1322 /* Now tack it back on in the right place. */
1323 bfd_section_list_insert_before (output_bfd
, as
, snew
);
1326 /* Save the end of this list. Further ophans of this type will
1327 follow the one we've just added. */
1328 place
->section
= &snew
->next
;
1330 /* The following is non-cosmetic. We try to put the output
1331 statements in some sort of reasonable order here, because they
1332 determine the final load addresses of the orphan sections.
1333 In addition, placing output statements in the wrong order may
1334 require extra segments. For instance, given a typical
1335 situation of all read-only sections placed in one segment and
1336 following that a segment containing all the read-write
1337 sections, we wouldn't want to place an orphan read/write
1338 section before or amongst the read-only ones. */
1339 if (add
.head
!= NULL
)
1341 lang_output_section_statement_type
*newly_added_os
;
1343 if (place
->stmt
== NULL
)
1345 lang_statement_union_type
**where
;
1346 lang_statement_union_type
**assign
= NULL
;
1348 /* Look for a suitable place for the new statement list.
1349 The idea is to skip over anything that might be inside
1350 a SECTIONS {} statement in a script, before we find
1351 another output_section_statement. Assignments to "dot"
1352 before an output section statement are assumed to
1354 for (where
= &after
->header
.next
;
1356 where
= &(*where
)->header
.next
)
1358 switch ((*where
)->header
.type
)
1360 case lang_assignment_statement_enum
:
1363 lang_assignment_statement_type
*ass
;
1364 ass
= &(*where
)->assignment_statement
;
1365 if (ass
->exp
->type
.node_class
!= etree_assert
1366 && ass
->exp
->assign
.dst
[0] == '.'
1367 && ass
->exp
->assign
.dst
[1] == 0)
1371 case lang_wild_statement_enum
:
1372 case lang_input_section_enum
:
1373 case lang_object_symbols_statement_enum
:
1374 case lang_fill_statement_enum
:
1375 case lang_data_statement_enum
:
1376 case lang_reloc_statement_enum
:
1377 case lang_padding_statement_enum
:
1378 case lang_constructors_statement_enum
:
1381 case lang_output_section_statement_enum
:
1384 case lang_input_statement_enum
:
1385 case lang_address_statement_enum
:
1386 case lang_target_statement_enum
:
1387 case lang_output_statement_enum
:
1388 case lang_group_statement_enum
:
1389 case lang_afile_asection_pair_statement_enum
:
1398 place
->os_tail
= &after
->next
;
1402 /* Put it after the last orphan statement we added. */
1403 *add
.tail
= *place
->stmt
;
1404 *place
->stmt
= add
.head
;
1407 /* Fix the global list pointer if we happened to tack our
1408 new list at the tail. */
1409 if (*old
->tail
== add
.head
)
1410 old
->tail
= add
.tail
;
1412 /* Save the end of this list. */
1413 place
->stmt
= add
.tail
;
1415 /* Do the same for the list of output section statements. */
1416 newly_added_os
= *os_tail
;
1418 newly_added_os
->next
= *place
->os_tail
;
1419 *place
->os_tail
= newly_added_os
;
1420 place
->os_tail
= &newly_added_os
->next
;
1422 /* Fixing the global list pointer here is a little different.
1423 We added to the list in lang_enter_output_section_statement,
1424 trimmed off the new output_section_statment above when
1425 assigning *os_tail = NULL, but possibly added it back in
1426 the same place when assigning *place->os_tail. */
1427 if (*os_tail
== NULL
)
1428 lang_output_section_statement
.tail
1429 = (lang_statement_union_type
**) os_tail
;
1436 lang_map_flags (flagword flag
)
1438 if (flag
& SEC_ALLOC
)
1441 if (flag
& SEC_CODE
)
1444 if (flag
& SEC_READONLY
)
1447 if (flag
& SEC_DATA
)
1450 if (flag
& SEC_LOAD
)
1457 lang_memory_region_type
*m
;
1460 minfo (_("\nMemory Configuration\n\n"));
1461 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
1462 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1464 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
1469 fprintf (config
.map_file
, "%-16s ", m
->name
);
1471 sprintf_vma (buf
, m
->origin
);
1472 minfo ("0x%s ", buf
);
1480 minfo ("0x%V", m
->length
);
1481 if (m
->flags
|| m
->not_flags
)
1489 lang_map_flags (m
->flags
);
1495 lang_map_flags (m
->not_flags
);
1502 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
1504 if (! command_line
.reduce_memory_overheads
)
1506 obstack_begin (&map_obstack
, 1000);
1507 for (p
= link_info
.input_bfds
; p
!= (bfd
*) NULL
; p
= p
->link_next
)
1508 bfd_map_over_sections (p
, init_map_userdata
, 0);
1509 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
1511 print_statements ();
1515 init_map_userdata (abfd
, sec
, data
)
1516 bfd
*abfd ATTRIBUTE_UNUSED
;
1518 void *data ATTRIBUTE_UNUSED
;
1520 fat_section_userdata_type
*new_data
1521 = ((fat_section_userdata_type
*) (stat_alloc
1522 (sizeof (fat_section_userdata_type
))));
1524 ASSERT (get_userdata (sec
) == NULL
);
1525 get_userdata (sec
) = new_data
;
1526 new_data
->map_symbol_def_tail
= &new_data
->map_symbol_def_head
;
1530 sort_def_symbol (hash_entry
, info
)
1531 struct bfd_link_hash_entry
*hash_entry
;
1532 void *info ATTRIBUTE_UNUSED
;
1534 if (hash_entry
->type
== bfd_link_hash_defined
1535 || hash_entry
->type
== bfd_link_hash_defweak
)
1537 struct fat_user_section_struct
*ud
;
1538 struct map_symbol_def
*def
;
1540 ud
= get_userdata (hash_entry
->u
.def
.section
);
1543 /* ??? What do we have to do to initialize this beforehand? */
1544 /* The first time we get here is bfd_abs_section... */
1545 init_map_userdata (0, hash_entry
->u
.def
.section
, 0);
1546 ud
= get_userdata (hash_entry
->u
.def
.section
);
1548 else if (!ud
->map_symbol_def_tail
)
1549 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
1551 def
= obstack_alloc (&map_obstack
, sizeof *def
);
1552 def
->entry
= hash_entry
;
1553 *(ud
->map_symbol_def_tail
) = def
;
1554 ud
->map_symbol_def_tail
= &def
->next
;
1559 /* Initialize an output section. */
1562 init_os (lang_output_section_statement_type
*s
)
1564 if (s
->bfd_section
!= NULL
)
1567 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
1568 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
1570 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
1571 if (s
->bfd_section
== NULL
)
1572 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
1573 if (s
->bfd_section
== NULL
)
1575 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
1576 output_bfd
->xvec
->name
, s
->name
);
1578 s
->bfd_section
->output_section
= s
->bfd_section
;
1580 /* We initialize an output sections output offset to minus its own
1581 vma to allow us to output a section through itself. */
1582 s
->bfd_section
->output_offset
= 0;
1583 if (!command_line
.reduce_memory_overheads
)
1585 fat_section_userdata_type
*new
1586 = stat_alloc (sizeof (fat_section_userdata_type
));
1587 memset (new, 0, sizeof (fat_section_userdata_type
));
1588 get_userdata (s
->bfd_section
) = new;
1592 /* If there is a base address, make sure that any sections it might
1593 mention are initialized. */
1594 if (s
->addr_tree
!= NULL
)
1595 exp_init_os (s
->addr_tree
);
1597 if (s
->load_base
!= NULL
)
1598 exp_init_os (s
->load_base
);
1601 /* Make sure that all output sections mentioned in an expression are
1605 exp_init_os (etree_type
*exp
)
1607 switch (exp
->type
.node_class
)
1610 exp_init_os (exp
->assign
.src
);
1614 exp_init_os (exp
->binary
.lhs
);
1615 exp_init_os (exp
->binary
.rhs
);
1619 exp_init_os (exp
->trinary
.cond
);
1620 exp_init_os (exp
->trinary
.lhs
);
1621 exp_init_os (exp
->trinary
.rhs
);
1625 exp_init_os (exp
->assert_s
.child
);
1629 exp_init_os (exp
->unary
.child
);
1633 switch (exp
->type
.node_code
)
1639 lang_output_section_statement_type
*os
;
1641 os
= lang_output_section_find (exp
->name
.name
);
1642 if (os
!= NULL
&& os
->bfd_section
== NULL
)
1654 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
1656 lang_input_statement_type
*entry
= data
;
1658 /* If we are only reading symbols from this object, then we want to
1659 discard all sections. */
1660 if (entry
->just_syms_flag
)
1662 bfd_link_just_syms (abfd
, sec
, &link_info
);
1666 if (!(abfd
->flags
& DYNAMIC
))
1667 bfd_section_already_linked (abfd
, sec
);
1670 /* The wild routines.
1672 These expand statements like *(.text) and foo.o to a list of
1673 explicit actions, like foo.o(.text), bar.o(.text) and
1674 foo.o(.text, .data). */
1676 /* Add SECTION to the output section OUTPUT. Do this by creating a
1677 lang_input_section statement which is placed at PTR. FILE is the
1678 input file which holds SECTION. */
1681 lang_add_section (lang_statement_list_type
*ptr
,
1683 lang_output_section_statement_type
*output
,
1684 lang_input_statement_type
*file
)
1686 flagword flags
= section
->flags
;
1687 bfd_boolean discard
;
1689 /* Discard sections marked with SEC_EXCLUDE. */
1690 discard
= (flags
& SEC_EXCLUDE
) != 0;
1692 /* Discard input sections which are assigned to a section named
1693 DISCARD_SECTION_NAME. */
1694 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1697 /* Discard debugging sections if we are stripping debugging
1699 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1700 && (flags
& SEC_DEBUGGING
) != 0)
1705 if (section
->output_section
== NULL
)
1707 /* This prevents future calls from assigning this section. */
1708 section
->output_section
= bfd_abs_section_ptr
;
1713 if (section
->output_section
== NULL
)
1716 lang_input_section_type
*new;
1719 if (output
->bfd_section
== NULL
)
1722 first
= ! output
->bfd_section
->linker_has_input
;
1723 output
->bfd_section
->linker_has_input
= 1;
1725 if (!link_info
.relocatable
1726 && !stripped_excluded_sections
)
1728 asection
*s
= output
->bfd_section
->map_tail
.s
;
1729 output
->bfd_section
->map_tail
.s
= section
;
1730 section
->map_head
.s
= NULL
;
1731 section
->map_tail
.s
= s
;
1733 s
->map_head
.s
= section
;
1735 output
->bfd_section
->map_head
.s
= section
;
1738 /* Add a section reference to the list. */
1739 new = new_stat (lang_input_section
, ptr
);
1741 new->section
= section
;
1743 section
->output_section
= output
->bfd_section
;
1745 flags
= section
->flags
;
1747 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1748 to an output section, because we want to be able to include a
1749 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1750 section (I don't know why we want to do this, but we do).
1751 build_link_order in ldwrite.c handles this case by turning
1752 the embedded SEC_NEVER_LOAD section into a fill. */
1754 flags
&= ~ SEC_NEVER_LOAD
;
1756 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1757 already been processed. One reason to do this is that on pe
1758 format targets, .text$foo sections go into .text and it's odd
1759 to see .text with SEC_LINK_ONCE set. */
1761 if (! link_info
.relocatable
)
1762 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1764 /* If this is not the first input section, and the SEC_READONLY
1765 flag is not currently set, then don't set it just because the
1766 input section has it set. */
1768 if (! first
&& (output
->bfd_section
->flags
& SEC_READONLY
) == 0)
1769 flags
&= ~ SEC_READONLY
;
1771 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1773 && ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1774 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1775 || ((flags
& SEC_MERGE
)
1776 && output
->bfd_section
->entsize
!= section
->entsize
)))
1778 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1779 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1782 output
->bfd_section
->flags
|= flags
;
1784 if (flags
& SEC_MERGE
)
1785 output
->bfd_section
->entsize
= section
->entsize
;
1787 /* If SEC_READONLY is not set in the input section, then clear
1788 it from the output section. */
1789 if ((section
->flags
& SEC_READONLY
) == 0)
1790 output
->bfd_section
->flags
&= ~SEC_READONLY
;
1792 switch (output
->sectype
)
1794 case normal_section
:
1799 case overlay_section
:
1800 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1802 case noload_section
:
1803 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1804 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1808 /* Copy over SEC_SMALL_DATA. */
1809 if (section
->flags
& SEC_SMALL_DATA
)
1810 output
->bfd_section
->flags
|= SEC_SMALL_DATA
;
1812 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1813 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1815 /* If supplied an alignment, then force it. */
1816 if (output
->section_alignment
!= -1)
1817 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1819 if (bfd_get_arch (section
->owner
) == bfd_arch_tic54x
1820 && (section
->flags
& SEC_TIC54X_BLOCK
) != 0)
1822 output
->bfd_section
->flags
|= SEC_TIC54X_BLOCK
;
1823 /* FIXME: This value should really be obtained from the bfd... */
1824 output
->block_value
= 128;
1829 /* Compare sections ASEC and BSEC according to SORT. */
1832 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
1841 case by_alignment_name
:
1842 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
1843 - bfd_section_alignment (asec
->owner
, asec
));
1849 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
1850 bfd_get_section_name (bsec
->owner
, bsec
));
1853 case by_name_alignment
:
1854 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
1855 bfd_get_section_name (bsec
->owner
, bsec
));
1861 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
1862 - bfd_section_alignment (asec
->owner
, asec
));
1869 /* Handle wildcard sorting. This returns the lang_input_section which
1870 should follow the one we are going to create for SECTION and FILE,
1871 based on the sorting requirements of WILD. It returns NULL if the
1872 new section should just go at the end of the current list. */
1874 static lang_statement_union_type
*
1875 wild_sort (lang_wild_statement_type
*wild
,
1876 struct wildcard_list
*sec
,
1877 lang_input_statement_type
*file
,
1880 const char *section_name
;
1881 lang_statement_union_type
*l
;
1883 if (!wild
->filenames_sorted
1884 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
1887 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1888 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
1890 lang_input_section_type
*ls
;
1892 if (l
->header
.type
!= lang_input_section_enum
)
1894 ls
= &l
->input_section
;
1896 /* Sorting by filename takes precedence over sorting by section
1899 if (wild
->filenames_sorted
)
1901 const char *fn
, *ln
;
1905 /* The PE support for the .idata section as generated by
1906 dlltool assumes that files will be sorted by the name of
1907 the archive and then the name of the file within the
1910 if (file
->the_bfd
!= NULL
1911 && bfd_my_archive (file
->the_bfd
) != NULL
)
1913 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1918 fn
= file
->filename
;
1922 if (ls
->ifile
->the_bfd
!= NULL
1923 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1925 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1930 ln
= ls
->ifile
->filename
;
1934 i
= strcmp (fn
, ln
);
1943 fn
= file
->filename
;
1945 ln
= ls
->ifile
->filename
;
1947 i
= strcmp (fn
, ln
);
1955 /* Here either the files are not sorted by name, or we are
1956 looking at the sections for this file. */
1958 if (sec
!= NULL
&& sec
->spec
.sorted
!= none
)
1960 if (compare_section (sec
->spec
.sorted
, section
,
1969 /* Expand a wild statement for a particular FILE. SECTION may be
1970 NULL, in which case it is a wild card. */
1973 output_section_callback (lang_wild_statement_type
*ptr
,
1974 struct wildcard_list
*sec
,
1976 lang_input_statement_type
*file
,
1979 lang_statement_union_type
*before
;
1981 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1982 if (unique_section_p (section
))
1985 before
= wild_sort (ptr
, sec
, file
, section
);
1987 /* Here BEFORE points to the lang_input_section which
1988 should follow the one we are about to add. If BEFORE
1989 is NULL, then the section should just go at the end
1990 of the current list. */
1993 lang_add_section (&ptr
->children
, section
,
1994 (lang_output_section_statement_type
*) output
,
1998 lang_statement_list_type list
;
1999 lang_statement_union_type
**pp
;
2001 lang_list_init (&list
);
2002 lang_add_section (&list
, section
,
2003 (lang_output_section_statement_type
*) output
,
2006 /* If we are discarding the section, LIST.HEAD will
2008 if (list
.head
!= NULL
)
2010 ASSERT (list
.head
->header
.next
== NULL
);
2012 for (pp
= &ptr
->children
.head
;
2014 pp
= &(*pp
)->header
.next
)
2015 ASSERT (*pp
!= NULL
);
2017 list
.head
->header
.next
= *pp
;
2023 /* Check if all sections in a wild statement for a particular FILE
2027 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
2028 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
2030 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
2033 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2034 if (unique_section_p (section
))
2037 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
2038 ((lang_output_section_statement_type
*) data
)->all_input_readonly
= FALSE
;
2041 /* This is passed a file name which must have been seen already and
2042 added to the statement tree. We will see if it has been opened
2043 already and had its symbols read. If not then we'll read it. */
2045 static lang_input_statement_type
*
2046 lookup_name (const char *name
)
2048 lang_input_statement_type
*search
;
2050 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
2052 search
= (lang_input_statement_type
*) search
->next_real_file
)
2054 /* Use the local_sym_name as the name of the file that has
2055 already been loaded as filename might have been transformed
2056 via the search directory lookup mechanism. */
2057 const char * filename
= search
->local_sym_name
;
2059 if (filename
== NULL
&& name
== NULL
)
2061 if (filename
!= NULL
2063 && strcmp (filename
, name
) == 0)
2068 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
2069 default_target
, FALSE
);
2071 /* If we have already added this file, or this file is not real
2072 (FIXME: can that ever actually happen?) or the name is NULL
2073 (FIXME: can that ever actually happen?) don't add this file. */
2076 || search
->filename
== NULL
)
2079 if (! load_symbols (search
, NULL
))
2085 /* Save LIST as a list of libraries whose symbols should not be exported. */
2090 struct excluded_lib
*next
;
2092 static struct excluded_lib
*excluded_libs
;
2095 add_excluded_libs (const char *list
)
2097 const char *p
= list
, *end
;
2101 struct excluded_lib
*entry
;
2102 end
= strpbrk (p
, ",:");
2104 end
= p
+ strlen (p
);
2105 entry
= xmalloc (sizeof (*entry
));
2106 entry
->next
= excluded_libs
;
2107 entry
->name
= xmalloc (end
- p
+ 1);
2108 memcpy (entry
->name
, p
, end
- p
);
2109 entry
->name
[end
- p
] = '\0';
2110 excluded_libs
= entry
;
2118 check_excluded_libs (bfd
*abfd
)
2120 struct excluded_lib
*lib
= excluded_libs
;
2124 int len
= strlen (lib
->name
);
2125 const char *filename
= lbasename (abfd
->filename
);
2127 if (strcmp (lib
->name
, "ALL") == 0)
2129 abfd
->no_export
= TRUE
;
2133 if (strncmp (lib
->name
, filename
, len
) == 0
2134 && (filename
[len
] == '\0'
2135 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
2136 && filename
[len
+ 2] == '\0')))
2138 abfd
->no_export
= TRUE
;
2146 /* Get the symbols for an input file. */
2149 load_symbols (lang_input_statement_type
*entry
,
2150 lang_statement_list_type
*place
)
2157 ldfile_open_file (entry
);
2159 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
2160 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
2163 lang_statement_list_type
*hold
;
2164 bfd_boolean bad_load
= TRUE
;
2165 bfd_boolean save_ldlang_sysrooted_script
;
2167 err
= bfd_get_error ();
2169 /* See if the emulation has some special knowledge. */
2170 if (ldemul_unrecognized_file (entry
))
2173 if (err
== bfd_error_file_ambiguously_recognized
)
2177 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
2178 einfo (_("%B: matching formats:"), entry
->the_bfd
);
2179 for (p
= matching
; *p
!= NULL
; p
++)
2183 else if (err
!= bfd_error_file_not_recognized
2185 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
2189 bfd_close (entry
->the_bfd
);
2190 entry
->the_bfd
= NULL
;
2192 /* Try to interpret the file as a linker script. */
2193 ldfile_open_command_file (entry
->filename
);
2197 save_ldlang_sysrooted_script
= ldlang_sysrooted_script
;
2198 ldlang_sysrooted_script
= entry
->sysrooted
;
2200 ldfile_assumed_script
= TRUE
;
2201 parser_input
= input_script
;
2202 /* We want to use the same -Bdynamic/-Bstatic as the one for
2204 config
.dynamic_link
= entry
->dynamic
;
2206 ldfile_assumed_script
= FALSE
;
2208 ldlang_sysrooted_script
= save_ldlang_sysrooted_script
;
2214 if (ldemul_recognized_file (entry
))
2217 /* We don't call ldlang_add_file for an archive. Instead, the
2218 add_symbols entry point will call ldlang_add_file, via the
2219 add_archive_element callback, for each element of the archive
2221 switch (bfd_get_format (entry
->the_bfd
))
2227 ldlang_add_file (entry
);
2228 if (trace_files
|| trace_file_tries
)
2229 info_msg ("%I\n", entry
);
2233 check_excluded_libs (entry
->the_bfd
);
2235 if (entry
->whole_archive
)
2238 bfd_boolean loaded
= TRUE
;
2242 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
2247 if (! bfd_check_format (member
, bfd_object
))
2249 einfo (_("%F%B: member %B in archive is not an object\n"),
2250 entry
->the_bfd
, member
);
2254 if (! ((*link_info
.callbacks
->add_archive_element
)
2255 (&link_info
, member
, "--whole-archive")))
2258 if (! bfd_link_add_symbols (member
, &link_info
))
2260 einfo (_("%F%B: could not read symbols: %E\n"), member
);
2265 entry
->loaded
= loaded
;
2271 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
2272 entry
->loaded
= TRUE
;
2274 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
2276 return entry
->loaded
;
2279 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2280 may be NULL, indicating that it is a wildcard. Separate
2281 lang_input_section statements are created for each part of the
2282 expansion; they are added after the wild statement S. OUTPUT is
2283 the output section. */
2286 wild (lang_wild_statement_type
*s
,
2287 const char *target ATTRIBUTE_UNUSED
,
2288 lang_output_section_statement_type
*output
)
2290 struct wildcard_list
*sec
;
2292 walk_wild (s
, output_section_callback
, output
);
2294 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
2296 if (default_common_section
!= NULL
)
2298 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
2300 /* Remember the section that common is going to in case we
2301 later get something which doesn't know where to put it. */
2302 default_common_section
= output
;
2307 /* Return TRUE iff target is the sought target. */
2310 get_target (const bfd_target
*target
, void *data
)
2312 const char *sought
= data
;
2314 return strcmp (target
->name
, sought
) == 0;
2317 /* Like strcpy() but convert to lower case as well. */
2320 stricpy (char *dest
, char *src
)
2324 while ((c
= *src
++) != 0)
2325 *dest
++ = TOLOWER (c
);
2330 /* Remove the first occurrence of needle (if any) in haystack
2334 strcut (char *haystack
, char *needle
)
2336 haystack
= strstr (haystack
, needle
);
2342 for (src
= haystack
+ strlen (needle
); *src
;)
2343 *haystack
++ = *src
++;
2349 /* Compare two target format name strings.
2350 Return a value indicating how "similar" they are. */
2353 name_compare (char *first
, char *second
)
2359 copy1
= xmalloc (strlen (first
) + 1);
2360 copy2
= xmalloc (strlen (second
) + 1);
2362 /* Convert the names to lower case. */
2363 stricpy (copy1
, first
);
2364 stricpy (copy2
, second
);
2366 /* Remove size and endian strings from the name. */
2367 strcut (copy1
, "big");
2368 strcut (copy1
, "little");
2369 strcut (copy2
, "big");
2370 strcut (copy2
, "little");
2372 /* Return a value based on how many characters match,
2373 starting from the beginning. If both strings are
2374 the same then return 10 * their length. */
2375 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
2376 if (copy1
[result
] == 0)
2388 /* Set by closest_target_match() below. */
2389 static const bfd_target
*winner
;
2391 /* Scan all the valid bfd targets looking for one that has the endianness
2392 requirement that was specified on the command line, and is the nearest
2393 match to the original output target. */
2396 closest_target_match (const bfd_target
*target
, void *data
)
2398 const bfd_target
*original
= data
;
2400 if (command_line
.endian
== ENDIAN_BIG
2401 && target
->byteorder
!= BFD_ENDIAN_BIG
)
2404 if (command_line
.endian
== ENDIAN_LITTLE
2405 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
2408 /* Must be the same flavour. */
2409 if (target
->flavour
!= original
->flavour
)
2412 /* If we have not found a potential winner yet, then record this one. */
2419 /* Oh dear, we now have two potential candidates for a successful match.
2420 Compare their names and choose the better one. */
2421 if (name_compare (target
->name
, original
->name
)
2422 > name_compare (winner
->name
, original
->name
))
2425 /* Keep on searching until wqe have checked them all. */
2429 /* Return the BFD target format of the first input file. */
2432 get_first_input_target (void)
2434 char *target
= NULL
;
2436 LANG_FOR_EACH_INPUT_STATEMENT (s
)
2438 if (s
->header
.type
== lang_input_statement_enum
2441 ldfile_open_file (s
);
2443 if (s
->the_bfd
!= NULL
2444 && bfd_check_format (s
->the_bfd
, bfd_object
))
2446 target
= bfd_get_target (s
->the_bfd
);
2458 lang_get_output_target (void)
2462 /* Has the user told us which output format to use? */
2463 if (output_target
!= NULL
)
2464 return output_target
;
2466 /* No - has the current target been set to something other than
2468 if (current_target
!= default_target
)
2469 return current_target
;
2471 /* No - can we determine the format of the first input file? */
2472 target
= get_first_input_target ();
2476 /* Failed - use the default output target. */
2477 return default_target
;
2480 /* Open the output file. */
2483 open_output (const char *name
)
2487 output_target
= lang_get_output_target ();
2489 /* Has the user requested a particular endianness on the command
2491 if (command_line
.endian
!= ENDIAN_UNSET
)
2493 const bfd_target
*target
;
2494 enum bfd_endian desired_endian
;
2496 /* Get the chosen target. */
2497 target
= bfd_search_for_target (get_target
, (void *) output_target
);
2499 /* If the target is not supported, we cannot do anything. */
2502 if (command_line
.endian
== ENDIAN_BIG
)
2503 desired_endian
= BFD_ENDIAN_BIG
;
2505 desired_endian
= BFD_ENDIAN_LITTLE
;
2507 /* See if the target has the wrong endianness. This should
2508 not happen if the linker script has provided big and
2509 little endian alternatives, but some scrips don't do
2511 if (target
->byteorder
!= desired_endian
)
2513 /* If it does, then see if the target provides
2514 an alternative with the correct endianness. */
2515 if (target
->alternative_target
!= NULL
2516 && (target
->alternative_target
->byteorder
== desired_endian
))
2517 output_target
= target
->alternative_target
->name
;
2520 /* Try to find a target as similar as possible to
2521 the default target, but which has the desired
2522 endian characteristic. */
2523 bfd_search_for_target (closest_target_match
,
2526 /* Oh dear - we could not find any targets that
2527 satisfy our requirements. */
2529 einfo (_("%P: warning: could not find any targets"
2530 " that match endianness requirement\n"));
2532 output_target
= winner
->name
;
2538 output
= bfd_openw (name
, output_target
);
2542 if (bfd_get_error () == bfd_error_invalid_target
)
2543 einfo (_("%P%F: target %s not found\n"), output_target
);
2545 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
2548 delete_output_file_on_failure
= TRUE
;
2550 if (! bfd_set_format (output
, bfd_object
))
2551 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
2552 if (! bfd_set_arch_mach (output
,
2553 ldfile_output_architecture
,
2554 ldfile_output_machine
))
2555 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
2557 link_info
.hash
= bfd_link_hash_table_create (output
);
2558 if (link_info
.hash
== NULL
)
2559 einfo (_("%P%F: can not create link hash table: %E\n"));
2561 bfd_set_gp_size (output
, g_switch_value
);
2566 ldlang_open_output (lang_statement_union_type
*statement
)
2568 switch (statement
->header
.type
)
2570 case lang_output_statement_enum
:
2571 ASSERT (output_bfd
== NULL
);
2572 output_bfd
= open_output (statement
->output_statement
.name
);
2573 ldemul_set_output_arch ();
2574 if (config
.magic_demand_paged
&& !link_info
.relocatable
)
2575 output_bfd
->flags
|= D_PAGED
;
2577 output_bfd
->flags
&= ~D_PAGED
;
2578 if (config
.text_read_only
)
2579 output_bfd
->flags
|= WP_TEXT
;
2581 output_bfd
->flags
&= ~WP_TEXT
;
2582 if (link_info
.traditional_format
)
2583 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
2585 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
2588 case lang_target_statement_enum
:
2589 current_target
= statement
->target_statement
.target
;
2596 /* Convert between addresses in bytes and sizes in octets.
2597 For currently supported targets, octets_per_byte is always a power
2598 of two, so we can use shifts. */
2599 #define TO_ADDR(X) ((X) >> opb_shift)
2600 #define TO_SIZE(X) ((X) << opb_shift)
2602 /* Support the above. */
2603 static unsigned int opb_shift
= 0;
2608 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2609 ldfile_output_machine
);
2612 while ((x
& 1) == 0)
2620 /* Open all the input files. */
2623 open_input_bfds (lang_statement_union_type
*s
, bfd_boolean force
)
2625 for (; s
!= NULL
; s
= s
->header
.next
)
2627 switch (s
->header
.type
)
2629 case lang_constructors_statement_enum
:
2630 open_input_bfds (constructor_list
.head
, force
);
2632 case lang_output_section_statement_enum
:
2633 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
2635 case lang_wild_statement_enum
:
2636 /* Maybe we should load the file's symbols. */
2637 if (s
->wild_statement
.filename
2638 && ! wildcardp (s
->wild_statement
.filename
))
2639 lookup_name (s
->wild_statement
.filename
);
2640 open_input_bfds (s
->wild_statement
.children
.head
, force
);
2642 case lang_group_statement_enum
:
2644 struct bfd_link_hash_entry
*undefs
;
2646 /* We must continually search the entries in the group
2647 until no new symbols are added to the list of undefined
2652 undefs
= link_info
.hash
->undefs_tail
;
2653 open_input_bfds (s
->group_statement
.children
.head
, TRUE
);
2655 while (undefs
!= link_info
.hash
->undefs_tail
);
2658 case lang_target_statement_enum
:
2659 current_target
= s
->target_statement
.target
;
2661 case lang_input_statement_enum
:
2662 if (s
->input_statement
.real
)
2664 lang_statement_list_type add
;
2666 s
->input_statement
.target
= current_target
;
2668 /* If we are being called from within a group, and this
2669 is an archive which has already been searched, then
2670 force it to be researched unless the whole archive
2671 has been loaded already. */
2673 && !s
->input_statement
.whole_archive
2674 && s
->input_statement
.loaded
2675 && bfd_check_format (s
->input_statement
.the_bfd
,
2677 s
->input_statement
.loaded
= FALSE
;
2679 lang_list_init (&add
);
2681 if (! load_symbols (&s
->input_statement
, &add
))
2682 config
.make_executable
= FALSE
;
2684 if (add
.head
!= NULL
)
2686 *add
.tail
= s
->header
.next
;
2687 s
->header
.next
= add
.head
;
2697 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
2700 lang_track_definedness (const char *name
)
2702 if (bfd_hash_lookup (&lang_definedness_table
, name
, TRUE
, FALSE
) == NULL
)
2703 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
2706 /* New-function for the definedness hash table. */
2708 static struct bfd_hash_entry
*
2709 lang_definedness_newfunc (struct bfd_hash_entry
*entry
,
2710 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
2711 const char *name ATTRIBUTE_UNUSED
)
2713 struct lang_definedness_hash_entry
*ret
2714 = (struct lang_definedness_hash_entry
*) entry
;
2717 ret
= (struct lang_definedness_hash_entry
*)
2718 bfd_hash_allocate (table
, sizeof (struct lang_definedness_hash_entry
));
2721 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
2723 ret
->iteration
= -1;
2727 /* Return the iteration when the definition of NAME was last updated. A
2728 value of -1 means that the symbol is not defined in the linker script
2729 or the command line, but may be defined in the linker symbol table. */
2732 lang_symbol_definition_iteration (const char *name
)
2734 struct lang_definedness_hash_entry
*defentry
2735 = (struct lang_definedness_hash_entry
*)
2736 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
2738 /* We've already created this one on the presence of DEFINED in the
2739 script, so it can't be NULL unless something is borked elsewhere in
2741 if (defentry
== NULL
)
2744 return defentry
->iteration
;
2747 /* Update the definedness state of NAME. */
2750 lang_update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
2752 struct lang_definedness_hash_entry
*defentry
2753 = (struct lang_definedness_hash_entry
*)
2754 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
2756 /* We don't keep track of symbols not tested with DEFINED. */
2757 if (defentry
== NULL
)
2760 /* If the symbol was already defined, and not from an earlier statement
2761 iteration, don't update the definedness iteration, because that'd
2762 make the symbol seem defined in the linker script at this point, and
2763 it wasn't; it was defined in some object. If we do anyway, DEFINED
2764 would start to yield false before this point and the construct "sym =
2765 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
2767 if (h
->type
!= bfd_link_hash_undefined
2768 && h
->type
!= bfd_link_hash_common
2769 && h
->type
!= bfd_link_hash_new
2770 && defentry
->iteration
== -1)
2773 defentry
->iteration
= lang_statement_iteration
;
2776 /* Add the supplied name to the symbol table as an undefined reference.
2777 This is a two step process as the symbol table doesn't even exist at
2778 the time the ld command line is processed. First we put the name
2779 on a list, then, once the output file has been opened, transfer the
2780 name to the symbol table. */
2782 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
2784 #define ldlang_undef_chain_list_head entry_symbol.next
2787 ldlang_add_undef (const char *const name
)
2789 ldlang_undef_chain_list_type
*new =
2790 stat_alloc (sizeof (ldlang_undef_chain_list_type
));
2792 new->next
= ldlang_undef_chain_list_head
;
2793 ldlang_undef_chain_list_head
= new;
2795 new->name
= xstrdup (name
);
2797 if (output_bfd
!= NULL
)
2798 insert_undefined (new->name
);
2801 /* Insert NAME as undefined in the symbol table. */
2804 insert_undefined (const char *name
)
2806 struct bfd_link_hash_entry
*h
;
2808 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
2810 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2811 if (h
->type
== bfd_link_hash_new
)
2813 h
->type
= bfd_link_hash_undefined
;
2814 h
->u
.undef
.abfd
= NULL
;
2815 bfd_link_add_undef (link_info
.hash
, h
);
2819 /* Run through the list of undefineds created above and place them
2820 into the linker hash table as undefined symbols belonging to the
2824 lang_place_undefineds (void)
2826 ldlang_undef_chain_list_type
*ptr
;
2828 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
2829 insert_undefined (ptr
->name
);
2832 /* Check for all readonly or some readwrite sections. */
2835 check_input_sections
2836 (lang_statement_union_type
*s
,
2837 lang_output_section_statement_type
*output_section_statement
)
2839 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2841 switch (s
->header
.type
)
2843 case lang_wild_statement_enum
:
2844 walk_wild (&s
->wild_statement
, check_section_callback
,
2845 output_section_statement
);
2846 if (! output_section_statement
->all_input_readonly
)
2849 case lang_constructors_statement_enum
:
2850 check_input_sections (constructor_list
.head
,
2851 output_section_statement
);
2852 if (! output_section_statement
->all_input_readonly
)
2855 case lang_group_statement_enum
:
2856 check_input_sections (s
->group_statement
.children
.head
,
2857 output_section_statement
);
2858 if (! output_section_statement
->all_input_readonly
)
2867 /* Update wildcard statements if needed. */
2870 update_wild_statements (lang_statement_union_type
*s
)
2872 struct wildcard_list
*sec
;
2874 switch (sort_section
)
2884 for (; s
!= NULL
; s
= s
->header
.next
)
2886 switch (s
->header
.type
)
2891 case lang_wild_statement_enum
:
2892 sec
= s
->wild_statement
.section_list
;
2895 switch (sec
->spec
.sorted
)
2898 sec
->spec
.sorted
= sort_section
;
2901 if (sort_section
== by_alignment
)
2902 sec
->spec
.sorted
= by_name_alignment
;
2905 if (sort_section
== by_name
)
2906 sec
->spec
.sorted
= by_alignment_name
;
2914 case lang_constructors_statement_enum
:
2915 update_wild_statements (constructor_list
.head
);
2918 case lang_output_section_statement_enum
:
2919 update_wild_statements
2920 (s
->output_section_statement
.children
.head
);
2923 case lang_group_statement_enum
:
2924 update_wild_statements (s
->group_statement
.children
.head
);
2932 /* Open input files and attach to output sections. */
2935 map_input_to_output_sections
2936 (lang_statement_union_type
*s
, const char *target
,
2937 lang_output_section_statement_type
*os
)
2939 for (; s
!= NULL
; s
= s
->header
.next
)
2941 switch (s
->header
.type
)
2943 case lang_wild_statement_enum
:
2944 wild (&s
->wild_statement
, target
, os
);
2946 case lang_constructors_statement_enum
:
2947 map_input_to_output_sections (constructor_list
.head
,
2951 case lang_output_section_statement_enum
:
2952 if (s
->output_section_statement
.constraint
)
2954 if (s
->output_section_statement
.constraint
== -1)
2956 s
->output_section_statement
.all_input_readonly
= TRUE
;
2957 check_input_sections (s
->output_section_statement
.children
.head
,
2958 &s
->output_section_statement
);
2959 if ((s
->output_section_statement
.all_input_readonly
2960 && s
->output_section_statement
.constraint
== ONLY_IF_RW
)
2961 || (!s
->output_section_statement
.all_input_readonly
2962 && s
->output_section_statement
.constraint
== ONLY_IF_RO
))
2964 s
->output_section_statement
.constraint
= -1;
2969 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2971 &s
->output_section_statement
);
2973 case lang_output_statement_enum
:
2975 case lang_target_statement_enum
:
2976 target
= s
->target_statement
.target
;
2978 case lang_group_statement_enum
:
2979 map_input_to_output_sections (s
->group_statement
.children
.head
,
2983 case lang_data_statement_enum
:
2984 /* Make sure that any sections mentioned in the expression
2986 exp_init_os (s
->data_statement
.exp
);
2987 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2989 /* The output section gets contents, and then we inspect for
2990 any flags set in the input script which override any ALLOC. */
2991 os
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
2992 if (!(os
->flags
& SEC_NEVER_LOAD
))
2993 os
->bfd_section
->flags
|= SEC_ALLOC
| SEC_LOAD
;
2995 case lang_fill_statement_enum
:
2996 case lang_input_section_enum
:
2997 case lang_object_symbols_statement_enum
:
2998 case lang_reloc_statement_enum
:
2999 case lang_padding_statement_enum
:
3000 case lang_input_statement_enum
:
3001 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3004 case lang_assignment_statement_enum
:
3005 if (os
!= NULL
&& os
->bfd_section
== NULL
)
3008 /* Make sure that any sections mentioned in the assignment
3010 exp_init_os (s
->assignment_statement
.exp
);
3012 case lang_afile_asection_pair_statement_enum
:
3015 case lang_address_statement_enum
:
3016 /* Mark the specified section with the supplied address.
3018 If this section was actually a segment marker, then the
3019 directive is ignored if the linker script explicitly
3020 processed the segment marker. Originally, the linker
3021 treated segment directives (like -Ttext on the
3022 command-line) as section directives. We honor the
3023 section directive semantics for backwards compatibilty;
3024 linker scripts that do not specifically check for
3025 SEGMENT_START automatically get the old semantics. */
3026 if (!s
->address_statement
.segment
3027 || !s
->address_statement
.segment
->used
)
3029 lang_output_section_statement_type
*aos
3030 = (lang_output_section_statement_lookup
3031 (s
->address_statement
.section_name
));
3033 if (aos
->bfd_section
== NULL
)
3035 aos
->addr_tree
= s
->address_statement
.address
;
3042 /* An output section might have been removed after its statement was
3043 added. For example, ldemul_before_allocation can remove dynamic
3044 sections if they turn out to be not needed. Clean them up here. */
3047 strip_excluded_output_sections (void)
3049 lang_output_section_statement_type
*os
;
3051 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
3057 if (os
->constraint
== -1)
3060 if (os
->bfd_section
== NULL
|| os
->bfd_section
->map_head
.s
== NULL
)
3063 for (s
= os
->bfd_section
->map_head
.s
; s
!= NULL
; s
= s
->map_head
.s
)
3064 if ((s
->flags
& SEC_EXCLUDE
) == 0)
3067 os
->bfd_section
->map_head
.link_order
= NULL
;
3068 os
->bfd_section
->map_tail
.link_order
= NULL
;
3072 s
= os
->bfd_section
;
3073 os
->bfd_section
= NULL
;
3074 if (!bfd_section_removed_from_list (output_bfd
, s
))
3076 bfd_section_list_remove (output_bfd
, s
);
3077 output_bfd
->section_count
--;
3082 /* Stop future calls to lang_add_section from messing with map_head
3083 and map_tail link_order fields. */
3084 stripped_excluded_sections
= TRUE
;
3088 print_output_section_statement
3089 (lang_output_section_statement_type
*output_section_statement
)
3091 asection
*section
= output_section_statement
->bfd_section
;
3094 if (output_section_statement
!= abs_output_section
)
3096 minfo ("\n%s", output_section_statement
->name
);
3098 if (section
!= NULL
)
3100 print_dot
= section
->vma
;
3102 len
= strlen (output_section_statement
->name
);
3103 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3108 while (len
< SECTION_NAME_MAP_LENGTH
)
3114 minfo ("0x%V %W", section
->vma
, section
->size
);
3116 if (output_section_statement
->load_base
!= NULL
)
3120 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
3121 "load base", lang_final_phase_enum
);
3122 minfo (_(" load address 0x%V"), addr
);
3129 print_statement_list (output_section_statement
->children
.head
,
3130 output_section_statement
);
3134 print_assignment (lang_assignment_statement_type
*assignment
,
3135 lang_output_section_statement_type
*output_section
)
3140 etree_value_type result
;
3142 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3145 if (assignment
->exp
->type
.node_class
== etree_assert
)
3148 tree
= assignment
->exp
->assert_s
.child
;
3152 const char *dst
= assignment
->exp
->assign
.dst
;
3153 is_dot
= dst
[0] == '.' && dst
[1] == 0;
3154 tree
= assignment
->exp
->assign
.src
;
3157 result
= exp_fold_tree (tree
, output_section
, lang_final_phase_enum
,
3158 print_dot
, &print_dot
);
3163 value
= result
.value
+ result
.section
->bfd_section
->vma
;
3165 minfo ("0x%V", value
);
3178 exp_print_tree (assignment
->exp
);
3183 print_input_statement (lang_input_statement_type
*statm
)
3185 if (statm
->filename
!= NULL
)
3187 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
3191 /* Print all symbols defined in a particular section. This is called
3192 via bfd_link_hash_traverse, or by print_all_symbols. */
3195 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
3197 asection
*sec
= ptr
;
3199 if ((hash_entry
->type
== bfd_link_hash_defined
3200 || hash_entry
->type
== bfd_link_hash_defweak
)
3201 && sec
== hash_entry
->u
.def
.section
)
3205 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3208 (hash_entry
->u
.def
.value
3209 + hash_entry
->u
.def
.section
->output_offset
3210 + hash_entry
->u
.def
.section
->output_section
->vma
));
3212 minfo (" %T\n", hash_entry
->root
.string
);
3219 print_all_symbols (sec
)
3222 struct fat_user_section_struct
*ud
= get_userdata (sec
);
3223 struct map_symbol_def
*def
;
3228 *ud
->map_symbol_def_tail
= 0;
3229 for (def
= ud
->map_symbol_def_head
; def
; def
= def
->next
)
3230 print_one_symbol (def
->entry
, sec
);
3233 /* Print information about an input section to the map file. */
3236 print_input_section (lang_input_section_type
*in
)
3238 asection
*i
= in
->section
;
3239 bfd_size_type size
= i
->size
;
3248 minfo ("%s", i
->name
);
3250 len
= 1 + strlen (i
->name
);
3251 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
3256 while (len
< SECTION_NAME_MAP_LENGTH
)
3262 if (i
->output_section
!= NULL
&& (i
->flags
& SEC_EXCLUDE
) == 0)
3263 addr
= i
->output_section
->vma
+ i
->output_offset
;
3270 minfo ("0x%V %W %B\n", addr
, TO_ADDR (size
), i
->owner
);
3272 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
3274 len
= SECTION_NAME_MAP_LENGTH
+ 3;
3286 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
3289 if (i
->output_section
!= NULL
&& (i
->flags
& SEC_EXCLUDE
) == 0)
3291 if (command_line
.reduce_memory_overheads
)
3292 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
3294 print_all_symbols (i
);
3296 print_dot
= addr
+ TO_ADDR (size
);
3302 print_fill_statement (lang_fill_statement_type
*fill
)
3306 fputs (" FILL mask 0x", config
.map_file
);
3307 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
3308 fprintf (config
.map_file
, "%02x", *p
);
3309 fputs ("\n", config
.map_file
);
3313 print_data_statement (lang_data_statement_type
*data
)
3321 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3324 addr
= data
->output_vma
;
3325 if (data
->output_section
!= NULL
)
3326 addr
+= data
->output_section
->vma
;
3354 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
3356 if (data
->exp
->type
.node_class
!= etree_value
)
3359 exp_print_tree (data
->exp
);
3364 print_dot
= addr
+ TO_ADDR (size
);
3367 /* Print an address statement. These are generated by options like
3371 print_address_statement (lang_address_statement_type
*address
)
3373 minfo (_("Address of section %s set to "), address
->section_name
);
3374 exp_print_tree (address
->address
);
3378 /* Print a reloc statement. */
3381 print_reloc_statement (lang_reloc_statement_type
*reloc
)
3388 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3391 addr
= reloc
->output_vma
;
3392 if (reloc
->output_section
!= NULL
)
3393 addr
+= reloc
->output_section
->vma
;
3395 size
= bfd_get_reloc_size (reloc
->howto
);
3397 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
3399 if (reloc
->name
!= NULL
)
3400 minfo ("%s+", reloc
->name
);
3402 minfo ("%s+", reloc
->section
->name
);
3404 exp_print_tree (reloc
->addend_exp
);
3408 print_dot
= addr
+ TO_ADDR (size
);
3412 print_padding_statement (lang_padding_statement_type
*s
)
3420 len
= sizeof " *fill*" - 1;
3421 while (len
< SECTION_NAME_MAP_LENGTH
)
3427 addr
= s
->output_offset
;
3428 if (s
->output_section
!= NULL
)
3429 addr
+= s
->output_section
->vma
;
3430 minfo ("0x%V %W ", addr
, (bfd_vma
) s
->size
);
3432 if (s
->fill
->size
!= 0)
3436 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
3437 fprintf (config
.map_file
, "%02x", *p
);
3442 print_dot
= addr
+ TO_ADDR (s
->size
);
3446 print_wild_statement (lang_wild_statement_type
*w
,
3447 lang_output_section_statement_type
*os
)
3449 struct wildcard_list
*sec
;
3453 if (w
->filenames_sorted
)
3455 if (w
->filename
!= NULL
)
3456 minfo ("%s", w
->filename
);
3459 if (w
->filenames_sorted
)
3463 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
3465 if (sec
->spec
.sorted
)
3467 if (sec
->spec
.exclude_name_list
!= NULL
)
3470 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
3471 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
3472 minfo (" %s", tmp
->name
);
3475 if (sec
->spec
.name
!= NULL
)
3476 minfo ("%s", sec
->spec
.name
);
3479 if (sec
->spec
.sorted
)
3488 print_statement_list (w
->children
.head
, os
);
3491 /* Print a group statement. */
3494 print_group (lang_group_statement_type
*s
,
3495 lang_output_section_statement_type
*os
)
3497 fprintf (config
.map_file
, "START GROUP\n");
3498 print_statement_list (s
->children
.head
, os
);
3499 fprintf (config
.map_file
, "END GROUP\n");
3502 /* Print the list of statements in S.
3503 This can be called for any statement type. */
3506 print_statement_list (lang_statement_union_type
*s
,
3507 lang_output_section_statement_type
*os
)
3511 print_statement (s
, os
);
3516 /* Print the first statement in statement list S.
3517 This can be called for any statement type. */
3520 print_statement (lang_statement_union_type
*s
,
3521 lang_output_section_statement_type
*os
)
3523 switch (s
->header
.type
)
3526 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
3529 case lang_constructors_statement_enum
:
3530 if (constructor_list
.head
!= NULL
)
3532 if (constructors_sorted
)
3533 minfo (" SORT (CONSTRUCTORS)\n");
3535 minfo (" CONSTRUCTORS\n");
3536 print_statement_list (constructor_list
.head
, os
);
3539 case lang_wild_statement_enum
:
3540 print_wild_statement (&s
->wild_statement
, os
);
3542 case lang_address_statement_enum
:
3543 print_address_statement (&s
->address_statement
);
3545 case lang_object_symbols_statement_enum
:
3546 minfo (" CREATE_OBJECT_SYMBOLS\n");
3548 case lang_fill_statement_enum
:
3549 print_fill_statement (&s
->fill_statement
);
3551 case lang_data_statement_enum
:
3552 print_data_statement (&s
->data_statement
);
3554 case lang_reloc_statement_enum
:
3555 print_reloc_statement (&s
->reloc_statement
);
3557 case lang_input_section_enum
:
3558 print_input_section (&s
->input_section
);
3560 case lang_padding_statement_enum
:
3561 print_padding_statement (&s
->padding_statement
);
3563 case lang_output_section_statement_enum
:
3564 print_output_section_statement (&s
->output_section_statement
);
3566 case lang_assignment_statement_enum
:
3567 print_assignment (&s
->assignment_statement
, os
);
3569 case lang_target_statement_enum
:
3570 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
3572 case lang_output_statement_enum
:
3573 minfo ("OUTPUT(%s", s
->output_statement
.name
);
3574 if (output_target
!= NULL
)
3575 minfo (" %s", output_target
);
3578 case lang_input_statement_enum
:
3579 print_input_statement (&s
->input_statement
);
3581 case lang_group_statement_enum
:
3582 print_group (&s
->group_statement
, os
);
3584 case lang_afile_asection_pair_statement_enum
:
3591 print_statements (void)
3593 print_statement_list (statement_list
.head
, abs_output_section
);
3596 /* Print the first N statements in statement list S to STDERR.
3597 If N == 0, nothing is printed.
3598 If N < 0, the entire list is printed.
3599 Intended to be called from GDB. */
3602 dprint_statement (lang_statement_union_type
*s
, int n
)
3604 FILE *map_save
= config
.map_file
;
3606 config
.map_file
= stderr
;
3609 print_statement_list (s
, abs_output_section
);
3612 while (s
&& --n
>= 0)
3614 print_statement (s
, abs_output_section
);
3619 config
.map_file
= map_save
;
3623 insert_pad (lang_statement_union_type
**ptr
,
3625 unsigned int alignment_needed
,
3626 asection
*output_section
,
3629 static fill_type zero_fill
= { 1, { 0 } };
3630 lang_statement_union_type
*pad
;
3632 pad
= ((lang_statement_union_type
*)
3633 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
3634 if (ptr
!= &statement_list
.head
3635 && pad
->header
.type
== lang_padding_statement_enum
3636 && pad
->padding_statement
.output_section
== output_section
)
3638 /* Use the existing pad statement. The above test on output
3639 section is probably redundant, but it doesn't hurt to check. */
3643 /* Make a new padding statement, linked into existing chain. */
3644 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
3645 pad
->header
.next
= *ptr
;
3647 pad
->header
.type
= lang_padding_statement_enum
;
3648 pad
->padding_statement
.output_section
= output_section
;
3651 pad
->padding_statement
.fill
= fill
;
3653 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
3654 pad
->padding_statement
.size
= alignment_needed
;
3655 output_section
->size
+= alignment_needed
;
3658 /* Work out how much this section will move the dot point. */
3662 (lang_statement_union_type
**this_ptr
,
3663 lang_output_section_statement_type
*output_section_statement
,
3667 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
3668 asection
*i
= is
->section
;
3670 if (!is
->ifile
->just_syms_flag
&& (i
->flags
& SEC_EXCLUDE
) == 0)
3672 unsigned int alignment_needed
;
3675 /* Align this section first to the input sections requirement,
3676 then to the output section's requirement. If this alignment
3677 is greater than any seen before, then record it too. Perform
3678 the alignment by inserting a magic 'padding' statement. */
3680 if (output_section_statement
->subsection_alignment
!= -1)
3681 i
->alignment_power
= output_section_statement
->subsection_alignment
;
3683 o
= output_section_statement
->bfd_section
;
3684 if (o
->alignment_power
< i
->alignment_power
)
3685 o
->alignment_power
= i
->alignment_power
;
3687 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
3689 if (alignment_needed
!= 0)
3691 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
3692 dot
+= alignment_needed
;
3695 /* Remember where in the output section this input section goes. */
3697 i
->output_offset
= dot
- o
->vma
;
3699 /* Mark how big the output section must be to contain this now. */
3700 dot
+= TO_ADDR (i
->size
);
3701 o
->size
= TO_SIZE (dot
- o
->vma
);
3705 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
3712 sort_sections_by_lma (const void *arg1
, const void *arg2
)
3714 const asection
*sec1
= *(const asection
**) arg1
;
3715 const asection
*sec2
= *(const asection
**) arg2
;
3717 if (bfd_section_lma (sec1
->owner
, sec1
)
3718 < bfd_section_lma (sec2
->owner
, sec2
))
3720 else if (bfd_section_lma (sec1
->owner
, sec1
)
3721 > bfd_section_lma (sec2
->owner
, sec2
))
3727 #define IGNORE_SECTION(s) \
3728 ((s->flags & SEC_NEVER_LOAD) != 0 \
3729 || (s->flags & SEC_ALLOC) == 0 \
3730 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
3731 && (s->flags & SEC_LOAD) == 0))
3733 /* Check to see if any allocated sections overlap with other allocated
3734 sections. This can happen if a linker script specifies the output
3735 section addresses of the two sections. */
3738 lang_check_section_addresses (void)
3741 asection
**sections
, **spp
;
3749 if (bfd_count_sections (output_bfd
) <= 1)
3752 amt
= bfd_count_sections (output_bfd
) * sizeof (asection
*);
3753 sections
= xmalloc (amt
);
3755 /* Scan all sections in the output list. */
3757 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3759 /* Only consider loadable sections with real contents. */
3760 if (IGNORE_SECTION (s
) || s
->size
== 0)
3763 sections
[count
] = s
;
3770 qsort (sections
, (size_t) count
, sizeof (asection
*),
3771 sort_sections_by_lma
);
3775 s_start
= bfd_section_lma (output_bfd
, s
);
3776 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
3777 for (count
--; count
; count
--)
3779 /* We must check the sections' LMA addresses not their VMA
3780 addresses because overlay sections can have overlapping VMAs
3781 but they must have distinct LMAs. */
3786 s_start
= bfd_section_lma (output_bfd
, s
);
3787 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
3789 /* Look for an overlap. */
3790 if (s_end
>= os_start
&& s_start
<= os_end
)
3791 einfo (_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
3792 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
3798 /* Make sure the new address is within the region. We explicitly permit the
3799 current address to be at the exact end of the region when the address is
3800 non-zero, in case the region is at the end of addressable memory and the
3801 calculation wraps around. */
3804 os_region_check (lang_output_section_statement_type
*os
,
3805 lang_memory_region_type
*region
,
3809 if ((region
->current
< region
->origin
3810 || (region
->current
- region
->origin
> region
->length
))
3811 && ((region
->current
!= region
->origin
+ region
->length
)
3816 einfo (_("%X%P: address 0x%v of %B section %s"
3817 " is not within region %s\n"),
3819 os
->bfd_section
->owner
,
3820 os
->bfd_section
->name
,
3825 einfo (_("%X%P: region %s is full (%B section %s)\n"),
3827 os
->bfd_section
->owner
,
3828 os
->bfd_section
->name
);
3830 /* Reset the region pointer. */
3831 region
->current
= region
->origin
;
3835 /* Set the sizes for all the output sections. */
3838 lang_size_sections_1
3839 (lang_statement_union_type
*s
,
3840 lang_output_section_statement_type
*output_section_statement
,
3841 lang_statement_union_type
**prev
,
3845 bfd_boolean check_regions
)
3847 /* Size up the sections from their constituent parts. */
3848 for (; s
!= NULL
; s
= s
->header
.next
)
3850 switch (s
->header
.type
)
3852 case lang_output_section_statement_enum
:
3855 lang_output_section_statement_type
*os
;
3857 os
= &s
->output_section_statement
;
3858 if (os
->bfd_section
== NULL
)
3859 /* This section was never actually created. */
3862 /* If this is a COFF shared library section, use the size and
3863 address from the input section. FIXME: This is COFF
3864 specific; it would be cleaner if there were some other way
3865 to do this, but nothing simple comes to mind. */
3866 if ((bfd_get_flavour (output_bfd
) == bfd_target_ecoff_flavour
3867 || bfd_get_flavour (output_bfd
) == bfd_target_coff_flavour
)
3868 && (os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
3872 if (os
->children
.head
== NULL
3873 || os
->children
.head
->header
.next
!= NULL
3874 || (os
->children
.head
->header
.type
3875 != lang_input_section_enum
))
3876 einfo (_("%P%X: Internal error on COFF shared library"
3877 " section %s\n"), os
->name
);
3879 input
= os
->children
.head
->input_section
.section
;
3880 bfd_set_section_vma (os
->bfd_section
->owner
,
3882 bfd_section_vma (input
->owner
, input
));
3883 os
->bfd_section
->size
= input
->size
;
3887 if (bfd_is_abs_section (os
->bfd_section
))
3889 /* No matter what happens, an abs section starts at zero. */
3890 ASSERT (os
->bfd_section
->vma
== 0);
3894 if (os
->addr_tree
== NULL
)
3896 /* No address specified for this section, get one
3897 from the region specification. */
3898 if (os
->region
== NULL
3899 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
3900 && os
->region
->name
[0] == '*'
3901 && strcmp (os
->region
->name
,
3902 DEFAULT_MEMORY_REGION
) == 0))
3904 os
->region
= lang_memory_default (os
->bfd_section
);
3907 /* If a loadable section is using the default memory
3908 region, and some non default memory regions were
3909 defined, issue an error message. */
3910 if (!IGNORE_SECTION (os
->bfd_section
)
3911 && ! link_info
.relocatable
3913 && strcmp (os
->region
->name
,
3914 DEFAULT_MEMORY_REGION
) == 0
3915 && lang_memory_region_list
!= NULL
3916 && (strcmp (lang_memory_region_list
->name
,
3917 DEFAULT_MEMORY_REGION
) != 0
3918 || lang_memory_region_list
->next
!= NULL
))
3920 /* By default this is an error rather than just a
3921 warning because if we allocate the section to the
3922 default memory region we can end up creating an
3923 excessively large binary, or even seg faulting when
3924 attempting to perform a negative seek. See
3925 sources.redhat.com/ml/binutils/2003-04/msg00423.html
3926 for an example of this. This behaviour can be
3927 overridden by the using the --no-check-sections
3929 if (command_line
.check_section_addresses
)
3930 einfo (_("%P%F: error: no memory region specified"
3931 " for loadable section `%s'\n"),
3932 bfd_get_section_name (output_bfd
,
3935 einfo (_("%P: warning: no memory region specified"
3936 " for loadable section `%s'\n"),
3937 bfd_get_section_name (output_bfd
,
3941 dot
= os
->region
->current
;
3943 if (os
->section_alignment
== -1)
3948 dot
= align_power (dot
,
3949 os
->bfd_section
->alignment_power
);
3951 if (dot
!= olddot
&& config
.warn_section_align
)
3952 einfo (_("%P: warning: changing start of section"
3953 " %s by %u bytes\n"),
3954 os
->name
, (unsigned int) (dot
- olddot
));
3962 r
= exp_fold_tree (os
->addr_tree
,
3964 lang_allocating_phase_enum
,
3969 einfo (_("%F%S: non constant or forward reference"
3970 " address expression for section %s\n"),
3973 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
3976 /* The section starts here.
3977 First, align to what the section needs. */
3979 if (os
->section_alignment
!= -1)
3980 dot
= align_power (dot
, os
->section_alignment
);
3982 bfd_set_section_vma (0, os
->bfd_section
, dot
);
3984 os
->bfd_section
->output_offset
= 0;
3987 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
3988 os
->fill
, dot
, relax
, check_regions
);
3990 /* Put the section within the requested block size, or
3991 align at the block boundary. */
3992 after
= ((os
->bfd_section
->vma
3993 + TO_ADDR (os
->bfd_section
->size
)
3994 + os
->block_value
- 1)
3995 & - (bfd_vma
) os
->block_value
);
3997 if (bfd_is_abs_section (os
->bfd_section
))
3998 ASSERT (after
== os
->bfd_section
->vma
);
4000 os
->bfd_section
->size
4001 = TO_SIZE (after
- os
->bfd_section
->vma
);
4003 dot
= os
->bfd_section
->vma
;
4004 /* .tbss sections effectively have zero size. */
4005 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
4006 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
4007 || link_info
.relocatable
)
4008 dot
+= TO_ADDR (os
->bfd_section
->size
);
4012 if (os
->update_dot_tree
!= 0)
4013 exp_fold_tree (os
->update_dot_tree
, abs_output_section
,
4014 lang_allocating_phase_enum
, dot
, &dot
);
4016 /* Update dot in the region ?
4017 We only do this if the section is going to be allocated,
4018 since unallocated sections do not contribute to the region's
4019 overall size in memory.
4021 If the SEC_NEVER_LOAD bit is not set, it will affect the
4022 addresses of sections after it. We have to update
4024 if (os
->region
!= NULL
4025 && ((os
->bfd_section
->flags
& SEC_NEVER_LOAD
) == 0
4026 || (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))))
4028 os
->region
->current
= dot
;
4031 /* Make sure the new address is within the region. */
4032 os_region_check (os
, os
->region
, os
->addr_tree
,
4033 os
->bfd_section
->vma
);
4035 /* If there's no load address specified, use the run
4036 region as the load region. */
4037 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
4038 os
->lma_region
= os
->region
;
4040 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
)
4042 /* Set load_base, which will be handled later. */
4043 os
->load_base
= exp_intop (os
->lma_region
->current
);
4044 os
->lma_region
->current
+=
4045 TO_ADDR (os
->bfd_section
->size
);
4047 os_region_check (os
, os
->lma_region
, NULL
,
4048 os
->bfd_section
->lma
);
4054 case lang_constructors_statement_enum
:
4055 dot
= lang_size_sections_1 (constructor_list
.head
,
4056 output_section_statement
,
4057 &s
->wild_statement
.children
.head
,
4058 fill
, dot
, relax
, check_regions
);
4061 case lang_data_statement_enum
:
4063 unsigned int size
= 0;
4065 s
->data_statement
.output_vma
=
4066 dot
- output_section_statement
->bfd_section
->vma
;
4067 s
->data_statement
.output_section
=
4068 output_section_statement
->bfd_section
;
4070 /* We might refer to provided symbols in the expression, and
4071 need to mark them as needed. */
4072 exp_fold_tree (s
->data_statement
.exp
, abs_output_section
,
4073 lang_allocating_phase_enum
, dot
, &dot
);
4075 switch (s
->data_statement
.type
)
4093 if (size
< TO_SIZE ((unsigned) 1))
4094 size
= TO_SIZE ((unsigned) 1);
4095 dot
+= TO_ADDR (size
);
4096 output_section_statement
->bfd_section
->size
+= size
;
4100 case lang_reloc_statement_enum
:
4104 s
->reloc_statement
.output_vma
=
4105 dot
- output_section_statement
->bfd_section
->vma
;
4106 s
->reloc_statement
.output_section
=
4107 output_section_statement
->bfd_section
;
4108 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
4109 dot
+= TO_ADDR (size
);
4110 output_section_statement
->bfd_section
->size
+= size
;
4114 case lang_wild_statement_enum
:
4116 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
4117 output_section_statement
,
4118 &s
->wild_statement
.children
.head
,
4119 fill
, dot
, relax
, check_regions
);
4123 case lang_object_symbols_statement_enum
:
4124 link_info
.create_object_symbols_section
=
4125 output_section_statement
->bfd_section
;
4127 case lang_output_statement_enum
:
4128 case lang_target_statement_enum
:
4130 case lang_input_section_enum
:
4134 i
= (*prev
)->input_section
.section
;
4139 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
4140 einfo (_("%P%F: can't relax section: %E\n"));
4144 dot
= size_input_section (prev
, output_section_statement
,
4145 output_section_statement
->fill
, dot
);
4148 case lang_input_statement_enum
:
4150 case lang_fill_statement_enum
:
4151 s
->fill_statement
.output_section
=
4152 output_section_statement
->bfd_section
;
4154 fill
= s
->fill_statement
.fill
;
4156 case lang_assignment_statement_enum
:
4158 bfd_vma newdot
= dot
;
4160 exp_fold_tree (s
->assignment_statement
.exp
,
4161 output_section_statement
,
4162 lang_allocating_phase_enum
,
4168 if (output_section_statement
== abs_output_section
)
4170 /* If we don't have an output section, then just adjust
4171 the default memory address. */
4172 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
4173 FALSE
)->current
= newdot
;
4177 /* Insert a pad after this statement. We can't
4178 put the pad before when relaxing, in case the
4179 assignment references dot. */
4180 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
4181 output_section_statement
->bfd_section
, dot
);
4183 /* Don't neuter the pad below when relaxing. */
4187 /* If dot is advanced, this implies that the section should
4188 have space allocated to it, unless the user has explicitly
4189 stated that the section should never be loaded. */
4190 if (!(output_section_statement
->flags
4191 & (SEC_NEVER_LOAD
| SEC_ALLOC
)))
4192 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
4199 case lang_padding_statement_enum
:
4200 /* If this is the first time lang_size_sections is called,
4201 we won't have any padding statements. If this is the
4202 second or later passes when relaxing, we should allow
4203 padding to shrink. If padding is needed on this pass, it
4204 will be added back in. */
4205 s
->padding_statement
.size
= 0;
4207 /* Make sure output_offset is valid. If relaxation shrinks
4208 the section and this pad isn't needed, it's possible to
4209 have output_offset larger than the final size of the
4210 section. bfd_set_section_contents will complain even for
4211 a pad size of zero. */
4212 s
->padding_statement
.output_offset
4213 = dot
- output_section_statement
->bfd_section
->vma
;
4216 case lang_group_statement_enum
:
4217 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
4218 output_section_statement
,
4219 &s
->group_statement
.children
.head
,
4220 fill
, dot
, relax
, check_regions
);
4227 /* We can only get here when relaxing is turned on. */
4228 case lang_address_statement_enum
:
4231 prev
= &s
->header
.next
;
4238 (lang_statement_union_type
*s
,
4239 lang_output_section_statement_type
*output_section_statement
,
4240 lang_statement_union_type
**prev
,
4244 bfd_boolean check_regions
)
4248 /* Callers of exp_fold_tree need to increment this. */
4249 lang_statement_iteration
++;
4251 exp_data_seg
.phase
= exp_dataseg_none
;
4252 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
4253 dot
, relax
, check_regions
);
4254 if (exp_data_seg
.phase
== exp_dataseg_end_seen
4255 && link_info
.relro
&& exp_data_seg
.relro_end
)
4257 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
4258 to put exp_data_seg.relro on a (common) page boundary. */
4259 bfd_vma old_min_base
, relro_end
, maxpage
;
4261 exp_data_seg
.phase
= exp_dataseg_relro_adjust
;
4262 old_min_base
= exp_data_seg
.min_base
;
4263 maxpage
= exp_data_seg
.maxpagesize
;
4264 exp_data_seg
.base
+= (-exp_data_seg
.relro_end
4265 & (exp_data_seg
.pagesize
- 1));
4266 /* Compute the expected PT_GNU_RELRO segment end. */
4267 relro_end
= (exp_data_seg
.relro_end
+ exp_data_seg
.pagesize
- 1)
4268 & ~(exp_data_seg
.pagesize
- 1);
4269 if (old_min_base
+ maxpage
< exp_data_seg
.base
)
4271 exp_data_seg
.base
-= maxpage
;
4272 relro_end
-= maxpage
;
4274 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
4275 dot
, relax
, check_regions
);
4276 if (exp_data_seg
.relro_end
> relro_end
)
4278 /* The alignment of sections between DATA_SEGMENT_ALIGN
4279 and DATA_SEGMENT_RELRO_END caused huge padding to be
4280 inserted at DATA_SEGMENT_RELRO_END. Try some other base. */
4282 unsigned int max_alignment_power
= 0;
4284 /* Find maximum alignment power of sections between
4285 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
4286 for (sec
= output_bfd
->sections
; sec
; sec
= sec
->next
)
4287 if (sec
->vma
>= exp_data_seg
.base
4288 && sec
->vma
< exp_data_seg
.relro_end
4289 && sec
->alignment_power
> max_alignment_power
)
4290 max_alignment_power
= sec
->alignment_power
;
4292 if (((bfd_vma
) 1 << max_alignment_power
) < exp_data_seg
.pagesize
)
4294 if (exp_data_seg
.base
- (1 << max_alignment_power
)
4296 exp_data_seg
.base
+= exp_data_seg
.pagesize
;
4297 exp_data_seg
.base
-= (1 << max_alignment_power
);
4298 result
= lang_size_sections_1 (s
, output_section_statement
,
4299 prev
, fill
, dot
, relax
,
4303 link_info
.relro_start
= exp_data_seg
.base
;
4304 link_info
.relro_end
= exp_data_seg
.relro_end
;
4306 else if (exp_data_seg
.phase
== exp_dataseg_end_seen
)
4308 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
4309 a page could be saved in the data segment. */
4310 bfd_vma first
, last
;
4312 first
= -exp_data_seg
.base
& (exp_data_seg
.pagesize
- 1);
4313 last
= exp_data_seg
.end
& (exp_data_seg
.pagesize
- 1);
4315 && ((exp_data_seg
.base
& ~(exp_data_seg
.pagesize
- 1))
4316 != (exp_data_seg
.end
& ~(exp_data_seg
.pagesize
- 1)))
4317 && first
+ last
<= exp_data_seg
.pagesize
)
4319 exp_data_seg
.phase
= exp_dataseg_adjust
;
4320 lang_statement_iteration
++;
4321 result
= lang_size_sections_1 (s
, output_section_statement
, prev
,
4322 fill
, dot
, relax
, check_regions
);
4329 /* Worker function for lang_do_assignments. Recursiveness goes here. */
4332 lang_do_assignments_1
4333 (lang_statement_union_type
*s
,
4334 lang_output_section_statement_type
*output_section_statement
,
4338 for (; s
!= NULL
; s
= s
->header
.next
)
4340 switch (s
->header
.type
)
4342 case lang_constructors_statement_enum
:
4343 dot
= lang_do_assignments_1 (constructor_list
.head
,
4344 output_section_statement
,
4349 case lang_output_section_statement_enum
:
4351 lang_output_section_statement_type
*os
;
4353 os
= &(s
->output_section_statement
);
4354 if (os
->bfd_section
!= NULL
)
4356 dot
= os
->bfd_section
->vma
;
4357 lang_do_assignments_1 (os
->children
.head
, os
, os
->fill
, dot
);
4358 /* .tbss sections effectively have zero size. */
4359 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
4360 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
4361 || link_info
.relocatable
)
4362 dot
+= TO_ADDR (os
->bfd_section
->size
);
4366 /* If nothing has been placed into the output section then
4367 it won't have a bfd_section. */
4368 if (os
->bfd_section
)
4370 os
->bfd_section
->lma
4371 = exp_get_abs_int (os
->load_base
, 0, "load base",
4372 lang_final_phase_enum
);
4377 case lang_wild_statement_enum
:
4379 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
4380 output_section_statement
,
4385 case lang_object_symbols_statement_enum
:
4386 case lang_output_statement_enum
:
4387 case lang_target_statement_enum
:
4389 case lang_data_statement_enum
:
4391 etree_value_type value
;
4393 value
= exp_fold_tree (s
->data_statement
.exp
,
4395 lang_final_phase_enum
, dot
, &dot
);
4397 einfo (_("%F%P: invalid data statement\n"));
4398 s
->data_statement
.value
4399 = value
.value
+ value
.section
->bfd_section
->vma
;
4403 switch (s
->data_statement
.type
)
4421 if (size
< TO_SIZE ((unsigned) 1))
4422 size
= TO_SIZE ((unsigned) 1);
4423 dot
+= TO_ADDR (size
);
4427 case lang_reloc_statement_enum
:
4429 etree_value_type value
;
4431 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
4433 lang_final_phase_enum
, dot
, &dot
);
4434 s
->reloc_statement
.addend_value
= value
.value
;
4436 einfo (_("%F%P: invalid reloc statement\n"));
4438 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
4441 case lang_input_section_enum
:
4443 asection
*in
= s
->input_section
.section
;
4445 if ((in
->flags
& SEC_EXCLUDE
) == 0)
4446 dot
+= TO_ADDR (in
->size
);
4450 case lang_input_statement_enum
:
4452 case lang_fill_statement_enum
:
4453 fill
= s
->fill_statement
.fill
;
4455 case lang_assignment_statement_enum
:
4457 exp_fold_tree (s
->assignment_statement
.exp
,
4458 output_section_statement
,
4459 lang_final_phase_enum
,
4465 case lang_padding_statement_enum
:
4466 dot
+= TO_ADDR (s
->padding_statement
.size
);
4469 case lang_group_statement_enum
:
4470 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
4471 output_section_statement
,
4479 case lang_address_statement_enum
:
4489 (lang_statement_union_type
*s
,
4490 lang_output_section_statement_type
*output_section_statement
,
4494 /* Callers of exp_fold_tree need to increment this. */
4495 lang_statement_iteration
++;
4496 lang_do_assignments_1 (s
, output_section_statement
, fill
, dot
);
4499 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
4500 operator .startof. (section_name), it produces an undefined symbol
4501 .startof.section_name. Similarly, when it sees
4502 .sizeof. (section_name), it produces an undefined symbol
4503 .sizeof.section_name. For all the output sections, we look for
4504 such symbols, and set them to the correct value. */
4507 lang_set_startof (void)
4511 if (link_info
.relocatable
)
4514 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4516 const char *secname
;
4518 struct bfd_link_hash_entry
*h
;
4520 secname
= bfd_get_section_name (output_bfd
, s
);
4521 buf
= xmalloc (10 + strlen (secname
));
4523 sprintf (buf
, ".startof.%s", secname
);
4524 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
4525 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
4527 h
->type
= bfd_link_hash_defined
;
4528 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
4529 h
->u
.def
.section
= bfd_abs_section_ptr
;
4532 sprintf (buf
, ".sizeof.%s", secname
);
4533 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
4534 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
4536 h
->type
= bfd_link_hash_defined
;
4537 h
->u
.def
.value
= TO_ADDR (s
->size
);
4538 h
->u
.def
.section
= bfd_abs_section_ptr
;
4548 struct bfd_link_hash_entry
*h
;
4551 if (link_info
.relocatable
|| link_info
.shared
)
4556 if (entry_symbol
.name
== NULL
)
4558 /* No entry has been specified. Look for start, but don't warn
4559 if we don't find it. */
4560 entry_symbol
.name
= "start";
4564 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
4565 FALSE
, FALSE
, TRUE
);
4567 && (h
->type
== bfd_link_hash_defined
4568 || h
->type
== bfd_link_hash_defweak
)
4569 && h
->u
.def
.section
->output_section
!= NULL
)
4573 val
= (h
->u
.def
.value
4574 + bfd_get_section_vma (output_bfd
,
4575 h
->u
.def
.section
->output_section
)
4576 + h
->u
.def
.section
->output_offset
);
4577 if (! bfd_set_start_address (output_bfd
, val
))
4578 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
4585 /* We couldn't find the entry symbol. Try parsing it as a
4587 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
4590 if (! bfd_set_start_address (output_bfd
, val
))
4591 einfo (_("%P%F: can't set start address\n"));
4597 /* Can't find the entry symbol, and it's not a number. Use
4598 the first address in the text section. */
4599 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
4603 einfo (_("%P: warning: cannot find entry symbol %s;"
4604 " defaulting to %V\n"),
4606 bfd_get_section_vma (output_bfd
, ts
));
4607 if (! bfd_set_start_address (output_bfd
,
4608 bfd_get_section_vma (output_bfd
,
4610 einfo (_("%P%F: can't set start address\n"));
4615 einfo (_("%P: warning: cannot find entry symbol %s;"
4616 " not setting start address\n"),
4622 /* Don't bfd_hash_table_free (&lang_definedness_table);
4623 map file output may result in a call of lang_track_definedness. */
4626 /* This is a small function used when we want to ignore errors from
4630 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
4632 /* Don't do anything. */
4635 /* Check that the architecture of all the input files is compatible
4636 with the output file. Also call the backend to let it do any
4637 other checking that is needed. */
4642 lang_statement_union_type
*file
;
4644 const bfd_arch_info_type
*compatible
;
4646 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
4648 input_bfd
= file
->input_statement
.the_bfd
;
4650 = bfd_arch_get_compatible (input_bfd
, output_bfd
,
4651 command_line
.accept_unknown_input_arch
);
4653 /* In general it is not possible to perform a relocatable
4654 link between differing object formats when the input
4655 file has relocations, because the relocations in the
4656 input format may not have equivalent representations in
4657 the output format (and besides BFD does not translate
4658 relocs for other link purposes than a final link). */
4659 if ((link_info
.relocatable
|| link_info
.emitrelocations
)
4660 && (compatible
== NULL
4661 || bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
4662 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
4664 einfo (_("%P%F: Relocatable linking with relocations from"
4665 " format %s (%B) to format %s (%B) is not supported\n"),
4666 bfd_get_target (input_bfd
), input_bfd
,
4667 bfd_get_target (output_bfd
), output_bfd
);
4668 /* einfo with %F exits. */
4671 if (compatible
== NULL
)
4673 if (command_line
.warn_mismatch
)
4674 einfo (_("%P: warning: %s architecture of input file `%B'"
4675 " is incompatible with %s output\n"),
4676 bfd_printable_name (input_bfd
), input_bfd
,
4677 bfd_printable_name (output_bfd
));
4679 else if (bfd_count_sections (input_bfd
))
4681 /* If the input bfd has no contents, it shouldn't set the
4682 private data of the output bfd. */
4684 bfd_error_handler_type pfn
= NULL
;
4686 /* If we aren't supposed to warn about mismatched input
4687 files, temporarily set the BFD error handler to a
4688 function which will do nothing. We still want to call
4689 bfd_merge_private_bfd_data, since it may set up
4690 information which is needed in the output file. */
4691 if (! command_line
.warn_mismatch
)
4692 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
4693 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
4695 if (command_line
.warn_mismatch
)
4696 einfo (_("%P%X: failed to merge target specific data"
4697 " of file %B\n"), input_bfd
);
4699 if (! command_line
.warn_mismatch
)
4700 bfd_set_error_handler (pfn
);
4705 /* Look through all the global common symbols and attach them to the
4706 correct section. The -sort-common command line switch may be used
4707 to roughly sort the entries by size. */
4712 if (command_line
.inhibit_common_definition
)
4714 if (link_info
.relocatable
4715 && ! command_line
.force_common_definition
)
4718 if (! config
.sort_common
)
4719 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
4724 for (power
= 4; power
>= 0; power
--)
4725 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
4729 /* Place one common symbol in the correct section. */
4732 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
4734 unsigned int power_of_two
;
4738 if (h
->type
!= bfd_link_hash_common
)
4742 power_of_two
= h
->u
.c
.p
->alignment_power
;
4744 if (config
.sort_common
4745 && power_of_two
< (unsigned int) *(int *) info
)
4748 section
= h
->u
.c
.p
->section
;
4750 /* Increase the size of the section to align the common sym. */
4751 section
->size
+= ((bfd_vma
) 1 << (power_of_two
+ opb_shift
)) - 1;
4752 section
->size
&= (- (bfd_vma
) 1 << (power_of_two
+ opb_shift
));
4754 /* Adjust the alignment if necessary. */
4755 if (power_of_two
> section
->alignment_power
)
4756 section
->alignment_power
= power_of_two
;
4758 /* Change the symbol from common to defined. */
4759 h
->type
= bfd_link_hash_defined
;
4760 h
->u
.def
.section
= section
;
4761 h
->u
.def
.value
= section
->size
;
4763 /* Increase the size of the section. */
4764 section
->size
+= size
;
4766 /* Make sure the section is allocated in memory, and make sure that
4767 it is no longer a common section. */
4768 section
->flags
|= SEC_ALLOC
;
4769 section
->flags
&= ~SEC_IS_COMMON
;
4771 if (config
.map_file
!= NULL
)
4773 static bfd_boolean header_printed
;
4778 if (! header_printed
)
4780 minfo (_("\nAllocating common symbols\n"));
4781 minfo (_("Common symbol size file\n\n"));
4782 header_printed
= TRUE
;
4785 name
= demangle (h
->root
.string
);
4787 len
= strlen (name
);
4802 if (size
<= 0xffffffff)
4803 sprintf (buf
, "%lx", (unsigned long) size
);
4805 sprintf_vma (buf
, size
);
4815 minfo ("%B\n", section
->owner
);
4821 /* Run through the input files and ensure that every input section has
4822 somewhere to go. If one is found without a destination then create
4823 an input request and place it into the statement tree. */
4826 lang_place_orphans (void)
4828 LANG_FOR_EACH_INPUT_STATEMENT (file
)
4832 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4834 if (s
->output_section
== NULL
)
4836 /* This section of the file is not attached, root
4837 around for a sensible place for it to go. */
4839 if (file
->just_syms_flag
)
4840 bfd_link_just_syms (file
->the_bfd
, s
, &link_info
);
4841 else if ((s
->flags
& SEC_EXCLUDE
) != 0)
4842 s
->output_section
= bfd_abs_section_ptr
;
4843 else if (strcmp (s
->name
, "COMMON") == 0)
4845 /* This is a lonely common section which must have
4846 come from an archive. We attach to the section
4847 with the wildcard. */
4848 if (! link_info
.relocatable
4849 || command_line
.force_common_definition
)
4851 if (default_common_section
== NULL
)
4853 default_common_section
=
4854 lang_output_section_statement_lookup (".bss");
4857 lang_add_section (&default_common_section
->children
, s
,
4858 default_common_section
, file
);
4861 else if (ldemul_place_orphan (file
, s
))
4865 lang_output_section_statement_type
*os
;
4867 os
= lang_output_section_statement_lookup (s
->name
);
4868 lang_add_section (&os
->children
, s
, os
, file
);
4876 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
4878 flagword
*ptr_flags
;
4880 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
4886 *ptr_flags
|= SEC_ALLOC
;
4890 *ptr_flags
|= SEC_READONLY
;
4894 *ptr_flags
|= SEC_DATA
;
4898 *ptr_flags
|= SEC_CODE
;
4903 *ptr_flags
|= SEC_LOAD
;
4907 einfo (_("%P%F: invalid syntax in flags\n"));
4914 /* Call a function on each input file. This function will be called
4915 on an archive, but not on the elements. */
4918 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
4920 lang_input_statement_type
*f
;
4922 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
4924 f
= (lang_input_statement_type
*) f
->next_real_file
)
4928 /* Call a function on each file. The function will be called on all
4929 the elements of an archive which are included in the link, but will
4930 not be called on the archive file itself. */
4933 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
4935 LANG_FOR_EACH_INPUT_STATEMENT (f
)
4942 ldlang_add_file (lang_input_statement_type
*entry
)
4946 lang_statement_append (&file_chain
,
4947 (lang_statement_union_type
*) entry
,
4950 /* The BFD linker needs to have a list of all input BFDs involved in
4952 ASSERT (entry
->the_bfd
->link_next
== NULL
);
4953 ASSERT (entry
->the_bfd
!= output_bfd
);
4954 for (pp
= &link_info
.input_bfds
; *pp
!= NULL
; pp
= &(*pp
)->link_next
)
4956 *pp
= entry
->the_bfd
;
4957 entry
->the_bfd
->usrdata
= entry
;
4958 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
4960 /* Look through the sections and check for any which should not be
4961 included in the link. We need to do this now, so that we can
4962 notice when the backend linker tries to report multiple
4963 definition errors for symbols which are in sections we aren't
4964 going to link. FIXME: It might be better to entirely ignore
4965 symbols which are defined in sections which are going to be
4966 discarded. This would require modifying the backend linker for
4967 each backend which might set the SEC_LINK_ONCE flag. If we do
4968 this, we should probably handle SEC_EXCLUDE in the same way. */
4970 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
4974 lang_add_output (const char *name
, int from_script
)
4976 /* Make -o on command line override OUTPUT in script. */
4977 if (!had_output_filename
|| !from_script
)
4979 output_filename
= name
;
4980 had_output_filename
= TRUE
;
4984 static lang_output_section_statement_type
*current_section
;
4995 for (l
= 0; l
< 32; l
++)
4997 if (i
>= (unsigned int) x
)
5005 lang_output_section_statement_type
*
5006 lang_enter_output_section_statement (const char *output_section_statement_name
,
5007 etree_type
*address_exp
,
5008 enum section_type sectype
,
5010 etree_type
*subalign
,
5014 lang_output_section_statement_type
*os
;
5018 lang_output_section_statement_lookup_1 (output_section_statement_name
,
5021 /* Make next things chain into subchain of this. */
5023 if (os
->addr_tree
== NULL
)
5025 os
->addr_tree
= address_exp
;
5027 os
->sectype
= sectype
;
5028 if (sectype
!= noload_section
)
5029 os
->flags
= SEC_NO_FLAGS
;
5031 os
->flags
= SEC_NEVER_LOAD
;
5032 os
->block_value
= 1;
5033 stat_ptr
= &os
->children
;
5035 os
->subsection_alignment
=
5036 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
5037 os
->section_alignment
=
5038 topower (exp_get_value_int (align
, -1, "section alignment", 0));
5040 os
->load_base
= ebase
;
5047 lang_output_statement_type
*new =
5048 new_stat (lang_output_statement
, stat_ptr
);
5050 new->name
= output_filename
;
5053 /* Reset the current counters in the regions. */
5056 lang_reset_memory_regions (void)
5058 lang_memory_region_type
*p
= lang_memory_region_list
;
5061 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
5063 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
5064 p
->current
= p
->origin
;
5067 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
5069 /* Save the last size for possible use by bfd_relax_section. */
5070 o
->rawsize
= o
->size
;
5075 /* Worker for lang_gc_sections_1. */
5078 gc_section_callback (lang_wild_statement_type
*ptr
,
5079 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
5081 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
5082 void *data ATTRIBUTE_UNUSED
)
5084 /* If the wild pattern was marked KEEP, the member sections
5085 should be as well. */
5086 if (ptr
->keep_sections
)
5087 section
->flags
|= SEC_KEEP
;
5090 /* Iterate over sections marking them against GC. */
5093 lang_gc_sections_1 (lang_statement_union_type
*s
)
5095 for (; s
!= NULL
; s
= s
->header
.next
)
5097 switch (s
->header
.type
)
5099 case lang_wild_statement_enum
:
5100 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
5102 case lang_constructors_statement_enum
:
5103 lang_gc_sections_1 (constructor_list
.head
);
5105 case lang_output_section_statement_enum
:
5106 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
5108 case lang_group_statement_enum
:
5109 lang_gc_sections_1 (s
->group_statement
.children
.head
);
5118 lang_gc_sections (void)
5120 struct bfd_link_hash_entry
*h
;
5121 ldlang_undef_chain_list_type
*ulist
;
5123 /* Keep all sections so marked in the link script. */
5125 lang_gc_sections_1 (statement_list
.head
);
5127 /* Keep all sections containing symbols undefined on the command-line,
5128 and the section containing the entry symbol. */
5130 for (ulist
= link_info
.gc_sym_list
; ulist
; ulist
= ulist
->next
)
5132 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
5133 FALSE
, FALSE
, FALSE
);
5136 && (h
->type
== bfd_link_hash_defined
5137 || h
->type
== bfd_link_hash_defweak
)
5138 && ! bfd_is_abs_section (h
->u
.def
.section
))
5140 h
->u
.def
.section
->flags
|= SEC_KEEP
;
5144 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
5145 the special case of debug info. (See bfd/stabs.c)
5146 Twiddle the flag here, to simplify later linker code. */
5147 if (link_info
.relocatable
)
5149 LANG_FOR_EACH_INPUT_STATEMENT (f
)
5152 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5153 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
5154 sec
->flags
&= ~SEC_EXCLUDE
;
5158 if (link_info
.gc_sections
)
5159 bfd_gc_sections (output_bfd
, &link_info
);
5163 lang_mark_used_section (void)
5165 unsigned int gc_sections
= link_info
.gc_sections
;
5167 link_info
.gc_sections
= 0;
5168 bfd_gc_sections (output_bfd
, &link_info
);
5169 link_info
.gc_sections
= gc_sections
;
5175 current_target
= default_target
;
5177 /* Open the output file. */
5178 lang_for_each_statement (ldlang_open_output
);
5181 ldemul_create_output_section_statements ();
5183 /* Add to the hash table all undefineds on the command line. */
5184 lang_place_undefineds ();
5186 if (!bfd_section_already_linked_table_init ())
5187 einfo (_("%P%F: Failed to create hash table\n"));
5189 /* Create a bfd for each input file. */
5190 current_target
= default_target
;
5191 open_input_bfds (statement_list
.head
, FALSE
);
5193 link_info
.gc_sym_list
= &entry_symbol
;
5194 if (entry_symbol
.name
== NULL
)
5195 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
5197 ldemul_after_open ();
5199 bfd_section_already_linked_table_free ();
5201 /* Make sure that we're not mixing architectures. We call this
5202 after all the input files have been opened, but before we do any
5203 other processing, so that any operations merge_private_bfd_data
5204 does on the output file will be known during the rest of the
5208 /* Handle .exports instead of a version script if we're told to do so. */
5209 if (command_line
.version_exports_section
)
5210 lang_do_version_exports_section ();
5212 /* Build all sets based on the information gathered from the input
5214 ldctor_build_sets ();
5216 /* Remove unreferenced sections if asked to. */
5217 lang_gc_sections ();
5219 /* Size up the common data. */
5222 /* Update wild statements. */
5223 update_wild_statements (statement_list
.head
);
5225 /* Run through the contours of the script and attach input sections
5226 to the correct output sections. */
5227 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
5229 /* Find any sections not attached explicitly and handle them. */
5230 lang_place_orphans ();
5232 if (! link_info
.relocatable
)
5236 /* Merge SEC_MERGE sections. This has to be done after GC of
5237 sections, so that GCed sections are not merged, but before
5238 assigning dynamic symbols, since removing whole input sections
5240 bfd_merge_sections (output_bfd
, &link_info
);
5242 /* Look for a text section and set the readonly attribute in it. */
5243 found
= bfd_get_section_by_name (output_bfd
, ".text");
5247 if (config
.text_read_only
)
5248 found
->flags
|= SEC_READONLY
;
5250 found
->flags
&= ~SEC_READONLY
;
5254 /* Do anything special before sizing sections. This is where ELF
5255 and other back-ends size dynamic sections. */
5256 ldemul_before_allocation ();
5258 /* We must record the program headers before we try to fix the
5259 section positions, since they will affect SIZEOF_HEADERS. */
5260 lang_record_phdrs ();
5262 /* Size up the sections. */
5263 lang_size_sections (statement_list
.head
, abs_output_section
,
5264 &statement_list
.head
, 0, 0, NULL
,
5265 command_line
.relax
? FALSE
: TRUE
);
5267 /* Now run around and relax if we can. */
5268 if (command_line
.relax
)
5270 /* Keep relaxing until bfd_relax_section gives up. */
5271 bfd_boolean relax_again
;
5275 relax_again
= FALSE
;
5277 /* Note: pe-dll.c does something like this also. If you find
5278 you need to change this code, you probably need to change
5279 pe-dll.c also. DJ */
5281 /* Do all the assignments with our current guesses as to
5283 lang_do_assignments (statement_list
.head
, abs_output_section
,
5286 /* We must do this after lang_do_assignments, because it uses
5288 lang_reset_memory_regions ();
5290 /* Perform another relax pass - this time we know where the
5291 globals are, so can make a better guess. */
5292 lang_size_sections (statement_list
.head
, abs_output_section
,
5293 &statement_list
.head
, 0, 0, &relax_again
, FALSE
);
5295 /* If the normal relax is done and the relax finalize pass
5296 is not performed yet, we perform another relax pass. */
5297 if (!relax_again
&& link_info
.need_relax_finalize
)
5299 link_info
.need_relax_finalize
= FALSE
;
5303 while (relax_again
);
5305 /* Final extra sizing to report errors. */
5306 lang_do_assignments (statement_list
.head
, abs_output_section
, NULL
, 0);
5307 lang_reset_memory_regions ();
5308 lang_size_sections (statement_list
.head
, abs_output_section
,
5309 &statement_list
.head
, 0, 0, NULL
, TRUE
);
5312 /* See if anything special should be done now we know how big
5314 ldemul_after_allocation ();
5316 /* Fix any .startof. or .sizeof. symbols. */
5317 lang_set_startof ();
5319 /* Do all the assignments, now that we know the final resting places
5320 of all the symbols. */
5322 lang_do_assignments (statement_list
.head
, abs_output_section
, NULL
, 0);
5324 /* Make sure that the section addresses make sense. */
5325 if (! link_info
.relocatable
5326 && command_line
.check_section_addresses
)
5327 lang_check_section_addresses ();
5330 lang_mark_used_section ();
5335 /* EXPORTED TO YACC */
5338 lang_add_wild (struct wildcard_spec
*filespec
,
5339 struct wildcard_list
*section_list
,
5340 bfd_boolean keep_sections
)
5342 struct wildcard_list
*curr
, *next
;
5343 lang_wild_statement_type
*new;
5345 /* Reverse the list as the parser puts it back to front. */
5346 for (curr
= section_list
, section_list
= NULL
;
5348 section_list
= curr
, curr
= next
)
5350 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
5351 placed_commons
= TRUE
;
5354 curr
->next
= section_list
;
5357 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
5359 if (strcmp (filespec
->name
, "*") == 0)
5360 filespec
->name
= NULL
;
5361 else if (! wildcardp (filespec
->name
))
5362 lang_has_input_file
= TRUE
;
5365 new = new_stat (lang_wild_statement
, stat_ptr
);
5366 new->filename
= NULL
;
5367 new->filenames_sorted
= FALSE
;
5368 if (filespec
!= NULL
)
5370 new->filename
= filespec
->name
;
5371 new->filenames_sorted
= filespec
->sorted
== by_name
;
5373 new->section_list
= section_list
;
5374 new->keep_sections
= keep_sections
;
5375 lang_list_init (&new->children
);
5376 analyze_walk_wild_section_handler (new);
5380 lang_section_start (const char *name
, etree_type
*address
,
5381 const segment_type
*segment
)
5383 lang_address_statement_type
*ad
;
5385 ad
= new_stat (lang_address_statement
, stat_ptr
);
5386 ad
->section_name
= name
;
5387 ad
->address
= address
;
5388 ad
->segment
= segment
;
5391 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
5392 because of a -e argument on the command line, or zero if this is
5393 called by ENTRY in a linker script. Command line arguments take
5397 lang_add_entry (const char *name
, bfd_boolean cmdline
)
5399 if (entry_symbol
.name
== NULL
5401 || ! entry_from_cmdline
)
5403 entry_symbol
.name
= name
;
5404 entry_from_cmdline
= cmdline
;
5409 lang_add_target (const char *name
)
5411 lang_target_statement_type
*new = new_stat (lang_target_statement
,
5419 lang_add_map (const char *name
)
5426 map_option_f
= TRUE
;
5434 lang_add_fill (fill_type
*fill
)
5436 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
5443 lang_add_data (int type
, union etree_union
*exp
)
5446 lang_data_statement_type
*new = new_stat (lang_data_statement
,
5454 /* Create a new reloc statement. RELOC is the BFD relocation type to
5455 generate. HOWTO is the corresponding howto structure (we could
5456 look this up, but the caller has already done so). SECTION is the
5457 section to generate a reloc against, or NAME is the name of the
5458 symbol to generate a reloc against. Exactly one of SECTION and
5459 NAME must be NULL. ADDEND is an expression for the addend. */
5462 lang_add_reloc (bfd_reloc_code_real_type reloc
,
5463 reloc_howto_type
*howto
,
5466 union etree_union
*addend
)
5468 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
5472 p
->section
= section
;
5474 p
->addend_exp
= addend
;
5476 p
->addend_value
= 0;
5477 p
->output_section
= NULL
;
5481 lang_assignment_statement_type
*
5482 lang_add_assignment (etree_type
*exp
)
5484 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
5492 lang_add_attribute (enum statement_enum attribute
)
5494 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
5498 lang_startup (const char *name
)
5500 if (startup_file
!= NULL
)
5502 einfo (_("%P%Fmultiple STARTUP files\n"));
5504 first_file
->filename
= name
;
5505 first_file
->local_sym_name
= name
;
5506 first_file
->real
= TRUE
;
5508 startup_file
= name
;
5512 lang_float (bfd_boolean maybe
)
5514 lang_float_flag
= maybe
;
5518 /* Work out the load- and run-time regions from a script statement, and
5519 store them in *LMA_REGION and *REGION respectively.
5521 MEMSPEC is the name of the run-time region, or the value of
5522 DEFAULT_MEMORY_REGION if the statement didn't specify one.
5523 LMA_MEMSPEC is the name of the load-time region, or null if the
5524 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
5525 had an explicit load address.
5527 It is an error to specify both a load region and a load address. */
5530 lang_get_regions (lang_memory_region_type
**region
,
5531 lang_memory_region_type
**lma_region
,
5532 const char *memspec
,
5533 const char *lma_memspec
,
5534 bfd_boolean have_lma
,
5535 bfd_boolean have_vma
)
5537 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
5539 /* If no runtime region or VMA has been specified, but the load region
5540 has been specified, then use the load region for the runtime region
5542 if (lma_memspec
!= NULL
5544 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
5545 *region
= *lma_region
;
5547 *region
= lang_memory_region_lookup (memspec
, FALSE
);
5549 if (have_lma
&& lma_memspec
!= 0)
5550 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
5554 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
5555 lang_output_section_phdr_list
*phdrs
,
5556 const char *lma_memspec
)
5558 lang_get_regions (¤t_section
->region
,
5559 ¤t_section
->lma_region
,
5560 memspec
, lma_memspec
,
5561 current_section
->load_base
!= NULL
,
5562 current_section
->addr_tree
!= NULL
);
5563 current_section
->fill
= fill
;
5564 current_section
->phdrs
= phdrs
;
5565 stat_ptr
= &statement_list
;
5568 /* Create an absolute symbol with the given name with the value of the
5569 address of first byte of the section named.
5571 If the symbol already exists, then do nothing. */
5574 lang_abs_symbol_at_beginning_of (const char *secname
, const char *name
)
5576 struct bfd_link_hash_entry
*h
;
5578 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
5580 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
5582 if (h
->type
== bfd_link_hash_new
5583 || h
->type
== bfd_link_hash_undefined
)
5587 h
->type
= bfd_link_hash_defined
;
5589 sec
= bfd_get_section_by_name (output_bfd
, secname
);
5593 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
5595 h
->u
.def
.section
= bfd_abs_section_ptr
;
5599 /* Create an absolute symbol with the given name with the value of the
5600 address of the first byte after the end of the section named.
5602 If the symbol already exists, then do nothing. */
5605 lang_abs_symbol_at_end_of (const char *secname
, const char *name
)
5607 struct bfd_link_hash_entry
*h
;
5609 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
5611 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
5613 if (h
->type
== bfd_link_hash_new
5614 || h
->type
== bfd_link_hash_undefined
)
5618 h
->type
= bfd_link_hash_defined
;
5620 sec
= bfd_get_section_by_name (output_bfd
, secname
);
5624 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
5625 + TO_ADDR (sec
->size
));
5627 h
->u
.def
.section
= bfd_abs_section_ptr
;
5632 lang_statement_append (lang_statement_list_type
*list
,
5633 lang_statement_union_type
*element
,
5634 lang_statement_union_type
**field
)
5636 *(list
->tail
) = element
;
5640 /* Set the output format type. -oformat overrides scripts. */
5643 lang_add_output_format (const char *format
,
5648 if (output_target
== NULL
|| !from_script
)
5650 if (command_line
.endian
== ENDIAN_BIG
5653 else if (command_line
.endian
== ENDIAN_LITTLE
5657 output_target
= format
;
5661 /* Enter a group. This creates a new lang_group_statement, and sets
5662 stat_ptr to build new statements within the group. */
5665 lang_enter_group (void)
5667 lang_group_statement_type
*g
;
5669 g
= new_stat (lang_group_statement
, stat_ptr
);
5670 lang_list_init (&g
->children
);
5671 stat_ptr
= &g
->children
;
5674 /* Leave a group. This just resets stat_ptr to start writing to the
5675 regular list of statements again. Note that this will not work if
5676 groups can occur inside anything else which can adjust stat_ptr,
5677 but currently they can't. */
5680 lang_leave_group (void)
5682 stat_ptr
= &statement_list
;
5685 /* Add a new program header. This is called for each entry in a PHDRS
5686 command in a linker script. */
5689 lang_new_phdr (const char *name
,
5691 bfd_boolean filehdr
,
5696 struct lang_phdr
*n
, **pp
;
5698 n
= stat_alloc (sizeof (struct lang_phdr
));
5701 n
->type
= exp_get_value_int (type
, 0, "program header type",
5702 lang_final_phase_enum
);
5703 n
->filehdr
= filehdr
;
5708 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5713 /* Record the program header information in the output BFD. FIXME: We
5714 should not be calling an ELF specific function here. */
5717 lang_record_phdrs (void)
5721 lang_output_section_phdr_list
*last
;
5722 struct lang_phdr
*l
;
5723 lang_output_section_statement_type
*os
;
5726 secs
= xmalloc (alc
* sizeof (asection
*));
5728 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
5735 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
5739 lang_output_section_phdr_list
*pl
;
5741 if (os
->constraint
== -1)
5749 if (os
->sectype
== noload_section
5750 || os
->bfd_section
== NULL
5751 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
5756 if (os
->bfd_section
== NULL
)
5759 for (; pl
!= NULL
; pl
= pl
->next
)
5761 if (strcmp (pl
->name
, l
->name
) == 0)
5766 secs
= xrealloc (secs
, alc
* sizeof (asection
*));
5768 secs
[c
] = os
->bfd_section
;
5775 if (l
->flags
== NULL
)
5778 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
5779 lang_final_phase_enum
);
5784 at
= exp_get_vma (l
->at
, 0, "phdr load address",
5785 lang_final_phase_enum
);
5787 if (! bfd_record_phdr (output_bfd
, l
->type
,
5788 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
5789 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
5790 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
5795 /* Make sure all the phdr assignments succeeded. */
5796 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
5800 lang_output_section_phdr_list
*pl
;
5802 if (os
->constraint
== -1
5803 || os
->bfd_section
== NULL
)
5806 for (pl
= os
->phdrs
;
5809 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
5810 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
5811 os
->name
, pl
->name
);
5815 /* Record a list of sections which may not be cross referenced. */
5818 lang_add_nocrossref (lang_nocrossref_type
*l
)
5820 struct lang_nocrossrefs
*n
;
5822 n
= xmalloc (sizeof *n
);
5823 n
->next
= nocrossref_list
;
5825 nocrossref_list
= n
;
5827 /* Set notice_all so that we get informed about all symbols. */
5828 link_info
.notice_all
= TRUE
;
5831 /* Overlay handling. We handle overlays with some static variables. */
5833 /* The overlay virtual address. */
5834 static etree_type
*overlay_vma
;
5835 /* And subsection alignment. */
5836 static etree_type
*overlay_subalign
;
5838 /* An expression for the maximum section size seen so far. */
5839 static etree_type
*overlay_max
;
5841 /* A list of all the sections in this overlay. */
5843 struct overlay_list
{
5844 struct overlay_list
*next
;
5845 lang_output_section_statement_type
*os
;
5848 static struct overlay_list
*overlay_list
;
5850 /* Start handling an overlay. */
5853 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
5855 /* The grammar should prevent nested overlays from occurring. */
5856 ASSERT (overlay_vma
== NULL
5857 && overlay_subalign
== NULL
5858 && overlay_max
== NULL
);
5860 overlay_vma
= vma_expr
;
5861 overlay_subalign
= subalign
;
5864 /* Start a section in an overlay. We handle this by calling
5865 lang_enter_output_section_statement with the correct VMA.
5866 lang_leave_overlay sets up the LMA and memory regions. */
5869 lang_enter_overlay_section (const char *name
)
5871 struct overlay_list
*n
;
5874 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
5875 0, overlay_subalign
, 0, 0);
5877 /* If this is the first section, then base the VMA of future
5878 sections on this one. This will work correctly even if `.' is
5879 used in the addresses. */
5880 if (overlay_list
== NULL
)
5881 overlay_vma
= exp_nameop (ADDR
, name
);
5883 /* Remember the section. */
5884 n
= xmalloc (sizeof *n
);
5885 n
->os
= current_section
;
5886 n
->next
= overlay_list
;
5889 size
= exp_nameop (SIZEOF
, name
);
5891 /* Arrange to work out the maximum section end address. */
5892 if (overlay_max
== NULL
)
5895 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
5898 /* Finish a section in an overlay. There isn't any special to do
5902 lang_leave_overlay_section (fill_type
*fill
,
5903 lang_output_section_phdr_list
*phdrs
)
5910 name
= current_section
->name
;
5912 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
5913 region and that no load-time region has been specified. It doesn't
5914 really matter what we say here, since lang_leave_overlay will
5916 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
5918 /* Define the magic symbols. */
5920 clean
= xmalloc (strlen (name
) + 1);
5922 for (s1
= name
; *s1
!= '\0'; s1
++)
5923 if (ISALNUM (*s1
) || *s1
== '_')
5927 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
5928 sprintf (buf
, "__load_start_%s", clean
);
5929 lang_add_assignment (exp_assop ('=', buf
,
5930 exp_nameop (LOADADDR
, name
)));
5932 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
5933 sprintf (buf
, "__load_stop_%s", clean
);
5934 lang_add_assignment (exp_assop ('=', buf
,
5936 exp_nameop (LOADADDR
, name
),
5937 exp_nameop (SIZEOF
, name
))));
5942 /* Finish an overlay. If there are any overlay wide settings, this
5943 looks through all the sections in the overlay and sets them. */
5946 lang_leave_overlay (etree_type
*lma_expr
,
5949 const char *memspec
,
5950 lang_output_section_phdr_list
*phdrs
,
5951 const char *lma_memspec
)
5953 lang_memory_region_type
*region
;
5954 lang_memory_region_type
*lma_region
;
5955 struct overlay_list
*l
;
5956 lang_nocrossref_type
*nocrossref
;
5958 lang_get_regions (®ion
, &lma_region
,
5959 memspec
, lma_memspec
,
5960 lma_expr
!= NULL
, FALSE
);
5964 /* After setting the size of the last section, set '.' to end of the
5966 if (overlay_list
!= NULL
)
5967 overlay_list
->os
->update_dot_tree
5968 = exp_assop ('=', ".", exp_binop ('+', overlay_vma
, overlay_max
));
5973 struct overlay_list
*next
;
5975 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
5978 l
->os
->region
= region
;
5979 l
->os
->lma_region
= lma_region
;
5981 /* The first section has the load address specified in the
5982 OVERLAY statement. The rest are worked out from that.
5983 The base address is not needed (and should be null) if
5984 an LMA region was specified. */
5986 l
->os
->load_base
= lma_expr
;
5987 else if (lma_region
== 0)
5988 l
->os
->load_base
= exp_binop ('+',
5989 exp_nameop (LOADADDR
, l
->next
->os
->name
),
5990 exp_nameop (SIZEOF
, l
->next
->os
->name
));
5992 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
5993 l
->os
->phdrs
= phdrs
;
5997 lang_nocrossref_type
*nc
;
5999 nc
= xmalloc (sizeof *nc
);
6000 nc
->name
= l
->os
->name
;
6001 nc
->next
= nocrossref
;
6010 if (nocrossref
!= NULL
)
6011 lang_add_nocrossref (nocrossref
);
6014 overlay_list
= NULL
;
6018 /* Version handling. This is only useful for ELF. */
6020 /* This global variable holds the version tree that we build. */
6022 struct bfd_elf_version_tree
*lang_elf_version_info
;
6024 /* If PREV is NULL, return first version pattern matching particular symbol.
6025 If PREV is non-NULL, return first version pattern matching particular
6026 symbol after PREV (previously returned by lang_vers_match). */
6028 static struct bfd_elf_version_expr
*
6029 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
6030 struct bfd_elf_version_expr
*prev
,
6033 const char *cxx_sym
= sym
;
6034 const char *java_sym
= sym
;
6035 struct bfd_elf_version_expr
*expr
= NULL
;
6037 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
6039 cxx_sym
= cplus_demangle (sym
, DMGL_PARAMS
| DMGL_ANSI
);
6043 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
6045 java_sym
= cplus_demangle (sym
, DMGL_JAVA
);
6050 if (head
->htab
&& (prev
== NULL
|| prev
->symbol
))
6052 struct bfd_elf_version_expr e
;
6054 switch (prev
? prev
->mask
: 0)
6057 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
6060 expr
= htab_find (head
->htab
, &e
);
6061 while (expr
&& strcmp (expr
->symbol
, sym
) == 0)
6062 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
6068 case BFD_ELF_VERSION_C_TYPE
:
6069 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
6072 expr
= htab_find (head
->htab
, &e
);
6073 while (expr
&& strcmp (expr
->symbol
, cxx_sym
) == 0)
6074 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
6080 case BFD_ELF_VERSION_CXX_TYPE
:
6081 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
6083 e
.symbol
= java_sym
;
6084 expr
= htab_find (head
->htab
, &e
);
6085 while (expr
&& strcmp (expr
->symbol
, java_sym
) == 0)
6086 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
6097 /* Finally, try the wildcards. */
6098 if (prev
== NULL
|| prev
->symbol
)
6099 expr
= head
->remaining
;
6106 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
6109 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
6111 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
6115 if (fnmatch (expr
->pattern
, s
, 0) == 0)
6122 free ((char *) cxx_sym
);
6123 if (java_sym
!= sym
)
6124 free ((char *) java_sym
);
6128 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
6129 return a string pointing to the symbol name. */
6132 realsymbol (const char *pattern
)
6135 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
6136 char *s
, *symbol
= xmalloc (strlen (pattern
) + 1);
6138 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
6140 /* It is a glob pattern only if there is no preceding
6142 if (! backslash
&& (*p
== '?' || *p
== '*' || *p
== '['))
6150 /* Remove the preceding backslash. */
6157 backslash
= *p
== '\\';
6172 /* This is called for each variable name or match expression. */
6174 struct bfd_elf_version_expr
*
6175 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
6179 struct bfd_elf_version_expr
*ret
;
6181 ret
= xmalloc (sizeof *ret
);
6186 ret
->symbol
= realsymbol (new);
6188 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
6189 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
6190 else if (strcasecmp (lang
, "C++") == 0)
6191 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
6192 else if (strcasecmp (lang
, "Java") == 0)
6193 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
6196 einfo (_("%X%P: unknown language `%s' in version information\n"),
6198 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
6201 return ldemul_new_vers_pattern (ret
);
6204 /* This is called for each set of variable names and match
6207 struct bfd_elf_version_tree
*
6208 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
6209 struct bfd_elf_version_expr
*locals
)
6211 struct bfd_elf_version_tree
*ret
;
6213 ret
= xcalloc (1, sizeof *ret
);
6214 ret
->globals
.list
= globals
;
6215 ret
->locals
.list
= locals
;
6216 ret
->match
= lang_vers_match
;
6217 ret
->name_indx
= (unsigned int) -1;
6221 /* This static variable keeps track of version indices. */
6223 static int version_index
;
6226 version_expr_head_hash (const void *p
)
6228 const struct bfd_elf_version_expr
*e
= p
;
6230 return htab_hash_string (e
->symbol
);
6234 version_expr_head_eq (const void *p1
, const void *p2
)
6236 const struct bfd_elf_version_expr
*e1
= p1
;
6237 const struct bfd_elf_version_expr
*e2
= p2
;
6239 return strcmp (e1
->symbol
, e2
->symbol
) == 0;
6243 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
6246 struct bfd_elf_version_expr
*e
, *next
;
6247 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
6249 for (e
= head
->list
; e
; e
= e
->next
)
6253 head
->mask
|= e
->mask
;
6258 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
6259 version_expr_head_eq
, NULL
);
6260 list_loc
= &head
->list
;
6261 remaining_loc
= &head
->remaining
;
6262 for (e
= head
->list
; e
; e
= next
)
6268 remaining_loc
= &e
->next
;
6272 void **loc
= htab_find_slot (head
->htab
, e
, INSERT
);
6276 struct bfd_elf_version_expr
*e1
, *last
;
6282 if (e1
->mask
== e
->mask
)
6290 while (e1
&& strcmp (e1
->symbol
, e
->symbol
) == 0);
6294 /* This is a duplicate. */
6295 /* FIXME: Memory leak. Sometimes pattern is not
6296 xmalloced alone, but in larger chunk of memory. */
6297 /* free (e->symbol); */
6302 e
->next
= last
->next
;
6310 list_loc
= &e
->next
;
6314 *remaining_loc
= NULL
;
6315 *list_loc
= head
->remaining
;
6318 head
->remaining
= head
->list
;
6321 /* This is called when we know the name and dependencies of the
6325 lang_register_vers_node (const char *name
,
6326 struct bfd_elf_version_tree
*version
,
6327 struct bfd_elf_version_deps
*deps
)
6329 struct bfd_elf_version_tree
*t
, **pp
;
6330 struct bfd_elf_version_expr
*e1
;
6335 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
6336 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
6338 einfo (_("%X%P: anonymous version tag cannot be combined"
6339 " with other version tags\n"));
6344 /* Make sure this node has a unique name. */
6345 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6346 if (strcmp (t
->name
, name
) == 0)
6347 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
6349 lang_finalize_version_expr_head (&version
->globals
);
6350 lang_finalize_version_expr_head (&version
->locals
);
6352 /* Check the global and local match names, and make sure there
6353 aren't any duplicates. */
6355 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
6357 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6359 struct bfd_elf_version_expr
*e2
;
6361 if (t
->locals
.htab
&& e1
->symbol
)
6363 e2
= htab_find (t
->locals
.htab
, e1
);
6364 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
6366 if (e1
->mask
== e2
->mask
)
6367 einfo (_("%X%P: duplicate expression `%s'"
6368 " in version information\n"), e1
->symbol
);
6372 else if (!e1
->symbol
)
6373 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
6374 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
6375 && e1
->mask
== e2
->mask
)
6376 einfo (_("%X%P: duplicate expression `%s'"
6377 " in version information\n"), e1
->pattern
);
6381 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
6383 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6385 struct bfd_elf_version_expr
*e2
;
6387 if (t
->globals
.htab
&& e1
->symbol
)
6389 e2
= htab_find (t
->globals
.htab
, e1
);
6390 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
6392 if (e1
->mask
== e2
->mask
)
6393 einfo (_("%X%P: duplicate expression `%s'"
6394 " in version information\n"),
6399 else if (!e1
->symbol
)
6400 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
6401 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
6402 && e1
->mask
== e2
->mask
)
6403 einfo (_("%X%P: duplicate expression `%s'"
6404 " in version information\n"), e1
->pattern
);
6408 version
->deps
= deps
;
6409 version
->name
= name
;
6410 if (name
[0] != '\0')
6413 version
->vernum
= version_index
;
6416 version
->vernum
= 0;
6418 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
6423 /* This is called when we see a version dependency. */
6425 struct bfd_elf_version_deps
*
6426 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
6428 struct bfd_elf_version_deps
*ret
;
6429 struct bfd_elf_version_tree
*t
;
6431 ret
= xmalloc (sizeof *ret
);
6434 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6436 if (strcmp (t
->name
, name
) == 0)
6438 ret
->version_needed
= t
;
6443 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
6449 lang_do_version_exports_section (void)
6451 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
6453 LANG_FOR_EACH_INPUT_STATEMENT (is
)
6455 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
6463 contents
= xmalloc (len
);
6464 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
6465 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
6468 while (p
< contents
+ len
)
6470 greg
= lang_new_vers_pattern (greg
, p
, NULL
);
6471 p
= strchr (p
, '\0') + 1;
6474 /* Do not free the contents, as we used them creating the regex. */
6476 /* Do not include this section in the link. */
6477 sec
->flags
|= SEC_EXCLUDE
;
6480 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
);
6481 lang_register_vers_node (command_line
.version_exports_section
,
6482 lang_new_vers_node (greg
, lreg
), NULL
);
6486 lang_add_unique (const char *name
)
6488 struct unique_sections
*ent
;
6490 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
6491 if (strcmp (ent
->name
, name
) == 0)
6494 ent
= xmalloc (sizeof *ent
);
6495 ent
->name
= xstrdup (name
);
6496 ent
->next
= unique_section_list
;
6497 unique_section_list
= ent
;