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 /* NAME is NULL for LMA memspecs if no region was specified. */
624 for (p
= lang_memory_region_list
;
625 p
!= (lang_memory_region_type
*) NULL
;
628 if (strcmp (p
->name
, name
) == 0)
635 /* This code used to always use the first region in the list as the
636 default region. I changed it to instead use a region
637 encompassing all of memory as the default region. This permits
638 NOLOAD sections to work reasonably without requiring a region.
639 People should specify what region they mean, if they really want
641 if (strcmp (name
, "*default*") == 0)
643 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
645 return lang_memory_region_list
;
651 lang_memory_region_type
*new =
652 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
654 new->name
= xstrdup (name
);
655 new->next
= (lang_memory_region_type
*) NULL
;
657 *lang_memory_region_list_tail
= new;
658 lang_memory_region_list_tail
= &new->next
;
662 new->length
= ~(bfd_size_type
) 0;
664 new->had_full_message
= false;
670 static lang_memory_region_type
*
671 lang_memory_default (section
)
674 lang_memory_region_type
*p
;
676 flagword sec_flags
= section
->flags
;
678 /* Override SEC_DATA to mean a writable section. */
679 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
680 sec_flags
|= SEC_DATA
;
682 for (p
= lang_memory_region_list
;
683 p
!= (lang_memory_region_type
*) NULL
;
686 if ((p
->flags
& sec_flags
) != 0
687 && (p
->not_flags
& sec_flags
) == 0)
692 return lang_memory_region_lookup ("*default*");
695 lang_output_section_statement_type
*
696 lang_output_section_find (name
)
697 const char *const name
;
699 lang_statement_union_type
*u
;
700 lang_output_section_statement_type
*lookup
;
702 for (u
= lang_output_section_statement
.head
;
703 u
!= (lang_statement_union_type
*) NULL
;
706 lookup
= &u
->output_section_statement
;
707 if (strcmp (name
, lookup
->name
) == 0)
712 return (lang_output_section_statement_type
*) NULL
;
715 lang_output_section_statement_type
*
716 lang_output_section_statement_lookup (name
)
717 const char *const name
;
719 lang_output_section_statement_type
*lookup
;
721 lookup
= lang_output_section_find (name
);
722 if (lookup
== (lang_output_section_statement_type
*) NULL
)
725 lookup
= (lang_output_section_statement_type
*)
726 new_stat (lang_output_section_statement
, stat_ptr
);
727 lookup
->region
= (lang_memory_region_type
*) NULL
;
728 lookup
->lma_region
= (lang_memory_region_type
*) NULL
;
729 lookup
->fill
= (fill_type
*) 0;
730 lookup
->block_value
= 1;
733 lookup
->next
= (lang_statement_union_type
*) NULL
;
734 lookup
->bfd_section
= (asection
*) NULL
;
735 lookup
->processed
= false;
736 lookup
->sectype
= normal_section
;
737 lookup
->addr_tree
= (etree_type
*) NULL
;
738 lang_list_init (&lookup
->children
);
740 lookup
->memspec
= (const char *) NULL
;
742 lookup
->subsection_alignment
= -1;
743 lookup
->section_alignment
= -1;
744 lookup
->load_base
= (union etree_union
*) NULL
;
745 lookup
->update_dot_tree
= NULL
;
746 lookup
->phdrs
= NULL
;
748 lang_statement_append (&lang_output_section_statement
,
749 (lang_statement_union_type
*) lookup
,
756 lang_map_flags (flag
)
759 if (flag
& SEC_ALLOC
)
765 if (flag
& SEC_READONLY
)
778 lang_memory_region_type
*m
;
780 minfo (_("\nMemory Configuration\n\n"));
781 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
782 _("Name"), _("Origin"), _("Length"), _("Attributes"));
784 for (m
= lang_memory_region_list
;
785 m
!= (lang_memory_region_type
*) NULL
;
791 fprintf (config
.map_file
, "%-16s ", m
->name
);
793 sprintf_vma (buf
, m
->origin
);
794 minfo ("0x%s ", buf
);
802 minfo ("0x%V", m
->length
);
803 if (m
->flags
|| m
->not_flags
)
811 lang_map_flags (m
->flags
);
817 lang_map_flags (m
->not_flags
);
824 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
829 /* Initialize an output section. */
833 lang_output_section_statement_type
*s
;
835 section_userdata_type
*new;
837 if (s
->bfd_section
!= NULL
)
840 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
841 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
843 new = ((section_userdata_type
*)
844 stat_alloc (sizeof (section_userdata_type
)));
846 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
847 if (s
->bfd_section
== (asection
*) NULL
)
848 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
849 if (s
->bfd_section
== (asection
*) NULL
)
851 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
852 output_bfd
->xvec
->name
, s
->name
);
854 s
->bfd_section
->output_section
= s
->bfd_section
;
856 /* We initialize an output sections output offset to minus its own
857 vma to allow us to output a section through itself. */
858 s
->bfd_section
->output_offset
= 0;
859 get_userdata (s
->bfd_section
) = (PTR
) new;
861 /* If there is a base address, make sure that any sections it might
862 mention are initialized. */
863 if (s
->addr_tree
!= NULL
)
864 exp_init_os (s
->addr_tree
);
867 /* Make sure that all output sections mentioned in an expression are
874 switch (exp
->type
.node_class
)
877 exp_init_os (exp
->assign
.src
);
881 exp_init_os (exp
->binary
.lhs
);
882 exp_init_os (exp
->binary
.rhs
);
886 exp_init_os (exp
->trinary
.cond
);
887 exp_init_os (exp
->trinary
.lhs
);
888 exp_init_os (exp
->trinary
.rhs
);
892 exp_init_os (exp
->unary
.child
);
896 switch (exp
->type
.node_code
)
902 lang_output_section_statement_type
*os
;
904 os
= lang_output_section_find (exp
->name
.name
);
905 if (os
!= NULL
&& os
->bfd_section
== NULL
)
916 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
917 once into the output. This routine checks each section, and
918 arrange to discard it if a section of the same name has already
919 been linked. If the section has COMDAT information, then it uses
920 that to decide whether the section should be included. This code
921 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
922 that is, it does not depend solely upon the section name.
923 section_already_linked is called via bfd_map_over_sections. */
925 /* This is the shape of the elements inside the already_linked hash
926 table. It maps a name onto a list of already_linked elements with
927 the same name. It's possible to get more than one element in a
928 list if the COMDAT sections have different names. */
930 struct already_linked_hash_entry
932 struct bfd_hash_entry root
;
933 struct already_linked
*entry
;
936 struct already_linked
938 struct already_linked
*next
;
942 /* The hash table. */
944 static struct bfd_hash_table already_linked_table
;
947 section_already_linked (abfd
, sec
, data
)
952 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
955 struct already_linked
*l
;
956 struct already_linked_hash_entry
*already_linked_list
;
958 /* If we are only reading symbols from this object, then we want to
959 discard all sections. */
960 if (entry
->just_syms_flag
)
962 sec
->output_section
= bfd_abs_section_ptr
;
963 sec
->output_offset
= sec
->vma
;
967 flags
= bfd_get_section_flags (abfd
, sec
);
969 if ((flags
& SEC_LINK_ONCE
) == 0)
972 /* FIXME: When doing a relocatable link, we may have trouble
973 copying relocations in other sections that refer to local symbols
974 in the section being discarded. Those relocations will have to
975 be converted somehow; as of this writing I'm not sure that any of
976 the backends handle that correctly.
978 It is tempting to instead not discard link once sections when
979 doing a relocatable link (technically, they should be discarded
980 whenever we are building constructors). However, that fails,
981 because the linker winds up combining all the link once sections
982 into a single large link once section, which defeats the purpose
983 of having link once sections in the first place.
985 Also, not merging link once sections in a relocatable link
986 causes trouble for MIPS ELF, which relies in link once semantics
987 to handle the .reginfo section correctly. */
989 name
= bfd_get_section_name (abfd
, sec
);
991 already_linked_list
=
992 ((struct already_linked_hash_entry
*)
993 bfd_hash_lookup (&already_linked_table
, name
, true, false));
995 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
997 if (sec
->comdat
== NULL
998 || l
->sec
->comdat
== NULL
999 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
1001 /* The section has already been linked. See if we should
1003 switch (flags
& SEC_LINK_DUPLICATES
)
1008 case SEC_LINK_DUPLICATES_DISCARD
:
1011 case SEC_LINK_DUPLICATES_ONE_ONLY
:
1012 if (sec
->comdat
== NULL
)
1013 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
1016 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
1017 abfd
, name
, sec
->comdat
->name
);
1020 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
1021 /* FIXME: We should really dig out the contents of both
1022 sections and memcmp them. The COFF/PE spec says that
1023 the Microsoft linker does not implement this
1024 correctly, so I'm not going to bother doing it
1027 case SEC_LINK_DUPLICATES_SAME_SIZE
:
1028 if (bfd_section_size (abfd
, sec
)
1029 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1030 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1035 /* Set the output_section field so that lang_add_section
1036 does not create a lang_input_section structure for this
1038 sec
->output_section
= bfd_abs_section_ptr
;
1044 /* This is the first section with this name. Record it. Allocate
1045 the memory from the same obstack as the hash table is kept in. */
1047 l
= ((struct already_linked
*)
1048 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1051 l
->next
= already_linked_list
->entry
;
1052 already_linked_list
->entry
= l
;
1055 /* Support routines for the hash table used by section_already_linked,
1056 initialize the table, fill in an entry and remove the table. */
1058 static struct bfd_hash_entry
*
1059 already_linked_newfunc (entry
, table
, string
)
1060 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1061 struct bfd_hash_table
*table
;
1062 const char *string ATTRIBUTE_UNUSED
;
1064 struct already_linked_hash_entry
*ret
=
1065 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1069 return (struct bfd_hash_entry
*) ret
;
1073 already_linked_table_init ()
1075 if (! bfd_hash_table_init_n (&already_linked_table
,
1076 already_linked_newfunc
,
1078 einfo (_("%P%F: Failed to create hash table\n"));
1082 already_linked_table_free ()
1084 bfd_hash_table_free (&already_linked_table
);
1087 /* The wild routines.
1089 These expand statements like *(.text) and foo.o to a list of
1090 explicit actions, like foo.o(.text), bar.o(.text) and
1091 foo.o(.text, .data). */
1093 /* Return true if the PATTERN argument is a wildcard pattern.
1094 Although backslashes are treated specially if a pattern contains
1095 wildcards, we do not consider the mere presence of a backslash to
1096 be enough to cause the pattern to be treated as a wildcard.
1097 That lets us handle DOS filenames more naturally. */
1101 const char *pattern
;
1105 for (s
= pattern
; *s
!= '\0'; ++s
)
1113 /* Add SECTION to the output section OUTPUT. Do this by creating a
1114 lang_input_section statement which is placed at PTR. FILE is the
1115 input file which holds SECTION. */
1118 lang_add_section (ptr
, section
, output
, file
)
1119 lang_statement_list_type
*ptr
;
1121 lang_output_section_statement_type
*output
;
1122 lang_input_statement_type
*file
;
1127 flags
= bfd_get_section_flags (section
->owner
, section
);
1131 /* If we are doing a final link, discard sections marked with
1133 if (! link_info
.relocateable
1134 && (flags
& SEC_EXCLUDE
) != 0)
1137 /* Discard input sections which are assigned to a section named
1138 DISCARD_SECTION_NAME. */
1139 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1142 /* Discard debugging sections if we are stripping debugging
1144 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1145 && (flags
& SEC_DEBUGGING
) != 0)
1150 if (section
->output_section
== NULL
)
1152 /* This prevents future calls from assigning this section. */
1153 section
->output_section
= bfd_abs_section_ptr
;
1158 if (section
->output_section
== NULL
)
1161 lang_input_section_type
*new;
1164 if (output
->bfd_section
== NULL
)
1167 first
= ! output
->bfd_section
->linker_has_input
;
1168 output
->bfd_section
->linker_has_input
= 1;
1170 /* Add a section reference to the list. */
1171 new = new_stat (lang_input_section
, ptr
);
1173 new->section
= section
;
1175 section
->output_section
= output
->bfd_section
;
1177 flags
= section
->flags
;
1179 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1180 to an output section, because we want to be able to include a
1181 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1182 section (I don't know why we want to do this, but we do).
1183 build_link_order in ldwrite.c handles this case by turning
1184 the embedded SEC_NEVER_LOAD section into a fill. */
1186 flags
&= ~ SEC_NEVER_LOAD
;
1188 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1189 already been processed. One reason to do this is that on pe
1190 format targets, .text$foo sections go into .text and it's odd
1191 to see .text with SEC_LINK_ONCE set. */
1193 if (! link_info
.relocateable
)
1194 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1196 /* If this is not the first input section, and the SEC_READONLY
1197 flag is not currently set, then don't set it just because the
1198 input section has it set. */
1200 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1201 flags
&= ~ SEC_READONLY
;
1203 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1205 && ((section
->output_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1206 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1207 || ((flags
& SEC_MERGE
)
1208 && section
->output_section
->entsize
!= section
->entsize
)))
1210 section
->output_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1211 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1214 section
->output_section
->flags
|= flags
;
1216 if (flags
& SEC_MERGE
)
1217 section
->output_section
->entsize
= section
->entsize
;
1219 /* If SEC_READONLY is not set in the input section, then clear
1220 it from the output section. */
1221 if ((section
->flags
& SEC_READONLY
) == 0)
1222 section
->output_section
->flags
&= ~SEC_READONLY
;
1224 switch (output
->sectype
)
1226 case normal_section
:
1231 case overlay_section
:
1232 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1234 case noload_section
:
1235 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1236 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1240 /* Copy over SEC_SMALL_DATA. */
1241 if (section
->flags
& SEC_SMALL_DATA
)
1242 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1244 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1245 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1247 /* If supplied an aligment, then force it. */
1248 if (output
->section_alignment
!= -1)
1249 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1251 if (section
->flags
& SEC_BLOCK
)
1253 section
->output_section
->flags
|= SEC_BLOCK
;
1254 /* FIXME: This value should really be obtained from the bfd... */
1255 output
->block_value
= 128;
1260 /* Handle wildcard sorting. This returns the lang_input_section which
1261 should follow the one we are going to create for SECTION and FILE,
1262 based on the sorting requirements of WILD. It returns NULL if the
1263 new section should just go at the end of the current list. */
1265 static lang_statement_union_type
*
1266 wild_sort (wild
, sec
, file
, section
)
1267 lang_wild_statement_type
*wild
;
1268 struct wildcard_list
*sec
;
1269 lang_input_statement_type
*file
;
1272 const char *section_name
;
1273 lang_statement_union_type
*l
;
1275 if (!wild
->filenames_sorted
&& (sec
== NULL
|| !sec
->spec
.sorted
))
1278 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1279 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
1281 lang_input_section_type
*ls
;
1283 if (l
->header
.type
!= lang_input_section_enum
)
1285 ls
= &l
->input_section
;
1287 /* Sorting by filename takes precedence over sorting by section
1290 if (wild
->filenames_sorted
)
1292 const char *fn
, *ln
;
1296 /* The PE support for the .idata section as generated by
1297 dlltool assumes that files will be sorted by the name of
1298 the archive and then the name of the file within the
1301 if (file
->the_bfd
!= NULL
1302 && bfd_my_archive (file
->the_bfd
) != NULL
)
1304 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1309 fn
= file
->filename
;
1313 if (ls
->ifile
->the_bfd
!= NULL
1314 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1316 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1321 ln
= ls
->ifile
->filename
;
1325 i
= strcmp (fn
, ln
);
1334 fn
= file
->filename
;
1336 ln
= ls
->ifile
->filename
;
1338 i
= strcmp (fn
, ln
);
1346 /* Here either the files are not sorted by name, or we are
1347 looking at the sections for this file. */
1349 if (sec
!= NULL
&& sec
->spec
.sorted
)
1351 if (strcmp (section_name
,
1352 bfd_get_section_name (ls
->ifile
->the_bfd
,
1362 /* Expand a wild statement for a particular FILE. SECTION may be
1363 NULL, in which case it is a wild card. */
1366 output_section_callback (ptr
, sec
, section
, file
, output
)
1367 lang_wild_statement_type
*ptr
;
1368 struct wildcard_list
*sec
;
1370 lang_input_statement_type
*file
;
1373 lang_statement_union_type
*before
;
1375 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1376 if (unique_section_p (bfd_get_section_name (file
->the_bfd
, section
)))
1379 /* If the wild pattern was marked KEEP, the member sections
1380 should be as well. */
1381 if (ptr
->keep_sections
)
1382 section
->flags
|= SEC_KEEP
;
1384 before
= wild_sort (ptr
, sec
, file
, section
);
1386 /* Here BEFORE points to the lang_input_section which
1387 should follow the one we are about to add. If BEFORE
1388 is NULL, then the section should just go at the end
1389 of the current list. */
1392 lang_add_section (&ptr
->children
, section
,
1393 (lang_output_section_statement_type
*) output
,
1397 lang_statement_list_type list
;
1398 lang_statement_union_type
**pp
;
1400 lang_list_init (&list
);
1401 lang_add_section (&list
, section
,
1402 (lang_output_section_statement_type
*) output
,
1405 /* If we are discarding the section, LIST.HEAD will
1407 if (list
.head
!= NULL
)
1409 ASSERT (list
.head
->header
.next
== NULL
);
1411 for (pp
= &ptr
->children
.head
;
1413 pp
= &(*pp
)->header
.next
)
1414 ASSERT (*pp
!= NULL
);
1416 list
.head
->header
.next
= *pp
;
1422 /* This is passed a file name which must have been seen already and
1423 added to the statement tree. We will see if it has been opened
1424 already and had its symbols read. If not then we'll read it. */
1426 static lang_input_statement_type
*
1430 lang_input_statement_type
*search
;
1432 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1433 search
!= (lang_input_statement_type
*) NULL
;
1434 search
= (lang_input_statement_type
*) search
->next_real_file
)
1436 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1438 if (search
->filename
!= (char *) NULL
1439 && name
!= (char *) NULL
1440 && strcmp (search
->filename
, name
) == 0)
1444 if (search
== (lang_input_statement_type
*) NULL
)
1445 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1448 /* If we have already added this file, or this file is not real
1449 (FIXME: can that ever actually happen?) or the name is NULL
1450 (FIXME: can that ever actually happen?) don't add this file. */
1453 || search
->filename
== (const char *) NULL
)
1456 if (! load_symbols (search
, (lang_statement_list_type
*) NULL
))
1462 /* Get the symbols for an input file. */
1465 load_symbols (entry
, place
)
1466 lang_input_statement_type
*entry
;
1467 lang_statement_list_type
*place
;
1474 ldfile_open_file (entry
);
1476 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1477 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1480 lang_statement_list_type
*hold
;
1481 boolean bad_load
= true;
1483 err
= bfd_get_error ();
1485 /* See if the emulation has some special knowledge. */
1486 if (ldemul_unrecognized_file (entry
))
1489 if (err
== bfd_error_file_ambiguously_recognized
)
1493 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1494 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1495 for (p
= matching
; *p
!= NULL
; p
++)
1499 else if (err
!= bfd_error_file_not_recognized
1501 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1505 bfd_close (entry
->the_bfd
);
1506 entry
->the_bfd
= NULL
;
1508 /* Try to interpret the file as a linker script. */
1509 ldfile_open_command_file (entry
->filename
);
1514 ldfile_assumed_script
= true;
1515 parser_input
= input_script
;
1517 ldfile_assumed_script
= false;
1524 if (ldemul_recognized_file (entry
))
1527 /* We don't call ldlang_add_file for an archive. Instead, the
1528 add_symbols entry point will call ldlang_add_file, via the
1529 add_archive_element callback, for each element of the archive
1531 switch (bfd_get_format (entry
->the_bfd
))
1537 ldlang_add_file (entry
);
1538 if (trace_files
|| trace_file_tries
)
1539 info_msg ("%I\n", entry
);
1543 if (entry
->whole_archive
)
1546 boolean loaded
= true;
1550 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
1555 if (! bfd_check_format (member
, bfd_object
))
1557 einfo (_("%F%B: member %B in archive is not an object\n"),
1558 entry
->the_bfd
, member
);
1562 if (! ((*link_info
.callbacks
->add_archive_element
)
1563 (&link_info
, member
, "--whole-archive")))
1566 if (! bfd_link_add_symbols (member
, &link_info
))
1568 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1573 entry
->loaded
= loaded
;
1579 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1580 entry
->loaded
= true;
1582 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1584 return entry
->loaded
;
1587 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1588 may be NULL, indicating that it is a wildcard. Separate
1589 lang_input_section statements are created for each part of the
1590 expansion; they are added after the wild statement S. OUTPUT is
1591 the output section. */
1594 wild (s
, target
, output
)
1595 lang_wild_statement_type
*s
;
1596 const char *target ATTRIBUTE_UNUSED
;
1597 lang_output_section_statement_type
*output
;
1599 struct wildcard_list
*sec
;
1601 walk_wild (s
, output_section_callback
, (PTR
) output
);
1603 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
1605 if (default_common_section
!= NULL
)
1607 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
1609 /* Remember the section that common is going to in case we
1610 later get something which doesn't know where to put it. */
1611 default_common_section
= output
;
1616 /* Return true iff target is the sought target. */
1619 get_target (target
, data
)
1620 const bfd_target
*target
;
1623 const char *sought
= (const char *) data
;
1625 return strcmp (target
->name
, sought
) == 0;
1628 /* Like strcpy() but convert to lower case as well. */
1637 while ((c
= *src
++) != 0)
1638 *dest
++ = TOLOWER (c
);
1643 /* Remove the first occurance of needle (if any) in haystack
1647 strcut (haystack
, needle
)
1651 haystack
= strstr (haystack
, needle
);
1657 for (src
= haystack
+ strlen (needle
); *src
;)
1658 *haystack
++ = *src
++;
1664 /* Compare two target format name strings.
1665 Return a value indicating how "similar" they are. */
1668 name_compare (first
, second
)
1676 copy1
= xmalloc (strlen (first
) + 1);
1677 copy2
= xmalloc (strlen (second
) + 1);
1679 /* Convert the names to lower case. */
1680 stricpy (copy1
, first
);
1681 stricpy (copy2
, second
);
1683 /* Remove and endian strings from the name. */
1684 strcut (copy1
, "big");
1685 strcut (copy1
, "little");
1686 strcut (copy2
, "big");
1687 strcut (copy2
, "little");
1689 /* Return a value based on how many characters match,
1690 starting from the beginning. If both strings are
1691 the same then return 10 * their length. */
1692 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1693 if (copy1
[result
] == 0)
1705 /* Set by closest_target_match() below. */
1706 static const bfd_target
*winner
;
1708 /* Scan all the valid bfd targets looking for one that has the endianness
1709 requirement that was specified on the command line, and is the nearest
1710 match to the original output target. */
1713 closest_target_match (target
, data
)
1714 const bfd_target
*target
;
1717 const bfd_target
*original
= (const bfd_target
*) data
;
1719 if (command_line
.endian
== ENDIAN_BIG
1720 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1723 if (command_line
.endian
== ENDIAN_LITTLE
1724 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1727 /* Must be the same flavour. */
1728 if (target
->flavour
!= original
->flavour
)
1731 /* If we have not found a potential winner yet, then record this one. */
1738 /* Oh dear, we now have two potential candidates for a successful match.
1739 Compare their names and choose the better one. */
1740 if (name_compare (target
->name
, original
->name
)
1741 > name_compare (winner
->name
, original
->name
))
1744 /* Keep on searching until wqe have checked them all. */
1748 /* Return the BFD target format of the first input file. */
1751 get_first_input_target ()
1753 char *target
= NULL
;
1755 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1757 if (s
->header
.type
== lang_input_statement_enum
1760 ldfile_open_file (s
);
1762 if (s
->the_bfd
!= NULL
1763 && bfd_check_format (s
->the_bfd
, bfd_object
))
1765 target
= bfd_get_target (s
->the_bfd
);
1776 /* Open the output file. */
1784 /* Has the user told us which output format to use? */
1785 if (output_target
== (char *) NULL
)
1787 /* No - has the current target been set to something other than
1789 if (current_target
!= default_target
)
1790 output_target
= current_target
;
1792 /* No - can we determine the format of the first input file? */
1795 output_target
= get_first_input_target ();
1797 /* Failed - use the default output target. */
1798 if (output_target
== NULL
)
1799 output_target
= default_target
;
1803 /* Has the user requested a particular endianness on the command
1805 if (command_line
.endian
!= ENDIAN_UNSET
)
1807 const bfd_target
*target
;
1808 enum bfd_endian desired_endian
;
1810 /* Get the chosen target. */
1811 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1813 /* If the target is not supported, we cannot do anything. */
1816 if (command_line
.endian
== ENDIAN_BIG
)
1817 desired_endian
= BFD_ENDIAN_BIG
;
1819 desired_endian
= BFD_ENDIAN_LITTLE
;
1821 /* See if the target has the wrong endianness. This should
1822 not happen if the linker script has provided big and
1823 little endian alternatives, but some scrips don't do
1825 if (target
->byteorder
!= desired_endian
)
1827 /* If it does, then see if the target provides
1828 an alternative with the correct endianness. */
1829 if (target
->alternative_target
!= NULL
1830 && (target
->alternative_target
->byteorder
== desired_endian
))
1831 output_target
= target
->alternative_target
->name
;
1834 /* Try to find a target as similar as possible to
1835 the default target, but which has the desired
1836 endian characteristic. */
1837 (void) bfd_search_for_target (closest_target_match
,
1840 /* Oh dear - we could not find any targets that
1841 satisfy our requirements. */
1843 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1845 output_target
= winner
->name
;
1851 output
= bfd_openw (name
, output_target
);
1853 if (output
== (bfd
*) NULL
)
1855 if (bfd_get_error () == bfd_error_invalid_target
)
1856 einfo (_("%P%F: target %s not found\n"), output_target
);
1858 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1861 delete_output_file_on_failure
= true;
1864 output
->flags
|= D_PAGED
;
1867 if (! bfd_set_format (output
, bfd_object
))
1868 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1869 if (! bfd_set_arch_mach (output
,
1870 ldfile_output_architecture
,
1871 ldfile_output_machine
))
1872 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1874 link_info
.hash
= bfd_link_hash_table_create (output
);
1875 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1876 einfo (_("%P%F: can not create link hash table: %E\n"));
1878 bfd_set_gp_size (output
, g_switch_value
);
1883 ldlang_open_output (statement
)
1884 lang_statement_union_type
*statement
;
1886 switch (statement
->header
.type
)
1888 case lang_output_statement_enum
:
1889 ASSERT (output_bfd
== (bfd
*) NULL
);
1890 output_bfd
= open_output (statement
->output_statement
.name
);
1891 ldemul_set_output_arch ();
1892 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1893 output_bfd
->flags
|= D_PAGED
;
1895 output_bfd
->flags
&= ~D_PAGED
;
1896 if (config
.text_read_only
)
1897 output_bfd
->flags
|= WP_TEXT
;
1899 output_bfd
->flags
&= ~WP_TEXT
;
1900 if (link_info
.traditional_format
)
1901 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1903 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1906 case lang_target_statement_enum
:
1907 current_target
= statement
->target_statement
.target
;
1914 /* Open all the input files. */
1917 open_input_bfds (s
, force
)
1918 lang_statement_union_type
*s
;
1921 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
1923 switch (s
->header
.type
)
1925 case lang_constructors_statement_enum
:
1926 open_input_bfds (constructor_list
.head
, force
);
1928 case lang_output_section_statement_enum
:
1929 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1931 case lang_wild_statement_enum
:
1932 /* Maybe we should load the file's symbols. */
1933 if (s
->wild_statement
.filename
1934 && ! wildcardp (s
->wild_statement
.filename
))
1935 (void) lookup_name (s
->wild_statement
.filename
);
1936 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1938 case lang_group_statement_enum
:
1940 struct bfd_link_hash_entry
*undefs
;
1942 /* We must continually search the entries in the group
1943 until no new symbols are added to the list of undefined
1948 undefs
= link_info
.hash
->undefs_tail
;
1949 open_input_bfds (s
->group_statement
.children
.head
, true);
1951 while (undefs
!= link_info
.hash
->undefs_tail
);
1954 case lang_target_statement_enum
:
1955 current_target
= s
->target_statement
.target
;
1957 case lang_input_statement_enum
:
1958 if (s
->input_statement
.real
)
1960 lang_statement_list_type add
;
1962 s
->input_statement
.target
= current_target
;
1964 /* If we are being called from within a group, and this
1965 is an archive which has already been searched, then
1966 force it to be researched unless the whole archive
1967 has been loaded already. */
1969 && !s
->input_statement
.whole_archive
1970 && s
->input_statement
.loaded
1971 && bfd_check_format (s
->input_statement
.the_bfd
,
1973 s
->input_statement
.loaded
= false;
1975 lang_list_init (&add
);
1977 if (! load_symbols (&s
->input_statement
, &add
))
1978 config
.make_executable
= false;
1980 if (add
.head
!= NULL
)
1982 *add
.tail
= s
->header
.next
;
1983 s
->header
.next
= add
.head
;
1993 /* If there are [COMMONS] statements, put a wild one into the bss
1997 lang_reasonable_defaults ()
2000 lang_output_section_statement_lookup (".text");
2001 lang_output_section_statement_lookup (".data");
2003 default_common_section
= lang_output_section_statement_lookup (".bss");
2005 if (placed_commons
== false)
2007 lang_wild_statement_type
*new =
2008 new_stat (lang_wild_statement
,
2009 &default_common_section
->children
);
2011 new->section_name
= "COMMON";
2012 new->filename
= (char *) NULL
;
2013 lang_list_init (&new->children
);
2018 /* Add the supplied name to the symbol table as an undefined reference.
2019 This is a two step process as the symbol table doesn't even exist at
2020 the time the ld command line is processed. First we put the name
2021 on a list, then, once the output file has been opened, transfer the
2022 name to the symbol table. */
2024 typedef struct ldlang_undef_chain_list
2026 struct ldlang_undef_chain_list
*next
;
2028 } ldlang_undef_chain_list_type
;
2030 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
2033 ldlang_add_undef (name
)
2034 const char *const name
;
2036 ldlang_undef_chain_list_type
*new =
2037 ((ldlang_undef_chain_list_type
*)
2038 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
2040 new->next
= ldlang_undef_chain_list_head
;
2041 ldlang_undef_chain_list_head
= new;
2043 new->name
= xstrdup (name
);
2045 if (output_bfd
!= NULL
)
2046 insert_undefined (new->name
);
2049 /* Insert NAME as undefined in the symbol table. */
2052 insert_undefined (name
)
2055 struct bfd_link_hash_entry
*h
;
2057 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, false, true);
2058 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2059 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2060 if (h
->type
== bfd_link_hash_new
)
2062 h
->type
= bfd_link_hash_undefined
;
2063 h
->u
.undef
.abfd
= NULL
;
2064 bfd_link_add_undef (link_info
.hash
, h
);
2068 /* Run through the list of undefineds created above and place them
2069 into the linker hash table as undefined symbols belonging to the
2073 lang_place_undefineds ()
2075 ldlang_undef_chain_list_type
*ptr
;
2077 for (ptr
= ldlang_undef_chain_list_head
;
2078 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
2081 insert_undefined (ptr
->name
);
2085 /* Open input files and attatch to output sections. */
2088 map_input_to_output_sections (s
, target
, output_section_statement
)
2089 lang_statement_union_type
*s
;
2091 lang_output_section_statement_type
*output_section_statement
;
2093 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2095 switch (s
->header
.type
)
2097 case lang_wild_statement_enum
:
2098 wild (&s
->wild_statement
, target
, output_section_statement
);
2100 case lang_constructors_statement_enum
:
2101 map_input_to_output_sections (constructor_list
.head
,
2103 output_section_statement
);
2105 case lang_output_section_statement_enum
:
2106 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2108 &s
->output_section_statement
);
2110 case lang_output_statement_enum
:
2112 case lang_target_statement_enum
:
2113 target
= s
->target_statement
.target
;
2115 case lang_group_statement_enum
:
2116 map_input_to_output_sections (s
->group_statement
.children
.head
,
2118 output_section_statement
);
2120 case lang_fill_statement_enum
:
2121 case lang_input_section_enum
:
2122 case lang_object_symbols_statement_enum
:
2123 case lang_data_statement_enum
:
2124 case lang_reloc_statement_enum
:
2125 case lang_padding_statement_enum
:
2126 case lang_input_statement_enum
:
2127 if (output_section_statement
!= NULL
2128 && output_section_statement
->bfd_section
== NULL
)
2129 init_os (output_section_statement
);
2131 case lang_assignment_statement_enum
:
2132 if (output_section_statement
!= NULL
2133 && output_section_statement
->bfd_section
== NULL
)
2134 init_os (output_section_statement
);
2136 /* Make sure that any sections mentioned in the assignment
2138 exp_init_os (s
->assignment_statement
.exp
);
2140 case lang_afile_asection_pair_statement_enum
:
2143 case lang_address_statement_enum
:
2144 /* Mark the specified section with the supplied address. */
2146 lang_output_section_statement_type
*os
=
2147 lang_output_section_statement_lookup
2148 (s
->address_statement
.section_name
);
2150 if (os
->bfd_section
== NULL
)
2152 os
->addr_tree
= s
->address_statement
.address
;
2160 print_output_section_statement (output_section_statement
)
2161 lang_output_section_statement_type
*output_section_statement
;
2163 asection
*section
= output_section_statement
->bfd_section
;
2166 if (output_section_statement
!= abs_output_section
)
2168 minfo ("\n%s", output_section_statement
->name
);
2170 if (section
!= NULL
)
2172 print_dot
= section
->vma
;
2174 len
= strlen (output_section_statement
->name
);
2175 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2180 while (len
< SECTION_NAME_MAP_LENGTH
)
2186 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2188 if (output_section_statement
->load_base
!= NULL
)
2192 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2193 "load base", lang_final_phase_enum
);
2194 minfo (_(" load address 0x%V"), addr
);
2201 print_statement_list (output_section_statement
->children
.head
,
2202 output_section_statement
);
2206 print_assignment (assignment
, output_section
)
2207 lang_assignment_statement_type
*assignment
;
2208 lang_output_section_statement_type
*output_section
;
2211 etree_value_type result
;
2213 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2216 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2217 lang_final_phase_enum
, print_dot
, &print_dot
);
2223 value
= result
.value
+ result
.section
->bfd_section
->vma
;
2224 dst
= assignment
->exp
->assign
.dst
;
2226 minfo ("0x%V", value
);
2227 if (dst
[0] == '.' && dst
[1] == 0)
2240 exp_print_tree (assignment
->exp
);
2246 print_input_statement (statm
)
2247 lang_input_statement_type
*statm
;
2249 if (statm
->filename
!= (char *) NULL
)
2251 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2255 /* Print all symbols defined in a particular section. This is called
2256 via bfd_link_hash_traverse. */
2259 print_one_symbol (hash_entry
, ptr
)
2260 struct bfd_link_hash_entry
*hash_entry
;
2263 asection
*sec
= (asection
*) ptr
;
2265 if ((hash_entry
->type
== bfd_link_hash_defined
2266 || hash_entry
->type
== bfd_link_hash_defweak
)
2267 && sec
== hash_entry
->u
.def
.section
)
2271 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2274 (hash_entry
->u
.def
.value
2275 + hash_entry
->u
.def
.section
->output_offset
2276 + hash_entry
->u
.def
.section
->output_section
->vma
));
2278 minfo (" %T\n", hash_entry
->root
.string
);
2284 /* Print information about an input section to the map file. */
2287 print_input_section (in
)
2288 lang_input_section_type
*in
;
2290 asection
*i
= in
->section
;
2291 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2292 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2293 ldfile_output_machine
);
2298 minfo ("%s", i
->name
);
2300 if (i
->output_section
!= NULL
)
2304 len
= 1 + strlen (i
->name
);
2305 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2310 while (len
< SECTION_NAME_MAP_LENGTH
)
2316 minfo ("0x%V %W %B\n",
2317 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2320 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2322 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2334 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2337 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2339 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2345 print_fill_statement (fill
)
2346 lang_fill_statement_type
*fill
;
2350 fputs (" FILL mask 0x", config
.map_file
);
2351 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
2352 fprintf (config
.map_file
, "%02x", *p
);
2353 fputs ("\n", config
.map_file
);
2357 print_data_statement (data
)
2358 lang_data_statement_type
*data
;
2364 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2365 ldfile_output_machine
);
2367 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2370 addr
= data
->output_vma
;
2371 if (data
->output_section
!= NULL
)
2372 addr
+= data
->output_section
->vma
;
2400 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2402 if (data
->exp
->type
.node_class
!= etree_value
)
2405 exp_print_tree (data
->exp
);
2410 print_dot
= addr
+ size
/ opb
;
2414 /* Print an address statement. These are generated by options like
2418 print_address_statement (address
)
2419 lang_address_statement_type
*address
;
2421 minfo (_("Address of section %s set to "), address
->section_name
);
2422 exp_print_tree (address
->address
);
2426 /* Print a reloc statement. */
2429 print_reloc_statement (reloc
)
2430 lang_reloc_statement_type
*reloc
;
2435 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2436 ldfile_output_machine
);
2438 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2441 addr
= reloc
->output_vma
;
2442 if (reloc
->output_section
!= NULL
)
2443 addr
+= reloc
->output_section
->vma
;
2445 size
= bfd_get_reloc_size (reloc
->howto
);
2447 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2449 if (reloc
->name
!= NULL
)
2450 minfo ("%s+", reloc
->name
);
2452 minfo ("%s+", reloc
->section
->name
);
2454 exp_print_tree (reloc
->addend_exp
);
2458 print_dot
= addr
+ size
/ opb
;
2462 print_padding_statement (s
)
2463 lang_padding_statement_type
*s
;
2467 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2468 ldfile_output_machine
);
2472 len
= sizeof " *fill*" - 1;
2473 while (len
< SECTION_NAME_MAP_LENGTH
)
2479 addr
= s
->output_offset
;
2480 if (s
->output_section
!= NULL
)
2481 addr
+= s
->output_section
->vma
;
2482 minfo ("0x%V %W ", addr
, s
->size
);
2484 if (s
->fill
->size
!= 0)
2488 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
2489 fprintf (config
.map_file
, "%02x", *p
);
2494 print_dot
= addr
+ s
->size
/ opb
;
2498 print_wild_statement (w
, os
)
2499 lang_wild_statement_type
*w
;
2500 lang_output_section_statement_type
*os
;
2502 struct wildcard_list
*sec
;
2506 if (w
->filenames_sorted
)
2508 if (w
->filename
!= NULL
)
2509 minfo ("%s", w
->filename
);
2512 if (w
->filenames_sorted
)
2516 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
2518 if (sec
->spec
.sorted
)
2520 if (sec
->spec
.exclude_name_list
!= NULL
)
2523 minfo ("EXCLUDE_FILE ( %s", sec
->spec
.exclude_name_list
->name
);
2524 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
2525 minfo (", %s", tmp
->name
);
2528 if (sec
->spec
.name
!= NULL
)
2529 minfo ("%s", sec
->spec
.name
);
2532 if (sec
->spec
.sorted
)
2539 print_statement_list (w
->children
.head
, os
);
2542 /* Print a group statement. */
2546 lang_group_statement_type
*s
;
2547 lang_output_section_statement_type
*os
;
2549 fprintf (config
.map_file
, "START GROUP\n");
2550 print_statement_list (s
->children
.head
, os
);
2551 fprintf (config
.map_file
, "END GROUP\n");
2554 /* Print the list of statements in S.
2555 This can be called for any statement type. */
2558 print_statement_list (s
, os
)
2559 lang_statement_union_type
*s
;
2560 lang_output_section_statement_type
*os
;
2564 print_statement (s
, os
);
2569 /* Print the first statement in statement list S.
2570 This can be called for any statement type. */
2573 print_statement (s
, os
)
2574 lang_statement_union_type
*s
;
2575 lang_output_section_statement_type
*os
;
2577 switch (s
->header
.type
)
2580 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2583 case lang_constructors_statement_enum
:
2584 if (constructor_list
.head
!= NULL
)
2586 if (constructors_sorted
)
2587 minfo (" SORT (CONSTRUCTORS)\n");
2589 minfo (" CONSTRUCTORS\n");
2590 print_statement_list (constructor_list
.head
, os
);
2593 case lang_wild_statement_enum
:
2594 print_wild_statement (&s
->wild_statement
, os
);
2596 case lang_address_statement_enum
:
2597 print_address_statement (&s
->address_statement
);
2599 case lang_object_symbols_statement_enum
:
2600 minfo (" CREATE_OBJECT_SYMBOLS\n");
2602 case lang_fill_statement_enum
:
2603 print_fill_statement (&s
->fill_statement
);
2605 case lang_data_statement_enum
:
2606 print_data_statement (&s
->data_statement
);
2608 case lang_reloc_statement_enum
:
2609 print_reloc_statement (&s
->reloc_statement
);
2611 case lang_input_section_enum
:
2612 print_input_section (&s
->input_section
);
2614 case lang_padding_statement_enum
:
2615 print_padding_statement (&s
->padding_statement
);
2617 case lang_output_section_statement_enum
:
2618 print_output_section_statement (&s
->output_section_statement
);
2620 case lang_assignment_statement_enum
:
2621 print_assignment (&s
->assignment_statement
, os
);
2623 case lang_target_statement_enum
:
2624 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2626 case lang_output_statement_enum
:
2627 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2628 if (output_target
!= NULL
)
2629 minfo (" %s", output_target
);
2632 case lang_input_statement_enum
:
2633 print_input_statement (&s
->input_statement
);
2635 case lang_group_statement_enum
:
2636 print_group (&s
->group_statement
, os
);
2638 case lang_afile_asection_pair_statement_enum
:
2647 print_statement_list (statement_list
.head
, abs_output_section
);
2650 /* Print the first N statements in statement list S to STDERR.
2651 If N == 0, nothing is printed.
2652 If N < 0, the entire list is printed.
2653 Intended to be called from GDB. */
2656 dprint_statement (s
, n
)
2657 lang_statement_union_type
*s
;
2660 FILE *map_save
= config
.map_file
;
2662 config
.map_file
= stderr
;
2665 print_statement_list (s
, abs_output_section
);
2668 while (s
&& --n
>= 0)
2670 print_statement (s
, abs_output_section
);
2675 config
.map_file
= map_save
;
2679 insert_pad (ptr
, fill
, alignment_needed
, output_section
, dot
)
2680 lang_statement_union_type
**ptr
;
2682 unsigned int alignment_needed
;
2683 asection
*output_section
;
2686 static fill_type zero_fill
= { 1, { 0 } };
2687 lang_statement_union_type
*pad
;
2689 pad
= ((lang_statement_union_type
*)
2690 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
2691 if (ptr
!= &statement_list
.head
2692 && pad
->header
.type
== lang_padding_statement_enum
2693 && pad
->padding_statement
.output_section
== output_section
)
2695 /* Use the existing pad statement. The above test on output
2696 section is probably redundant, but it doesn't hurt to check. */
2700 /* Make a new padding statement, linked into existing chain. */
2701 pad
= ((lang_statement_union_type
*)
2702 stat_alloc (sizeof (lang_padding_statement_type
)));
2703 pad
->header
.next
= *ptr
;
2705 pad
->header
.type
= lang_padding_statement_enum
;
2706 pad
->padding_statement
.output_section
= output_section
;
2707 if (fill
== (fill_type
*) 0)
2709 pad
->padding_statement
.fill
= fill
;
2711 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
2712 pad
->padding_statement
.size
= alignment_needed
;
2713 output_section
->_raw_size
+= alignment_needed
;
2716 /* Work out how much this section will move the dot point. */
2719 size_input_section (this_ptr
, output_section_statement
, fill
, dot
)
2720 lang_statement_union_type
**this_ptr
;
2721 lang_output_section_statement_type
*output_section_statement
;
2725 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2726 asection
*i
= is
->section
;
2728 if (is
->ifile
->just_syms_flag
== false)
2730 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2731 ldfile_output_machine
);
2732 unsigned int alignment_needed
;
2735 /* Align this section first to the input sections requirement,
2736 then to the output section's requirement. If this alignment
2737 is greater than any seen before, then record it too. Perform
2738 the alignment by inserting a magic 'padding' statement. */
2740 if (output_section_statement
->subsection_alignment
!= -1)
2741 i
->alignment_power
= output_section_statement
->subsection_alignment
;
2743 o
= output_section_statement
->bfd_section
;
2744 if (o
->alignment_power
< i
->alignment_power
)
2745 o
->alignment_power
= i
->alignment_power
;
2747 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
2749 if (alignment_needed
!= 0)
2751 insert_pad (this_ptr
, fill
, alignment_needed
* opb
, o
, dot
);
2752 dot
+= alignment_needed
;
2755 /* Remember where in the output section this input section goes. */
2757 i
->output_offset
= dot
- o
->vma
;
2759 /* Mark how big the output section must be to contain this now. */
2760 if (i
->_cooked_size
!= 0)
2761 dot
+= i
->_cooked_size
/ opb
;
2763 dot
+= i
->_raw_size
/ opb
;
2764 o
->_raw_size
= (dot
- o
->vma
) * opb
;
2768 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2774 #define IGNORE_SECTION(bfd, s) \
2775 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2776 != (SEC_ALLOC | SEC_LOAD)) \
2777 || bfd_section_size (bfd, s) == 0)
2779 /* Check to see if any allocated sections overlap with other allocated
2780 sections. This can happen when the linker script specifically specifies
2781 the output section addresses of the two sections. */
2784 lang_check_section_addresses ()
2787 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2789 /* Scan all sections in the output list. */
2790 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2794 /* Ignore sections which are not loaded or which have no contents. */
2795 if (IGNORE_SECTION (output_bfd
, s
))
2798 /* Once we reach section 's' stop our seach. This prevents two
2799 warning messages from being produced, one for 'section A overlaps
2800 section B' and one for 'section B overlaps section A'. */
2801 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2808 /* Only consider loadable sections with real contents. */
2809 if (IGNORE_SECTION (output_bfd
, os
))
2812 /* We must check the sections' LMA addresses not their
2813 VMA addresses because overlay sections can have
2814 overlapping VMAs but they must have distinct LMAs. */
2815 s_start
= bfd_section_lma (output_bfd
, s
);
2816 os_start
= bfd_section_lma (output_bfd
, os
);
2817 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2818 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2820 /* Look for an overlap. */
2821 if ((s_end
< os_start
) || (s_start
> os_end
))
2825 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2826 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2828 /* Once we have found one overlap for this section,
2829 stop looking for others. */
2835 /* Make sure the new address is within the region. We explicitly permit the
2836 current address to be at the exact end of the region when the address is
2837 non-zero, in case the region is at the end of addressable memory and the
2838 calculation wraps around. */
2841 os_region_check (os
, region
, tree
, base
)
2842 lang_output_section_statement_type
*os
;
2843 struct memory_region_struct
*region
;
2847 if ((region
->current
< region
->origin
2848 || (region
->current
- region
->origin
> region
->length
))
2849 && ((region
->current
!= region
->origin
+ region
->length
)
2852 if (tree
!= (etree_type
*) NULL
)
2854 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2856 os
->bfd_section
->owner
,
2857 os
->bfd_section
->name
,
2862 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2864 os
->bfd_section
->owner
,
2865 os
->bfd_section
->name
);
2867 /* Reset the region pointer. */
2868 region
->current
= region
->origin
;
2872 /* Set the sizes for all the output sections. */
2875 lang_size_sections_1 (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2876 lang_statement_union_type
*s
;
2877 lang_output_section_statement_type
*output_section_statement
;
2878 lang_statement_union_type
**prev
;
2883 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2884 ldfile_output_machine
);
2886 /* Size up the sections from their constituent parts. */
2887 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2889 switch (s
->header
.type
)
2891 case lang_output_section_statement_enum
:
2894 lang_output_section_statement_type
*os
;
2896 os
= &s
->output_section_statement
;
2897 if (os
->bfd_section
== NULL
)
2898 /* This section was never actually created. */
2901 /* If this is a COFF shared library section, use the size and
2902 address from the input section. FIXME: This is COFF
2903 specific; it would be cleaner if there were some other way
2904 to do this, but nothing simple comes to mind. */
2905 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2909 if (os
->children
.head
== NULL
2910 || os
->children
.head
->header
.next
!= NULL
2911 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2912 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2915 input
= os
->children
.head
->input_section
.section
;
2916 bfd_set_section_vma (os
->bfd_section
->owner
,
2918 bfd_section_vma (input
->owner
, input
));
2919 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2923 if (bfd_is_abs_section (os
->bfd_section
))
2925 /* No matter what happens, an abs section starts at zero. */
2926 ASSERT (os
->bfd_section
->vma
== 0);
2930 if (os
->addr_tree
== (etree_type
*) NULL
)
2932 /* No address specified for this section, get one
2933 from the region specification. */
2934 if (os
->region
== (lang_memory_region_type
*) NULL
2935 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2936 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2937 && os
->region
->name
[0] == '*'
2938 && strcmp (os
->region
->name
, "*default*") == 0))
2940 os
->region
= lang_memory_default (os
->bfd_section
);
2943 /* If a loadable section is using the default memory
2944 region, and some non default memory regions were
2945 defined, issue a warning. */
2946 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2947 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2948 && (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2949 & SEC_NEVER_LOAD
) == 0
2950 && ! link_info
.relocateable
2951 && strcmp (os
->region
->name
, "*default*") == 0
2952 && lang_memory_region_list
!= NULL
2953 && (strcmp (lang_memory_region_list
->name
,
2955 || lang_memory_region_list
->next
!= NULL
))
2956 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2957 bfd_get_section_name (output_bfd
,
2960 dot
= os
->region
->current
;
2962 if (os
->section_alignment
== -1)
2967 dot
= align_power (dot
,
2968 os
->bfd_section
->alignment_power
);
2970 if (dot
!= olddot
&& config
.warn_section_align
)
2971 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2972 os
->name
, (unsigned int) (dot
- olddot
));
2979 r
= exp_fold_tree (os
->addr_tree
,
2981 lang_allocating_phase_enum
,
2983 if (r
.valid_p
== false)
2985 einfo (_("%F%S: non constant address expression for section %s\n"),
2988 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2991 /* The section starts here.
2992 First, align to what the section needs. */
2994 if (os
->section_alignment
!= -1)
2995 dot
= align_power (dot
, os
->section_alignment
);
2997 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2999 os
->bfd_section
->output_offset
= 0;
3002 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
3003 os
->fill
, dot
, relax
);
3005 /* Put the section within the requested block size, or
3006 align at the block boundary. */
3007 after
= ALIGN_N (os
->bfd_section
->vma
3008 + os
->bfd_section
->_raw_size
/ opb
,
3009 /* The coercion here is important, see ld.h. */
3010 (bfd_vma
) os
->block_value
);
3012 if (bfd_is_abs_section (os
->bfd_section
))
3013 ASSERT (after
== os
->bfd_section
->vma
);
3015 os
->bfd_section
->_raw_size
=
3016 (after
- os
->bfd_section
->vma
) * opb
;
3018 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3019 os
->processed
= true;
3021 if (os
->update_dot_tree
!= 0)
3022 exp_fold_tree (os
->update_dot_tree
, abs_output_section
,
3023 lang_allocating_phase_enum
, dot
, &dot
);
3025 /* Update dot in the region ?
3026 We only do this if the section is going to be allocated,
3027 since unallocated sections do not contribute to the region's
3028 overall size in memory.
3030 If the SEC_NEVER_LOAD bit is not set, it will affect the
3031 addresses of sections after it. We have to update
3033 if (os
->region
!= (lang_memory_region_type
*) NULL
3034 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3035 & SEC_NEVER_LOAD
) == 0
3036 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3037 & (SEC_ALLOC
| SEC_LOAD
))))
3039 os
->region
->current
= dot
;
3041 /* Make sure the new address is within the region. */
3042 os_region_check (os
, os
->region
, os
->addr_tree
,
3043 os
->bfd_section
->vma
);
3045 /* If there's no load address specified, use the run
3046 region as the load region. */
3047 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
3048 os
->lma_region
= os
->region
;
3050 if (os
->lma_region
!= NULL
)
3052 if (os
->load_base
!= NULL
)
3054 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
3058 /* Don't allocate twice. */
3059 if (os
->lma_region
!= os
->region
)
3061 /* Set load_base, which will be handled later. */
3063 exp_intop (os
->lma_region
->current
);
3064 os
->lma_region
->current
+=
3065 os
->bfd_section
->_raw_size
/ opb
;
3066 os_region_check (os
, os
->lma_region
, NULL
,
3067 os
->bfd_section
->lma
);
3075 case lang_constructors_statement_enum
:
3076 dot
= lang_size_sections_1 (constructor_list
.head
,
3077 output_section_statement
,
3078 &s
->wild_statement
.children
.head
,
3082 case lang_data_statement_enum
:
3084 unsigned int size
= 0;
3086 s
->data_statement
.output_vma
=
3087 dot
- output_section_statement
->bfd_section
->vma
;
3088 s
->data_statement
.output_section
=
3089 output_section_statement
->bfd_section
;
3091 switch (s
->data_statement
.type
)
3112 output_section_statement
->bfd_section
->_raw_size
+= size
;
3113 /* The output section gets contents, and then we inspect for
3114 any flags set in the input script which override any ALLOC. */
3115 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3116 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3118 output_section_statement
->bfd_section
->flags
|=
3119 SEC_ALLOC
| SEC_LOAD
;
3124 case lang_reloc_statement_enum
:
3128 s
->reloc_statement
.output_vma
=
3129 dot
- output_section_statement
->bfd_section
->vma
;
3130 s
->reloc_statement
.output_section
=
3131 output_section_statement
->bfd_section
;
3132 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3134 output_section_statement
->bfd_section
->_raw_size
+= size
;
3138 case lang_wild_statement_enum
:
3140 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
3141 output_section_statement
,
3142 &s
->wild_statement
.children
.head
,
3147 case lang_object_symbols_statement_enum
:
3148 link_info
.create_object_symbols_section
=
3149 output_section_statement
->bfd_section
;
3151 case lang_output_statement_enum
:
3152 case lang_target_statement_enum
:
3154 case lang_input_section_enum
:
3158 i
= (*prev
)->input_section
.section
;
3161 if (i
->_cooked_size
== 0)
3162 i
->_cooked_size
= i
->_raw_size
;
3168 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3169 einfo (_("%P%F: can't relax section: %E\n"));
3173 dot
= size_input_section (prev
, output_section_statement
,
3174 output_section_statement
->fill
, dot
);
3177 case lang_input_statement_enum
:
3179 case lang_fill_statement_enum
:
3180 s
->fill_statement
.output_section
=
3181 output_section_statement
->bfd_section
;
3183 fill
= s
->fill_statement
.fill
;
3185 case lang_assignment_statement_enum
:
3187 bfd_vma newdot
= dot
;
3189 exp_fold_tree (s
->assignment_statement
.exp
,
3190 output_section_statement
,
3191 lang_allocating_phase_enum
,
3197 if (output_section_statement
== abs_output_section
)
3199 /* If we don't have an output section, then just adjust
3200 the default memory address. */
3201 lang_memory_region_lookup ("*default*")->current
= newdot
;
3205 /* Insert a pad after this statement. We can't
3206 put the pad before when relaxing, in case the
3207 assignment references dot. */
3208 insert_pad (&s
->header
.next
, fill
, (newdot
- dot
) * opb
,
3209 output_section_statement
->bfd_section
, dot
);
3211 /* Don't neuter the pad below when relaxing. */
3220 case lang_padding_statement_enum
:
3221 /* If this is the first time lang_size_sections is called,
3222 we won't have any padding statements. If this is the
3223 second or later passes when relaxing, we should allow
3224 padding to shrink. If padding is needed on this pass, it
3225 will be added back in. */
3226 s
->padding_statement
.size
= 0;
3228 /* Make sure output_offset is valid. If relaxation shrinks
3229 the section and this pad isn't needed, it's possible to
3230 have output_offset larger than the final size of the
3231 section. bfd_set_section_contents will complain even for
3232 a pad size of zero. */
3233 s
->padding_statement
.output_offset
3234 = dot
- output_section_statement
->bfd_section
->vma
;
3237 case lang_group_statement_enum
:
3238 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
3239 output_section_statement
,
3240 &s
->group_statement
.children
.head
,
3248 /* We can only get here when relaxing is turned on. */
3249 case lang_address_statement_enum
:
3252 prev
= &s
->header
.next
;
3258 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
3259 lang_statement_union_type
*s
;
3260 lang_output_section_statement_type
*output_section_statement
;
3261 lang_statement_union_type
**prev
;
3268 exp_data_seg
.phase
= exp_dataseg_none
;
3269 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
3271 if (exp_data_seg
.phase
== exp_dataseg_end_seen
)
3273 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3274 a page could be saved in the data segment. */
3275 bfd_vma first
, last
;
3277 first
= -exp_data_seg
.base
& (exp_data_seg
.pagesize
- 1);
3278 last
= exp_data_seg
.end
& (exp_data_seg
.pagesize
- 1);
3280 && ((exp_data_seg
.base
& ~(exp_data_seg
.pagesize
- 1))
3281 != (exp_data_seg
.end
& ~(exp_data_seg
.pagesize
- 1)))
3282 && first
+ last
<= exp_data_seg
.pagesize
)
3284 exp_data_seg
.phase
= exp_dataseg_adjust
;
3285 result
= lang_size_sections_1 (s
, output_section_statement
, prev
,
3294 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3295 lang_statement_union_type
*s
;
3296 lang_output_section_statement_type
*output_section_statement
;
3300 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3301 ldfile_output_machine
);
3303 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3305 switch (s
->header
.type
)
3307 case lang_constructors_statement_enum
:
3308 dot
= lang_do_assignments (constructor_list
.head
,
3309 output_section_statement
,
3314 case lang_output_section_statement_enum
:
3316 lang_output_section_statement_type
*os
;
3318 os
= &(s
->output_section_statement
);
3319 if (os
->bfd_section
!= NULL
)
3321 dot
= os
->bfd_section
->vma
;
3322 (void) lang_do_assignments (os
->children
.head
, os
,
3324 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3329 /* If nothing has been placed into the output section then
3330 it won't have a bfd_section. */
3331 if (os
->bfd_section
)
3333 os
->bfd_section
->lma
3334 = exp_get_abs_int (os
->load_base
, 0, "load base",
3335 lang_final_phase_enum
);
3340 case lang_wild_statement_enum
:
3342 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3343 output_section_statement
,
3348 case lang_object_symbols_statement_enum
:
3349 case lang_output_statement_enum
:
3350 case lang_target_statement_enum
:
3352 case lang_common_statement_enum
:
3355 case lang_data_statement_enum
:
3357 etree_value_type value
;
3359 value
= exp_fold_tree (s
->data_statement
.exp
,
3361 lang_final_phase_enum
, dot
, &dot
);
3362 s
->data_statement
.value
= value
.value
;
3363 if (value
.valid_p
== false)
3364 einfo (_("%F%P: invalid data statement\n"));
3368 switch (s
->data_statement
.type
)
3392 case lang_reloc_statement_enum
:
3394 etree_value_type value
;
3396 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3398 lang_final_phase_enum
, dot
, &dot
);
3399 s
->reloc_statement
.addend_value
= value
.value
;
3400 if (value
.valid_p
== false)
3401 einfo (_("%F%P: invalid reloc statement\n"));
3403 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3406 case lang_input_section_enum
:
3408 asection
*in
= s
->input_section
.section
;
3410 if (in
->_cooked_size
!= 0)
3411 dot
+= in
->_cooked_size
/ opb
;
3413 dot
+= in
->_raw_size
/ opb
;
3417 case lang_input_statement_enum
:
3419 case lang_fill_statement_enum
:
3420 fill
= s
->fill_statement
.fill
;
3422 case lang_assignment_statement_enum
:
3424 exp_fold_tree (s
->assignment_statement
.exp
,
3425 output_section_statement
,
3426 lang_final_phase_enum
,
3432 case lang_padding_statement_enum
:
3433 dot
+= s
->padding_statement
.size
/ opb
;
3436 case lang_group_statement_enum
:
3437 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3438 output_section_statement
,
3446 case lang_address_statement_enum
:
3454 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3455 operator .startof. (section_name), it produces an undefined symbol
3456 .startof.section_name. Similarly, when it sees
3457 .sizeof. (section_name), it produces an undefined symbol
3458 .sizeof.section_name. For all the output sections, we look for
3459 such symbols, and set them to the correct value. */
3466 if (link_info
.relocateable
)
3469 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3471 const char *secname
;
3473 struct bfd_link_hash_entry
*h
;
3475 secname
= bfd_get_section_name (output_bfd
, s
);
3476 buf
= xmalloc (10 + strlen (secname
));
3478 sprintf (buf
, ".startof.%s", secname
);
3479 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3480 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3482 h
->type
= bfd_link_hash_defined
;
3483 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3484 h
->u
.def
.section
= bfd_abs_section_ptr
;
3487 sprintf (buf
, ".sizeof.%s", secname
);
3488 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3489 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3493 opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3494 ldfile_output_machine
);
3495 h
->type
= bfd_link_hash_defined
;
3496 if (s
->_cooked_size
!= 0)
3497 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3499 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3500 h
->u
.def
.section
= bfd_abs_section_ptr
;
3510 struct bfd_link_hash_entry
*h
;
3513 if (link_info
.relocateable
|| link_info
.shared
)
3518 if (entry_symbol
== (char *) NULL
)
3520 /* No entry has been specified. Look for start, but don't warn
3521 if we don't find it. */
3522 entry_symbol
= "start";
3526 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
3527 if (h
!= (struct bfd_link_hash_entry
*) NULL
3528 && (h
->type
== bfd_link_hash_defined
3529 || h
->type
== bfd_link_hash_defweak
)
3530 && h
->u
.def
.section
->output_section
!= NULL
)
3534 val
= (h
->u
.def
.value
3535 + bfd_get_section_vma (output_bfd
,
3536 h
->u
.def
.section
->output_section
)
3537 + h
->u
.def
.section
->output_offset
);
3538 if (! bfd_set_start_address (output_bfd
, val
))
3539 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
);
3546 /* We couldn't find the entry symbol. Try parsing it as a
3548 val
= bfd_scan_vma (entry_symbol
, &send
, 0);
3551 if (! bfd_set_start_address (output_bfd
, val
))
3552 einfo (_("%P%F: can't set start address\n"));
3558 /* Can't find the entry symbol, and it's not a number. Use
3559 the first address in the text section. */
3560 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
3561 if (ts
!= (asection
*) NULL
)
3564 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3565 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
3566 if (! bfd_set_start_address (output_bfd
,
3567 bfd_get_section_vma (output_bfd
,
3569 einfo (_("%P%F: can't set start address\n"));
3574 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3581 /* This is a small function used when we want to ignore errors from
3585 #ifdef ANSI_PROTOTYPES
3586 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3588 ignore_bfd_errors (s
)
3589 const char *s ATTRIBUTE_UNUSED
;
3592 /* Don't do anything. */
3595 /* Check that the architecture of all the input files is compatible
3596 with the output file. Also call the backend to let it do any
3597 other checking that is needed. */
3602 lang_statement_union_type
*file
;
3604 const bfd_arch_info_type
*compatible
;
3606 for (file
= file_chain
.head
;
3607 file
!= (lang_statement_union_type
*) NULL
;
3608 file
= file
->input_statement
.next
)
3610 input_bfd
= file
->input_statement
.the_bfd
;
3611 compatible
= bfd_arch_get_compatible (input_bfd
, output_bfd
);
3613 /* In general it is not possible to perform a relocatable
3614 link between differing object formats when the input
3615 file has relocations, because the relocations in the
3616 input format may not have equivalent representations in
3617 the output format (and besides BFD does not translate
3618 relocs for other link purposes than a final link). */
3619 if ((link_info
.relocateable
|| link_info
.emitrelocations
)
3620 && (compatible
== NULL
3621 || bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
3622 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
3624 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3625 bfd_get_target (input_bfd
), input_bfd
,
3626 bfd_get_target (output_bfd
), output_bfd
);
3627 /* einfo with %F exits. */
3630 if (compatible
== NULL
)
3632 if (command_line
.warn_mismatch
)
3633 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3634 bfd_printable_name (input_bfd
), input_bfd
,
3635 bfd_printable_name (output_bfd
));
3637 else if (bfd_count_sections (input_bfd
))
3639 /* If the input bfd has no contents, it shouldn't set the
3640 private data of the output bfd. */
3642 bfd_error_handler_type pfn
= NULL
;
3644 /* If we aren't supposed to warn about mismatched input
3645 files, temporarily set the BFD error handler to a
3646 function which will do nothing. We still want to call
3647 bfd_merge_private_bfd_data, since it may set up
3648 information which is needed in the output file. */
3649 if (! command_line
.warn_mismatch
)
3650 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3651 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3653 if (command_line
.warn_mismatch
)
3654 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3657 if (! command_line
.warn_mismatch
)
3658 bfd_set_error_handler (pfn
);
3663 /* Look through all the global common symbols and attach them to the
3664 correct section. The -sort-common command line switch may be used
3665 to roughly sort the entries by size. */
3670 if (command_line
.inhibit_common_definition
)
3672 if (link_info
.relocateable
3673 && ! command_line
.force_common_definition
)
3676 if (! config
.sort_common
)
3677 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3682 for (power
= 4; power
>= 0; power
--)
3683 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3688 /* Place one common symbol in the correct section. */
3691 lang_one_common (h
, info
)
3692 struct bfd_link_hash_entry
*h
;
3695 unsigned int power_of_two
;
3698 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3699 ldfile_output_machine
);
3701 if (h
->type
!= bfd_link_hash_common
)
3705 power_of_two
= h
->u
.c
.p
->alignment_power
;
3707 if (config
.sort_common
3708 && power_of_two
< (unsigned int) *(int *) info
)
3711 section
= h
->u
.c
.p
->section
;
3713 /* Increase the size of the section. */
3714 section
->_cooked_size
= ALIGN_N ((section
->_cooked_size
+ opb
- 1) / opb
,
3715 (bfd_size_type
) (1 << power_of_two
)) * opb
;
3717 /* Adjust the alignment if necessary. */
3718 if (power_of_two
> section
->alignment_power
)
3719 section
->alignment_power
= power_of_two
;
3721 /* Change the symbol from common to defined. */
3722 h
->type
= bfd_link_hash_defined
;
3723 h
->u
.def
.section
= section
;
3724 h
->u
.def
.value
= section
->_cooked_size
;
3726 /* Increase the size of the section. */
3727 section
->_cooked_size
+= size
;
3729 /* Make sure the section is allocated in memory, and make sure that
3730 it is no longer a common section. */
3731 section
->flags
|= SEC_ALLOC
;
3732 section
->flags
&= ~SEC_IS_COMMON
;
3734 if (config
.map_file
!= NULL
)
3736 static boolean header_printed
;
3741 if (! header_printed
)
3743 minfo (_("\nAllocating common symbols\n"));
3744 minfo (_("Common symbol size file\n\n"));
3745 header_printed
= true;
3748 name
= demangle (h
->root
.string
);
3750 len
= strlen (name
);
3765 if (size
<= 0xffffffff)
3766 sprintf (buf
, "%lx", (unsigned long) size
);
3768 sprintf_vma (buf
, size
);
3778 minfo ("%B\n", section
->owner
);
3784 /* Run through the input files and ensure that every input section has
3785 somewhere to go. If one is found without a destination then create
3786 an input request and place it into the statement tree. */
3789 lang_place_orphans ()
3791 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3795 for (s
= file
->the_bfd
->sections
;
3796 s
!= (asection
*) NULL
;
3799 if (s
->output_section
== (asection
*) NULL
)
3801 /* This section of the file is not attatched, root
3802 around for a sensible place for it to go. */
3804 if (file
->just_syms_flag
)
3806 /* We are only retrieving symbol values from this
3807 file. We want the symbols to act as though the
3808 values in the file are absolute. */
3809 s
->output_section
= bfd_abs_section_ptr
;
3810 s
->output_offset
= s
->vma
;
3812 else if (strcmp (s
->name
, "COMMON") == 0)
3814 /* This is a lonely common section which must have
3815 come from an archive. We attach to the section
3816 with the wildcard. */
3817 if (! link_info
.relocateable
3818 || command_line
.force_common_definition
)
3820 if (default_common_section
== NULL
)
3823 /* This message happens when using the
3824 svr3.ifile linker script, so I have
3826 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3828 default_common_section
=
3829 lang_output_section_statement_lookup (".bss");
3832 lang_add_section (&default_common_section
->children
, s
,
3833 default_common_section
, file
);
3836 else if (ldemul_place_orphan (file
, s
))
3840 lang_output_section_statement_type
*os
;
3842 os
= lang_output_section_statement_lookup (s
->name
);
3843 lang_add_section (&os
->children
, s
, os
, file
);
3851 lang_set_flags (ptr
, flags
, invert
)
3852 lang_memory_region_type
*ptr
;
3856 flagword
*ptr_flags
;
3858 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3864 *ptr_flags
|= SEC_ALLOC
;
3868 *ptr_flags
|= SEC_READONLY
;
3872 *ptr_flags
|= SEC_DATA
;
3876 *ptr_flags
|= SEC_CODE
;
3881 *ptr_flags
|= SEC_LOAD
;
3885 einfo (_("%P%F: invalid syntax in flags\n"));
3892 /* Call a function on each input file. This function will be called
3893 on an archive, but not on the elements. */
3896 lang_for_each_input_file (func
)
3897 void (*func
) PARAMS ((lang_input_statement_type
*));
3899 lang_input_statement_type
*f
;
3901 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3903 f
= (lang_input_statement_type
*) f
->next_real_file
)
3907 /* Call a function on each file. The function will be called on all
3908 the elements of an archive which are included in the link, but will
3909 not be called on the archive file itself. */
3912 lang_for_each_file (func
)
3913 void (*func
) PARAMS ((lang_input_statement_type
*));
3915 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3926 lang_for_each_input_section (func
)
3927 void (*func
) PARAMS ((bfd
*ab
, asection
*as
));
3929 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3933 for (s
= f
->the_bfd
->sections
;
3934 s
!= (asection
*) NULL
;
3937 func (f
->the_bfd
, s
);
3945 ldlang_add_file (entry
)
3946 lang_input_statement_type
*entry
;
3950 lang_statement_append (&file_chain
,
3951 (lang_statement_union_type
*) entry
,
3954 /* The BFD linker needs to have a list of all input BFDs involved in
3956 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3957 ASSERT (entry
->the_bfd
!= output_bfd
);
3958 for (pp
= &link_info
.input_bfds
;
3959 *pp
!= (bfd
*) NULL
;
3960 pp
= &(*pp
)->link_next
)
3962 *pp
= entry
->the_bfd
;
3963 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3964 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3966 /* Look through the sections and check for any which should not be
3967 included in the link. We need to do this now, so that we can
3968 notice when the backend linker tries to report multiple
3969 definition errors for symbols which are in sections we aren't
3970 going to link. FIXME: It might be better to entirely ignore
3971 symbols which are defined in sections which are going to be
3972 discarded. This would require modifying the backend linker for
3973 each backend which might set the SEC_LINK_ONCE flag. If we do
3974 this, we should probably handle SEC_EXCLUDE in the same way. */
3976 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
3980 lang_add_output (name
, from_script
)
3984 /* Make -o on command line override OUTPUT in script. */
3985 if (had_output_filename
== false || !from_script
)
3987 output_filename
= name
;
3988 had_output_filename
= true;
3992 static lang_output_section_statement_type
*current_section
;
4004 for (l
= 0; l
< 32; l
++)
4006 if (i
>= (unsigned int) x
)
4014 lang_output_section_statement_type
*
4015 lang_enter_output_section_statement (output_section_statement_name
,
4016 address_exp
, sectype
, block_value
,
4017 align
, subalign
, ebase
)
4018 const char *output_section_statement_name
;
4019 etree_type
*address_exp
;
4020 enum section_type sectype
;
4021 bfd_vma block_value
;
4023 etree_type
*subalign
;
4026 lang_output_section_statement_type
*os
;
4030 lang_output_section_statement_lookup (output_section_statement_name
);
4032 /* Add this statement to tree. */
4034 add_statement (lang_output_section_statement_enum
,
4035 output_section_statement
);
4037 /* Make next things chain into subchain of this. */
4039 if (os
->addr_tree
== (etree_type
*) NULL
)
4041 os
->addr_tree
= address_exp
;
4043 os
->sectype
= sectype
;
4044 if (sectype
!= noload_section
)
4045 os
->flags
= SEC_NO_FLAGS
;
4047 os
->flags
= SEC_NEVER_LOAD
;
4048 os
->block_value
= block_value
? block_value
: 1;
4049 stat_ptr
= &os
->children
;
4051 os
->subsection_alignment
=
4052 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
4053 os
->section_alignment
=
4054 topower (exp_get_value_int (align
, -1, "section alignment", 0));
4056 os
->load_base
= ebase
;
4063 lang_output_statement_type
*new =
4064 new_stat (lang_output_statement
, stat_ptr
);
4066 new->name
= output_filename
;
4069 /* Reset the current counters in the regions. */
4072 lang_reset_memory_regions ()
4074 lang_memory_region_type
*p
= lang_memory_region_list
;
4077 for (p
= lang_memory_region_list
;
4078 p
!= (lang_memory_region_type
*) NULL
;
4081 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
4082 p
->current
= p
->origin
;
4085 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4089 /* If the wild pattern was marked KEEP, the member sections
4090 should be as well. */
4093 gc_section_callback (ptr
, sec
, section
, file
, data
)
4094 lang_wild_statement_type
*ptr
;
4095 struct wildcard_list
*sec ATTRIBUTE_UNUSED
;
4097 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
4098 PTR data ATTRIBUTE_UNUSED
;
4100 if (ptr
->keep_sections
)
4101 section
->flags
|= SEC_KEEP
;
4104 /* Handle a wild statement, marking it against GC. */
4108 lang_wild_statement_type
*s
;
4110 walk_wild (s
, gc_section_callback
, NULL
);
4113 /* Iterate over sections marking them against GC. */
4116 lang_gc_sections_1 (s
)
4117 lang_statement_union_type
*s
;
4119 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
4121 switch (s
->header
.type
)
4123 case lang_wild_statement_enum
:
4124 lang_gc_wild (&s
->wild_statement
);
4126 case lang_constructors_statement_enum
:
4127 lang_gc_sections_1 (constructor_list
.head
);
4129 case lang_output_section_statement_enum
:
4130 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4132 case lang_group_statement_enum
:
4133 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4144 struct bfd_link_hash_entry
*h
;
4145 ldlang_undef_chain_list_type
*ulist
, fake_list_start
;
4147 /* Keep all sections so marked in the link script. */
4149 lang_gc_sections_1 (statement_list
.head
);
4151 /* Keep all sections containing symbols undefined on the command-line.
4152 Handle the entry symbol at the same time. */
4154 if (entry_symbol
!= NULL
)
4156 fake_list_start
.next
= ldlang_undef_chain_list_head
;
4157 fake_list_start
.name
= (char *) entry_symbol
;
4158 ulist
= &fake_list_start
;
4161 ulist
= ldlang_undef_chain_list_head
;
4163 for (; ulist
; ulist
= ulist
->next
)
4165 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4166 false, false, false);
4168 if (h
!= (struct bfd_link_hash_entry
*) NULL
4169 && (h
->type
== bfd_link_hash_defined
4170 || h
->type
== bfd_link_hash_defweak
)
4171 && ! bfd_is_abs_section (h
->u
.def
.section
))
4173 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4177 bfd_gc_sections (output_bfd
, &link_info
);
4183 lang_reasonable_defaults ();
4184 current_target
= default_target
;
4186 /* Open the output file. */
4187 lang_for_each_statement (ldlang_open_output
);
4189 ldemul_create_output_section_statements ();
4191 /* Add to the hash table all undefineds on the command line. */
4192 lang_place_undefineds ();
4194 already_linked_table_init ();
4196 /* Create a bfd for each input file. */
4197 current_target
= default_target
;
4198 open_input_bfds (statement_list
.head
, false);
4200 ldemul_after_open ();
4202 already_linked_table_free ();
4204 /* Make sure that we're not mixing architectures. We call this
4205 after all the input files have been opened, but before we do any
4206 other processing, so that any operations merge_private_bfd_data
4207 does on the output file will be known during the rest of the
4211 /* Handle .exports instead of a version script if we're told to do so. */
4212 if (command_line
.version_exports_section
)
4213 lang_do_version_exports_section ();
4215 /* Build all sets based on the information gathered from the input
4217 ldctor_build_sets ();
4219 /* Remove unreferenced sections if asked to. */
4220 if (command_line
.gc_sections
)
4221 lang_gc_sections ();
4223 /* If there were any SEC_MERGE sections, finish their merging, so that
4224 section sizes can be computed. This has to be done after GC of sections,
4225 so that GCed sections are not merged, but before assigning output
4226 sections, since removing whole input sections is hard then. */
4227 bfd_merge_sections (output_bfd
, &link_info
);
4229 /* Size up the common data. */
4232 /* Run through the contours of the script and attach input sections
4233 to the correct output sections. */
4234 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4235 (lang_output_section_statement_type
*) NULL
);
4237 /* Find any sections not attached explicitly and handle them. */
4238 lang_place_orphans ();
4240 if (! link_info
.relocateable
)
4242 /* Look for a text section and set the readonly attribute in it. */
4243 asection
*found
= bfd_get_section_by_name (output_bfd
, ".text");
4245 if (found
!= (asection
*) NULL
)
4247 if (config
.text_read_only
)
4248 found
->flags
|= SEC_READONLY
;
4250 found
->flags
&= ~SEC_READONLY
;
4254 /* Do anything special before sizing sections. This is where ELF
4255 and other back-ends size dynamic sections. */
4256 ldemul_before_allocation ();
4258 /* We must record the program headers before we try to fix the
4259 section positions, since they will affect SIZEOF_HEADERS. */
4260 lang_record_phdrs ();
4262 /* Size up the sections. */
4263 lang_size_sections (statement_list
.head
,
4265 &statement_list
.head
, 0, (bfd_vma
) 0, NULL
);
4267 /* Now run around and relax if we can. */
4268 if (command_line
.relax
)
4270 /* Keep relaxing until bfd_relax_section gives up. */
4271 boolean relax_again
;
4275 lang_reset_memory_regions ();
4277 relax_again
= false;
4279 /* Note: pe-dll.c does something like this also. If you find
4280 you need to change this code, you probably need to change
4281 pe-dll.c also. DJ */
4283 /* Do all the assignments with our current guesses as to
4285 lang_do_assignments (statement_list
.head
,
4287 (fill_type
*) 0, (bfd_vma
) 0);
4289 /* Perform another relax pass - this time we know where the
4290 globals are, so can make better guess. */
4291 lang_size_sections (statement_list
.head
,
4293 &(statement_list
.head
), 0, (bfd_vma
) 0,
4296 while (relax_again
);
4299 /* See if anything special should be done now we know how big
4301 ldemul_after_allocation ();
4303 /* Fix any .startof. or .sizeof. symbols. */
4304 lang_set_startof ();
4306 /* Do all the assignments, now that we know the final resting places
4307 of all the symbols. */
4309 lang_do_assignments (statement_list
.head
,
4311 (fill_type
*) 0, (bfd_vma
) 0);
4313 /* Make sure that the section addresses make sense. */
4314 if (! link_info
.relocateable
4315 && command_line
.check_section_addresses
)
4316 lang_check_section_addresses ();
4324 /* EXPORTED TO YACC */
4327 lang_add_wild (filespec
, section_list
, keep_sections
)
4328 struct wildcard_spec
*filespec
;
4329 struct wildcard_list
*section_list
;
4330 boolean keep_sections
;
4332 struct wildcard_list
*curr
, *next
;
4333 lang_wild_statement_type
*new;
4335 /* Reverse the list as the parser puts it back to front. */
4336 for (curr
= section_list
, section_list
= NULL
;
4338 section_list
= curr
, curr
= next
)
4340 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
4341 placed_commons
= true;
4344 curr
->next
= section_list
;
4347 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
4349 if (strcmp (filespec
->name
, "*") == 0)
4350 filespec
->name
= NULL
;
4351 else if (! wildcardp (filespec
->name
))
4352 lang_has_input_file
= true;
4355 new = new_stat (lang_wild_statement
, stat_ptr
);
4356 new->filename
= NULL
;
4357 new->filenames_sorted
= false;
4358 if (filespec
!= NULL
)
4360 new->filename
= filespec
->name
;
4361 new->filenames_sorted
= filespec
->sorted
;
4363 new->section_list
= section_list
;
4364 new->keep_sections
= keep_sections
;
4365 lang_list_init (&new->children
);
4369 lang_section_start (name
, address
)
4371 etree_type
*address
;
4373 lang_address_statement_type
*ad
;
4375 ad
= new_stat (lang_address_statement
, stat_ptr
);
4376 ad
->section_name
= name
;
4377 ad
->address
= address
;
4380 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4381 because of a -e argument on the command line, or zero if this is
4382 called by ENTRY in a linker script. Command line arguments take
4386 lang_add_entry (name
, cmdline
)
4390 if (entry_symbol
== NULL
4392 || ! entry_from_cmdline
)
4394 entry_symbol
= name
;
4395 entry_from_cmdline
= cmdline
;
4400 lang_add_target (name
)
4403 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4419 map_option_f
= true;
4427 lang_add_fill (fill
)
4430 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4437 lang_add_data (type
, exp
)
4439 union etree_union
*exp
;
4442 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4450 /* Create a new reloc statement. RELOC is the BFD relocation type to
4451 generate. HOWTO is the corresponding howto structure (we could
4452 look this up, but the caller has already done so). SECTION is the
4453 section to generate a reloc against, or NAME is the name of the
4454 symbol to generate a reloc against. Exactly one of SECTION and
4455 NAME must be NULL. ADDEND is an expression for the addend. */
4458 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4459 bfd_reloc_code_real_type reloc
;
4460 reloc_howto_type
*howto
;
4463 union etree_union
*addend
;
4465 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4469 p
->section
= section
;
4471 p
->addend_exp
= addend
;
4473 p
->addend_value
= 0;
4474 p
->output_section
= NULL
;
4478 lang_assignment_statement_type
*
4479 lang_add_assignment (exp
)
4482 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4490 lang_add_attribute (attribute
)
4491 enum statement_enum attribute
;
4493 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4500 if (startup_file
!= (char *) NULL
)
4502 einfo (_("%P%Fmultiple STARTUP files\n"));
4504 first_file
->filename
= name
;
4505 first_file
->local_sym_name
= name
;
4506 first_file
->real
= true;
4508 startup_file
= name
;
4515 lang_float_flag
= maybe
;
4519 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4521 const char *memspec
;
4522 struct lang_output_section_phdr_list
*phdrs
;
4523 const char *lma_memspec
;
4525 current_section
->fill
= fill
;
4526 current_section
->region
= lang_memory_region_lookup (memspec
);
4527 current_section
->lma_region
= lang_memory_region_lookup (lma_memspec
);
4529 /* If no runtime region has been given, but the load region has
4530 been, use the load region. */
4531 if (current_section
->lma_region
!= 0 && strcmp (memspec
, "*default*") == 0)
4532 current_section
->region
= current_section
->lma_region
;
4534 current_section
->phdrs
= phdrs
;
4535 stat_ptr
= &statement_list
;
4538 /* Create an absolute symbol with the given name with the value of the
4539 address of first byte of the section named.
4541 If the symbol already exists, then do nothing. */
4544 lang_abs_symbol_at_beginning_of (secname
, name
)
4545 const char *secname
;
4548 struct bfd_link_hash_entry
*h
;
4550 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4551 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4552 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4554 if (h
->type
== bfd_link_hash_new
4555 || h
->type
== bfd_link_hash_undefined
)
4559 h
->type
= bfd_link_hash_defined
;
4561 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4562 if (sec
== (asection
*) NULL
)
4565 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4567 h
->u
.def
.section
= bfd_abs_section_ptr
;
4571 /* Create an absolute symbol with the given name with the value of the
4572 address of the first byte after the end of the section named.
4574 If the symbol already exists, then do nothing. */
4577 lang_abs_symbol_at_end_of (secname
, name
)
4578 const char *secname
;
4581 struct bfd_link_hash_entry
*h
;
4583 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4584 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4585 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4587 if (h
->type
== bfd_link_hash_new
4588 || h
->type
== bfd_link_hash_undefined
)
4592 h
->type
= bfd_link_hash_defined
;
4594 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4595 if (sec
== (asection
*) NULL
)
4598 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4599 + bfd_section_size (output_bfd
, sec
) /
4600 bfd_octets_per_byte (output_bfd
));
4602 h
->u
.def
.section
= bfd_abs_section_ptr
;
4607 lang_statement_append (list
, element
, field
)
4608 lang_statement_list_type
*list
;
4609 lang_statement_union_type
*element
;
4610 lang_statement_union_type
**field
;
4612 *(list
->tail
) = element
;
4616 /* Set the output format type. -oformat overrides scripts. */
4619 lang_add_output_format (format
, big
, little
, from_script
)
4625 if (output_target
== NULL
|| !from_script
)
4627 if (command_line
.endian
== ENDIAN_BIG
4630 else if (command_line
.endian
== ENDIAN_LITTLE
4634 output_target
= format
;
4638 /* Enter a group. This creates a new lang_group_statement, and sets
4639 stat_ptr to build new statements within the group. */
4644 lang_group_statement_type
*g
;
4646 g
= new_stat (lang_group_statement
, stat_ptr
);
4647 lang_list_init (&g
->children
);
4648 stat_ptr
= &g
->children
;
4651 /* Leave a group. This just resets stat_ptr to start writing to the
4652 regular list of statements again. Note that this will not work if
4653 groups can occur inside anything else which can adjust stat_ptr,
4654 but currently they can't. */
4659 stat_ptr
= &statement_list
;
4662 /* Add a new program header. This is called for each entry in a PHDRS
4663 command in a linker script. */
4666 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4674 struct lang_phdr
*n
, **pp
;
4676 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4679 n
->type
= exp_get_value_int (type
, 0, "program header type",
4680 lang_final_phase_enum
);
4681 n
->filehdr
= filehdr
;
4686 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4691 /* Record the program header information in the output BFD. FIXME: We
4692 should not be calling an ELF specific function here. */
4695 lang_record_phdrs ()
4699 struct lang_output_section_phdr_list
*last
;
4700 struct lang_phdr
*l
;
4701 lang_statement_union_type
*u
;
4704 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4706 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4713 for (u
= lang_output_section_statement
.head
;
4715 u
= u
->output_section_statement
.next
)
4717 lang_output_section_statement_type
*os
;
4718 struct lang_output_section_phdr_list
*pl
;
4720 os
= &u
->output_section_statement
;
4727 if (os
->sectype
== noload_section
4728 || os
->bfd_section
== NULL
4729 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4734 if (os
->bfd_section
== NULL
)
4737 for (; pl
!= NULL
; pl
= pl
->next
)
4739 if (strcmp (pl
->name
, l
->name
) == 0)
4744 secs
= ((asection
**)
4745 xrealloc (secs
, alc
* sizeof (asection
*)));
4747 secs
[c
] = os
->bfd_section
;
4754 if (l
->flags
== NULL
)
4757 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4758 lang_final_phase_enum
);
4763 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4764 lang_final_phase_enum
);
4766 if (! bfd_record_phdr (output_bfd
, l
->type
,
4767 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
4768 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4769 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4774 /* Make sure all the phdr assignments succeeded. */
4775 for (u
= lang_output_section_statement
.head
;
4777 u
= u
->output_section_statement
.next
)
4779 struct lang_output_section_phdr_list
*pl
;
4781 if (u
->output_section_statement
.bfd_section
== NULL
)
4784 for (pl
= u
->output_section_statement
.phdrs
;
4787 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4788 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4789 u
->output_section_statement
.name
, pl
->name
);
4793 /* Record a list of sections which may not be cross referenced. */
4796 lang_add_nocrossref (l
)
4797 struct lang_nocrossref
*l
;
4799 struct lang_nocrossrefs
*n
;
4801 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4802 n
->next
= nocrossref_list
;
4804 nocrossref_list
= n
;
4806 /* Set notice_all so that we get informed about all symbols. */
4807 link_info
.notice_all
= true;
4810 /* Overlay handling. We handle overlays with some static variables. */
4812 /* The overlay virtual address. */
4813 static etree_type
*overlay_vma
;
4815 /* An expression for the maximum section size seen so far. */
4816 static etree_type
*overlay_max
;
4818 /* A list of all the sections in this overlay. */
4820 struct overlay_list
{
4821 struct overlay_list
*next
;
4822 lang_output_section_statement_type
*os
;
4825 static struct overlay_list
*overlay_list
;
4827 /* Start handling an overlay. */
4830 lang_enter_overlay (vma_expr
)
4831 etree_type
*vma_expr
;
4833 /* The grammar should prevent nested overlays from occurring. */
4834 ASSERT (overlay_vma
== NULL
&& overlay_max
== NULL
);
4836 overlay_vma
= vma_expr
;
4839 /* Start a section in an overlay. We handle this by calling
4840 lang_enter_output_section_statement with the correct VMA.
4841 lang_leave_overlay sets up the LMA and memory regions. */
4844 lang_enter_overlay_section (name
)
4847 struct overlay_list
*n
;
4850 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4853 /* If this is the first section, then base the VMA of future
4854 sections on this one. This will work correctly even if `.' is
4855 used in the addresses. */
4856 if (overlay_list
== NULL
)
4857 overlay_vma
= exp_nameop (ADDR
, name
);
4859 /* Remember the section. */
4860 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4861 n
->os
= current_section
;
4862 n
->next
= overlay_list
;
4865 size
= exp_nameop (SIZEOF
, name
);
4867 /* Arrange to work out the maximum section end address. */
4868 if (overlay_max
== NULL
)
4871 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4874 /* Finish a section in an overlay. There isn't any special to do
4878 lang_leave_overlay_section (fill
, phdrs
)
4880 struct lang_output_section_phdr_list
*phdrs
;
4887 name
= current_section
->name
;
4889 /* For now, assume that "*default*" is the run-time memory region and
4890 that no load-time region has been specified. It doesn't really
4891 matter what we say here, since lang_leave_overlay will override it. */
4892 lang_leave_output_section_statement (fill
, "*default*", phdrs
, 0);
4894 /* Define the magic symbols. */
4896 clean
= xmalloc (strlen (name
) + 1);
4898 for (s1
= name
; *s1
!= '\0'; s1
++)
4899 if (ISALNUM (*s1
) || *s1
== '_')
4903 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4904 sprintf (buf
, "__load_start_%s", clean
);
4905 lang_add_assignment (exp_assop ('=', buf
,
4906 exp_nameop (LOADADDR
, name
)));
4908 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4909 sprintf (buf
, "__load_stop_%s", clean
);
4910 lang_add_assignment (exp_assop ('=', buf
,
4912 exp_nameop (LOADADDR
, name
),
4913 exp_nameop (SIZEOF
, name
))));
4918 /* Finish an overlay. If there are any overlay wide settings, this
4919 looks through all the sections in the overlay and sets them. */
4922 lang_leave_overlay (lma_expr
, nocrossrefs
, fill
, memspec
, phdrs
, lma_memspec
)
4923 etree_type
*lma_expr
;
4926 const char *memspec
;
4927 struct lang_output_section_phdr_list
*phdrs
;
4928 const char *lma_memspec
;
4930 lang_memory_region_type
*region
;
4931 lang_memory_region_type
*lma_region
;
4932 struct overlay_list
*l
;
4933 struct lang_nocrossref
*nocrossref
;
4935 region
= lang_memory_region_lookup (memspec
);
4936 lma_region
= lang_memory_region_lookup (lma_memspec
);
4940 /* After setting the size of the last section, set '.' to end of the
4942 if (overlay_list
!= NULL
)
4943 overlay_list
->os
->update_dot_tree
4944 = exp_assop ('=', ".", exp_binop ('+', overlay_vma
, overlay_max
));
4949 struct overlay_list
*next
;
4951 if (fill
!= (fill_type
*) 0 && l
->os
->fill
== (fill_type
*) 0)
4954 l
->os
->region
= region
;
4955 l
->os
->lma_region
= lma_region
;
4957 /* The first section has the load address specified in the
4958 OVERLAY statement. The rest are worked out from that.
4959 The base address is not needed (and should be null) if
4960 an LMA region was specified. */
4962 l
->os
->load_base
= lma_expr
;
4963 else if (lma_region
== 0)
4964 l
->os
->load_base
= exp_binop ('+',
4965 exp_nameop (LOADADDR
, l
->next
->os
->name
),
4966 exp_nameop (SIZEOF
, l
->next
->os
->name
));
4968 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4969 l
->os
->phdrs
= phdrs
;
4973 struct lang_nocrossref
*nc
;
4975 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
4976 nc
->name
= l
->os
->name
;
4977 nc
->next
= nocrossref
;
4986 if (nocrossref
!= NULL
)
4987 lang_add_nocrossref (nocrossref
);
4990 overlay_list
= NULL
;
4994 /* Version handling. This is only useful for ELF. */
4996 /* This global variable holds the version tree that we build. */
4998 struct bfd_elf_version_tree
*lang_elf_version_info
;
5001 lang_vers_match_lang_c (expr
, sym
)
5002 struct bfd_elf_version_expr
*expr
;
5005 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5007 return fnmatch (expr
->pattern
, sym
, 0) == 0;
5011 lang_vers_match_lang_cplusplus (expr
, sym
)
5012 struct bfd_elf_version_expr
*expr
;
5018 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5021 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
5024 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5025 Should we early out false in this case? */
5026 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5030 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5038 lang_vers_match_lang_java (expr
, sym
)
5039 struct bfd_elf_version_expr
*expr
;
5045 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5048 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
5051 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5052 Should we early out false in this case? */
5053 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5057 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5064 /* This is called for each variable name or match expression. */
5066 struct bfd_elf_version_expr
*
5067 lang_new_vers_pattern (orig
, new, lang
)
5068 struct bfd_elf_version_expr
*orig
;
5072 struct bfd_elf_version_expr
*ret
;
5074 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
5078 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
5079 ret
->match
= lang_vers_match_lang_c
;
5080 else if (strcasecmp (lang
, "C++") == 0)
5081 ret
->match
= lang_vers_match_lang_cplusplus
;
5082 else if (strcasecmp (lang
, "Java") == 0)
5083 ret
->match
= lang_vers_match_lang_java
;
5086 einfo (_("%X%P: unknown language `%s' in version information\n"),
5088 ret
->match
= lang_vers_match_lang_c
;
5094 /* This is called for each set of variable names and match
5097 struct bfd_elf_version_tree
*
5098 lang_new_vers_node (globals
, locals
)
5099 struct bfd_elf_version_expr
*globals
;
5100 struct bfd_elf_version_expr
*locals
;
5102 struct bfd_elf_version_tree
*ret
;
5104 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
5108 ret
->globals
= globals
;
5109 ret
->locals
= locals
;
5111 ret
->name_indx
= (unsigned int) -1;
5116 /* This static variable keeps track of version indices. */
5118 static int version_index
;
5120 /* This is called when we know the name and dependencies of the
5124 lang_register_vers_node (name
, version
, deps
)
5126 struct bfd_elf_version_tree
*version
;
5127 struct bfd_elf_version_deps
*deps
;
5129 struct bfd_elf_version_tree
*t
, **pp
;
5130 struct bfd_elf_version_expr
*e1
;
5135 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
5136 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
5138 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5142 /* Make sure this node has a unique name. */
5143 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5144 if (strcmp (t
->name
, name
) == 0)
5145 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5147 /* Check the global and local match names, and make sure there
5148 aren't any duplicates. */
5150 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5152 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5154 struct bfd_elf_version_expr
*e2
;
5156 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5157 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5158 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5163 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
5165 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5167 struct bfd_elf_version_expr
*e2
;
5169 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
5170 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5171 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5176 version
->deps
= deps
;
5177 version
->name
= name
;
5178 if (name
[0] != '\0')
5181 version
->vernum
= version_index
;
5184 version
->vernum
= 0;
5186 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5191 /* This is called when we see a version dependency. */
5193 struct bfd_elf_version_deps
*
5194 lang_add_vers_depend (list
, name
)
5195 struct bfd_elf_version_deps
*list
;
5198 struct bfd_elf_version_deps
*ret
;
5199 struct bfd_elf_version_tree
*t
;
5201 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5204 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5206 if (strcmp (t
->name
, name
) == 0)
5208 ret
->version_needed
= t
;
5213 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5219 lang_do_version_exports_section ()
5221 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5223 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5225 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5232 len
= bfd_section_size (is
->the_bfd
, sec
);
5233 contents
= xmalloc (len
);
5234 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5235 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
5238 while (p
< contents
+ len
)
5240 greg
= lang_new_vers_pattern (greg
, p
, NULL
);
5241 p
= strchr (p
, '\0') + 1;
5244 /* Do not free the contents, as we used them creating the regex. */
5246 /* Do not include this section in the link. */
5247 bfd_set_section_flags (is
->the_bfd
, sec
,
5248 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5251 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
);
5252 lang_register_vers_node (command_line
.version_exports_section
,
5253 lang_new_vers_node (greg
, lreg
), NULL
);
5257 lang_add_unique (name
)
5260 struct unique_sections
*ent
;
5262 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5263 if (strcmp (ent
->name
, name
) == 0)
5266 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
5267 ent
->name
= xstrdup (name
);
5268 ent
->next
= unique_section_list
;
5269 unique_section_list
= ent
;