1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
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"
44 static lang_statement_union_type
*new_statement
45 PARAMS ((enum statement_enum
, size_t, lang_statement_list_type
*));
48 static struct obstack stat_obstack
;
50 #define obstack_chunk_alloc xmalloc
51 #define obstack_chunk_free free
52 static const char *startup_file
;
53 static lang_statement_list_type input_file_chain
;
54 static boolean placed_commons
= false;
55 static lang_output_section_statement_type
*default_common_section
;
56 static boolean map_option_f
;
57 static bfd_vma print_dot
;
58 static lang_input_statement_type
*first_file
;
59 static const char *current_target
;
60 static const char *output_target
;
61 static lang_statement_list_type statement_list
;
62 static struct lang_phdr
*lang_phdr_list
;
64 static void lang_for_each_statement_worker
65 PARAMS ((void (*) (lang_statement_union_type
*),
66 lang_statement_union_type
*));
67 static lang_input_statement_type
*new_afile
68 PARAMS ((const char *, lang_input_file_enum_type
, const char *, boolean
));
69 static lang_memory_region_type
*lang_memory_default
PARAMS ((asection
*));
70 static void lang_map_flags
PARAMS ((flagword
));
71 static void init_os
PARAMS ((lang_output_section_statement_type
*));
72 static void exp_init_os
PARAMS ((etree_type
*));
73 static void section_already_linked
PARAMS ((bfd
*, asection
*, PTR
));
74 static struct bfd_hash_entry
*already_linked_newfunc
75 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
76 static void already_linked_table_init
PARAMS ((void));
77 static void already_linked_table_free
PARAMS ((void));
78 static boolean wildcardp
PARAMS ((const char *));
79 static lang_statement_union_type
*wild_sort
80 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*,
81 lang_input_statement_type
*, asection
*));
82 static void output_section_callback
83 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
84 lang_input_statement_type
*, PTR
));
85 static lang_input_statement_type
*lookup_name
PARAMS ((const char *));
86 static boolean load_symbols
87 PARAMS ((lang_input_statement_type
*, lang_statement_list_type
*));
89 PARAMS ((lang_wild_statement_type
*,
90 const char *, lang_output_section_statement_type
*));
91 static bfd
*open_output
PARAMS ((const char *));
92 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*));
93 static void open_input_bfds
PARAMS ((lang_statement_union_type
*, boolean
));
94 static void lang_reasonable_defaults
PARAMS ((void));
95 static void insert_undefined
PARAMS ((const char *));
96 static void lang_place_undefineds
PARAMS ((void));
97 static void map_input_to_output_sections
98 PARAMS ((lang_statement_union_type
*, const char *,
99 lang_output_section_statement_type
*));
100 static void print_output_section_statement
101 PARAMS ((lang_output_section_statement_type
*));
102 static void print_assignment
103 PARAMS ((lang_assignment_statement_type
*,
104 lang_output_section_statement_type
*));
105 static void print_input_statement
PARAMS ((lang_input_statement_type
*));
106 static boolean print_one_symbol
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
107 static void print_input_section
PARAMS ((lang_input_section_type
*));
108 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*));
109 static void print_data_statement
PARAMS ((lang_data_statement_type
*));
110 static void print_address_statement
PARAMS ((lang_address_statement_type
*));
111 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*));
112 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*));
113 static void print_wild_statement
114 PARAMS ((lang_wild_statement_type
*, lang_output_section_statement_type
*));
115 static void print_group
116 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
117 static void print_statement
118 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
119 static void print_statement_list
120 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
121 static void print_statements
PARAMS ((void));
122 static void insert_pad
123 PARAMS ((lang_statement_union_type
**, fill_type
*,
124 unsigned int, asection
*, bfd_vma
));
125 static bfd_vma size_input_section
126 PARAMS ((lang_statement_union_type
**, lang_output_section_statement_type
*,
127 fill_type
*, bfd_vma
));
128 static void lang_finish
PARAMS ((void));
129 static void ignore_bfd_errors
PARAMS ((const char *, ...));
130 static void lang_check
PARAMS ((void));
131 static void lang_common
PARAMS ((void));
132 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
133 static void lang_place_orphans
PARAMS ((void));
134 static int topower
PARAMS ((int));
135 static void lang_set_startof
PARAMS ((void));
136 static void gc_section_callback
137 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
138 lang_input_statement_type
*, PTR
));
139 static void lang_record_phdrs
PARAMS ((void));
140 static void lang_gc_wild
PARAMS ((lang_wild_statement_type
*));
141 static void lang_gc_sections_1
PARAMS ((lang_statement_union_type
*));
142 static void lang_gc_sections
PARAMS ((void));
143 static int lang_vers_match_lang_c
144 PARAMS ((struct bfd_elf_version_expr
*, const char *));
145 static int lang_vers_match_lang_cplusplus
146 PARAMS ((struct bfd_elf_version_expr
*, const char *));
147 static int lang_vers_match_lang_java
148 PARAMS ((struct bfd_elf_version_expr
*, const char *));
149 static void lang_do_version_exports_section
PARAMS ((void));
150 static void lang_check_section_addresses
PARAMS ((void));
151 static void os_region_check
152 PARAMS ((lang_output_section_statement_type
*,
153 struct memory_region_struct
*, etree_type
*, bfd_vma
));
154 static bfd_vma lang_size_sections_1
155 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*,
156 lang_statement_union_type
**, fill_type
*, bfd_vma
, boolean
*));
158 typedef void (*callback_t
) PARAMS ((lang_wild_statement_type
*,
159 struct wildcard_list
*,
161 lang_input_statement_type
*,
163 static void walk_wild
164 PARAMS ((lang_wild_statement_type
*, callback_t
, PTR
));
165 static void walk_wild_section
166 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
168 static void walk_wild_file
169 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
172 static int get_target
PARAMS ((const bfd_target
*, PTR
));
173 static void stricpy
PARAMS ((char *, char *));
174 static void strcut
PARAMS ((char *, char *));
175 static int name_compare
PARAMS ((char *, char *));
176 static int closest_target_match
PARAMS ((const bfd_target
*, PTR
));
177 static char * get_first_input_target
PARAMS ((void));
180 lang_output_section_statement_type
*abs_output_section
;
181 lang_statement_list_type lang_output_section_statement
;
182 lang_statement_list_type
*stat_ptr
= &statement_list
;
183 lang_statement_list_type file_chain
= { NULL
, NULL
};
184 const char *entry_symbol
= NULL
;
185 const char *entry_section
= ".text";
186 boolean entry_from_cmdline
;
187 boolean lang_has_input_file
= false;
188 boolean had_output_filename
= false;
189 boolean lang_float_flag
= false;
190 boolean delete_output_file_on_failure
= false;
191 struct lang_nocrossrefs
*nocrossref_list
;
192 struct unique_sections
*unique_section_list
;
194 etree_type
*base
; /* Relocation base - or null */
196 #if defined (__STDC__) || defined (ALMOST_STDC)
197 #define cat(a,b) a##b
199 #define cat(a,b) a/**/b
202 /* Don't beautify the line below with "innocent" whitespace, it breaks
203 the K&R C preprocessor! */
204 #define new_stat(x, y) \
205 (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
207 #define outside_section_address(q) \
208 ((q)->output_offset + (q)->output_section->vma)
210 #define outside_symbol_address(q) \
211 ((q)->value + outside_section_address (q->section))
213 #define SECTION_NAME_MAP_LENGTH (16)
219 return obstack_alloc (&stat_obstack
, size
);
223 unique_section_p (secnam
)
226 struct unique_sections
*unam
;
228 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
229 if (wildcardp (unam
->name
)
230 ? fnmatch (unam
->name
, secnam
, 0) == 0
231 : strcmp (unam
->name
, secnam
) == 0)
239 /* Generic traversal routines for finding matching sections. */
242 walk_wild_section (ptr
, file
, callback
, data
)
243 lang_wild_statement_type
*ptr
;
244 lang_input_statement_type
*file
;
250 if (file
->just_syms_flag
)
253 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
255 struct wildcard_list
*sec
;
257 sec
= ptr
->section_list
;
259 (*callback
) (ptr
, sec
, s
, file
, data
);
263 boolean skip
= false;
264 struct name_list
*list_tmp
;
266 /* Don't process sections from files which were
268 for (list_tmp
= sec
->spec
.exclude_name_list
;
270 list_tmp
= list_tmp
->next
)
272 if (wildcardp (list_tmp
->name
))
273 skip
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
275 skip
= strcmp (list_tmp
->name
, file
->filename
) == 0;
277 /* If this file is part of an archive, and the archive is
278 excluded, exclude this file. */
279 if (! skip
&& file
->the_bfd
!= NULL
280 && file
->the_bfd
->my_archive
!= NULL
281 && file
->the_bfd
->my_archive
->filename
!= NULL
)
283 if (wildcardp (list_tmp
->name
))
284 skip
= fnmatch (list_tmp
->name
,
285 file
->the_bfd
->my_archive
->filename
,
288 skip
= strcmp (list_tmp
->name
,
289 file
->the_bfd
->my_archive
->filename
) == 0;
296 if (!skip
&& sec
->spec
.name
!= NULL
)
298 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
300 if (wildcardp (sec
->spec
.name
))
301 skip
= fnmatch (sec
->spec
.name
, sname
, 0) != 0;
303 skip
= strcmp (sec
->spec
.name
, sname
) != 0;
307 (*callback
) (ptr
, sec
, s
, file
, data
);
314 /* Handle a wild statement for a single file F. */
317 walk_wild_file (s
, f
, callback
, data
)
318 lang_wild_statement_type
*s
;
319 lang_input_statement_type
*f
;
323 if (f
->the_bfd
== NULL
324 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
325 walk_wild_section (s
, f
, callback
, data
);
330 /* This is an archive file. We must map each member of the
331 archive separately. */
332 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
333 while (member
!= NULL
)
335 /* When lookup_name is called, it will call the add_symbols
336 entry point for the archive. For each element of the
337 archive which is included, BFD will call ldlang_add_file,
338 which will set the usrdata field of the member to the
339 lang_input_statement. */
340 if (member
->usrdata
!= NULL
)
342 walk_wild_section (s
,
343 (lang_input_statement_type
*) member
->usrdata
,
347 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
353 walk_wild (s
, callback
, data
)
354 lang_wild_statement_type
*s
;
358 const char *file_spec
= s
->filename
;
360 if (file_spec
== NULL
)
362 /* Perform the iteration over all files in the list. */
363 LANG_FOR_EACH_INPUT_STATEMENT (f
)
365 walk_wild_file (s
, f
, callback
, data
);
368 else if (wildcardp (file_spec
))
370 LANG_FOR_EACH_INPUT_STATEMENT (f
)
372 if (fnmatch (file_spec
, f
->filename
, FNM_FILE_NAME
) == 0)
373 walk_wild_file (s
, f
, callback
, data
);
378 lang_input_statement_type
*f
;
380 /* Perform the iteration over a single file. */
381 f
= lookup_name (file_spec
);
383 walk_wild_file (s
, f
, callback
, data
);
387 /* lang_for_each_statement walks the parse tree and calls the provided
388 function for each node. */
391 lang_for_each_statement_worker (func
, s
)
392 void (*func
) PARAMS ((lang_statement_union_type
*));
393 lang_statement_union_type
*s
;
395 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
399 switch (s
->header
.type
)
401 case lang_constructors_statement_enum
:
402 lang_for_each_statement_worker (func
, constructor_list
.head
);
404 case lang_output_section_statement_enum
:
405 lang_for_each_statement_worker
407 s
->output_section_statement
.children
.head
);
409 case lang_wild_statement_enum
:
410 lang_for_each_statement_worker
412 s
->wild_statement
.children
.head
);
414 case lang_group_statement_enum
:
415 lang_for_each_statement_worker (func
,
416 s
->group_statement
.children
.head
);
418 case lang_data_statement_enum
:
419 case lang_reloc_statement_enum
:
420 case lang_object_symbols_statement_enum
:
421 case lang_output_statement_enum
:
422 case lang_target_statement_enum
:
423 case lang_input_section_enum
:
424 case lang_input_statement_enum
:
425 case lang_assignment_statement_enum
:
426 case lang_padding_statement_enum
:
427 case lang_address_statement_enum
:
428 case lang_fill_statement_enum
:
438 lang_for_each_statement (func
)
439 void (*func
) PARAMS ((lang_statement_union_type
*));
441 lang_for_each_statement_worker (func
, statement_list
.head
);
444 /*----------------------------------------------------------------------*/
447 lang_list_init (list
)
448 lang_statement_list_type
*list
;
450 list
->head
= (lang_statement_union_type
*) NULL
;
451 list
->tail
= &list
->head
;
454 /* Build a new statement node for the parse tree. */
456 static lang_statement_union_type
*
457 new_statement (type
, size
, list
)
458 enum statement_enum type
;
460 lang_statement_list_type
*list
;
462 lang_statement_union_type
*new = (lang_statement_union_type
*)
465 new->header
.type
= type
;
466 new->header
.next
= (lang_statement_union_type
*) NULL
;
467 lang_statement_append (list
, new, &new->header
.next
);
471 /* Build a new input file node for the language. There are several
472 ways in which we treat an input file, eg, we only look at symbols,
473 or prefix it with a -l etc.
475 We can be supplied with requests for input files more than once;
476 they may, for example be split over serveral lines like foo.o(.text)
477 foo.o(.data) etc, so when asked for a file we check that we haven't
478 got it already so we don't duplicate the bfd. */
480 static lang_input_statement_type
*
481 new_afile (name
, file_type
, target
, add_to_list
)
483 lang_input_file_enum_type file_type
;
487 lang_input_statement_type
*p
;
490 p
= new_stat (lang_input_statement
, stat_ptr
);
493 p
= ((lang_input_statement_type
*)
494 stat_alloc (sizeof (lang_input_statement_type
)));
495 p
->header
.next
= NULL
;
498 lang_has_input_file
= true;
502 case lang_input_file_is_symbols_only_enum
:
504 p
->is_archive
= false;
506 p
->local_sym_name
= name
;
507 p
->just_syms_flag
= true;
508 p
->search_dirs_flag
= false;
510 case lang_input_file_is_fake_enum
:
512 p
->is_archive
= false;
514 p
->local_sym_name
= name
;
515 p
->just_syms_flag
= false;
516 p
->search_dirs_flag
= false;
518 case lang_input_file_is_l_enum
:
519 p
->is_archive
= true;
522 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
523 p
->just_syms_flag
= false;
524 p
->search_dirs_flag
= true;
526 case lang_input_file_is_marker_enum
:
528 p
->is_archive
= false;
530 p
->local_sym_name
= name
;
531 p
->just_syms_flag
= false;
532 p
->search_dirs_flag
= true;
534 case lang_input_file_is_search_file_enum
:
536 p
->is_archive
= false;
538 p
->local_sym_name
= name
;
539 p
->just_syms_flag
= false;
540 p
->search_dirs_flag
= true;
542 case lang_input_file_is_file_enum
:
544 p
->is_archive
= false;
546 p
->local_sym_name
= name
;
547 p
->just_syms_flag
= false;
548 p
->search_dirs_flag
= false;
553 p
->the_bfd
= (bfd
*) NULL
;
554 p
->asymbols
= (asymbol
**) NULL
;
555 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
556 p
->next
= (lang_statement_union_type
*) NULL
;
558 p
->dynamic
= config
.dynamic_link
;
559 p
->whole_archive
= whole_archive
;
561 lang_statement_append (&input_file_chain
,
562 (lang_statement_union_type
*) p
,
567 lang_input_statement_type
*
568 lang_add_input_file (name
, file_type
, target
)
570 lang_input_file_enum_type file_type
;
573 lang_has_input_file
= true;
574 return new_afile (name
, file_type
, target
, true);
577 /* Build enough state so that the parser can build its tree. */
582 obstack_begin (&stat_obstack
, 1000);
584 stat_ptr
= &statement_list
;
586 lang_list_init (stat_ptr
);
588 lang_list_init (&input_file_chain
);
589 lang_list_init (&lang_output_section_statement
);
590 lang_list_init (&file_chain
);
591 first_file
= lang_add_input_file ((char *) NULL
,
592 lang_input_file_is_marker_enum
,
595 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
597 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
601 /*----------------------------------------------------------------------
602 A region is an area of memory declared with the
603 MEMORY { name:org=exp, len=exp ... }
606 We maintain a list of all the regions here.
608 If no regions are specified in the script, then the default is used
609 which is created when looked up to be the entire data space. */
611 static lang_memory_region_type
*lang_memory_region_list
;
612 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
614 lang_memory_region_type
*
615 lang_memory_region_lookup (name
)
616 const char *const name
;
618 lang_memory_region_type
*p
;
620 for (p
= lang_memory_region_list
;
621 p
!= (lang_memory_region_type
*) NULL
;
624 if (strcmp (p
->name
, name
) == 0)
631 /* This code used to always use the first region in the list as the
632 default region. I changed it to instead use a region
633 encompassing all of memory as the default region. This permits
634 NOLOAD sections to work reasonably without requiring a region.
635 People should specify what region they mean, if they really want
637 if (strcmp (name
, "*default*") == 0)
639 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
641 return lang_memory_region_list
;
647 lang_memory_region_type
*new =
648 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
650 new->name
= xstrdup (name
);
651 new->next
= (lang_memory_region_type
*) NULL
;
653 *lang_memory_region_list_tail
= new;
654 lang_memory_region_list_tail
= &new->next
;
658 new->length
= ~(bfd_size_type
) 0;
660 new->had_full_message
= false;
666 static lang_memory_region_type
*
667 lang_memory_default (section
)
670 lang_memory_region_type
*p
;
672 flagword sec_flags
= section
->flags
;
674 /* Override SEC_DATA to mean a writable section. */
675 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
676 sec_flags
|= SEC_DATA
;
678 for (p
= lang_memory_region_list
;
679 p
!= (lang_memory_region_type
*) NULL
;
682 if ((p
->flags
& sec_flags
) != 0
683 && (p
->not_flags
& sec_flags
) == 0)
688 return lang_memory_region_lookup ("*default*");
691 lang_output_section_statement_type
*
692 lang_output_section_find (name
)
693 const char *const name
;
695 lang_statement_union_type
*u
;
696 lang_output_section_statement_type
*lookup
;
698 for (u
= lang_output_section_statement
.head
;
699 u
!= (lang_statement_union_type
*) NULL
;
702 lookup
= &u
->output_section_statement
;
703 if (strcmp (name
, lookup
->name
) == 0)
708 return (lang_output_section_statement_type
*) NULL
;
711 lang_output_section_statement_type
*
712 lang_output_section_statement_lookup (name
)
713 const char *const name
;
715 lang_output_section_statement_type
*lookup
;
717 lookup
= lang_output_section_find (name
);
718 if (lookup
== (lang_output_section_statement_type
*) NULL
)
721 lookup
= (lang_output_section_statement_type
*)
722 new_stat (lang_output_section_statement
, stat_ptr
);
723 lookup
->region
= (lang_memory_region_type
*) NULL
;
724 lookup
->lma_region
= (lang_memory_region_type
*) NULL
;
725 lookup
->fill
= (fill_type
*) 0;
726 lookup
->block_value
= 1;
729 lookup
->next
= (lang_statement_union_type
*) NULL
;
730 lookup
->bfd_section
= (asection
*) NULL
;
731 lookup
->processed
= false;
732 lookup
->sectype
= normal_section
;
733 lookup
->addr_tree
= (etree_type
*) NULL
;
734 lang_list_init (&lookup
->children
);
736 lookup
->memspec
= (const char *) NULL
;
738 lookup
->subsection_alignment
= -1;
739 lookup
->section_alignment
= -1;
740 lookup
->load_base
= (union etree_union
*) NULL
;
741 lookup
->phdrs
= NULL
;
743 lang_statement_append (&lang_output_section_statement
,
744 (lang_statement_union_type
*) lookup
,
751 lang_map_flags (flag
)
754 if (flag
& SEC_ALLOC
)
760 if (flag
& SEC_READONLY
)
773 lang_memory_region_type
*m
;
775 minfo (_("\nMemory Configuration\n\n"));
776 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
777 _("Name"), _("Origin"), _("Length"), _("Attributes"));
779 for (m
= lang_memory_region_list
;
780 m
!= (lang_memory_region_type
*) NULL
;
786 fprintf (config
.map_file
, "%-16s ", m
->name
);
788 sprintf_vma (buf
, m
->origin
);
789 minfo ("0x%s ", buf
);
797 minfo ("0x%V", m
->length
);
798 if (m
->flags
|| m
->not_flags
)
806 lang_map_flags (m
->flags
);
812 lang_map_flags (m
->not_flags
);
819 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
824 /* Initialize an output section. */
828 lang_output_section_statement_type
*s
;
830 section_userdata_type
*new;
832 if (s
->bfd_section
!= NULL
)
835 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
836 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
838 new = ((section_userdata_type
*)
839 stat_alloc (sizeof (section_userdata_type
)));
841 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
842 if (s
->bfd_section
== (asection
*) NULL
)
843 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
844 if (s
->bfd_section
== (asection
*) NULL
)
846 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
847 output_bfd
->xvec
->name
, s
->name
);
849 s
->bfd_section
->output_section
= s
->bfd_section
;
851 /* We initialize an output sections output offset to minus its own
852 vma to allow us to output a section through itself. */
853 s
->bfd_section
->output_offset
= 0;
854 get_userdata (s
->bfd_section
) = (PTR
) new;
856 /* If there is a base address, make sure that any sections it might
857 mention are initialized. */
858 if (s
->addr_tree
!= NULL
)
859 exp_init_os (s
->addr_tree
);
862 /* Make sure that all output sections mentioned in an expression are
869 switch (exp
->type
.node_class
)
872 exp_init_os (exp
->assign
.src
);
876 exp_init_os (exp
->binary
.lhs
);
877 exp_init_os (exp
->binary
.rhs
);
881 exp_init_os (exp
->trinary
.cond
);
882 exp_init_os (exp
->trinary
.lhs
);
883 exp_init_os (exp
->trinary
.rhs
);
887 exp_init_os (exp
->unary
.child
);
891 switch (exp
->type
.node_code
)
897 lang_output_section_statement_type
*os
;
899 os
= lang_output_section_find (exp
->name
.name
);
900 if (os
!= NULL
&& os
->bfd_section
== NULL
)
911 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
912 once into the output. This routine checks each section, and
913 arrange to discard it if a section of the same name has already
914 been linked. If the section has COMDAT information, then it uses
915 that to decide whether the section should be included. This code
916 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
917 that is, it does not depend solely upon the section name.
918 section_already_linked is called via bfd_map_over_sections. */
920 /* This is the shape of the elements inside the already_linked hash
921 table. It maps a name onto a list of already_linked elements with
922 the same name. It's possible to get more than one element in a
923 list if the COMDAT sections have different names. */
925 struct already_linked_hash_entry
927 struct bfd_hash_entry root
;
928 struct already_linked
*entry
;
931 struct already_linked
933 struct already_linked
*next
;
937 /* The hash table. */
939 static struct bfd_hash_table already_linked_table
;
942 section_already_linked (abfd
, sec
, data
)
947 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
950 struct already_linked
*l
;
951 struct already_linked_hash_entry
*already_linked_list
;
953 /* If we are only reading symbols from this object, then we want to
954 discard all sections. */
955 if (entry
->just_syms_flag
)
957 sec
->output_section
= bfd_abs_section_ptr
;
958 sec
->output_offset
= sec
->vma
;
962 flags
= bfd_get_section_flags (abfd
, sec
);
964 if ((flags
& SEC_LINK_ONCE
) == 0)
967 /* FIXME: When doing a relocatable link, we may have trouble
968 copying relocations in other sections that refer to local symbols
969 in the section being discarded. Those relocations will have to
970 be converted somehow; as of this writing I'm not sure that any of
971 the backends handle that correctly.
973 It is tempting to instead not discard link once sections when
974 doing a relocatable link (technically, they should be discarded
975 whenever we are building constructors). However, that fails,
976 because the linker winds up combining all the link once sections
977 into a single large link once section, which defeats the purpose
978 of having link once sections in the first place.
980 Also, not merging link once sections in a relocatable link
981 causes trouble for MIPS ELF, which relies in link once semantics
982 to handle the .reginfo section correctly. */
984 name
= bfd_get_section_name (abfd
, sec
);
986 already_linked_list
=
987 ((struct already_linked_hash_entry
*)
988 bfd_hash_lookup (&already_linked_table
, name
, true, false));
990 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
992 if (sec
->comdat
== NULL
993 || l
->sec
->comdat
== NULL
994 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
996 /* The section has already been linked. See if we should
998 switch (flags
& SEC_LINK_DUPLICATES
)
1003 case SEC_LINK_DUPLICATES_DISCARD
:
1006 case SEC_LINK_DUPLICATES_ONE_ONLY
:
1007 if (sec
->comdat
== NULL
)
1008 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
1011 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
1012 abfd
, name
, sec
->comdat
->name
);
1015 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
1016 /* FIXME: We should really dig out the contents of both
1017 sections and memcmp them. The COFF/PE spec says that
1018 the Microsoft linker does not implement this
1019 correctly, so I'm not going to bother doing it
1022 case SEC_LINK_DUPLICATES_SAME_SIZE
:
1023 if (bfd_section_size (abfd
, sec
)
1024 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1025 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1030 /* Set the output_section field so that lang_add_section
1031 does not create a lang_input_section structure for this
1033 sec
->output_section
= bfd_abs_section_ptr
;
1039 /* This is the first section with this name. Record it. Allocate
1040 the memory from the same obstack as the hash table is kept in. */
1042 l
= ((struct already_linked
*)
1043 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1046 l
->next
= already_linked_list
->entry
;
1047 already_linked_list
->entry
= l
;
1050 /* Support routines for the hash table used by section_already_linked,
1051 initialize the table, fill in an entry and remove the table. */
1053 static struct bfd_hash_entry
*
1054 already_linked_newfunc (entry
, table
, string
)
1055 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1056 struct bfd_hash_table
*table
;
1057 const char *string ATTRIBUTE_UNUSED
;
1059 struct already_linked_hash_entry
*ret
=
1060 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1064 return (struct bfd_hash_entry
*) ret
;
1068 already_linked_table_init ()
1070 if (! bfd_hash_table_init_n (&already_linked_table
,
1071 already_linked_newfunc
,
1073 einfo (_("%P%F: Failed to create hash table\n"));
1077 already_linked_table_free ()
1079 bfd_hash_table_free (&already_linked_table
);
1082 /* The wild routines.
1084 These expand statements like *(.text) and foo.o to a list of
1085 explicit actions, like foo.o(.text), bar.o(.text) and
1086 foo.o(.text, .data). */
1088 /* Return true if the PATTERN argument is a wildcard pattern.
1089 Although backslashes are treated specially if a pattern contains
1090 wildcards, we do not consider the mere presence of a backslash to
1091 be enough to cause the pattern to be treated as a wildcard.
1092 That lets us handle DOS filenames more naturally. */
1096 const char *pattern
;
1100 for (s
= pattern
; *s
!= '\0'; ++s
)
1108 /* Add SECTION to the output section OUTPUT. Do this by creating a
1109 lang_input_section statement which is placed at PTR. FILE is the
1110 input file which holds SECTION. */
1113 lang_add_section (ptr
, section
, output
, file
)
1114 lang_statement_list_type
*ptr
;
1116 lang_output_section_statement_type
*output
;
1117 lang_input_statement_type
*file
;
1122 flags
= bfd_get_section_flags (section
->owner
, section
);
1126 /* If we are doing a final link, discard sections marked with
1128 if (! link_info
.relocateable
1129 && (flags
& SEC_EXCLUDE
) != 0)
1132 /* Discard input sections which are assigned to a section named
1133 DISCARD_SECTION_NAME. */
1134 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1137 /* Discard debugging sections if we are stripping debugging
1139 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1140 && (flags
& SEC_DEBUGGING
) != 0)
1145 if (section
->output_section
== NULL
)
1147 /* This prevents future calls from assigning this section. */
1148 section
->output_section
= bfd_abs_section_ptr
;
1153 if (section
->output_section
== NULL
)
1156 lang_input_section_type
*new;
1159 if (output
->bfd_section
== NULL
)
1162 first
= ! output
->bfd_section
->linker_has_input
;
1163 output
->bfd_section
->linker_has_input
= 1;
1165 /* Add a section reference to the list. */
1166 new = new_stat (lang_input_section
, ptr
);
1168 new->section
= section
;
1170 section
->output_section
= output
->bfd_section
;
1172 flags
= section
->flags
;
1174 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1175 to an output section, because we want to be able to include a
1176 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1177 section (I don't know why we want to do this, but we do).
1178 build_link_order in ldwrite.c handles this case by turning
1179 the embedded SEC_NEVER_LOAD section into a fill. */
1181 flags
&= ~ SEC_NEVER_LOAD
;
1183 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1184 already been processed. One reason to do this is that on pe
1185 format targets, .text$foo sections go into .text and it's odd
1186 to see .text with SEC_LINK_ONCE set. */
1188 if (! link_info
.relocateable
)
1189 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1191 /* If this is not the first input section, and the SEC_READONLY
1192 flag is not currently set, then don't set it just because the
1193 input section has it set. */
1195 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1196 flags
&= ~ SEC_READONLY
;
1198 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1200 && ((section
->output_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1201 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1202 || ((flags
& SEC_MERGE
)
1203 && section
->output_section
->entsize
!= section
->entsize
)))
1205 section
->output_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1206 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1209 section
->output_section
->flags
|= flags
;
1211 if (flags
& SEC_MERGE
)
1212 section
->output_section
->entsize
= section
->entsize
;
1214 /* If SEC_READONLY is not set in the input section, then clear
1215 it from the output section. */
1216 if ((section
->flags
& SEC_READONLY
) == 0)
1217 section
->output_section
->flags
&= ~SEC_READONLY
;
1219 switch (output
->sectype
)
1221 case normal_section
:
1226 case overlay_section
:
1227 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1229 case noload_section
:
1230 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1231 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1235 /* Copy over SEC_SMALL_DATA. */
1236 if (section
->flags
& SEC_SMALL_DATA
)
1237 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1239 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1240 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1242 /* If supplied an aligment, then force it. */
1243 if (output
->section_alignment
!= -1)
1244 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1246 if (section
->flags
& SEC_BLOCK
)
1248 section
->output_section
->flags
|= SEC_BLOCK
;
1249 /* FIXME: This value should really be obtained from the bfd... */
1250 output
->block_value
= 128;
1255 /* Handle wildcard sorting. This returns the lang_input_section which
1256 should follow the one we are going to create for SECTION and FILE,
1257 based on the sorting requirements of WILD. It returns NULL if the
1258 new section should just go at the end of the current list. */
1260 static lang_statement_union_type
*
1261 wild_sort (wild
, sec
, file
, section
)
1262 lang_wild_statement_type
*wild
;
1263 struct wildcard_list
*sec
;
1264 lang_input_statement_type
*file
;
1267 const char *section_name
;
1268 lang_statement_union_type
*l
;
1270 if (!wild
->filenames_sorted
&& (sec
== NULL
|| !sec
->spec
.sorted
))
1273 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1274 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
1276 lang_input_section_type
*ls
;
1278 if (l
->header
.type
!= lang_input_section_enum
)
1280 ls
= &l
->input_section
;
1282 /* Sorting by filename takes precedence over sorting by section
1285 if (wild
->filenames_sorted
)
1287 const char *fn
, *ln
;
1291 /* The PE support for the .idata section as generated by
1292 dlltool assumes that files will be sorted by the name of
1293 the archive and then the name of the file within the
1296 if (file
->the_bfd
!= NULL
1297 && bfd_my_archive (file
->the_bfd
) != NULL
)
1299 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1304 fn
= file
->filename
;
1308 if (ls
->ifile
->the_bfd
!= NULL
1309 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1311 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1316 ln
= ls
->ifile
->filename
;
1320 i
= strcmp (fn
, ln
);
1329 fn
= file
->filename
;
1331 ln
= ls
->ifile
->filename
;
1333 i
= strcmp (fn
, ln
);
1341 /* Here either the files are not sorted by name, or we are
1342 looking at the sections for this file. */
1344 if (sec
!= NULL
&& sec
->spec
.sorted
)
1346 if (strcmp (section_name
,
1347 bfd_get_section_name (ls
->ifile
->the_bfd
,
1357 /* Expand a wild statement for a particular FILE. SECTION may be
1358 NULL, in which case it is a wild card. */
1361 output_section_callback (ptr
, sec
, section
, file
, output
)
1362 lang_wild_statement_type
*ptr
;
1363 struct wildcard_list
*sec
;
1365 lang_input_statement_type
*file
;
1368 lang_statement_union_type
*before
;
1370 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1371 if (unique_section_p (bfd_get_section_name (file
->the_bfd
, section
)))
1374 /* If the wild pattern was marked KEEP, the member sections
1375 should be as well. */
1376 if (ptr
->keep_sections
)
1377 section
->flags
|= SEC_KEEP
;
1379 before
= wild_sort (ptr
, sec
, file
, section
);
1381 /* Here BEFORE points to the lang_input_section which
1382 should follow the one we are about to add. If BEFORE
1383 is NULL, then the section should just go at the end
1384 of the current list. */
1387 lang_add_section (&ptr
->children
, section
,
1388 (lang_output_section_statement_type
*) output
,
1392 lang_statement_list_type list
;
1393 lang_statement_union_type
**pp
;
1395 lang_list_init (&list
);
1396 lang_add_section (&list
, section
,
1397 (lang_output_section_statement_type
*) output
,
1400 /* If we are discarding the section, LIST.HEAD will
1402 if (list
.head
!= NULL
)
1404 ASSERT (list
.head
->header
.next
== NULL
);
1406 for (pp
= &ptr
->children
.head
;
1408 pp
= &(*pp
)->header
.next
)
1409 ASSERT (*pp
!= NULL
);
1411 list
.head
->header
.next
= *pp
;
1417 /* This is passed a file name which must have been seen already and
1418 added to the statement tree. We will see if it has been opened
1419 already and had its symbols read. If not then we'll read it. */
1421 static lang_input_statement_type
*
1425 lang_input_statement_type
*search
;
1427 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1428 search
!= (lang_input_statement_type
*) NULL
;
1429 search
= (lang_input_statement_type
*) search
->next_real_file
)
1431 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1433 if (search
->filename
!= (char *) NULL
1434 && name
!= (char *) NULL
1435 && strcmp (search
->filename
, name
) == 0)
1439 if (search
== (lang_input_statement_type
*) NULL
)
1440 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1443 /* If we have already added this file, or this file is not real
1444 (FIXME: can that ever actually happen?) or the name is NULL
1445 (FIXME: can that ever actually happen?) don't add this file. */
1448 || search
->filename
== (const char *) NULL
)
1451 if (! load_symbols (search
, (lang_statement_list_type
*) NULL
))
1457 /* Get the symbols for an input file. */
1460 load_symbols (entry
, place
)
1461 lang_input_statement_type
*entry
;
1462 lang_statement_list_type
*place
;
1469 ldfile_open_file (entry
);
1471 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1472 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1475 lang_statement_list_type
*hold
;
1476 boolean bad_load
= true;
1478 err
= bfd_get_error ();
1480 /* See if the emulation has some special knowledge. */
1481 if (ldemul_unrecognized_file (entry
))
1484 if (err
== bfd_error_file_ambiguously_recognized
)
1488 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1489 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1490 for (p
= matching
; *p
!= NULL
; p
++)
1494 else if (err
!= bfd_error_file_not_recognized
1496 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1500 bfd_close (entry
->the_bfd
);
1501 entry
->the_bfd
= NULL
;
1503 /* Try to interpret the file as a linker script. */
1504 ldfile_open_command_file (entry
->filename
);
1509 ldfile_assumed_script
= true;
1510 parser_input
= input_script
;
1512 ldfile_assumed_script
= false;
1519 if (ldemul_recognized_file (entry
))
1522 /* We don't call ldlang_add_file for an archive. Instead, the
1523 add_symbols entry point will call ldlang_add_file, via the
1524 add_archive_element callback, for each element of the archive
1526 switch (bfd_get_format (entry
->the_bfd
))
1532 ldlang_add_file (entry
);
1533 if (trace_files
|| trace_file_tries
)
1534 info_msg ("%I\n", entry
);
1538 if (entry
->whole_archive
)
1541 boolean loaded
= true;
1545 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
1550 if (! bfd_check_format (member
, bfd_object
))
1552 einfo (_("%F%B: member %B in archive is not an object\n"),
1553 entry
->the_bfd
, member
);
1557 if (! ((*link_info
.callbacks
->add_archive_element
)
1558 (&link_info
, member
, "--whole-archive")))
1561 if (! bfd_link_add_symbols (member
, &link_info
))
1563 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1568 entry
->loaded
= loaded
;
1574 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1575 entry
->loaded
= true;
1577 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1579 return entry
->loaded
;
1582 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1583 may be NULL, indicating that it is a wildcard. Separate
1584 lang_input_section statements are created for each part of the
1585 expansion; they are added after the wild statement S. OUTPUT is
1586 the output section. */
1589 wild (s
, target
, output
)
1590 lang_wild_statement_type
*s
;
1591 const char *target ATTRIBUTE_UNUSED
;
1592 lang_output_section_statement_type
*output
;
1594 struct wildcard_list
*sec
;
1596 walk_wild (s
, output_section_callback
, (PTR
) output
);
1598 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
1600 if (default_common_section
!= NULL
)
1602 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
1604 /* Remember the section that common is going to in case we
1605 later get something which doesn't know where to put it. */
1606 default_common_section
= output
;
1611 /* Return true iff target is the sought target. */
1614 get_target (target
, data
)
1615 const bfd_target
*target
;
1618 const char *sought
= (const char *) data
;
1620 return strcmp (target
->name
, sought
) == 0;
1623 /* Like strcpy() but convert to lower case as well. */
1632 while ((c
= *src
++) != 0)
1633 *dest
++ = TOLOWER (c
);
1638 /* Remove the first occurance of needle (if any) in haystack
1642 strcut (haystack
, needle
)
1646 haystack
= strstr (haystack
, needle
);
1652 for (src
= haystack
+ strlen (needle
); *src
;)
1653 *haystack
++ = *src
++;
1659 /* Compare two target format name strings.
1660 Return a value indicating how "similar" they are. */
1663 name_compare (first
, second
)
1671 copy1
= xmalloc (strlen (first
) + 1);
1672 copy2
= xmalloc (strlen (second
) + 1);
1674 /* Convert the names to lower case. */
1675 stricpy (copy1
, first
);
1676 stricpy (copy2
, second
);
1678 /* Remove and endian strings from the name. */
1679 strcut (copy1
, "big");
1680 strcut (copy1
, "little");
1681 strcut (copy2
, "big");
1682 strcut (copy2
, "little");
1684 /* Return a value based on how many characters match,
1685 starting from the beginning. If both strings are
1686 the same then return 10 * their length. */
1687 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1688 if (copy1
[result
] == 0)
1700 /* Set by closest_target_match() below. */
1701 static const bfd_target
*winner
;
1703 /* Scan all the valid bfd targets looking for one that has the endianness
1704 requirement that was specified on the command line, and is the nearest
1705 match to the original output target. */
1708 closest_target_match (target
, data
)
1709 const bfd_target
*target
;
1712 const bfd_target
*original
= (const bfd_target
*) data
;
1714 if (command_line
.endian
== ENDIAN_BIG
1715 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1718 if (command_line
.endian
== ENDIAN_LITTLE
1719 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1722 /* Must be the same flavour. */
1723 if (target
->flavour
!= original
->flavour
)
1726 /* If we have not found a potential winner yet, then record this one. */
1733 /* Oh dear, we now have two potential candidates for a successful match.
1734 Compare their names and choose the better one. */
1735 if (name_compare (target
->name
, original
->name
)
1736 > name_compare (winner
->name
, original
->name
))
1739 /* Keep on searching until wqe have checked them all. */
1743 /* Return the BFD target format of the first input file. */
1746 get_first_input_target ()
1748 char *target
= NULL
;
1750 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1752 if (s
->header
.type
== lang_input_statement_enum
1755 ldfile_open_file (s
);
1757 if (s
->the_bfd
!= NULL
1758 && bfd_check_format (s
->the_bfd
, bfd_object
))
1760 target
= bfd_get_target (s
->the_bfd
);
1771 /* Open the output file. */
1779 /* Has the user told us which output format to use? */
1780 if (output_target
== (char *) NULL
)
1782 /* No - has the current target been set to something other than
1784 if (current_target
!= default_target
)
1785 output_target
= current_target
;
1787 /* No - can we determine the format of the first input file? */
1790 output_target
= get_first_input_target ();
1792 /* Failed - use the default output target. */
1793 if (output_target
== NULL
)
1794 output_target
= default_target
;
1798 /* Has the user requested a particular endianness on the command
1800 if (command_line
.endian
!= ENDIAN_UNSET
)
1802 const bfd_target
*target
;
1803 enum bfd_endian desired_endian
;
1805 /* Get the chosen target. */
1806 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1808 /* If the target is not supported, we cannot do anything. */
1811 if (command_line
.endian
== ENDIAN_BIG
)
1812 desired_endian
= BFD_ENDIAN_BIG
;
1814 desired_endian
= BFD_ENDIAN_LITTLE
;
1816 /* See if the target has the wrong endianness. This should
1817 not happen if the linker script has provided big and
1818 little endian alternatives, but some scrips don't do
1820 if (target
->byteorder
!= desired_endian
)
1822 /* If it does, then see if the target provides
1823 an alternative with the correct endianness. */
1824 if (target
->alternative_target
!= NULL
1825 && (target
->alternative_target
->byteorder
== desired_endian
))
1826 output_target
= target
->alternative_target
->name
;
1829 /* Try to find a target as similar as possible to
1830 the default target, but which has the desired
1831 endian characteristic. */
1832 (void) bfd_search_for_target (closest_target_match
,
1835 /* Oh dear - we could not find any targets that
1836 satisfy our requirements. */
1838 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1840 output_target
= winner
->name
;
1846 output
= bfd_openw (name
, output_target
);
1848 if (output
== (bfd
*) NULL
)
1850 if (bfd_get_error () == bfd_error_invalid_target
)
1851 einfo (_("%P%F: target %s not found\n"), output_target
);
1853 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1856 delete_output_file_on_failure
= true;
1859 output
->flags
|= D_PAGED
;
1862 if (! bfd_set_format (output
, bfd_object
))
1863 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1864 if (! bfd_set_arch_mach (output
,
1865 ldfile_output_architecture
,
1866 ldfile_output_machine
))
1867 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1869 link_info
.hash
= bfd_link_hash_table_create (output
);
1870 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1871 einfo (_("%P%F: can not create link hash table: %E\n"));
1873 bfd_set_gp_size (output
, g_switch_value
);
1878 ldlang_open_output (statement
)
1879 lang_statement_union_type
*statement
;
1881 switch (statement
->header
.type
)
1883 case lang_output_statement_enum
:
1884 ASSERT (output_bfd
== (bfd
*) NULL
);
1885 output_bfd
= open_output (statement
->output_statement
.name
);
1886 ldemul_set_output_arch ();
1887 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1888 output_bfd
->flags
|= D_PAGED
;
1890 output_bfd
->flags
&= ~D_PAGED
;
1891 if (config
.text_read_only
)
1892 output_bfd
->flags
|= WP_TEXT
;
1894 output_bfd
->flags
&= ~WP_TEXT
;
1895 if (link_info
.traditional_format
)
1896 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1898 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1901 case lang_target_statement_enum
:
1902 current_target
= statement
->target_statement
.target
;
1909 /* Open all the input files. */
1912 open_input_bfds (s
, force
)
1913 lang_statement_union_type
*s
;
1916 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
1918 switch (s
->header
.type
)
1920 case lang_constructors_statement_enum
:
1921 open_input_bfds (constructor_list
.head
, force
);
1923 case lang_output_section_statement_enum
:
1924 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1926 case lang_wild_statement_enum
:
1927 /* Maybe we should load the file's symbols. */
1928 if (s
->wild_statement
.filename
1929 && ! wildcardp (s
->wild_statement
.filename
))
1930 (void) lookup_name (s
->wild_statement
.filename
);
1931 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1933 case lang_group_statement_enum
:
1935 struct bfd_link_hash_entry
*undefs
;
1937 /* We must continually search the entries in the group
1938 until no new symbols are added to the list of undefined
1943 undefs
= link_info
.hash
->undefs_tail
;
1944 open_input_bfds (s
->group_statement
.children
.head
, true);
1946 while (undefs
!= link_info
.hash
->undefs_tail
);
1949 case lang_target_statement_enum
:
1950 current_target
= s
->target_statement
.target
;
1952 case lang_input_statement_enum
:
1953 if (s
->input_statement
.real
)
1955 lang_statement_list_type add
;
1957 s
->input_statement
.target
= current_target
;
1959 /* If we are being called from within a group, and this
1960 is an archive which has already been searched, then
1961 force it to be researched unless the whole archive
1962 has been loaded already. */
1964 && !s
->input_statement
.whole_archive
1965 && s
->input_statement
.loaded
1966 && bfd_check_format (s
->input_statement
.the_bfd
,
1968 s
->input_statement
.loaded
= false;
1970 lang_list_init (&add
);
1972 if (! load_symbols (&s
->input_statement
, &add
))
1973 config
.make_executable
= false;
1975 if (add
.head
!= NULL
)
1977 *add
.tail
= s
->header
.next
;
1978 s
->header
.next
= add
.head
;
1988 /* If there are [COMMONS] statements, put a wild one into the bss
1992 lang_reasonable_defaults ()
1995 lang_output_section_statement_lookup (".text");
1996 lang_output_section_statement_lookup (".data");
1998 default_common_section
= lang_output_section_statement_lookup (".bss");
2000 if (placed_commons
== false)
2002 lang_wild_statement_type
*new =
2003 new_stat (lang_wild_statement
,
2004 &default_common_section
->children
);
2006 new->section_name
= "COMMON";
2007 new->filename
= (char *) NULL
;
2008 lang_list_init (&new->children
);
2013 /* Add the supplied name to the symbol table as an undefined reference.
2014 This is a two step process as the symbol table doesn't even exist at
2015 the time the ld command line is processed. First we put the name
2016 on a list, then, once the output file has been opened, transfer the
2017 name to the symbol table. */
2019 typedef struct ldlang_undef_chain_list
2021 struct ldlang_undef_chain_list
*next
;
2023 } ldlang_undef_chain_list_type
;
2025 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
2028 ldlang_add_undef (name
)
2029 const char *const name
;
2031 ldlang_undef_chain_list_type
*new =
2032 ((ldlang_undef_chain_list_type
*)
2033 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
2035 new->next
= ldlang_undef_chain_list_head
;
2036 ldlang_undef_chain_list_head
= new;
2038 new->name
= xstrdup (name
);
2040 if (output_bfd
!= NULL
)
2041 insert_undefined (new->name
);
2044 /* Insert NAME as undefined in the symbol table. */
2047 insert_undefined (name
)
2050 struct bfd_link_hash_entry
*h
;
2052 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, false, true);
2053 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2054 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2055 if (h
->type
== bfd_link_hash_new
)
2057 h
->type
= bfd_link_hash_undefined
;
2058 h
->u
.undef
.abfd
= NULL
;
2059 bfd_link_add_undef (link_info
.hash
, h
);
2063 /* Run through the list of undefineds created above and place them
2064 into the linker hash table as undefined symbols belonging to the
2068 lang_place_undefineds ()
2070 ldlang_undef_chain_list_type
*ptr
;
2072 for (ptr
= ldlang_undef_chain_list_head
;
2073 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
2076 insert_undefined (ptr
->name
);
2080 /* Open input files and attatch to output sections. */
2083 map_input_to_output_sections (s
, target
, output_section_statement
)
2084 lang_statement_union_type
*s
;
2086 lang_output_section_statement_type
*output_section_statement
;
2088 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2090 switch (s
->header
.type
)
2092 case lang_wild_statement_enum
:
2093 wild (&s
->wild_statement
, target
, output_section_statement
);
2095 case lang_constructors_statement_enum
:
2096 map_input_to_output_sections (constructor_list
.head
,
2098 output_section_statement
);
2100 case lang_output_section_statement_enum
:
2101 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2103 &s
->output_section_statement
);
2105 case lang_output_statement_enum
:
2107 case lang_target_statement_enum
:
2108 target
= s
->target_statement
.target
;
2110 case lang_group_statement_enum
:
2111 map_input_to_output_sections (s
->group_statement
.children
.head
,
2113 output_section_statement
);
2115 case lang_fill_statement_enum
:
2116 case lang_input_section_enum
:
2117 case lang_object_symbols_statement_enum
:
2118 case lang_data_statement_enum
:
2119 case lang_reloc_statement_enum
:
2120 case lang_padding_statement_enum
:
2121 case lang_input_statement_enum
:
2122 if (output_section_statement
!= NULL
2123 && output_section_statement
->bfd_section
== NULL
)
2124 init_os (output_section_statement
);
2126 case lang_assignment_statement_enum
:
2127 if (output_section_statement
!= NULL
2128 && output_section_statement
->bfd_section
== NULL
)
2129 init_os (output_section_statement
);
2131 /* Make sure that any sections mentioned in the assignment
2133 exp_init_os (s
->assignment_statement
.exp
);
2135 case lang_afile_asection_pair_statement_enum
:
2138 case lang_address_statement_enum
:
2139 /* Mark the specified section with the supplied address. */
2141 lang_output_section_statement_type
*os
=
2142 lang_output_section_statement_lookup
2143 (s
->address_statement
.section_name
);
2145 if (os
->bfd_section
== NULL
)
2147 os
->addr_tree
= s
->address_statement
.address
;
2155 print_output_section_statement (output_section_statement
)
2156 lang_output_section_statement_type
*output_section_statement
;
2158 asection
*section
= output_section_statement
->bfd_section
;
2161 if (output_section_statement
!= abs_output_section
)
2163 minfo ("\n%s", output_section_statement
->name
);
2165 if (section
!= NULL
)
2167 print_dot
= section
->vma
;
2169 len
= strlen (output_section_statement
->name
);
2170 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2175 while (len
< SECTION_NAME_MAP_LENGTH
)
2181 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2183 if (output_section_statement
->load_base
!= NULL
)
2187 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2188 "load base", lang_final_phase_enum
);
2189 minfo (_(" load address 0x%V"), addr
);
2196 print_statement_list (output_section_statement
->children
.head
,
2197 output_section_statement
);
2201 print_assignment (assignment
, output_section
)
2202 lang_assignment_statement_type
*assignment
;
2203 lang_output_section_statement_type
*output_section
;
2206 etree_value_type result
;
2208 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2211 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2212 lang_final_phase_enum
, print_dot
, &print_dot
);
2218 value
= result
.value
+ result
.section
->bfd_section
->vma
;
2219 dst
= assignment
->exp
->assign
.dst
;
2221 minfo ("0x%V", value
);
2222 if (dst
[0] == '.' && dst
[1] == 0)
2235 exp_print_tree (assignment
->exp
);
2241 print_input_statement (statm
)
2242 lang_input_statement_type
*statm
;
2244 if (statm
->filename
!= (char *) NULL
)
2246 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2250 /* Print all symbols defined in a particular section. This is called
2251 via bfd_link_hash_traverse. */
2254 print_one_symbol (hash_entry
, ptr
)
2255 struct bfd_link_hash_entry
*hash_entry
;
2258 asection
*sec
= (asection
*) ptr
;
2260 if ((hash_entry
->type
== bfd_link_hash_defined
2261 || hash_entry
->type
== bfd_link_hash_defweak
)
2262 && sec
== hash_entry
->u
.def
.section
)
2266 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2269 (hash_entry
->u
.def
.value
2270 + hash_entry
->u
.def
.section
->output_offset
2271 + hash_entry
->u
.def
.section
->output_section
->vma
));
2273 minfo (" %T\n", hash_entry
->root
.string
);
2279 /* Print information about an input section to the map file. */
2282 print_input_section (in
)
2283 lang_input_section_type
*in
;
2285 asection
*i
= in
->section
;
2286 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2287 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2288 ldfile_output_machine
);
2293 minfo ("%s", i
->name
);
2295 if (i
->output_section
!= NULL
)
2299 len
= 1 + strlen (i
->name
);
2300 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2305 while (len
< SECTION_NAME_MAP_LENGTH
)
2311 minfo ("0x%V %W %B\n",
2312 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2315 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2317 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2329 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2332 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2334 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2340 print_fill_statement (fill
)
2341 lang_fill_statement_type
*fill
;
2345 fputs (" FILL mask 0x", config
.map_file
);
2346 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
2347 fprintf (config
.map_file
, "%02x", *p
);
2348 fputs ("\n", config
.map_file
);
2352 print_data_statement (data
)
2353 lang_data_statement_type
*data
;
2359 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2360 ldfile_output_machine
);
2362 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2365 addr
= data
->output_vma
;
2366 if (data
->output_section
!= NULL
)
2367 addr
+= data
->output_section
->vma
;
2395 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2397 if (data
->exp
->type
.node_class
!= etree_value
)
2400 exp_print_tree (data
->exp
);
2405 print_dot
= addr
+ size
/ opb
;
2409 /* Print an address statement. These are generated by options like
2413 print_address_statement (address
)
2414 lang_address_statement_type
*address
;
2416 minfo (_("Address of section %s set to "), address
->section_name
);
2417 exp_print_tree (address
->address
);
2421 /* Print a reloc statement. */
2424 print_reloc_statement (reloc
)
2425 lang_reloc_statement_type
*reloc
;
2430 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2431 ldfile_output_machine
);
2433 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2436 addr
= reloc
->output_vma
;
2437 if (reloc
->output_section
!= NULL
)
2438 addr
+= reloc
->output_section
->vma
;
2440 size
= bfd_get_reloc_size (reloc
->howto
);
2442 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2444 if (reloc
->name
!= NULL
)
2445 minfo ("%s+", reloc
->name
);
2447 minfo ("%s+", reloc
->section
->name
);
2449 exp_print_tree (reloc
->addend_exp
);
2453 print_dot
= addr
+ size
/ opb
;
2457 print_padding_statement (s
)
2458 lang_padding_statement_type
*s
;
2462 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2463 ldfile_output_machine
);
2467 len
= sizeof " *fill*" - 1;
2468 while (len
< SECTION_NAME_MAP_LENGTH
)
2474 addr
= s
->output_offset
;
2475 if (s
->output_section
!= NULL
)
2476 addr
+= s
->output_section
->vma
;
2477 minfo ("0x%V %W ", addr
, s
->size
);
2479 if (s
->fill
->size
!= 0)
2483 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
2484 fprintf (config
.map_file
, "%02x", *p
);
2489 print_dot
= addr
+ s
->size
/ opb
;
2493 print_wild_statement (w
, os
)
2494 lang_wild_statement_type
*w
;
2495 lang_output_section_statement_type
*os
;
2497 struct wildcard_list
*sec
;
2501 if (w
->filenames_sorted
)
2503 if (w
->filename
!= NULL
)
2504 minfo ("%s", w
->filename
);
2507 if (w
->filenames_sorted
)
2511 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
2513 if (sec
->spec
.sorted
)
2515 if (sec
->spec
.exclude_name_list
!= NULL
)
2518 minfo ("EXCLUDE_FILE ( %s", sec
->spec
.exclude_name_list
->name
);
2519 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
2520 minfo (", %s", tmp
->name
);
2523 if (sec
->spec
.name
!= NULL
)
2524 minfo ("%s", sec
->spec
.name
);
2527 if (sec
->spec
.sorted
)
2534 print_statement_list (w
->children
.head
, os
);
2537 /* Print a group statement. */
2541 lang_group_statement_type
*s
;
2542 lang_output_section_statement_type
*os
;
2544 fprintf (config
.map_file
, "START GROUP\n");
2545 print_statement_list (s
->children
.head
, os
);
2546 fprintf (config
.map_file
, "END GROUP\n");
2549 /* Print the list of statements in S.
2550 This can be called for any statement type. */
2553 print_statement_list (s
, os
)
2554 lang_statement_union_type
*s
;
2555 lang_output_section_statement_type
*os
;
2559 print_statement (s
, os
);
2564 /* Print the first statement in statement list S.
2565 This can be called for any statement type. */
2568 print_statement (s
, os
)
2569 lang_statement_union_type
*s
;
2570 lang_output_section_statement_type
*os
;
2572 switch (s
->header
.type
)
2575 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2578 case lang_constructors_statement_enum
:
2579 if (constructor_list
.head
!= NULL
)
2581 if (constructors_sorted
)
2582 minfo (" SORT (CONSTRUCTORS)\n");
2584 minfo (" CONSTRUCTORS\n");
2585 print_statement_list (constructor_list
.head
, os
);
2588 case lang_wild_statement_enum
:
2589 print_wild_statement (&s
->wild_statement
, os
);
2591 case lang_address_statement_enum
:
2592 print_address_statement (&s
->address_statement
);
2594 case lang_object_symbols_statement_enum
:
2595 minfo (" CREATE_OBJECT_SYMBOLS\n");
2597 case lang_fill_statement_enum
:
2598 print_fill_statement (&s
->fill_statement
);
2600 case lang_data_statement_enum
:
2601 print_data_statement (&s
->data_statement
);
2603 case lang_reloc_statement_enum
:
2604 print_reloc_statement (&s
->reloc_statement
);
2606 case lang_input_section_enum
:
2607 print_input_section (&s
->input_section
);
2609 case lang_padding_statement_enum
:
2610 print_padding_statement (&s
->padding_statement
);
2612 case lang_output_section_statement_enum
:
2613 print_output_section_statement (&s
->output_section_statement
);
2615 case lang_assignment_statement_enum
:
2616 print_assignment (&s
->assignment_statement
, os
);
2618 case lang_target_statement_enum
:
2619 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2621 case lang_output_statement_enum
:
2622 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2623 if (output_target
!= NULL
)
2624 minfo (" %s", output_target
);
2627 case lang_input_statement_enum
:
2628 print_input_statement (&s
->input_statement
);
2630 case lang_group_statement_enum
:
2631 print_group (&s
->group_statement
, os
);
2633 case lang_afile_asection_pair_statement_enum
:
2642 print_statement_list (statement_list
.head
, abs_output_section
);
2645 /* Print the first N statements in statement list S to STDERR.
2646 If N == 0, nothing is printed.
2647 If N < 0, the entire list is printed.
2648 Intended to be called from GDB. */
2651 dprint_statement (s
, n
)
2652 lang_statement_union_type
*s
;
2655 FILE *map_save
= config
.map_file
;
2657 config
.map_file
= stderr
;
2660 print_statement_list (s
, abs_output_section
);
2663 while (s
&& --n
>= 0)
2665 print_statement (s
, abs_output_section
);
2670 config
.map_file
= map_save
;
2674 insert_pad (ptr
, fill
, alignment_needed
, output_section
, dot
)
2675 lang_statement_union_type
**ptr
;
2677 unsigned int alignment_needed
;
2678 asection
*output_section
;
2681 static fill_type zero_fill
= { 1, { 0 } };
2682 lang_statement_union_type
*pad
;
2684 pad
= ((lang_statement_union_type
*)
2685 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
2686 if (ptr
!= &statement_list
.head
2687 && pad
->header
.type
== lang_padding_statement_enum
2688 && pad
->padding_statement
.output_section
== output_section
)
2690 /* Use the existing pad statement. The above test on output
2691 section is probably redundant, but it doesn't hurt to check. */
2695 /* Make a new padding statement, linked into existing chain. */
2696 pad
= ((lang_statement_union_type
*)
2697 stat_alloc (sizeof (lang_padding_statement_type
)));
2698 pad
->header
.next
= *ptr
;
2700 pad
->header
.type
= lang_padding_statement_enum
;
2701 pad
->padding_statement
.output_section
= output_section
;
2702 if (fill
== (fill_type
*) 0)
2704 pad
->padding_statement
.fill
= fill
;
2706 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
2707 pad
->padding_statement
.size
= alignment_needed
;
2708 output_section
->_raw_size
+= alignment_needed
;
2711 /* Work out how much this section will move the dot point. */
2714 size_input_section (this_ptr
, output_section_statement
, fill
, dot
)
2715 lang_statement_union_type
**this_ptr
;
2716 lang_output_section_statement_type
*output_section_statement
;
2720 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2721 asection
*i
= is
->section
;
2723 if (is
->ifile
->just_syms_flag
== false)
2725 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2726 ldfile_output_machine
);
2727 unsigned int alignment_needed
;
2730 /* Align this section first to the input sections requirement,
2731 then to the output section's requirement. If this alignment
2732 is greater than any seen before, then record it too. Perform
2733 the alignment by inserting a magic 'padding' statement. */
2735 if (output_section_statement
->subsection_alignment
!= -1)
2736 i
->alignment_power
= output_section_statement
->subsection_alignment
;
2738 o
= output_section_statement
->bfd_section
;
2739 if (o
->alignment_power
< i
->alignment_power
)
2740 o
->alignment_power
= i
->alignment_power
;
2742 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
2744 if (alignment_needed
!= 0)
2746 insert_pad (this_ptr
, fill
, alignment_needed
* opb
, o
, dot
);
2747 dot
+= alignment_needed
;
2750 /* Remember where in the output section this input section goes. */
2752 i
->output_offset
= dot
- o
->vma
;
2754 /* Mark how big the output section must be to contain this now. */
2755 if (i
->_cooked_size
!= 0)
2756 dot
+= i
->_cooked_size
/ opb
;
2758 dot
+= i
->_raw_size
/ opb
;
2759 o
->_raw_size
= (dot
- o
->vma
) * opb
;
2763 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2769 #define IGNORE_SECTION(bfd, s) \
2770 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2771 != (SEC_ALLOC | SEC_LOAD)) \
2772 || bfd_section_size (bfd, s) == 0)
2774 /* Check to see if any allocated sections overlap with other allocated
2775 sections. This can happen when the linker script specifically specifies
2776 the output section addresses of the two sections. */
2779 lang_check_section_addresses ()
2782 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2784 /* Scan all sections in the output list. */
2785 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2789 /* Ignore sections which are not loaded or which have no contents. */
2790 if (IGNORE_SECTION (output_bfd
, s
))
2793 /* Once we reach section 's' stop our seach. This prevents two
2794 warning messages from being produced, one for 'section A overlaps
2795 section B' and one for 'section B overlaps section A'. */
2796 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2803 /* Only consider loadable sections with real contents. */
2804 if (IGNORE_SECTION (output_bfd
, os
))
2807 /* We must check the sections' LMA addresses not their
2808 VMA addresses because overlay sections can have
2809 overlapping VMAs but they must have distinct LMAs. */
2810 s_start
= bfd_section_lma (output_bfd
, s
);
2811 os_start
= bfd_section_lma (output_bfd
, os
);
2812 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2813 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2815 /* Look for an overlap. */
2816 if ((s_end
< os_start
) || (s_start
> os_end
))
2820 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2821 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2823 /* Once we have found one overlap for this section,
2824 stop looking for others. */
2830 /* Make sure the new address is within the region. We explicitly permit the
2831 current address to be at the exact end of the region when the address is
2832 non-zero, in case the region is at the end of addressable memory and the
2833 calculation wraps around. */
2836 os_region_check (os
, region
, tree
, base
)
2837 lang_output_section_statement_type
*os
;
2838 struct memory_region_struct
*region
;
2842 if ((region
->current
< region
->origin
2843 || (region
->current
- region
->origin
> region
->length
))
2844 && ((region
->current
!= region
->origin
+ region
->length
)
2847 if (tree
!= (etree_type
*) NULL
)
2849 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2851 os
->bfd_section
->owner
,
2852 os
->bfd_section
->name
,
2857 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2859 os
->bfd_section
->owner
,
2860 os
->bfd_section
->name
);
2862 /* Reset the region pointer. */
2863 region
->current
= region
->origin
;
2867 /* Set the sizes for all the output sections. */
2870 lang_size_sections_1 (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2871 lang_statement_union_type
*s
;
2872 lang_output_section_statement_type
*output_section_statement
;
2873 lang_statement_union_type
**prev
;
2878 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2879 ldfile_output_machine
);
2881 /* Size up the sections from their constituent parts. */
2882 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2884 switch (s
->header
.type
)
2886 case lang_output_section_statement_enum
:
2889 lang_output_section_statement_type
*os
;
2891 os
= &s
->output_section_statement
;
2892 if (os
->bfd_section
== NULL
)
2893 /* This section was never actually created. */
2896 /* If this is a COFF shared library section, use the size and
2897 address from the input section. FIXME: This is COFF
2898 specific; it would be cleaner if there were some other way
2899 to do this, but nothing simple comes to mind. */
2900 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2904 if (os
->children
.head
== NULL
2905 || os
->children
.head
->header
.next
!= NULL
2906 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2907 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2910 input
= os
->children
.head
->input_section
.section
;
2911 bfd_set_section_vma (os
->bfd_section
->owner
,
2913 bfd_section_vma (input
->owner
, input
));
2914 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2918 if (bfd_is_abs_section (os
->bfd_section
))
2920 /* No matter what happens, an abs section starts at zero. */
2921 ASSERT (os
->bfd_section
->vma
== 0);
2925 if (os
->addr_tree
== (etree_type
*) NULL
)
2927 /* No address specified for this section, get one
2928 from the region specification. */
2929 if (os
->region
== (lang_memory_region_type
*) NULL
2930 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2931 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2932 && os
->region
->name
[0] == '*'
2933 && strcmp (os
->region
->name
, "*default*") == 0))
2935 os
->region
= lang_memory_default (os
->bfd_section
);
2938 /* If a loadable section is using the default memory
2939 region, and some non default memory regions were
2940 defined, issue a warning. */
2941 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2942 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2943 && (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2944 & SEC_NEVER_LOAD
) == 0
2945 && ! link_info
.relocateable
2946 && strcmp (os
->region
->name
, "*default*") == 0
2947 && lang_memory_region_list
!= NULL
2948 && (strcmp (lang_memory_region_list
->name
,
2950 || lang_memory_region_list
->next
!= NULL
))
2951 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2952 bfd_get_section_name (output_bfd
,
2955 dot
= os
->region
->current
;
2957 if (os
->section_alignment
== -1)
2962 dot
= align_power (dot
,
2963 os
->bfd_section
->alignment_power
);
2965 if (dot
!= olddot
&& config
.warn_section_align
)
2966 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2967 os
->name
, (unsigned int) (dot
- olddot
));
2974 r
= exp_fold_tree (os
->addr_tree
,
2976 lang_allocating_phase_enum
,
2978 if (r
.valid_p
== false)
2980 einfo (_("%F%S: non constant address expression for section %s\n"),
2983 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2986 /* The section starts here.
2987 First, align to what the section needs. */
2989 if (os
->section_alignment
!= -1)
2990 dot
= align_power (dot
, os
->section_alignment
);
2992 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2994 os
->bfd_section
->output_offset
= 0;
2997 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
2998 os
->fill
, dot
, relax
);
3000 /* Put the section within the requested block size, or
3001 align at the block boundary. */
3002 after
= ALIGN_N (os
->bfd_section
->vma
3003 + os
->bfd_section
->_raw_size
/ opb
,
3004 /* The coercion here is important, see ld.h. */
3005 (bfd_vma
) os
->block_value
);
3007 if (bfd_is_abs_section (os
->bfd_section
))
3008 ASSERT (after
== os
->bfd_section
->vma
);
3010 os
->bfd_section
->_raw_size
=
3011 (after
- os
->bfd_section
->vma
) * opb
;
3012 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3013 os
->processed
= true;
3015 /* Update dot in the region ?
3016 We only do this if the section is going to be allocated,
3017 since unallocated sections do not contribute to the region's
3018 overall size in memory.
3020 If the SEC_NEVER_LOAD bit is not set, it will affect the
3021 addresses of sections after it. We have to update
3023 if (os
->region
!= (lang_memory_region_type
*) NULL
3024 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3025 & SEC_NEVER_LOAD
) == 0
3026 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3027 & (SEC_ALLOC
| SEC_LOAD
))))
3029 os
->region
->current
= dot
;
3031 /* Make sure the new address is within the region. */
3032 os_region_check (os
, os
->region
, os
->addr_tree
,
3033 os
->bfd_section
->vma
);
3035 /* If there's no load address specified, use the run
3036 region as the load region. */
3037 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
3038 os
->lma_region
= os
->region
;
3040 if (os
->lma_region
!= NULL
)
3042 if (os
->load_base
!= NULL
)
3044 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
3048 /* Don't allocate twice. */
3049 if (os
->lma_region
!= os
->region
)
3051 /* Set load_base, which will be handled later. */
3053 exp_intop (os
->lma_region
->current
);
3054 os
->lma_region
->current
+=
3055 os
->bfd_section
->_raw_size
/ opb
;
3056 os_region_check (os
, os
->lma_region
, NULL
,
3057 os
->bfd_section
->lma
);
3065 case lang_constructors_statement_enum
:
3066 dot
= lang_size_sections_1 (constructor_list
.head
,
3067 output_section_statement
,
3068 &s
->wild_statement
.children
.head
,
3072 case lang_data_statement_enum
:
3074 unsigned int size
= 0;
3076 s
->data_statement
.output_vma
=
3077 dot
- output_section_statement
->bfd_section
->vma
;
3078 s
->data_statement
.output_section
=
3079 output_section_statement
->bfd_section
;
3081 switch (s
->data_statement
.type
)
3102 output_section_statement
->bfd_section
->_raw_size
+= size
;
3103 /* The output section gets contents, and then we inspect for
3104 any flags set in the input script which override any ALLOC. */
3105 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3106 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3108 output_section_statement
->bfd_section
->flags
|=
3109 SEC_ALLOC
| SEC_LOAD
;
3114 case lang_reloc_statement_enum
:
3118 s
->reloc_statement
.output_vma
=
3119 dot
- output_section_statement
->bfd_section
->vma
;
3120 s
->reloc_statement
.output_section
=
3121 output_section_statement
->bfd_section
;
3122 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3124 output_section_statement
->bfd_section
->_raw_size
+= size
;
3128 case lang_wild_statement_enum
:
3130 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
3131 output_section_statement
,
3132 &s
->wild_statement
.children
.head
,
3137 case lang_object_symbols_statement_enum
:
3138 link_info
.create_object_symbols_section
=
3139 output_section_statement
->bfd_section
;
3141 case lang_output_statement_enum
:
3142 case lang_target_statement_enum
:
3144 case lang_input_section_enum
:
3148 i
= (*prev
)->input_section
.section
;
3151 if (i
->_cooked_size
== 0)
3152 i
->_cooked_size
= i
->_raw_size
;
3158 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3159 einfo (_("%P%F: can't relax section: %E\n"));
3163 dot
= size_input_section (prev
, output_section_statement
,
3164 output_section_statement
->fill
, dot
);
3167 case lang_input_statement_enum
:
3169 case lang_fill_statement_enum
:
3170 s
->fill_statement
.output_section
=
3171 output_section_statement
->bfd_section
;
3173 fill
= s
->fill_statement
.fill
;
3175 case lang_assignment_statement_enum
:
3177 bfd_vma newdot
= dot
;
3179 exp_fold_tree (s
->assignment_statement
.exp
,
3180 output_section_statement
,
3181 lang_allocating_phase_enum
,
3187 if (output_section_statement
== abs_output_section
)
3189 /* If we don't have an output section, then just adjust
3190 the default memory address. */
3191 lang_memory_region_lookup ("*default*")->current
= newdot
;
3195 /* Insert a pad after this statement. We can't
3196 put the pad before when relaxing, in case the
3197 assignment references dot. */
3198 insert_pad (&s
->header
.next
, fill
, (newdot
- dot
) * opb
,
3199 output_section_statement
->bfd_section
, dot
);
3201 /* Don't neuter the pad below when relaxing. */
3210 case lang_padding_statement_enum
:
3211 /* If this is the first time lang_size_sections is called,
3212 we won't have any padding statements. If this is the
3213 second or later passes when relaxing, we should allow
3214 padding to shrink. If padding is needed on this pass, it
3215 will be added back in. */
3216 s
->padding_statement
.size
= 0;
3218 /* Make sure output_offset is valid. If relaxation shrinks
3219 the section and this pad isn't needed, it's possible to
3220 have output_offset larger than the final size of the
3221 section. bfd_set_section_contents will complain even for
3222 a pad size of zero. */
3223 s
->padding_statement
.output_offset
3224 = dot
- output_section_statement
->bfd_section
->vma
;
3227 case lang_group_statement_enum
:
3228 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
3229 output_section_statement
,
3230 &s
->group_statement
.children
.head
,
3238 /* We can only get here when relaxing is turned on. */
3239 case lang_address_statement_enum
:
3242 prev
= &s
->header
.next
;
3248 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
3249 lang_statement_union_type
*s
;
3250 lang_output_section_statement_type
*output_section_statement
;
3251 lang_statement_union_type
**prev
;
3258 exp_data_seg
.phase
= exp_dataseg_none
;
3259 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
3261 if (exp_data_seg
.phase
== exp_dataseg_end_seen
)
3263 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3264 a page could be saved in the data segment. */
3265 bfd_vma first
, last
;
3267 first
= -exp_data_seg
.base
& (exp_data_seg
.pagesize
- 1);
3268 last
= exp_data_seg
.end
& (exp_data_seg
.pagesize
- 1);
3270 && ((exp_data_seg
.base
& ~(exp_data_seg
.pagesize
- 1))
3271 != (exp_data_seg
.end
& ~(exp_data_seg
.pagesize
- 1)))
3272 && first
+ last
<= exp_data_seg
.pagesize
)
3274 exp_data_seg
.phase
= exp_dataseg_adjust
;
3275 result
= lang_size_sections_1 (s
, output_section_statement
, prev
,
3284 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3285 lang_statement_union_type
*s
;
3286 lang_output_section_statement_type
*output_section_statement
;
3290 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3291 ldfile_output_machine
);
3293 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3295 switch (s
->header
.type
)
3297 case lang_constructors_statement_enum
:
3298 dot
= lang_do_assignments (constructor_list
.head
,
3299 output_section_statement
,
3304 case lang_output_section_statement_enum
:
3306 lang_output_section_statement_type
*os
;
3308 os
= &(s
->output_section_statement
);
3309 if (os
->bfd_section
!= NULL
)
3311 dot
= os
->bfd_section
->vma
;
3312 (void) lang_do_assignments (os
->children
.head
, os
,
3314 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3319 /* If nothing has been placed into the output section then
3320 it won't have a bfd_section. */
3321 if (os
->bfd_section
)
3323 os
->bfd_section
->lma
3324 = exp_get_abs_int (os
->load_base
, 0, "load base",
3325 lang_final_phase_enum
);
3330 case lang_wild_statement_enum
:
3332 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3333 output_section_statement
,
3338 case lang_object_symbols_statement_enum
:
3339 case lang_output_statement_enum
:
3340 case lang_target_statement_enum
:
3342 case lang_common_statement_enum
:
3345 case lang_data_statement_enum
:
3347 etree_value_type value
;
3349 value
= exp_fold_tree (s
->data_statement
.exp
,
3351 lang_final_phase_enum
, dot
, &dot
);
3352 s
->data_statement
.value
= value
.value
;
3353 if (value
.valid_p
== false)
3354 einfo (_("%F%P: invalid data statement\n"));
3358 switch (s
->data_statement
.type
)
3382 case lang_reloc_statement_enum
:
3384 etree_value_type value
;
3386 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3388 lang_final_phase_enum
, dot
, &dot
);
3389 s
->reloc_statement
.addend_value
= value
.value
;
3390 if (value
.valid_p
== false)
3391 einfo (_("%F%P: invalid reloc statement\n"));
3393 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3396 case lang_input_section_enum
:
3398 asection
*in
= s
->input_section
.section
;
3400 if (in
->_cooked_size
!= 0)
3401 dot
+= in
->_cooked_size
/ opb
;
3403 dot
+= in
->_raw_size
/ opb
;
3407 case lang_input_statement_enum
:
3409 case lang_fill_statement_enum
:
3410 fill
= s
->fill_statement
.fill
;
3412 case lang_assignment_statement_enum
:
3414 exp_fold_tree (s
->assignment_statement
.exp
,
3415 output_section_statement
,
3416 lang_final_phase_enum
,
3422 case lang_padding_statement_enum
:
3423 dot
+= s
->padding_statement
.size
/ opb
;
3426 case lang_group_statement_enum
:
3427 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3428 output_section_statement
,
3436 case lang_address_statement_enum
:
3444 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3445 operator .startof. (section_name), it produces an undefined symbol
3446 .startof.section_name. Similarly, when it sees
3447 .sizeof. (section_name), it produces an undefined symbol
3448 .sizeof.section_name. For all the output sections, we look for
3449 such symbols, and set them to the correct value. */
3456 if (link_info
.relocateable
)
3459 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3461 const char *secname
;
3463 struct bfd_link_hash_entry
*h
;
3465 secname
= bfd_get_section_name (output_bfd
, s
);
3466 buf
= xmalloc (10 + strlen (secname
));
3468 sprintf (buf
, ".startof.%s", secname
);
3469 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3470 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3472 h
->type
= bfd_link_hash_defined
;
3473 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3474 h
->u
.def
.section
= bfd_abs_section_ptr
;
3477 sprintf (buf
, ".sizeof.%s", secname
);
3478 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3479 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3483 opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3484 ldfile_output_machine
);
3485 h
->type
= bfd_link_hash_defined
;
3486 if (s
->_cooked_size
!= 0)
3487 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3489 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3490 h
->u
.def
.section
= bfd_abs_section_ptr
;
3500 struct bfd_link_hash_entry
*h
;
3503 if (link_info
.relocateable
|| link_info
.shared
)
3508 if (entry_symbol
== (char *) NULL
)
3510 /* No entry has been specified. Look for start, but don't warn
3511 if we don't find it. */
3512 entry_symbol
= "start";
3516 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
3517 if (h
!= (struct bfd_link_hash_entry
*) NULL
3518 && (h
->type
== bfd_link_hash_defined
3519 || h
->type
== bfd_link_hash_defweak
)
3520 && h
->u
.def
.section
->output_section
!= NULL
)
3524 val
= (h
->u
.def
.value
3525 + bfd_get_section_vma (output_bfd
,
3526 h
->u
.def
.section
->output_section
)
3527 + h
->u
.def
.section
->output_offset
);
3528 if (! bfd_set_start_address (output_bfd
, val
))
3529 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
);
3536 /* We couldn't find the entry symbol. Try parsing it as a
3538 val
= bfd_scan_vma (entry_symbol
, &send
, 0);
3541 if (! bfd_set_start_address (output_bfd
, val
))
3542 einfo (_("%P%F: can't set start address\n"));
3548 /* Can't find the entry symbol, and it's not a number. Use
3549 the first address in the text section. */
3550 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
3551 if (ts
!= (asection
*) NULL
)
3554 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3555 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
3556 if (! bfd_set_start_address (output_bfd
,
3557 bfd_get_section_vma (output_bfd
,
3559 einfo (_("%P%F: can't set start address\n"));
3564 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3571 /* This is a small function used when we want to ignore errors from
3575 #ifdef ANSI_PROTOTYPES
3576 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3578 ignore_bfd_errors (s
)
3579 const char *s ATTRIBUTE_UNUSED
;
3582 /* Don't do anything. */
3585 /* Check that the architecture of all the input files is compatible
3586 with the output file. Also call the backend to let it do any
3587 other checking that is needed. */
3592 lang_statement_union_type
*file
;
3594 const bfd_arch_info_type
*compatible
;
3596 for (file
= file_chain
.head
;
3597 file
!= (lang_statement_union_type
*) NULL
;
3598 file
= file
->input_statement
.next
)
3600 input_bfd
= file
->input_statement
.the_bfd
;
3601 compatible
= bfd_arch_get_compatible (input_bfd
, output_bfd
);
3603 /* In general it is not possible to perform a relocatable
3604 link between differing object formats when the input
3605 file has relocations, because the relocations in the
3606 input format may not have equivalent representations in
3607 the output format (and besides BFD does not translate
3608 relocs for other link purposes than a final link). */
3609 if ((link_info
.relocateable
|| link_info
.emitrelocations
)
3610 && (compatible
== NULL
3611 || bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
3612 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
3614 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3615 bfd_get_target (input_bfd
), input_bfd
,
3616 bfd_get_target (output_bfd
), output_bfd
);
3617 /* einfo with %F exits. */
3620 if (compatible
== NULL
)
3622 if (command_line
.warn_mismatch
)
3623 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3624 bfd_printable_name (input_bfd
), input_bfd
,
3625 bfd_printable_name (output_bfd
));
3627 else if (bfd_count_sections (input_bfd
))
3629 /* If the input bfd has no contents, it shouldn't set the
3630 private data of the output bfd. */
3632 bfd_error_handler_type pfn
= NULL
;
3634 /* If we aren't supposed to warn about mismatched input
3635 files, temporarily set the BFD error handler to a
3636 function which will do nothing. We still want to call
3637 bfd_merge_private_bfd_data, since it may set up
3638 information which is needed in the output file. */
3639 if (! command_line
.warn_mismatch
)
3640 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3641 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3643 if (command_line
.warn_mismatch
)
3644 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3647 if (! command_line
.warn_mismatch
)
3648 bfd_set_error_handler (pfn
);
3653 /* Look through all the global common symbols and attach them to the
3654 correct section. The -sort-common command line switch may be used
3655 to roughly sort the entries by size. */
3660 if (command_line
.inhibit_common_definition
)
3662 if (link_info
.relocateable
3663 && ! command_line
.force_common_definition
)
3666 if (! config
.sort_common
)
3667 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3672 for (power
= 4; power
>= 0; power
--)
3673 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3678 /* Place one common symbol in the correct section. */
3681 lang_one_common (h
, info
)
3682 struct bfd_link_hash_entry
*h
;
3685 unsigned int power_of_two
;
3688 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3689 ldfile_output_machine
);
3691 if (h
->type
!= bfd_link_hash_common
)
3695 power_of_two
= h
->u
.c
.p
->alignment_power
;
3697 if (config
.sort_common
3698 && power_of_two
< (unsigned int) *(int *) info
)
3701 section
= h
->u
.c
.p
->section
;
3703 /* Increase the size of the section. */
3704 section
->_cooked_size
= ALIGN_N ((section
->_cooked_size
+ opb
- 1) / opb
,
3705 (bfd_size_type
) (1 << power_of_two
)) * opb
;
3707 /* Adjust the alignment if necessary. */
3708 if (power_of_two
> section
->alignment_power
)
3709 section
->alignment_power
= power_of_two
;
3711 /* Change the symbol from common to defined. */
3712 h
->type
= bfd_link_hash_defined
;
3713 h
->u
.def
.section
= section
;
3714 h
->u
.def
.value
= section
->_cooked_size
;
3716 /* Increase the size of the section. */
3717 section
->_cooked_size
+= size
;
3719 /* Make sure the section is allocated in memory, and make sure that
3720 it is no longer a common section. */
3721 section
->flags
|= SEC_ALLOC
;
3722 section
->flags
&= ~SEC_IS_COMMON
;
3724 if (config
.map_file
!= NULL
)
3726 static boolean header_printed
;
3731 if (! header_printed
)
3733 minfo (_("\nAllocating common symbols\n"));
3734 minfo (_("Common symbol size file\n\n"));
3735 header_printed
= true;
3738 name
= demangle (h
->root
.string
);
3740 len
= strlen (name
);
3755 if (size
<= 0xffffffff)
3756 sprintf (buf
, "%lx", (unsigned long) size
);
3758 sprintf_vma (buf
, size
);
3768 minfo ("%B\n", section
->owner
);
3774 /* Run through the input files and ensure that every input section has
3775 somewhere to go. If one is found without a destination then create
3776 an input request and place it into the statement tree. */
3779 lang_place_orphans ()
3781 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3785 for (s
= file
->the_bfd
->sections
;
3786 s
!= (asection
*) NULL
;
3789 if (s
->output_section
== (asection
*) NULL
)
3791 /* This section of the file is not attatched, root
3792 around for a sensible place for it to go. */
3794 if (file
->just_syms_flag
)
3796 /* We are only retrieving symbol values from this
3797 file. We want the symbols to act as though the
3798 values in the file are absolute. */
3799 s
->output_section
= bfd_abs_section_ptr
;
3800 s
->output_offset
= s
->vma
;
3802 else if (strcmp (s
->name
, "COMMON") == 0)
3804 /* This is a lonely common section which must have
3805 come from an archive. We attach to the section
3806 with the wildcard. */
3807 if (! link_info
.relocateable
3808 || command_line
.force_common_definition
)
3810 if (default_common_section
== NULL
)
3813 /* This message happens when using the
3814 svr3.ifile linker script, so I have
3816 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3818 default_common_section
=
3819 lang_output_section_statement_lookup (".bss");
3822 lang_add_section (&default_common_section
->children
, s
,
3823 default_common_section
, file
);
3826 else if (ldemul_place_orphan (file
, s
))
3830 lang_output_section_statement_type
*os
;
3832 os
= lang_output_section_statement_lookup (s
->name
);
3833 lang_add_section (&os
->children
, s
, os
, file
);
3841 lang_set_flags (ptr
, flags
, invert
)
3842 lang_memory_region_type
*ptr
;
3846 flagword
*ptr_flags
;
3848 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3854 *ptr_flags
|= SEC_ALLOC
;
3858 *ptr_flags
|= SEC_READONLY
;
3862 *ptr_flags
|= SEC_DATA
;
3866 *ptr_flags
|= SEC_CODE
;
3871 *ptr_flags
|= SEC_LOAD
;
3875 einfo (_("%P%F: invalid syntax in flags\n"));
3882 /* Call a function on each input file. This function will be called
3883 on an archive, but not on the elements. */
3886 lang_for_each_input_file (func
)
3887 void (*func
) PARAMS ((lang_input_statement_type
*));
3889 lang_input_statement_type
*f
;
3891 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3893 f
= (lang_input_statement_type
*) f
->next_real_file
)
3897 /* Call a function on each file. The function will be called on all
3898 the elements of an archive which are included in the link, but will
3899 not be called on the archive file itself. */
3902 lang_for_each_file (func
)
3903 void (*func
) PARAMS ((lang_input_statement_type
*));
3905 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3916 lang_for_each_input_section (func
)
3917 void (*func
) PARAMS ((bfd
*ab
, asection
*as
));
3919 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3923 for (s
= f
->the_bfd
->sections
;
3924 s
!= (asection
*) NULL
;
3927 func (f
->the_bfd
, s
);
3935 ldlang_add_file (entry
)
3936 lang_input_statement_type
*entry
;
3940 lang_statement_append (&file_chain
,
3941 (lang_statement_union_type
*) entry
,
3944 /* The BFD linker needs to have a list of all input BFDs involved in
3946 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3947 ASSERT (entry
->the_bfd
!= output_bfd
);
3948 for (pp
= &link_info
.input_bfds
;
3949 *pp
!= (bfd
*) NULL
;
3950 pp
= &(*pp
)->link_next
)
3952 *pp
= entry
->the_bfd
;
3953 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3954 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3956 /* Look through the sections and check for any which should not be
3957 included in the link. We need to do this now, so that we can
3958 notice when the backend linker tries to report multiple
3959 definition errors for symbols which are in sections we aren't
3960 going to link. FIXME: It might be better to entirely ignore
3961 symbols which are defined in sections which are going to be
3962 discarded. This would require modifying the backend linker for
3963 each backend which might set the SEC_LINK_ONCE flag. If we do
3964 this, we should probably handle SEC_EXCLUDE in the same way. */
3966 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
3970 lang_add_output (name
, from_script
)
3974 /* Make -o on command line override OUTPUT in script. */
3975 if (had_output_filename
== false || !from_script
)
3977 output_filename
= name
;
3978 had_output_filename
= true;
3982 static lang_output_section_statement_type
*current_section
;
3994 for (l
= 0; l
< 32; l
++)
3996 if (i
>= (unsigned int) x
)
4004 lang_output_section_statement_type
*
4005 lang_enter_output_section_statement (output_section_statement_name
,
4006 address_exp
, sectype
, block_value
,
4007 align
, subalign
, ebase
)
4008 const char *output_section_statement_name
;
4009 etree_type
*address_exp
;
4010 enum section_type sectype
;
4011 bfd_vma block_value
;
4013 etree_type
*subalign
;
4016 lang_output_section_statement_type
*os
;
4020 lang_output_section_statement_lookup (output_section_statement_name
);
4022 /* Add this statement to tree. */
4024 add_statement (lang_output_section_statement_enum
,
4025 output_section_statement
);
4027 /* Make next things chain into subchain of this. */
4029 if (os
->addr_tree
== (etree_type
*) NULL
)
4031 os
->addr_tree
= address_exp
;
4033 os
->sectype
= sectype
;
4034 if (sectype
!= noload_section
)
4035 os
->flags
= SEC_NO_FLAGS
;
4037 os
->flags
= SEC_NEVER_LOAD
;
4038 os
->block_value
= block_value
? block_value
: 1;
4039 stat_ptr
= &os
->children
;
4041 os
->subsection_alignment
=
4042 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
4043 os
->section_alignment
=
4044 topower (exp_get_value_int (align
, -1, "section alignment", 0));
4046 os
->load_base
= ebase
;
4053 lang_output_statement_type
*new =
4054 new_stat (lang_output_statement
, stat_ptr
);
4056 new->name
= output_filename
;
4059 /* Reset the current counters in the regions. */
4062 lang_reset_memory_regions ()
4064 lang_memory_region_type
*p
= lang_memory_region_list
;
4067 for (p
= lang_memory_region_list
;
4068 p
!= (lang_memory_region_type
*) NULL
;
4071 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
4072 p
->current
= p
->origin
;
4075 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4079 /* If the wild pattern was marked KEEP, the member sections
4080 should be as well. */
4083 gc_section_callback (ptr
, sec
, section
, file
, data
)
4084 lang_wild_statement_type
*ptr
;
4085 struct wildcard_list
*sec ATTRIBUTE_UNUSED
;
4087 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
4088 PTR data ATTRIBUTE_UNUSED
;
4090 if (ptr
->keep_sections
)
4091 section
->flags
|= SEC_KEEP
;
4094 /* Handle a wild statement, marking it against GC. */
4098 lang_wild_statement_type
*s
;
4100 walk_wild (s
, gc_section_callback
, NULL
);
4103 /* Iterate over sections marking them against GC. */
4106 lang_gc_sections_1 (s
)
4107 lang_statement_union_type
*s
;
4109 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
4111 switch (s
->header
.type
)
4113 case lang_wild_statement_enum
:
4114 lang_gc_wild (&s
->wild_statement
);
4116 case lang_constructors_statement_enum
:
4117 lang_gc_sections_1 (constructor_list
.head
);
4119 case lang_output_section_statement_enum
:
4120 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4122 case lang_group_statement_enum
:
4123 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4134 struct bfd_link_hash_entry
*h
;
4135 ldlang_undef_chain_list_type
*ulist
, fake_list_start
;
4137 /* Keep all sections so marked in the link script. */
4139 lang_gc_sections_1 (statement_list
.head
);
4141 /* Keep all sections containing symbols undefined on the command-line.
4142 Handle the entry symbol at the same time. */
4144 if (entry_symbol
!= NULL
)
4146 fake_list_start
.next
= ldlang_undef_chain_list_head
;
4147 fake_list_start
.name
= (char *) entry_symbol
;
4148 ulist
= &fake_list_start
;
4151 ulist
= ldlang_undef_chain_list_head
;
4153 for (; ulist
; ulist
= ulist
->next
)
4155 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4156 false, false, false);
4158 if (h
!= (struct bfd_link_hash_entry
*) NULL
4159 && (h
->type
== bfd_link_hash_defined
4160 || h
->type
== bfd_link_hash_defweak
)
4161 && ! bfd_is_abs_section (h
->u
.def
.section
))
4163 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4167 bfd_gc_sections (output_bfd
, &link_info
);
4173 lang_reasonable_defaults ();
4174 current_target
= default_target
;
4176 /* Open the output file. */
4177 lang_for_each_statement (ldlang_open_output
);
4179 ldemul_create_output_section_statements ();
4181 /* Add to the hash table all undefineds on the command line. */
4182 lang_place_undefineds ();
4184 already_linked_table_init ();
4186 /* Create a bfd for each input file. */
4187 current_target
= default_target
;
4188 open_input_bfds (statement_list
.head
, false);
4190 ldemul_after_open ();
4192 already_linked_table_free ();
4194 /* Make sure that we're not mixing architectures. We call this
4195 after all the input files have been opened, but before we do any
4196 other processing, so that any operations merge_private_bfd_data
4197 does on the output file will be known during the rest of the
4201 /* Handle .exports instead of a version script if we're told to do so. */
4202 if (command_line
.version_exports_section
)
4203 lang_do_version_exports_section ();
4205 /* Build all sets based on the information gathered from the input
4207 ldctor_build_sets ();
4209 /* Remove unreferenced sections if asked to. */
4210 if (command_line
.gc_sections
)
4211 lang_gc_sections ();
4213 /* If there were any SEC_MERGE sections, finish their merging, so that
4214 section sizes can be computed. This has to be done after GC of sections,
4215 so that GCed sections are not merged, but before assigning output
4216 sections, since removing whole input sections is hard then. */
4217 bfd_merge_sections (output_bfd
, &link_info
);
4219 /* Size up the common data. */
4222 /* Run through the contours of the script and attach input sections
4223 to the correct output sections. */
4224 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4225 (lang_output_section_statement_type
*) NULL
);
4227 /* Find any sections not attached explicitly and handle them. */
4228 lang_place_orphans ();
4230 if (! link_info
.relocateable
)
4232 /* Look for a text section and set the readonly attribute in it. */
4233 asection
*found
= bfd_get_section_by_name (output_bfd
, ".text");
4235 if (found
!= (asection
*) NULL
)
4237 if (config
.text_read_only
)
4238 found
->flags
|= SEC_READONLY
;
4240 found
->flags
&= ~SEC_READONLY
;
4244 /* Do anything special before sizing sections. This is where ELF
4245 and other back-ends size dynamic sections. */
4246 ldemul_before_allocation ();
4248 /* We must record the program headers before we try to fix the
4249 section positions, since they will affect SIZEOF_HEADERS. */
4250 lang_record_phdrs ();
4252 /* Size up the sections. */
4253 lang_size_sections (statement_list
.head
,
4255 &statement_list
.head
, 0, (bfd_vma
) 0, NULL
);
4257 /* Now run around and relax if we can. */
4258 if (command_line
.relax
)
4260 /* Keep relaxing until bfd_relax_section gives up. */
4261 boolean relax_again
;
4265 lang_reset_memory_regions ();
4267 relax_again
= false;
4269 /* Note: pe-dll.c does something like this also. If you find
4270 you need to change this code, you probably need to change
4271 pe-dll.c also. DJ */
4273 /* Do all the assignments with our current guesses as to
4275 lang_do_assignments (statement_list
.head
,
4277 (fill_type
*) 0, (bfd_vma
) 0);
4279 /* Perform another relax pass - this time we know where the
4280 globals are, so can make better guess. */
4281 lang_size_sections (statement_list
.head
,
4283 &(statement_list
.head
), 0, (bfd_vma
) 0,
4286 while (relax_again
);
4289 /* See if anything special should be done now we know how big
4291 ldemul_after_allocation ();
4293 /* Fix any .startof. or .sizeof. symbols. */
4294 lang_set_startof ();
4296 /* Do all the assignments, now that we know the final resting places
4297 of all the symbols. */
4299 lang_do_assignments (statement_list
.head
,
4301 (fill_type
*) 0, (bfd_vma
) 0);
4303 /* Make sure that the section addresses make sense. */
4304 if (! link_info
.relocateable
4305 && command_line
.check_section_addresses
)
4306 lang_check_section_addresses ();
4314 /* EXPORTED TO YACC */
4317 lang_add_wild (filespec
, section_list
, keep_sections
)
4318 struct wildcard_spec
*filespec
;
4319 struct wildcard_list
*section_list
;
4320 boolean keep_sections
;
4322 struct wildcard_list
*curr
, *next
;
4323 lang_wild_statement_type
*new;
4325 /* Reverse the list as the parser puts it back to front. */
4326 for (curr
= section_list
, section_list
= NULL
;
4328 section_list
= curr
, curr
= next
)
4330 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
4331 placed_commons
= true;
4334 curr
->next
= section_list
;
4337 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
4339 if (strcmp (filespec
->name
, "*") == 0)
4340 filespec
->name
= NULL
;
4341 else if (! wildcardp (filespec
->name
))
4342 lang_has_input_file
= true;
4345 new = new_stat (lang_wild_statement
, stat_ptr
);
4346 new->filename
= NULL
;
4347 new->filenames_sorted
= false;
4348 if (filespec
!= NULL
)
4350 new->filename
= filespec
->name
;
4351 new->filenames_sorted
= filespec
->sorted
;
4353 new->section_list
= section_list
;
4354 new->keep_sections
= keep_sections
;
4355 lang_list_init (&new->children
);
4359 lang_section_start (name
, address
)
4361 etree_type
*address
;
4363 lang_address_statement_type
*ad
;
4365 ad
= new_stat (lang_address_statement
, stat_ptr
);
4366 ad
->section_name
= name
;
4367 ad
->address
= address
;
4370 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4371 because of a -e argument on the command line, or zero if this is
4372 called by ENTRY in a linker script. Command line arguments take
4376 lang_add_entry (name
, cmdline
)
4380 if (entry_symbol
== NULL
4382 || ! entry_from_cmdline
)
4384 entry_symbol
= name
;
4385 entry_from_cmdline
= cmdline
;
4390 lang_add_target (name
)
4393 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4409 map_option_f
= true;
4417 lang_add_fill (fill
)
4420 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4427 lang_add_data (type
, exp
)
4429 union etree_union
*exp
;
4432 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4440 /* Create a new reloc statement. RELOC is the BFD relocation type to
4441 generate. HOWTO is the corresponding howto structure (we could
4442 look this up, but the caller has already done so). SECTION is the
4443 section to generate a reloc against, or NAME is the name of the
4444 symbol to generate a reloc against. Exactly one of SECTION and
4445 NAME must be NULL. ADDEND is an expression for the addend. */
4448 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4449 bfd_reloc_code_real_type reloc
;
4450 reloc_howto_type
*howto
;
4453 union etree_union
*addend
;
4455 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4459 p
->section
= section
;
4461 p
->addend_exp
= addend
;
4463 p
->addend_value
= 0;
4464 p
->output_section
= NULL
;
4468 lang_assignment_statement_type
*
4469 lang_add_assignment (exp
)
4472 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4480 lang_add_attribute (attribute
)
4481 enum statement_enum attribute
;
4483 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4490 if (startup_file
!= (char *) NULL
)
4492 einfo (_("%P%Fmultiple STARTUP files\n"));
4494 first_file
->filename
= name
;
4495 first_file
->local_sym_name
= name
;
4496 first_file
->real
= true;
4498 startup_file
= name
;
4505 lang_float_flag
= maybe
;
4509 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4511 const char *memspec
;
4512 struct lang_output_section_phdr_list
*phdrs
;
4513 const char *lma_memspec
;
4515 current_section
->fill
= fill
;
4516 current_section
->region
= lang_memory_region_lookup (memspec
);
4517 if (strcmp (lma_memspec
, "*default*") != 0)
4519 current_section
->lma_region
= lang_memory_region_lookup (lma_memspec
);
4520 /* If no runtime region has been given, but the load region has
4521 been, use the load region. */
4522 if (strcmp (memspec
, "*default*") == 0)
4523 current_section
->region
= lang_memory_region_lookup (lma_memspec
);
4525 current_section
->phdrs
= phdrs
;
4526 stat_ptr
= &statement_list
;
4529 /* Create an absolute symbol with the given name with the value of the
4530 address of first byte of the section named.
4532 If the symbol already exists, then do nothing. */
4535 lang_abs_symbol_at_beginning_of (secname
, name
)
4536 const char *secname
;
4539 struct bfd_link_hash_entry
*h
;
4541 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4542 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4543 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4545 if (h
->type
== bfd_link_hash_new
4546 || h
->type
== bfd_link_hash_undefined
)
4550 h
->type
= bfd_link_hash_defined
;
4552 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4553 if (sec
== (asection
*) NULL
)
4556 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4558 h
->u
.def
.section
= bfd_abs_section_ptr
;
4562 /* Create an absolute symbol with the given name with the value of the
4563 address of the first byte after the end of the section named.
4565 If the symbol already exists, then do nothing. */
4568 lang_abs_symbol_at_end_of (secname
, name
)
4569 const char *secname
;
4572 struct bfd_link_hash_entry
*h
;
4574 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4575 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4576 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4578 if (h
->type
== bfd_link_hash_new
4579 || h
->type
== bfd_link_hash_undefined
)
4583 h
->type
= bfd_link_hash_defined
;
4585 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4586 if (sec
== (asection
*) NULL
)
4589 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4590 + bfd_section_size (output_bfd
, sec
) /
4591 bfd_octets_per_byte (output_bfd
));
4593 h
->u
.def
.section
= bfd_abs_section_ptr
;
4598 lang_statement_append (list
, element
, field
)
4599 lang_statement_list_type
*list
;
4600 lang_statement_union_type
*element
;
4601 lang_statement_union_type
**field
;
4603 *(list
->tail
) = element
;
4607 /* Set the output format type. -oformat overrides scripts. */
4610 lang_add_output_format (format
, big
, little
, from_script
)
4616 if (output_target
== NULL
|| !from_script
)
4618 if (command_line
.endian
== ENDIAN_BIG
4621 else if (command_line
.endian
== ENDIAN_LITTLE
4625 output_target
= format
;
4629 /* Enter a group. This creates a new lang_group_statement, and sets
4630 stat_ptr to build new statements within the group. */
4635 lang_group_statement_type
*g
;
4637 g
= new_stat (lang_group_statement
, stat_ptr
);
4638 lang_list_init (&g
->children
);
4639 stat_ptr
= &g
->children
;
4642 /* Leave a group. This just resets stat_ptr to start writing to the
4643 regular list of statements again. Note that this will not work if
4644 groups can occur inside anything else which can adjust stat_ptr,
4645 but currently they can't. */
4650 stat_ptr
= &statement_list
;
4653 /* Add a new program header. This is called for each entry in a PHDRS
4654 command in a linker script. */
4657 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4665 struct lang_phdr
*n
, **pp
;
4667 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4670 n
->type
= exp_get_value_int (type
, 0, "program header type",
4671 lang_final_phase_enum
);
4672 n
->filehdr
= filehdr
;
4677 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4682 /* Record the program header information in the output BFD. FIXME: We
4683 should not be calling an ELF specific function here. */
4686 lang_record_phdrs ()
4690 struct lang_output_section_phdr_list
*last
;
4691 struct lang_phdr
*l
;
4692 lang_statement_union_type
*u
;
4695 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4697 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4704 for (u
= lang_output_section_statement
.head
;
4706 u
= u
->output_section_statement
.next
)
4708 lang_output_section_statement_type
*os
;
4709 struct lang_output_section_phdr_list
*pl
;
4711 os
= &u
->output_section_statement
;
4718 if (os
->sectype
== noload_section
4719 || os
->bfd_section
== NULL
4720 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4725 if (os
->bfd_section
== NULL
)
4728 for (; pl
!= NULL
; pl
= pl
->next
)
4730 if (strcmp (pl
->name
, l
->name
) == 0)
4735 secs
= ((asection
**)
4736 xrealloc (secs
, alc
* sizeof (asection
*)));
4738 secs
[c
] = os
->bfd_section
;
4745 if (l
->flags
== NULL
)
4748 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4749 lang_final_phase_enum
);
4754 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4755 lang_final_phase_enum
);
4757 if (! bfd_record_phdr (output_bfd
, l
->type
,
4758 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
4759 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4760 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4765 /* Make sure all the phdr assignments succeeded. */
4766 for (u
= lang_output_section_statement
.head
;
4768 u
= u
->output_section_statement
.next
)
4770 struct lang_output_section_phdr_list
*pl
;
4772 if (u
->output_section_statement
.bfd_section
== NULL
)
4775 for (pl
= u
->output_section_statement
.phdrs
;
4778 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4779 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4780 u
->output_section_statement
.name
, pl
->name
);
4784 /* Record a list of sections which may not be cross referenced. */
4787 lang_add_nocrossref (l
)
4788 struct lang_nocrossref
*l
;
4790 struct lang_nocrossrefs
*n
;
4792 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4793 n
->next
= nocrossref_list
;
4795 nocrossref_list
= n
;
4797 /* Set notice_all so that we get informed about all symbols. */
4798 link_info
.notice_all
= true;
4801 /* Overlay handling. We handle overlays with some static variables. */
4803 /* The overlay virtual address. */
4804 static etree_type
*overlay_vma
;
4806 /* The overlay load address. */
4807 static etree_type
*overlay_lma
;
4809 /* Whether nocrossrefs is set for this overlay. */
4810 static int overlay_nocrossrefs
;
4812 /* An expression for the maximum section size seen so far. */
4813 static etree_type
*overlay_max
;
4815 /* A list of all the sections in this overlay. */
4817 struct overlay_list
{
4818 struct overlay_list
*next
;
4819 lang_output_section_statement_type
*os
;
4822 static struct overlay_list
*overlay_list
;
4824 /* Start handling an overlay. */
4827 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
4828 etree_type
*vma_expr
;
4829 etree_type
*lma_expr
;
4832 /* The grammar should prevent nested overlays from occurring. */
4833 ASSERT (overlay_vma
== NULL
4834 && overlay_lma
== NULL
4835 && overlay_list
== NULL
4836 && overlay_max
== NULL
);
4838 overlay_vma
= vma_expr
;
4839 overlay_lma
= lma_expr
;
4840 overlay_nocrossrefs
= nocrossrefs
;
4843 /* Start a section in an overlay. We handle this by calling
4844 lang_enter_output_section_statement with the correct VMA and LMA. */
4847 lang_enter_overlay_section (name
)
4850 struct overlay_list
*n
;
4853 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4854 0, 0, 0, overlay_lma
);
4856 /* If this is the first section, then base the VMA and LMA of future
4857 sections on this one. This will work correctly even if `.' is
4858 used in the addresses. */
4859 if (overlay_list
== NULL
)
4861 overlay_vma
= exp_nameop (ADDR
, name
);
4862 overlay_lma
= exp_nameop (LOADADDR
, name
);
4865 /* Remember the section. */
4866 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4867 n
->os
= current_section
;
4868 n
->next
= overlay_list
;
4871 size
= exp_nameop (SIZEOF
, name
);
4873 /* Adjust the LMA for the next section. */
4874 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
4876 /* Arrange to work out the maximum section end address. */
4877 if (overlay_max
== NULL
)
4880 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4883 /* Finish a section in an overlay. There isn't any special to do
4887 lang_leave_overlay_section (fill
, phdrs
)
4889 struct lang_output_section_phdr_list
*phdrs
;
4896 name
= current_section
->name
;
4898 lang_leave_output_section_statement (fill
, "*default*",
4899 phdrs
, "*default*");
4901 /* Define the magic symbols. */
4903 clean
= xmalloc (strlen (name
) + 1);
4905 for (s1
= name
; *s1
!= '\0'; s1
++)
4906 if (ISALNUM (*s1
) || *s1
== '_')
4910 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4911 sprintf (buf
, "__load_start_%s", clean
);
4912 lang_add_assignment (exp_assop ('=', buf
,
4913 exp_nameop (LOADADDR
, name
)));
4915 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4916 sprintf (buf
, "__load_stop_%s", clean
);
4917 lang_add_assignment (exp_assop ('=', buf
,
4919 exp_nameop (LOADADDR
, name
),
4920 exp_nameop (SIZEOF
, name
))));
4925 /* Finish an overlay. If there are any overlay wide settings, this
4926 looks through all the sections in the overlay and sets them. */
4929 lang_leave_overlay (fill
, memspec
, phdrs
, lma_memspec
)
4931 const char *memspec
;
4932 struct lang_output_section_phdr_list
*phdrs
;
4933 const char *lma_memspec
;
4935 lang_memory_region_type
*region
;
4936 lang_memory_region_type
*default_region
;
4937 lang_memory_region_type
*lma_region
;
4938 struct overlay_list
*l
;
4939 struct lang_nocrossref
*nocrossref
;
4941 default_region
= lang_memory_region_lookup ("*default*");
4943 if (memspec
== NULL
)
4946 region
= lang_memory_region_lookup (memspec
);
4948 if (lma_memspec
== NULL
)
4951 lma_region
= lang_memory_region_lookup (lma_memspec
);
4958 struct overlay_list
*next
;
4960 if (fill
!= (fill_type
*) 0 && l
->os
->fill
== (fill_type
*) 0)
4963 /* Assign a region to the sections, if one has been specified.
4964 Override the assignment of the default section, but not
4966 if (region
!= NULL
&&
4967 (l
->os
->region
== NULL
||
4968 l
->os
->region
== default_region
))
4969 l
->os
->region
= region
;
4971 /* We only set lma_region for the first overlay section, as
4972 subsequent overlay sections will have load_base set relative
4973 to the first section. Also, don't set lma_region if
4974 load_base is specified. FIXME: There should really be a test
4975 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4976 rather than letting LDADDR simply override LMA_REGION. */
4977 if (lma_region
!= NULL
&& l
->os
->lma_region
== NULL
4978 && l
->next
== NULL
&& l
->os
->load_base
== NULL
)
4979 l
->os
->lma_region
= lma_region
;
4981 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4982 l
->os
->phdrs
= phdrs
;
4984 if (overlay_nocrossrefs
)
4986 struct lang_nocrossref
*nc
;
4988 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
4989 nc
->name
= l
->os
->name
;
4990 nc
->next
= nocrossref
;
4999 if (nocrossref
!= NULL
)
5000 lang_add_nocrossref (nocrossref
);
5002 /* Update . for the end of the overlay. */
5003 lang_add_assignment (exp_assop ('=', ".",
5004 exp_binop ('+', overlay_vma
, overlay_max
)));
5008 overlay_nocrossrefs
= 0;
5009 overlay_list
= NULL
;
5013 /* Version handling. This is only useful for ELF. */
5015 /* This global variable holds the version tree that we build. */
5017 struct bfd_elf_version_tree
*lang_elf_version_info
;
5020 lang_vers_match_lang_c (expr
, sym
)
5021 struct bfd_elf_version_expr
*expr
;
5024 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5026 return fnmatch (expr
->pattern
, sym
, 0) == 0;
5030 lang_vers_match_lang_cplusplus (expr
, sym
)
5031 struct bfd_elf_version_expr
*expr
;
5037 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5040 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
5043 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5044 Should we early out false in this case? */
5045 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5049 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5057 lang_vers_match_lang_java (expr
, sym
)
5058 struct bfd_elf_version_expr
*expr
;
5064 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5067 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
5070 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5071 Should we early out false in this case? */
5072 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5076 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5083 /* This is called for each variable name or match expression. */
5085 struct bfd_elf_version_expr
*
5086 lang_new_vers_pattern (orig
, new, lang
)
5087 struct bfd_elf_version_expr
*orig
;
5091 struct bfd_elf_version_expr
*ret
;
5093 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
5097 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
5098 ret
->match
= lang_vers_match_lang_c
;
5099 else if (strcasecmp (lang
, "C++") == 0)
5100 ret
->match
= lang_vers_match_lang_cplusplus
;
5101 else if (strcasecmp (lang
, "Java") == 0)
5102 ret
->match
= lang_vers_match_lang_java
;
5105 einfo (_("%X%P: unknown language `%s' in version information\n"),
5107 ret
->match
= lang_vers_match_lang_c
;
5113 /* This is called for each set of variable names and match
5116 struct bfd_elf_version_tree
*
5117 lang_new_vers_node (globals
, locals
)
5118 struct bfd_elf_version_expr
*globals
;
5119 struct bfd_elf_version_expr
*locals
;
5121 struct bfd_elf_version_tree
*ret
;
5123 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
5127 ret
->globals
= globals
;
5128 ret
->locals
= locals
;
5130 ret
->name_indx
= (unsigned int) -1;
5135 /* This static variable keeps track of version indices. */
5137 static int version_index
;
5139 /* This is called when we know the name and dependencies of the
5143 lang_register_vers_node (name
, version
, deps
)
5145 struct bfd_elf_version_tree
*version
;
5146 struct bfd_elf_version_deps
*deps
;
5148 struct bfd_elf_version_tree
*t
, **pp
;
5149 struct bfd_elf_version_expr
*e1
;
5154 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
5155 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
5157 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5161 /* Make sure this node has a unique name. */
5162 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5163 if (strcmp (t
->name
, name
) == 0)
5164 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5166 /* Check the global and local match names, and make sure there
5167 aren't any duplicates. */
5169 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5171 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5173 struct bfd_elf_version_expr
*e2
;
5175 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5176 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5177 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5182 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
5184 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5186 struct bfd_elf_version_expr
*e2
;
5188 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
5189 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5190 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5195 version
->deps
= deps
;
5196 version
->name
= name
;
5197 if (name
[0] != '\0')
5200 version
->vernum
= version_index
;
5203 version
->vernum
= 0;
5205 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5210 /* This is called when we see a version dependency. */
5212 struct bfd_elf_version_deps
*
5213 lang_add_vers_depend (list
, name
)
5214 struct bfd_elf_version_deps
*list
;
5217 struct bfd_elf_version_deps
*ret
;
5218 struct bfd_elf_version_tree
*t
;
5220 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5223 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5225 if (strcmp (t
->name
, name
) == 0)
5227 ret
->version_needed
= t
;
5232 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5238 lang_do_version_exports_section ()
5240 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5242 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5244 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5251 len
= bfd_section_size (is
->the_bfd
, sec
);
5252 contents
= xmalloc (len
);
5253 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5254 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
5257 while (p
< contents
+ len
)
5259 greg
= lang_new_vers_pattern (greg
, p
, NULL
);
5260 p
= strchr (p
, '\0') + 1;
5263 /* Do not free the contents, as we used them creating the regex. */
5265 /* Do not include this section in the link. */
5266 bfd_set_section_flags (is
->the_bfd
, sec
,
5267 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5270 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
);
5271 lang_register_vers_node (command_line
.version_exports_section
,
5272 lang_new_vers_node (greg
, lreg
), NULL
);
5276 lang_add_unique (name
)
5279 struct unique_sections
*ent
;
5281 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5282 if (strcmp (ent
->name
, name
) == 0)
5285 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
5286 ent
->name
= xstrdup (name
);
5287 ent
->next
= unique_section_list
;
5288 unique_section_list
= ent
;