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 lang_place_undefineds
PARAMS ((void));
96 static void map_input_to_output_sections
97 PARAMS ((lang_statement_union_type
*, const char *,
98 lang_output_section_statement_type
*));
99 static void print_output_section_statement
100 PARAMS ((lang_output_section_statement_type
*));
101 static void print_assignment
102 PARAMS ((lang_assignment_statement_type
*,
103 lang_output_section_statement_type
*));
104 static void print_input_statement
PARAMS ((lang_input_statement_type
*));
105 static boolean print_one_symbol
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
106 static void print_input_section
PARAMS ((lang_input_section_type
*));
107 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*));
108 static void print_data_statement
PARAMS ((lang_data_statement_type
*));
109 static void print_address_statement
PARAMS ((lang_address_statement_type
*));
110 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*));
111 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*));
112 static void print_wild_statement
113 PARAMS ((lang_wild_statement_type
*, lang_output_section_statement_type
*));
114 static void print_group
115 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
116 static void print_statement
117 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
118 static void print_statement_list
119 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
120 static void print_statements
PARAMS ((void));
121 static void insert_pad
122 PARAMS ((lang_statement_union_type
**, fill_type
,
123 unsigned int, asection
*, bfd_vma
));
124 static bfd_vma size_input_section
125 PARAMS ((lang_statement_union_type
**, lang_output_section_statement_type
*,
126 fill_type
, bfd_vma
));
127 static void lang_finish
PARAMS ((void));
128 static void ignore_bfd_errors
PARAMS ((const char *, ...));
129 static void lang_check
PARAMS ((void));
130 static void lang_common
PARAMS ((void));
131 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
132 static void lang_place_orphans
PARAMS ((void));
133 static int topower
PARAMS ((int));
134 static void lang_set_startof
PARAMS ((void));
135 static void gc_section_callback
136 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
137 lang_input_statement_type
*, PTR
));
138 static void lang_record_phdrs
PARAMS ((void));
139 static void lang_gc_wild
PARAMS ((lang_wild_statement_type
*));
140 static void lang_gc_sections_1
PARAMS ((lang_statement_union_type
*));
141 static void lang_gc_sections
PARAMS ((void));
142 static int lang_vers_match_lang_c
143 PARAMS ((struct bfd_elf_version_expr
*, const char *));
144 static int lang_vers_match_lang_cplusplus
145 PARAMS ((struct bfd_elf_version_expr
*, const char *));
146 static int lang_vers_match_lang_java
147 PARAMS ((struct bfd_elf_version_expr
*, const char *));
148 static void lang_do_version_exports_section
PARAMS ((void));
149 static void lang_check_section_addresses
PARAMS ((void));
150 static void os_region_check
151 PARAMS ((lang_output_section_statement_type
*,
152 struct memory_region_struct
*, etree_type
*, bfd_vma
));
153 static bfd_vma lang_size_sections_1
154 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*,
155 lang_statement_union_type
**, fill_type
, bfd_vma
, boolean
*));
157 typedef void (*callback_t
) PARAMS ((lang_wild_statement_type
*,
158 struct wildcard_list
*,
160 lang_input_statement_type
*,
162 static void walk_wild
163 PARAMS ((lang_wild_statement_type
*, callback_t
, PTR
));
164 static void walk_wild_section
165 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
167 static void walk_wild_file
168 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
171 static int get_target
PARAMS ((const bfd_target
*, PTR
));
172 static void stricpy
PARAMS ((char *, char *));
173 static void strcut
PARAMS ((char *, char *));
174 static int name_compare
PARAMS ((char *, char *));
175 static int closest_target_match
PARAMS ((const bfd_target
*, PTR
));
176 static char * get_first_input_target
PARAMS ((void));
179 lang_output_section_statement_type
*abs_output_section
;
180 lang_statement_list_type lang_output_section_statement
;
181 lang_statement_list_type
*stat_ptr
= &statement_list
;
182 lang_statement_list_type file_chain
= { NULL
, NULL
};
183 const char *entry_symbol
= NULL
;
184 const char *entry_section
= ".text";
185 boolean entry_from_cmdline
;
186 boolean lang_has_input_file
= false;
187 boolean had_output_filename
= false;
188 boolean lang_float_flag
= false;
189 boolean delete_output_file_on_failure
= false;
190 struct lang_nocrossrefs
*nocrossref_list
;
191 struct unique_sections
*unique_section_list
;
193 etree_type
*base
; /* Relocation base - or null */
195 #if defined (__STDC__) || defined (ALMOST_STDC)
196 #define cat(a,b) a##b
198 #define cat(a,b) a/**/b
201 /* Don't beautify the line below with "innocent" whitespace, it breaks
202 the K&R C preprocessor! */
203 #define new_stat(x, y) \
204 (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
206 #define outside_section_address(q) \
207 ((q)->output_offset + (q)->output_section->vma)
209 #define outside_symbol_address(q) \
210 ((q)->value + outside_section_address (q->section))
212 #define SECTION_NAME_MAP_LENGTH (16)
218 return obstack_alloc (&stat_obstack
, size
);
222 unique_section_p (secnam
)
225 struct unique_sections
*unam
;
227 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
228 if (wildcardp (unam
->name
)
229 ? fnmatch (unam
->name
, secnam
, 0) == 0
230 : strcmp (unam
->name
, secnam
) == 0)
238 /* Generic traversal routines for finding matching sections. */
241 walk_wild_section (ptr
, file
, callback
, data
)
242 lang_wild_statement_type
*ptr
;
243 lang_input_statement_type
*file
;
249 if (file
->just_syms_flag
)
252 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
254 struct wildcard_list
*sec
;
256 sec
= ptr
->section_list
;
258 (*callback
) (ptr
, sec
, s
, file
, data
);
262 boolean skip
= false;
263 struct name_list
*list_tmp
;
265 /* Don't process sections from files which were
267 for (list_tmp
= sec
->spec
.exclude_name_list
;
269 list_tmp
= list_tmp
->next
)
271 if (wildcardp (list_tmp
->name
))
272 skip
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
274 skip
= strcmp (list_tmp
->name
, file
->filename
) == 0;
276 /* If this file is part of an archive, and the archive is
277 excluded, exclude this file. */
278 if (! skip
&& file
->the_bfd
!= NULL
279 && file
->the_bfd
->my_archive
!= NULL
280 && file
->the_bfd
->my_archive
->filename
!= NULL
)
282 if (wildcardp (list_tmp
->name
))
283 skip
= fnmatch (list_tmp
->name
,
284 file
->the_bfd
->my_archive
->filename
,
287 skip
= strcmp (list_tmp
->name
,
288 file
->the_bfd
->my_archive
->filename
) == 0;
295 if (!skip
&& sec
->spec
.name
!= NULL
)
297 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
299 if (wildcardp (sec
->spec
.name
))
300 skip
= fnmatch (sec
->spec
.name
, sname
, 0) != 0;
302 skip
= strcmp (sec
->spec
.name
, sname
) != 0;
306 (*callback
) (ptr
, sec
, s
, file
, data
);
313 /* Handle a wild statement for a single file F. */
316 walk_wild_file (s
, f
, callback
, data
)
317 lang_wild_statement_type
*s
;
318 lang_input_statement_type
*f
;
322 if (f
->the_bfd
== NULL
323 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
324 walk_wild_section (s
, f
, callback
, data
);
329 /* This is an archive file. We must map each member of the
330 archive separately. */
331 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
332 while (member
!= NULL
)
334 /* When lookup_name is called, it will call the add_symbols
335 entry point for the archive. For each element of the
336 archive which is included, BFD will call ldlang_add_file,
337 which will set the usrdata field of the member to the
338 lang_input_statement. */
339 if (member
->usrdata
!= NULL
)
341 walk_wild_section (s
,
342 (lang_input_statement_type
*) member
->usrdata
,
346 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
352 walk_wild (s
, callback
, data
)
353 lang_wild_statement_type
*s
;
357 const char *file_spec
= s
->filename
;
359 if (file_spec
== NULL
)
361 /* Perform the iteration over all files in the list. */
362 LANG_FOR_EACH_INPUT_STATEMENT (f
)
364 walk_wild_file (s
, f
, callback
, data
);
367 else if (wildcardp (file_spec
))
369 LANG_FOR_EACH_INPUT_STATEMENT (f
)
371 if (fnmatch (file_spec
, f
->filename
, FNM_FILE_NAME
) == 0)
372 walk_wild_file (s
, f
, callback
, data
);
377 lang_input_statement_type
*f
;
379 /* Perform the iteration over a single file. */
380 f
= lookup_name (file_spec
);
382 walk_wild_file (s
, f
, callback
, data
);
386 /* lang_for_each_statement walks the parse tree and calls the provided
387 function for each node. */
390 lang_for_each_statement_worker (func
, s
)
391 void (*func
) PARAMS ((lang_statement_union_type
*));
392 lang_statement_union_type
*s
;
394 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
398 switch (s
->header
.type
)
400 case lang_constructors_statement_enum
:
401 lang_for_each_statement_worker (func
, constructor_list
.head
);
403 case lang_output_section_statement_enum
:
404 lang_for_each_statement_worker
406 s
->output_section_statement
.children
.head
);
408 case lang_wild_statement_enum
:
409 lang_for_each_statement_worker
411 s
->wild_statement
.children
.head
);
413 case lang_group_statement_enum
:
414 lang_for_each_statement_worker (func
,
415 s
->group_statement
.children
.head
);
417 case lang_data_statement_enum
:
418 case lang_reloc_statement_enum
:
419 case lang_object_symbols_statement_enum
:
420 case lang_output_statement_enum
:
421 case lang_target_statement_enum
:
422 case lang_input_section_enum
:
423 case lang_input_statement_enum
:
424 case lang_assignment_statement_enum
:
425 case lang_padding_statement_enum
:
426 case lang_address_statement_enum
:
427 case lang_fill_statement_enum
:
437 lang_for_each_statement (func
)
438 void (*func
) PARAMS ((lang_statement_union_type
*));
440 lang_for_each_statement_worker (func
, statement_list
.head
);
443 /*----------------------------------------------------------------------*/
446 lang_list_init (list
)
447 lang_statement_list_type
*list
;
449 list
->head
= (lang_statement_union_type
*) NULL
;
450 list
->tail
= &list
->head
;
453 /* Build a new statement node for the parse tree. */
455 static lang_statement_union_type
*
456 new_statement (type
, size
, list
)
457 enum statement_enum type
;
459 lang_statement_list_type
*list
;
461 lang_statement_union_type
*new = (lang_statement_union_type
*)
464 new->header
.type
= type
;
465 new->header
.next
= (lang_statement_union_type
*) NULL
;
466 lang_statement_append (list
, new, &new->header
.next
);
470 /* Build a new input file node for the language. There are several
471 ways in which we treat an input file, eg, we only look at symbols,
472 or prefix it with a -l etc.
474 We can be supplied with requests for input files more than once;
475 they may, for example be split over serveral lines like foo.o(.text)
476 foo.o(.data) etc, so when asked for a file we check that we haven't
477 got it already so we don't duplicate the bfd. */
479 static lang_input_statement_type
*
480 new_afile (name
, file_type
, target
, add_to_list
)
482 lang_input_file_enum_type file_type
;
486 lang_input_statement_type
*p
;
489 p
= new_stat (lang_input_statement
, stat_ptr
);
492 p
= ((lang_input_statement_type
*)
493 stat_alloc (sizeof (lang_input_statement_type
)));
494 p
->header
.next
= NULL
;
497 lang_has_input_file
= true;
501 case lang_input_file_is_symbols_only_enum
:
503 p
->is_archive
= false;
505 p
->local_sym_name
= name
;
506 p
->just_syms_flag
= true;
507 p
->search_dirs_flag
= false;
509 case lang_input_file_is_fake_enum
:
511 p
->is_archive
= false;
513 p
->local_sym_name
= name
;
514 p
->just_syms_flag
= false;
515 p
->search_dirs_flag
= false;
517 case lang_input_file_is_l_enum
:
518 p
->is_archive
= true;
521 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
522 p
->just_syms_flag
= false;
523 p
->search_dirs_flag
= true;
525 case lang_input_file_is_marker_enum
:
527 p
->is_archive
= false;
529 p
->local_sym_name
= name
;
530 p
->just_syms_flag
= false;
531 p
->search_dirs_flag
= true;
533 case lang_input_file_is_search_file_enum
:
535 p
->is_archive
= false;
537 p
->local_sym_name
= name
;
538 p
->just_syms_flag
= false;
539 p
->search_dirs_flag
= true;
541 case lang_input_file_is_file_enum
:
543 p
->is_archive
= false;
545 p
->local_sym_name
= name
;
546 p
->just_syms_flag
= false;
547 p
->search_dirs_flag
= false;
552 p
->the_bfd
= (bfd
*) NULL
;
553 p
->asymbols
= (asymbol
**) NULL
;
554 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
555 p
->next
= (lang_statement_union_type
*) NULL
;
557 p
->dynamic
= config
.dynamic_link
;
558 p
->whole_archive
= whole_archive
;
560 lang_statement_append (&input_file_chain
,
561 (lang_statement_union_type
*) p
,
566 lang_input_statement_type
*
567 lang_add_input_file (name
, file_type
, target
)
569 lang_input_file_enum_type file_type
;
572 lang_has_input_file
= true;
573 return new_afile (name
, file_type
, target
, true);
576 /* Build enough state so that the parser can build its tree. */
581 obstack_begin (&stat_obstack
, 1000);
583 stat_ptr
= &statement_list
;
585 lang_list_init (stat_ptr
);
587 lang_list_init (&input_file_chain
);
588 lang_list_init (&lang_output_section_statement
);
589 lang_list_init (&file_chain
);
590 first_file
= lang_add_input_file ((char *) NULL
,
591 lang_input_file_is_marker_enum
,
594 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
596 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
600 /*----------------------------------------------------------------------
601 A region is an area of memory declared with the
602 MEMORY { name:org=exp, len=exp ... }
605 We maintain a list of all the regions here.
607 If no regions are specified in the script, then the default is used
608 which is created when looked up to be the entire data space. */
610 static lang_memory_region_type
*lang_memory_region_list
;
611 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
613 lang_memory_region_type
*
614 lang_memory_region_lookup (name
)
615 const char *const name
;
617 lang_memory_region_type
*p
;
619 for (p
= lang_memory_region_list
;
620 p
!= (lang_memory_region_type
*) NULL
;
623 if (strcmp (p
->name
, name
) == 0)
630 /* This code used to always use the first region in the list as the
631 default region. I changed it to instead use a region
632 encompassing all of memory as the default region. This permits
633 NOLOAD sections to work reasonably without requiring a region.
634 People should specify what region they mean, if they really want
636 if (strcmp (name
, "*default*") == 0)
638 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
640 return lang_memory_region_list
;
646 lang_memory_region_type
*new =
647 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
649 new->name
= xstrdup (name
);
650 new->next
= (lang_memory_region_type
*) NULL
;
652 *lang_memory_region_list_tail
= new;
653 lang_memory_region_list_tail
= &new->next
;
657 new->length
= ~(bfd_size_type
) 0;
659 new->had_full_message
= false;
665 static lang_memory_region_type
*
666 lang_memory_default (section
)
669 lang_memory_region_type
*p
;
671 flagword sec_flags
= section
->flags
;
673 /* Override SEC_DATA to mean a writable section. */
674 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
675 sec_flags
|= SEC_DATA
;
677 for (p
= lang_memory_region_list
;
678 p
!= (lang_memory_region_type
*) NULL
;
681 if ((p
->flags
& sec_flags
) != 0
682 && (p
->not_flags
& sec_flags
) == 0)
687 return lang_memory_region_lookup ("*default*");
690 lang_output_section_statement_type
*
691 lang_output_section_find (name
)
692 const char *const name
;
694 lang_statement_union_type
*u
;
695 lang_output_section_statement_type
*lookup
;
697 for (u
= lang_output_section_statement
.head
;
698 u
!= (lang_statement_union_type
*) NULL
;
701 lookup
= &u
->output_section_statement
;
702 if (strcmp (name
, lookup
->name
) == 0)
707 return (lang_output_section_statement_type
*) NULL
;
710 lang_output_section_statement_type
*
711 lang_output_section_statement_lookup (name
)
712 const char *const name
;
714 lang_output_section_statement_type
*lookup
;
716 lookup
= lang_output_section_find (name
);
717 if (lookup
== (lang_output_section_statement_type
*) NULL
)
720 lookup
= (lang_output_section_statement_type
*)
721 new_stat (lang_output_section_statement
, stat_ptr
);
722 lookup
->region
= (lang_memory_region_type
*) NULL
;
723 lookup
->lma_region
= (lang_memory_region_type
*) NULL
;
725 lookup
->block_value
= 1;
728 lookup
->next
= (lang_statement_union_type
*) NULL
;
729 lookup
->bfd_section
= (asection
*) NULL
;
730 lookup
->processed
= false;
731 lookup
->sectype
= normal_section
;
732 lookup
->addr_tree
= (etree_type
*) NULL
;
733 lang_list_init (&lookup
->children
);
735 lookup
->memspec
= (const char *) NULL
;
737 lookup
->subsection_alignment
= -1;
738 lookup
->section_alignment
= -1;
739 lookup
->load_base
= (union etree_union
*) NULL
;
740 lookup
->phdrs
= NULL
;
742 lang_statement_append (&lang_output_section_statement
,
743 (lang_statement_union_type
*) lookup
,
750 lang_map_flags (flag
)
753 if (flag
& SEC_ALLOC
)
759 if (flag
& SEC_READONLY
)
772 lang_memory_region_type
*m
;
774 minfo (_("\nMemory Configuration\n\n"));
775 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
776 _("Name"), _("Origin"), _("Length"), _("Attributes"));
778 for (m
= lang_memory_region_list
;
779 m
!= (lang_memory_region_type
*) NULL
;
785 fprintf (config
.map_file
, "%-16s ", m
->name
);
787 sprintf_vma (buf
, m
->origin
);
788 minfo ("0x%s ", buf
);
796 minfo ("0x%V", m
->length
);
797 if (m
->flags
|| m
->not_flags
)
805 lang_map_flags (m
->flags
);
811 lang_map_flags (m
->not_flags
);
818 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
823 /* Initialize an output section. */
827 lang_output_section_statement_type
*s
;
829 section_userdata_type
*new;
831 if (s
->bfd_section
!= NULL
)
834 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
835 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
837 new = ((section_userdata_type
*)
838 stat_alloc (sizeof (section_userdata_type
)));
840 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
841 if (s
->bfd_section
== (asection
*) NULL
)
842 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
843 if (s
->bfd_section
== (asection
*) NULL
)
845 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
846 output_bfd
->xvec
->name
, s
->name
);
848 s
->bfd_section
->output_section
= s
->bfd_section
;
850 /* We initialize an output sections output offset to minus its own
851 vma to allow us to output a section through itself. */
852 s
->bfd_section
->output_offset
= 0;
853 get_userdata (s
->bfd_section
) = (PTR
) new;
855 /* If there is a base address, make sure that any sections it might
856 mention are initialized. */
857 if (s
->addr_tree
!= NULL
)
858 exp_init_os (s
->addr_tree
);
861 /* Make sure that all output sections mentioned in an expression are
868 switch (exp
->type
.node_class
)
871 exp_init_os (exp
->assign
.src
);
875 exp_init_os (exp
->binary
.lhs
);
876 exp_init_os (exp
->binary
.rhs
);
880 exp_init_os (exp
->trinary
.cond
);
881 exp_init_os (exp
->trinary
.lhs
);
882 exp_init_os (exp
->trinary
.rhs
);
886 exp_init_os (exp
->unary
.child
);
890 switch (exp
->type
.node_code
)
896 lang_output_section_statement_type
*os
;
898 os
= lang_output_section_find (exp
->name
.name
);
899 if (os
!= NULL
&& os
->bfd_section
== NULL
)
910 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
911 once into the output. This routine checks each section, and
912 arrange to discard it if a section of the same name has already
913 been linked. If the section has COMDAT information, then it uses
914 that to decide whether the section should be included. This code
915 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
916 that is, it does not depend solely upon the section name.
917 section_already_linked is called via bfd_map_over_sections. */
919 /* This is the shape of the elements inside the already_linked hash
920 table. It maps a name onto a list of already_linked elements with
921 the same name. It's possible to get more than one element in a
922 list if the COMDAT sections have different names. */
924 struct already_linked_hash_entry
926 struct bfd_hash_entry root
;
927 struct already_linked
*entry
;
930 struct already_linked
932 struct already_linked
*next
;
936 /* The hash table. */
938 static struct bfd_hash_table already_linked_table
;
941 section_already_linked (abfd
, sec
, data
)
946 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
949 struct already_linked
*l
;
950 struct already_linked_hash_entry
*already_linked_list
;
952 /* If we are only reading symbols from this object, then we want to
953 discard all sections. */
954 if (entry
->just_syms_flag
)
956 sec
->output_section
= bfd_abs_section_ptr
;
957 sec
->output_offset
= sec
->vma
;
961 flags
= bfd_get_section_flags (abfd
, sec
);
963 if ((flags
& SEC_LINK_ONCE
) == 0)
966 /* FIXME: When doing a relocatable link, we may have trouble
967 copying relocations in other sections that refer to local symbols
968 in the section being discarded. Those relocations will have to
969 be converted somehow; as of this writing I'm not sure that any of
970 the backends handle that correctly.
972 It is tempting to instead not discard link once sections when
973 doing a relocatable link (technically, they should be discarded
974 whenever we are building constructors). However, that fails,
975 because the linker winds up combining all the link once sections
976 into a single large link once section, which defeats the purpose
977 of having link once sections in the first place.
979 Also, not merging link once sections in a relocatable link
980 causes trouble for MIPS ELF, which relies in link once semantics
981 to handle the .reginfo section correctly. */
983 name
= bfd_get_section_name (abfd
, sec
);
985 already_linked_list
=
986 ((struct already_linked_hash_entry
*)
987 bfd_hash_lookup (&already_linked_table
, name
, true, false));
989 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
991 if (sec
->comdat
== NULL
992 || l
->sec
->comdat
== NULL
993 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
995 /* The section has already been linked. See if we should
997 switch (flags
& SEC_LINK_DUPLICATES
)
1002 case SEC_LINK_DUPLICATES_DISCARD
:
1005 case SEC_LINK_DUPLICATES_ONE_ONLY
:
1006 if (sec
->comdat
== NULL
)
1007 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
1010 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
1011 abfd
, name
, sec
->comdat
->name
);
1014 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
1015 /* FIXME: We should really dig out the contents of both
1016 sections and memcmp them. The COFF/PE spec says that
1017 the Microsoft linker does not implement this
1018 correctly, so I'm not going to bother doing it
1021 case SEC_LINK_DUPLICATES_SAME_SIZE
:
1022 if (bfd_section_size (abfd
, sec
)
1023 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1024 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1029 /* Set the output_section field so that lang_add_section
1030 does not create a lang_input_section structure for this
1032 sec
->output_section
= bfd_abs_section_ptr
;
1038 /* This is the first section with this name. Record it. Allocate
1039 the memory from the same obstack as the hash table is kept in. */
1041 l
= ((struct already_linked
*)
1042 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1045 l
->next
= already_linked_list
->entry
;
1046 already_linked_list
->entry
= l
;
1049 /* Support routines for the hash table used by section_already_linked,
1050 initialize the table, fill in an entry and remove the table. */
1052 static struct bfd_hash_entry
*
1053 already_linked_newfunc (entry
, table
, string
)
1054 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1055 struct bfd_hash_table
*table
;
1056 const char *string ATTRIBUTE_UNUSED
;
1058 struct already_linked_hash_entry
*ret
=
1059 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1063 return (struct bfd_hash_entry
*) ret
;
1067 already_linked_table_init ()
1069 if (! bfd_hash_table_init_n (&already_linked_table
,
1070 already_linked_newfunc
,
1072 einfo (_("%P%F: Failed to create hash table\n"));
1076 already_linked_table_free ()
1078 bfd_hash_table_free (&already_linked_table
);
1081 /* The wild routines.
1083 These expand statements like *(.text) and foo.o to a list of
1084 explicit actions, like foo.o(.text), bar.o(.text) and
1085 foo.o(.text, .data). */
1087 /* Return true if the PATTERN argument is a wildcard pattern.
1088 Although backslashes are treated specially if a pattern contains
1089 wildcards, we do not consider the mere presence of a backslash to
1090 be enough to cause the pattern to be treated as a wildcard.
1091 That lets us handle DOS filenames more naturally. */
1095 const char *pattern
;
1099 for (s
= pattern
; *s
!= '\0'; ++s
)
1107 /* Add SECTION to the output section OUTPUT. Do this by creating a
1108 lang_input_section statement which is placed at PTR. FILE is the
1109 input file which holds SECTION. */
1112 lang_add_section (ptr
, section
, output
, file
)
1113 lang_statement_list_type
*ptr
;
1115 lang_output_section_statement_type
*output
;
1116 lang_input_statement_type
*file
;
1121 flags
= bfd_get_section_flags (section
->owner
, section
);
1125 /* If we are doing a final link, discard sections marked with
1127 if (! link_info
.relocateable
1128 && (flags
& SEC_EXCLUDE
) != 0)
1131 /* Discard input sections which are assigned to a section named
1132 DISCARD_SECTION_NAME. */
1133 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1136 /* Discard debugging sections if we are stripping debugging
1138 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1139 && (flags
& SEC_DEBUGGING
) != 0)
1144 if (section
->output_section
== NULL
)
1146 /* This prevents future calls from assigning this section. */
1147 section
->output_section
= bfd_abs_section_ptr
;
1152 if (section
->output_section
== NULL
)
1155 lang_input_section_type
*new;
1158 if (output
->bfd_section
== NULL
)
1161 first
= ! output
->bfd_section
->linker_has_input
;
1162 output
->bfd_section
->linker_has_input
= 1;
1164 /* Add a section reference to the list. */
1165 new = new_stat (lang_input_section
, ptr
);
1167 new->section
= section
;
1169 section
->output_section
= output
->bfd_section
;
1171 flags
= section
->flags
;
1173 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1174 to an output section, because we want to be able to include a
1175 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1176 section (I don't know why we want to do this, but we do).
1177 build_link_order in ldwrite.c handles this case by turning
1178 the embedded SEC_NEVER_LOAD section into a fill. */
1180 flags
&= ~ SEC_NEVER_LOAD
;
1182 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1183 already been processed. One reason to do this is that on pe
1184 format targets, .text$foo sections go into .text and it's odd
1185 to see .text with SEC_LINK_ONCE set. */
1187 if (! link_info
.relocateable
)
1188 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1190 /* If this is not the first input section, and the SEC_READONLY
1191 flag is not currently set, then don't set it just because the
1192 input section has it set. */
1194 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1195 flags
&= ~ SEC_READONLY
;
1197 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1199 && ((section
->output_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1200 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1201 || ((flags
& SEC_MERGE
)
1202 && section
->output_section
->entsize
!= section
->entsize
)))
1204 section
->output_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1205 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1208 section
->output_section
->flags
|= flags
;
1210 if (flags
& SEC_MERGE
)
1211 section
->output_section
->entsize
= section
->entsize
;
1213 /* If SEC_READONLY is not set in the input section, then clear
1214 it from the output section. */
1215 if ((section
->flags
& SEC_READONLY
) == 0)
1216 section
->output_section
->flags
&= ~SEC_READONLY
;
1218 switch (output
->sectype
)
1220 case normal_section
:
1225 case overlay_section
:
1226 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1228 case noload_section
:
1229 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1230 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1234 /* Copy over SEC_SMALL_DATA. */
1235 if (section
->flags
& SEC_SMALL_DATA
)
1236 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1238 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1239 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1241 /* If supplied an aligment, then force it. */
1242 if (output
->section_alignment
!= -1)
1243 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1245 if (section
->flags
& SEC_BLOCK
)
1247 section
->output_section
->flags
|= SEC_BLOCK
;
1248 /* FIXME: This value should really be obtained from the bfd... */
1249 output
->block_value
= 128;
1254 /* Handle wildcard sorting. This returns the lang_input_section which
1255 should follow the one we are going to create for SECTION and FILE,
1256 based on the sorting requirements of WILD. It returns NULL if the
1257 new section should just go at the end of the current list. */
1259 static lang_statement_union_type
*
1260 wild_sort (wild
, sec
, file
, section
)
1261 lang_wild_statement_type
*wild
;
1262 struct wildcard_list
*sec
;
1263 lang_input_statement_type
*file
;
1266 const char *section_name
;
1267 lang_statement_union_type
*l
;
1269 if (!wild
->filenames_sorted
&& (sec
== NULL
|| !sec
->spec
.sorted
))
1272 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1273 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
1275 lang_input_section_type
*ls
;
1277 if (l
->header
.type
!= lang_input_section_enum
)
1279 ls
= &l
->input_section
;
1281 /* Sorting by filename takes precedence over sorting by section
1284 if (wild
->filenames_sorted
)
1286 const char *fn
, *ln
;
1290 /* The PE support for the .idata section as generated by
1291 dlltool assumes that files will be sorted by the name of
1292 the archive and then the name of the file within the
1295 if (file
->the_bfd
!= NULL
1296 && bfd_my_archive (file
->the_bfd
) != NULL
)
1298 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1303 fn
= file
->filename
;
1307 if (ls
->ifile
->the_bfd
!= NULL
1308 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1310 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1315 ln
= ls
->ifile
->filename
;
1319 i
= strcmp (fn
, ln
);
1328 fn
= file
->filename
;
1330 ln
= ls
->ifile
->filename
;
1332 i
= strcmp (fn
, ln
);
1340 /* Here either the files are not sorted by name, or we are
1341 looking at the sections for this file. */
1343 if (sec
!= NULL
&& sec
->spec
.sorted
)
1345 if (strcmp (section_name
,
1346 bfd_get_section_name (ls
->ifile
->the_bfd
,
1356 /* Expand a wild statement for a particular FILE. SECTION may be
1357 NULL, in which case it is a wild card. */
1360 output_section_callback (ptr
, sec
, section
, file
, output
)
1361 lang_wild_statement_type
*ptr
;
1362 struct wildcard_list
*sec
;
1364 lang_input_statement_type
*file
;
1367 lang_statement_union_type
*before
;
1369 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1370 if (unique_section_p (bfd_get_section_name (file
->the_bfd
, section
)))
1373 /* If the wild pattern was marked KEEP, the member sections
1374 should be as well. */
1375 if (ptr
->keep_sections
)
1376 section
->flags
|= SEC_KEEP
;
1378 before
= wild_sort (ptr
, sec
, file
, section
);
1380 /* Here BEFORE points to the lang_input_section which
1381 should follow the one we are about to add. If BEFORE
1382 is NULL, then the section should just go at the end
1383 of the current list. */
1386 lang_add_section (&ptr
->children
, section
,
1387 (lang_output_section_statement_type
*) output
,
1391 lang_statement_list_type list
;
1392 lang_statement_union_type
**pp
;
1394 lang_list_init (&list
);
1395 lang_add_section (&list
, section
,
1396 (lang_output_section_statement_type
*) output
,
1399 /* If we are discarding the section, LIST.HEAD will
1401 if (list
.head
!= NULL
)
1403 ASSERT (list
.head
->header
.next
== NULL
);
1405 for (pp
= &ptr
->children
.head
;
1407 pp
= &(*pp
)->header
.next
)
1408 ASSERT (*pp
!= NULL
);
1410 list
.head
->header
.next
= *pp
;
1416 /* This is passed a file name which must have been seen already and
1417 added to the statement tree. We will see if it has been opened
1418 already and had its symbols read. If not then we'll read it. */
1420 static lang_input_statement_type
*
1424 lang_input_statement_type
*search
;
1426 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1427 search
!= (lang_input_statement_type
*) NULL
;
1428 search
= (lang_input_statement_type
*) search
->next_real_file
)
1430 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1432 if (search
->filename
!= (char *) NULL
1433 && name
!= (char *) NULL
1434 && strcmp (search
->filename
, name
) == 0)
1438 if (search
== (lang_input_statement_type
*) NULL
)
1439 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1442 /* If we have already added this file, or this file is not real
1443 (FIXME: can that ever actually happen?) or the name is NULL
1444 (FIXME: can that ever actually happen?) don't add this file. */
1447 || search
->filename
== (const char *) NULL
)
1450 if (! load_symbols (search
, (lang_statement_list_type
*) NULL
))
1456 /* Get the symbols for an input file. */
1459 load_symbols (entry
, place
)
1460 lang_input_statement_type
*entry
;
1461 lang_statement_list_type
*place
;
1468 ldfile_open_file (entry
);
1470 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1471 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1474 lang_statement_list_type
*hold
;
1475 boolean bad_load
= true;
1477 err
= bfd_get_error ();
1479 /* See if the emulation has some special knowledge. */
1480 if (ldemul_unrecognized_file (entry
))
1483 if (err
== bfd_error_file_ambiguously_recognized
)
1487 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1488 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1489 for (p
= matching
; *p
!= NULL
; p
++)
1493 else if (err
!= bfd_error_file_not_recognized
1495 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1499 bfd_close (entry
->the_bfd
);
1500 entry
->the_bfd
= NULL
;
1502 /* Try to interpret the file as a linker script. */
1503 ldfile_open_command_file (entry
->filename
);
1508 ldfile_assumed_script
= true;
1509 parser_input
= input_script
;
1511 ldfile_assumed_script
= false;
1518 if (ldemul_recognized_file (entry
))
1521 /* We don't call ldlang_add_file for an archive. Instead, the
1522 add_symbols entry point will call ldlang_add_file, via the
1523 add_archive_element callback, for each element of the archive
1525 switch (bfd_get_format (entry
->the_bfd
))
1531 ldlang_add_file (entry
);
1532 if (trace_files
|| trace_file_tries
)
1533 info_msg ("%I\n", entry
);
1537 if (entry
->whole_archive
)
1539 bfd
* member
= NULL
;
1540 boolean loaded
= true;
1544 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
1549 if (! bfd_check_format (member
, bfd_object
))
1551 einfo (_("%F%B: member %B in archive is not an object\n"),
1552 entry
->the_bfd
, member
);
1556 if (! ((*link_info
.callbacks
->add_archive_element
)
1557 (&link_info
, member
, "--whole-archive")))
1560 if (! bfd_link_add_symbols (member
, &link_info
))
1562 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1567 entry
->loaded
= loaded
;
1573 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1574 entry
->loaded
= true;
1576 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1578 return entry
->loaded
;
1581 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1582 may be NULL, indicating that it is a wildcard. Separate
1583 lang_input_section statements are created for each part of the
1584 expansion; they are added after the wild statement S. OUTPUT is
1585 the output section. */
1588 wild (s
, target
, output
)
1589 lang_wild_statement_type
*s
;
1590 const char *target ATTRIBUTE_UNUSED
;
1591 lang_output_section_statement_type
*output
;
1593 struct wildcard_list
*sec
;
1595 walk_wild (s
, output_section_callback
, (PTR
) output
);
1597 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
1599 if (default_common_section
!= NULL
)
1601 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
1603 /* Remember the section that common is going to in case we
1604 later get something which doesn't know where to put it. */
1605 default_common_section
= output
;
1610 /* Return true iff target is the sought target. */
1613 get_target (target
, data
)
1614 const bfd_target
*target
;
1617 const char *sought
= (const char *) data
;
1619 return strcmp (target
->name
, sought
) == 0;
1622 /* Like strcpy() but convert to lower case as well. */
1631 while ((c
= *src
++) != 0)
1632 *dest
++ = TOLOWER (c
);
1637 /* Remove the first occurance of needle (if any) in haystack
1641 strcut (haystack
, needle
)
1645 haystack
= strstr (haystack
, needle
);
1651 for (src
= haystack
+ strlen (needle
); *src
;)
1652 *haystack
++ = *src
++;
1658 /* Compare two target format name strings.
1659 Return a value indicating how "similar" they are. */
1662 name_compare (first
, second
)
1670 copy1
= xmalloc (strlen (first
) + 1);
1671 copy2
= xmalloc (strlen (second
) + 1);
1673 /* Convert the names to lower case. */
1674 stricpy (copy1
, first
);
1675 stricpy (copy2
, second
);
1677 /* Remove and endian strings from the name. */
1678 strcut (copy1
, "big");
1679 strcut (copy1
, "little");
1680 strcut (copy2
, "big");
1681 strcut (copy2
, "little");
1683 /* Return a value based on how many characters match,
1684 starting from the beginning. If both strings are
1685 the same then return 10 * their length. */
1686 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1687 if (copy1
[result
] == 0)
1699 /* Set by closest_target_match() below. */
1700 static const bfd_target
*winner
;
1702 /* Scan all the valid bfd targets looking for one that has the endianness
1703 requirement that was specified on the command line, and is the nearest
1704 match to the original output target. */
1707 closest_target_match (target
, data
)
1708 const bfd_target
*target
;
1711 const bfd_target
*original
= (const bfd_target
*) data
;
1713 if (command_line
.endian
== ENDIAN_BIG
1714 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1717 if (command_line
.endian
== ENDIAN_LITTLE
1718 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1721 /* Must be the same flavour. */
1722 if (target
->flavour
!= original
->flavour
)
1725 /* If we have not found a potential winner yet, then record this one. */
1732 /* Oh dear, we now have two potential candidates for a successful match.
1733 Compare their names and choose the better one. */
1734 if (name_compare (target
->name
, original
->name
)
1735 > name_compare (winner
->name
, original
->name
))
1738 /* Keep on searching until wqe have checked them all. */
1742 /* Return the BFD target format of the first input file. */
1745 get_first_input_target ()
1747 char *target
= NULL
;
1749 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1751 if (s
->header
.type
== lang_input_statement_enum
1754 ldfile_open_file (s
);
1756 if (s
->the_bfd
!= NULL
1757 && bfd_check_format (s
->the_bfd
, bfd_object
))
1759 target
= bfd_get_target (s
->the_bfd
);
1770 /* Open the output file. */
1778 /* Has the user told us which output format to use? */
1779 if (output_target
== (char *) NULL
)
1781 /* No - has the current target been set to something other than
1783 if (current_target
!= default_target
)
1784 output_target
= current_target
;
1786 /* No - can we determine the format of the first input file? */
1789 output_target
= get_first_input_target ();
1791 /* Failed - use the default output target. */
1792 if (output_target
== NULL
)
1793 output_target
= default_target
;
1797 /* Has the user requested a particular endianness on the command
1799 if (command_line
.endian
!= ENDIAN_UNSET
)
1801 const bfd_target
*target
;
1802 enum bfd_endian desired_endian
;
1804 /* Get the chosen target. */
1805 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1807 /* If the target is not supported, we cannot do anything. */
1810 if (command_line
.endian
== ENDIAN_BIG
)
1811 desired_endian
= BFD_ENDIAN_BIG
;
1813 desired_endian
= BFD_ENDIAN_LITTLE
;
1815 /* See if the target has the wrong endianness. This should
1816 not happen if the linker script has provided big and
1817 little endian alternatives, but some scrips don't do
1819 if (target
->byteorder
!= desired_endian
)
1821 /* If it does, then see if the target provides
1822 an alternative with the correct endianness. */
1823 if (target
->alternative_target
!= NULL
1824 && (target
->alternative_target
->byteorder
== desired_endian
))
1825 output_target
= target
->alternative_target
->name
;
1828 /* Try to find a target as similar as possible to
1829 the default target, but which has the desired
1830 endian characteristic. */
1831 (void) bfd_search_for_target (closest_target_match
,
1834 /* Oh dear - we could not find any targets that
1835 satisfy our requirements. */
1837 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1839 output_target
= winner
->name
;
1845 output
= bfd_openw (name
, output_target
);
1847 if (output
== (bfd
*) NULL
)
1849 if (bfd_get_error () == bfd_error_invalid_target
)
1850 einfo (_("%P%F: target %s not found\n"), output_target
);
1852 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1855 delete_output_file_on_failure
= true;
1858 output
->flags
|= D_PAGED
;
1861 if (! bfd_set_format (output
, bfd_object
))
1862 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1863 if (! bfd_set_arch_mach (output
,
1864 ldfile_output_architecture
,
1865 ldfile_output_machine
))
1866 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1868 link_info
.hash
= bfd_link_hash_table_create (output
);
1869 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1870 einfo (_("%P%F: can not create link hash table: %E\n"));
1872 bfd_set_gp_size (output
, g_switch_value
);
1877 ldlang_open_output (statement
)
1878 lang_statement_union_type
*statement
;
1880 switch (statement
->header
.type
)
1882 case lang_output_statement_enum
:
1883 ASSERT (output_bfd
== (bfd
*) NULL
);
1884 output_bfd
= open_output (statement
->output_statement
.name
);
1885 ldemul_set_output_arch ();
1886 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1887 output_bfd
->flags
|= D_PAGED
;
1889 output_bfd
->flags
&= ~D_PAGED
;
1890 if (config
.text_read_only
)
1891 output_bfd
->flags
|= WP_TEXT
;
1893 output_bfd
->flags
&= ~WP_TEXT
;
1894 if (link_info
.traditional_format
)
1895 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1897 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1900 case lang_target_statement_enum
:
1901 current_target
= statement
->target_statement
.target
;
1908 /* Open all the input files. */
1911 open_input_bfds (s
, force
)
1912 lang_statement_union_type
*s
;
1915 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
1917 switch (s
->header
.type
)
1919 case lang_constructors_statement_enum
:
1920 open_input_bfds (constructor_list
.head
, force
);
1922 case lang_output_section_statement_enum
:
1923 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1925 case lang_wild_statement_enum
:
1926 /* Maybe we should load the file's symbols. */
1927 if (s
->wild_statement
.filename
1928 && ! wildcardp (s
->wild_statement
.filename
))
1929 (void) lookup_name (s
->wild_statement
.filename
);
1930 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1932 case lang_group_statement_enum
:
1934 struct bfd_link_hash_entry
*undefs
;
1936 /* We must continually search the entries in the group
1937 until no new symbols are added to the list of undefined
1942 undefs
= link_info
.hash
->undefs_tail
;
1943 open_input_bfds (s
->group_statement
.children
.head
, true);
1945 while (undefs
!= link_info
.hash
->undefs_tail
);
1948 case lang_target_statement_enum
:
1949 current_target
= s
->target_statement
.target
;
1951 case lang_input_statement_enum
:
1952 if (s
->input_statement
.real
)
1954 lang_statement_list_type add
;
1956 s
->input_statement
.target
= current_target
;
1958 /* If we are being called from within a group, and this
1959 is an archive which has already been searched, then
1960 force it to be researched unless the whole archive
1961 has been loaded already. */
1963 && !s
->input_statement
.whole_archive
1964 && s
->input_statement
.loaded
1965 && bfd_check_format (s
->input_statement
.the_bfd
,
1967 s
->input_statement
.loaded
= false;
1969 lang_list_init (&add
);
1971 if (! load_symbols (&s
->input_statement
, &add
))
1972 config
.make_executable
= false;
1974 if (add
.head
!= NULL
)
1976 *add
.tail
= s
->header
.next
;
1977 s
->header
.next
= add
.head
;
1987 /* If there are [COMMONS] statements, put a wild one into the bss
1991 lang_reasonable_defaults ()
1994 lang_output_section_statement_lookup (".text");
1995 lang_output_section_statement_lookup (".data");
1997 default_common_section
= lang_output_section_statement_lookup (".bss");
1999 if (placed_commons
== false)
2001 lang_wild_statement_type
*new =
2002 new_stat (lang_wild_statement
,
2003 &default_common_section
->children
);
2005 new->section_name
= "COMMON";
2006 new->filename
= (char *) NULL
;
2007 lang_list_init (&new->children
);
2012 /* Add the supplied name to the symbol table as an undefined reference.
2013 Remove items from the chain as we open input bfds. */
2014 typedef struct ldlang_undef_chain_list
2016 struct ldlang_undef_chain_list
*next
;
2018 } ldlang_undef_chain_list_type
;
2020 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
2023 ldlang_add_undef (name
)
2024 const char *const name
;
2026 ldlang_undef_chain_list_type
*new =
2027 ((ldlang_undef_chain_list_type
*)
2028 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
2030 new->next
= ldlang_undef_chain_list_head
;
2031 ldlang_undef_chain_list_head
= new;
2033 new->name
= xstrdup (name
);
2036 /* Run through the list of undefineds created above and place them
2037 into the linker hash table as undefined symbols belonging to the
2041 lang_place_undefineds ()
2043 ldlang_undef_chain_list_type
*ptr
;
2045 for (ptr
= ldlang_undef_chain_list_head
;
2046 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
2049 struct bfd_link_hash_entry
*h
;
2051 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
2052 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2053 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2054 if (h
->type
== bfd_link_hash_new
)
2056 h
->type
= bfd_link_hash_undefined
;
2057 h
->u
.undef
.abfd
= NULL
;
2058 bfd_link_add_undef (link_info
.hash
, h
);
2063 /* Open input files and attatch to output sections. */
2066 map_input_to_output_sections (s
, target
, output_section_statement
)
2067 lang_statement_union_type
*s
;
2069 lang_output_section_statement_type
*output_section_statement
;
2071 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2073 switch (s
->header
.type
)
2075 case lang_wild_statement_enum
:
2076 wild (&s
->wild_statement
, target
, output_section_statement
);
2078 case lang_constructors_statement_enum
:
2079 map_input_to_output_sections (constructor_list
.head
,
2081 output_section_statement
);
2083 case lang_output_section_statement_enum
:
2084 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2086 &s
->output_section_statement
);
2088 case lang_output_statement_enum
:
2090 case lang_target_statement_enum
:
2091 target
= s
->target_statement
.target
;
2093 case lang_group_statement_enum
:
2094 map_input_to_output_sections (s
->group_statement
.children
.head
,
2096 output_section_statement
);
2098 case lang_fill_statement_enum
:
2099 case lang_input_section_enum
:
2100 case lang_object_symbols_statement_enum
:
2101 case lang_data_statement_enum
:
2102 case lang_reloc_statement_enum
:
2103 case lang_padding_statement_enum
:
2104 case lang_input_statement_enum
:
2105 if (output_section_statement
!= NULL
2106 && output_section_statement
->bfd_section
== NULL
)
2107 init_os (output_section_statement
);
2109 case lang_assignment_statement_enum
:
2110 if (output_section_statement
!= NULL
2111 && output_section_statement
->bfd_section
== NULL
)
2112 init_os (output_section_statement
);
2114 /* Make sure that any sections mentioned in the assignment
2116 exp_init_os (s
->assignment_statement
.exp
);
2118 case lang_afile_asection_pair_statement_enum
:
2121 case lang_address_statement_enum
:
2122 /* Mark the specified section with the supplied address. */
2124 lang_output_section_statement_type
*os
=
2125 lang_output_section_statement_lookup
2126 (s
->address_statement
.section_name
);
2128 if (os
->bfd_section
== NULL
)
2130 os
->addr_tree
= s
->address_statement
.address
;
2138 print_output_section_statement (output_section_statement
)
2139 lang_output_section_statement_type
*output_section_statement
;
2141 asection
*section
= output_section_statement
->bfd_section
;
2144 if (output_section_statement
!= abs_output_section
)
2146 minfo ("\n%s", output_section_statement
->name
);
2148 if (section
!= NULL
)
2150 print_dot
= section
->vma
;
2152 len
= strlen (output_section_statement
->name
);
2153 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2158 while (len
< SECTION_NAME_MAP_LENGTH
)
2164 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2166 if (output_section_statement
->load_base
!= NULL
)
2170 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2171 "load base", lang_final_phase_enum
);
2172 minfo (_(" load address 0x%V"), addr
);
2179 print_statement_list (output_section_statement
->children
.head
,
2180 output_section_statement
);
2184 print_assignment (assignment
, output_section
)
2185 lang_assignment_statement_type
*assignment
;
2186 lang_output_section_statement_type
*output_section
;
2189 etree_value_type result
;
2191 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2194 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2195 lang_final_phase_enum
, print_dot
, &print_dot
);
2197 minfo ("0x%V", result
.value
+ result
.section
->bfd_section
->vma
);
2208 exp_print_tree (assignment
->exp
);
2214 print_input_statement (statm
)
2215 lang_input_statement_type
*statm
;
2217 if (statm
->filename
!= (char *) NULL
)
2219 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2223 /* Print all symbols defined in a particular section. This is called
2224 via bfd_link_hash_traverse. */
2227 print_one_symbol (hash_entry
, ptr
)
2228 struct bfd_link_hash_entry
*hash_entry
;
2231 asection
*sec
= (asection
*) ptr
;
2233 if ((hash_entry
->type
== bfd_link_hash_defined
2234 || hash_entry
->type
== bfd_link_hash_defweak
)
2235 && sec
== hash_entry
->u
.def
.section
)
2239 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2242 (hash_entry
->u
.def
.value
2243 + hash_entry
->u
.def
.section
->output_offset
2244 + hash_entry
->u
.def
.section
->output_section
->vma
));
2246 minfo (" %T\n", hash_entry
->root
.string
);
2252 /* Print information about an input section to the map file. */
2255 print_input_section (in
)
2256 lang_input_section_type
*in
;
2258 asection
*i
= in
->section
;
2259 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2260 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2261 ldfile_output_machine
);
2266 minfo ("%s", i
->name
);
2268 if (i
->output_section
!= NULL
)
2272 len
= 1 + strlen (i
->name
);
2273 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2278 while (len
< SECTION_NAME_MAP_LENGTH
)
2284 minfo ("0x%V %W %B\n",
2285 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2288 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2290 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2302 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2305 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2307 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2313 print_fill_statement (fill
)
2314 lang_fill_statement_type
*fill
;
2316 fprintf (config
.map_file
, " FILL mask 0x%x\n", fill
->fill
);
2320 print_data_statement (data
)
2321 lang_data_statement_type
*data
;
2327 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2328 ldfile_output_machine
);
2330 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2333 addr
= data
->output_vma
;
2334 if (data
->output_section
!= NULL
)
2335 addr
+= data
->output_section
->vma
;
2363 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2365 if (data
->exp
->type
.node_class
!= etree_value
)
2368 exp_print_tree (data
->exp
);
2373 print_dot
= addr
+ size
/ opb
;
2377 /* Print an address statement. These are generated by options like
2381 print_address_statement (address
)
2382 lang_address_statement_type
*address
;
2384 minfo (_("Address of section %s set to "), address
->section_name
);
2385 exp_print_tree (address
->address
);
2389 /* Print a reloc statement. */
2392 print_reloc_statement (reloc
)
2393 lang_reloc_statement_type
*reloc
;
2398 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2399 ldfile_output_machine
);
2401 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2404 addr
= reloc
->output_vma
;
2405 if (reloc
->output_section
!= NULL
)
2406 addr
+= reloc
->output_section
->vma
;
2408 size
= bfd_get_reloc_size (reloc
->howto
);
2410 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2412 if (reloc
->name
!= NULL
)
2413 minfo ("%s+", reloc
->name
);
2415 minfo ("%s+", reloc
->section
->name
);
2417 exp_print_tree (reloc
->addend_exp
);
2421 print_dot
= addr
+ size
/ opb
;
2425 print_padding_statement (s
)
2426 lang_padding_statement_type
*s
;
2430 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2431 ldfile_output_machine
);
2435 len
= sizeof " *fill*" - 1;
2436 while (len
< SECTION_NAME_MAP_LENGTH
)
2442 addr
= s
->output_offset
;
2443 if (s
->output_section
!= NULL
)
2444 addr
+= s
->output_section
->vma
;
2445 minfo ("0x%V %W", addr
, s
->size
);
2448 minfo (" %u", s
->fill
);
2452 print_dot
= addr
+ s
->size
/ opb
;
2456 print_wild_statement (w
, os
)
2457 lang_wild_statement_type
*w
;
2458 lang_output_section_statement_type
*os
;
2460 struct wildcard_list
*sec
;
2464 if (w
->filenames_sorted
)
2466 if (w
->filename
!= NULL
)
2467 minfo ("%s", w
->filename
);
2470 if (w
->filenames_sorted
)
2474 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
2476 if (sec
->spec
.sorted
)
2478 if (sec
->spec
.exclude_name_list
!= NULL
)
2481 minfo ("EXCLUDE_FILE ( %s", sec
->spec
.exclude_name_list
->name
);
2482 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
2483 minfo (", %s", tmp
->name
);
2486 if (sec
->spec
.name
!= NULL
)
2487 minfo ("%s", sec
->spec
.name
);
2490 if (sec
->spec
.sorted
)
2497 print_statement_list (w
->children
.head
, os
);
2500 /* Print a group statement. */
2504 lang_group_statement_type
*s
;
2505 lang_output_section_statement_type
*os
;
2507 fprintf (config
.map_file
, "START GROUP\n");
2508 print_statement_list (s
->children
.head
, os
);
2509 fprintf (config
.map_file
, "END GROUP\n");
2512 /* Print the list of statements in S.
2513 This can be called for any statement type. */
2516 print_statement_list (s
, os
)
2517 lang_statement_union_type
*s
;
2518 lang_output_section_statement_type
*os
;
2522 print_statement (s
, os
);
2527 /* Print the first statement in statement list S.
2528 This can be called for any statement type. */
2531 print_statement (s
, os
)
2532 lang_statement_union_type
*s
;
2533 lang_output_section_statement_type
*os
;
2535 switch (s
->header
.type
)
2538 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2541 case lang_constructors_statement_enum
:
2542 if (constructor_list
.head
!= NULL
)
2544 if (constructors_sorted
)
2545 minfo (" SORT (CONSTRUCTORS)\n");
2547 minfo (" CONSTRUCTORS\n");
2548 print_statement_list (constructor_list
.head
, os
);
2551 case lang_wild_statement_enum
:
2552 print_wild_statement (&s
->wild_statement
, os
);
2554 case lang_address_statement_enum
:
2555 print_address_statement (&s
->address_statement
);
2557 case lang_object_symbols_statement_enum
:
2558 minfo (" CREATE_OBJECT_SYMBOLS\n");
2560 case lang_fill_statement_enum
:
2561 print_fill_statement (&s
->fill_statement
);
2563 case lang_data_statement_enum
:
2564 print_data_statement (&s
->data_statement
);
2566 case lang_reloc_statement_enum
:
2567 print_reloc_statement (&s
->reloc_statement
);
2569 case lang_input_section_enum
:
2570 print_input_section (&s
->input_section
);
2572 case lang_padding_statement_enum
:
2573 print_padding_statement (&s
->padding_statement
);
2575 case lang_output_section_statement_enum
:
2576 print_output_section_statement (&s
->output_section_statement
);
2578 case lang_assignment_statement_enum
:
2579 print_assignment (&s
->assignment_statement
, os
);
2581 case lang_target_statement_enum
:
2582 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2584 case lang_output_statement_enum
:
2585 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2586 if (output_target
!= NULL
)
2587 minfo (" %s", output_target
);
2590 case lang_input_statement_enum
:
2591 print_input_statement (&s
->input_statement
);
2593 case lang_group_statement_enum
:
2594 print_group (&s
->group_statement
, os
);
2596 case lang_afile_asection_pair_statement_enum
:
2605 print_statement_list (statement_list
.head
, abs_output_section
);
2608 /* Print the first N statements in statement list S to STDERR.
2609 If N == 0, nothing is printed.
2610 If N < 0, the entire list is printed.
2611 Intended to be called from GDB. */
2614 dprint_statement (s
, n
)
2615 lang_statement_union_type
*s
;
2618 FILE *map_save
= config
.map_file
;
2620 config
.map_file
= stderr
;
2623 print_statement_list (s
, abs_output_section
);
2626 while (s
&& --n
>= 0)
2628 print_statement (s
, abs_output_section
);
2633 config
.map_file
= map_save
;
2637 insert_pad (ptr
, fill
, alignment_needed
, output_section
, dot
)
2638 lang_statement_union_type
**ptr
;
2640 unsigned int alignment_needed
;
2641 asection
*output_section
;
2644 lang_statement_union_type
*pad
;
2646 pad
= ((lang_statement_union_type
*)
2647 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
2648 if (ptr
!= &statement_list
.head
2649 && pad
->header
.type
== lang_padding_statement_enum
2650 && pad
->padding_statement
.output_section
== output_section
)
2652 /* Use the existing pad statement. The above test on output
2653 section is probably redundant, but it doesn't hurt to check. */
2657 /* Make a new padding statement, linked into existing chain. */
2658 pad
= ((lang_statement_union_type
*)
2659 stat_alloc (sizeof (lang_padding_statement_type
)));
2660 pad
->header
.next
= *ptr
;
2662 pad
->header
.type
= lang_padding_statement_enum
;
2663 pad
->padding_statement
.output_section
= output_section
;
2664 pad
->padding_statement
.fill
= fill
;
2666 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
2667 pad
->padding_statement
.size
= alignment_needed
;
2668 output_section
->_raw_size
+= alignment_needed
;
2671 /* Work out how much this section will move the dot point. */
2674 size_input_section (this_ptr
, output_section_statement
, fill
, dot
)
2675 lang_statement_union_type
**this_ptr
;
2676 lang_output_section_statement_type
*output_section_statement
;
2680 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2681 asection
*i
= is
->section
;
2683 if (is
->ifile
->just_syms_flag
== false)
2685 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2686 ldfile_output_machine
);
2687 unsigned int alignment_needed
;
2690 /* Align this section first to the input sections requirement,
2691 then to the output section's requirement. If this alignment
2692 is greater than any seen before, then record it too. Perform
2693 the alignment by inserting a magic 'padding' statement. */
2695 if (output_section_statement
->subsection_alignment
!= -1)
2696 i
->alignment_power
= output_section_statement
->subsection_alignment
;
2698 o
= output_section_statement
->bfd_section
;
2699 if (o
->alignment_power
< i
->alignment_power
)
2700 o
->alignment_power
= i
->alignment_power
;
2702 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
2704 if (alignment_needed
!= 0)
2706 insert_pad (this_ptr
, fill
, alignment_needed
* opb
, o
, dot
);
2707 dot
+= alignment_needed
;
2710 /* Remember where in the output section this input section goes. */
2712 i
->output_offset
= dot
- o
->vma
;
2714 /* Mark how big the output section must be to contain this now. */
2715 if (i
->_cooked_size
!= 0)
2716 dot
+= i
->_cooked_size
/ opb
;
2718 dot
+= i
->_raw_size
/ opb
;
2719 o
->_raw_size
= (dot
- o
->vma
) * opb
;
2723 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2729 #define IGNORE_SECTION(bfd, s) \
2730 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2731 != (SEC_ALLOC | SEC_LOAD)) \
2732 || bfd_section_size (bfd, s) == 0)
2734 /* Check to see if any allocated sections overlap with other allocated
2735 sections. This can happen when the linker script specifically specifies
2736 the output section addresses of the two sections. */
2739 lang_check_section_addresses ()
2742 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2744 /* Scan all sections in the output list. */
2745 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2749 /* Ignore sections which are not loaded or which have no contents. */
2750 if (IGNORE_SECTION (output_bfd
, s
))
2753 /* Once we reach section 's' stop our seach. This prevents two
2754 warning messages from being produced, one for 'section A overlaps
2755 section B' and one for 'section B overlaps section A'. */
2756 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2763 /* Only consider loadable sections with real contents. */
2764 if (IGNORE_SECTION (output_bfd
, os
))
2767 /* We must check the sections' LMA addresses not their
2768 VMA addresses because overlay sections can have
2769 overlapping VMAs but they must have distinct LMAs. */
2770 s_start
= bfd_section_lma (output_bfd
, s
);
2771 os_start
= bfd_section_lma (output_bfd
, os
);
2772 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2773 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2775 /* Look for an overlap. */
2776 if ((s_end
< os_start
) || (s_start
> os_end
))
2780 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2781 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2783 /* Once we have found one overlap for this section,
2784 stop looking for others. */
2790 /* Make sure the new address is within the region. We explicitly permit the
2791 current address to be at the exact end of the region when the address is
2792 non-zero, in case the region is at the end of addressable memory and the
2793 calculation wraps around. */
2796 os_region_check (os
, region
, tree
, base
)
2797 lang_output_section_statement_type
*os
;
2798 struct memory_region_struct
*region
;
2802 if ((region
->current
< region
->origin
2803 || (region
->current
- region
->origin
> region
->length
))
2804 && ((region
->current
!= region
->origin
+ region
->length
)
2807 if (tree
!= (etree_type
*) NULL
)
2809 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2811 os
->bfd_section
->owner
,
2812 os
->bfd_section
->name
,
2817 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2819 os
->bfd_section
->owner
,
2820 os
->bfd_section
->name
);
2822 /* Reset the region pointer. */
2823 region
->current
= region
->origin
;
2827 /* Set the sizes for all the output sections. */
2830 lang_size_sections_1 (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2831 lang_statement_union_type
*s
;
2832 lang_output_section_statement_type
*output_section_statement
;
2833 lang_statement_union_type
**prev
;
2838 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2839 ldfile_output_machine
);
2841 /* Size up the sections from their constituent parts. */
2842 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2844 switch (s
->header
.type
)
2846 case lang_output_section_statement_enum
:
2849 lang_output_section_statement_type
*os
;
2851 os
= &s
->output_section_statement
;
2852 if (os
->bfd_section
== NULL
)
2853 /* This section was never actually created. */
2856 /* If this is a COFF shared library section, use the size and
2857 address from the input section. FIXME: This is COFF
2858 specific; it would be cleaner if there were some other way
2859 to do this, but nothing simple comes to mind. */
2860 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2864 if (os
->children
.head
== NULL
2865 || os
->children
.head
->header
.next
!= NULL
2866 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2867 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2870 input
= os
->children
.head
->input_section
.section
;
2871 bfd_set_section_vma (os
->bfd_section
->owner
,
2873 bfd_section_vma (input
->owner
, input
));
2874 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2878 if (bfd_is_abs_section (os
->bfd_section
))
2880 /* No matter what happens, an abs section starts at zero. */
2881 ASSERT (os
->bfd_section
->vma
== 0);
2885 if (os
->addr_tree
== (etree_type
*) NULL
)
2887 /* No address specified for this section, get one
2888 from the region specification. */
2889 if (os
->region
== (lang_memory_region_type
*) NULL
2890 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2891 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2892 && os
->region
->name
[0] == '*'
2893 && strcmp (os
->region
->name
, "*default*") == 0))
2895 os
->region
= lang_memory_default (os
->bfd_section
);
2898 /* If a loadable section is using the default memory
2899 region, and some non default memory regions were
2900 defined, issue a warning. */
2901 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2902 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2903 && ! link_info
.relocateable
2904 && strcmp (os
->region
->name
, "*default*") == 0
2905 && lang_memory_region_list
!= NULL
2906 && (strcmp (lang_memory_region_list
->name
,
2908 || lang_memory_region_list
->next
!= NULL
))
2909 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2910 bfd_get_section_name (output_bfd
,
2913 dot
= os
->region
->current
;
2915 if (os
->section_alignment
== -1)
2920 dot
= align_power (dot
,
2921 os
->bfd_section
->alignment_power
);
2923 if (dot
!= olddot
&& config
.warn_section_align
)
2924 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2925 os
->name
, (unsigned int) (dot
- olddot
));
2932 r
= exp_fold_tree (os
->addr_tree
,
2934 lang_allocating_phase_enum
,
2936 if (r
.valid_p
== false)
2938 einfo (_("%F%S: non constant address expression for section %s\n"),
2941 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2944 /* The section starts here.
2945 First, align to what the section needs. */
2947 if (os
->section_alignment
!= -1)
2948 dot
= align_power (dot
, os
->section_alignment
);
2950 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2952 os
->bfd_section
->output_offset
= 0;
2955 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
2956 os
->fill
, dot
, relax
);
2958 /* Put the section within the requested block size, or
2959 align at the block boundary. */
2960 after
= ALIGN_N (os
->bfd_section
->vma
2961 + os
->bfd_section
->_raw_size
/ opb
,
2962 /* The coercion here is important, see ld.h. */
2963 (bfd_vma
) os
->block_value
);
2965 if (bfd_is_abs_section (os
->bfd_section
))
2966 ASSERT (after
== os
->bfd_section
->vma
);
2968 os
->bfd_section
->_raw_size
=
2969 (after
- os
->bfd_section
->vma
) * opb
;
2970 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
2971 os
->processed
= true;
2973 /* Update dot in the region ?
2974 We only do this if the section is going to be allocated,
2975 since unallocated sections do not contribute to the region's
2976 overall size in memory.
2978 If the SEC_NEVER_LOAD bit is not set, it will affect the
2979 addresses of sections after it. We have to update
2981 if (os
->region
!= (lang_memory_region_type
*) NULL
2982 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2983 & SEC_NEVER_LOAD
) == 0
2984 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2985 & (SEC_ALLOC
| SEC_LOAD
))))
2987 os
->region
->current
= dot
;
2989 /* Make sure the new address is within the region. */
2990 os_region_check (os
, os
->region
, os
->addr_tree
,
2991 os
->bfd_section
->vma
);
2993 /* If there's no load address specified, use the run
2994 region as the load region. */
2995 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
2996 os
->lma_region
= os
->region
;
2998 if (os
->lma_region
!= NULL
)
3000 if (os
->load_base
!= NULL
)
3002 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
3006 /* Don't allocate twice. */
3007 if (os
->lma_region
!= os
->region
)
3009 /* Set load_base, which will be handled later. */
3011 exp_intop (os
->lma_region
->current
);
3012 os
->lma_region
->current
+=
3013 os
->bfd_section
->_raw_size
/ opb
;
3014 os_region_check (os
, os
->lma_region
, NULL
,
3015 os
->bfd_section
->lma
);
3023 case lang_constructors_statement_enum
:
3024 dot
= lang_size_sections_1 (constructor_list
.head
,
3025 output_section_statement
,
3026 &s
->wild_statement
.children
.head
,
3030 case lang_data_statement_enum
:
3032 unsigned int size
= 0;
3034 s
->data_statement
.output_vma
=
3035 dot
- output_section_statement
->bfd_section
->vma
;
3036 s
->data_statement
.output_section
=
3037 output_section_statement
->bfd_section
;
3039 switch (s
->data_statement
.type
)
3060 output_section_statement
->bfd_section
->_raw_size
+= size
;
3061 /* The output section gets contents, and then we inspect for
3062 any flags set in the input script which override any ALLOC. */
3063 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3064 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3066 output_section_statement
->bfd_section
->flags
|=
3067 SEC_ALLOC
| SEC_LOAD
;
3072 case lang_reloc_statement_enum
:
3076 s
->reloc_statement
.output_vma
=
3077 dot
- output_section_statement
->bfd_section
->vma
;
3078 s
->reloc_statement
.output_section
=
3079 output_section_statement
->bfd_section
;
3080 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3082 output_section_statement
->bfd_section
->_raw_size
+= size
;
3086 case lang_wild_statement_enum
:
3088 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
3089 output_section_statement
,
3090 &s
->wild_statement
.children
.head
,
3095 case lang_object_symbols_statement_enum
:
3096 link_info
.create_object_symbols_section
=
3097 output_section_statement
->bfd_section
;
3099 case lang_output_statement_enum
:
3100 case lang_target_statement_enum
:
3102 case lang_input_section_enum
:
3106 i
= (*prev
)->input_section
.section
;
3109 if (i
->_cooked_size
== 0)
3110 i
->_cooked_size
= i
->_raw_size
;
3116 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3117 einfo (_("%P%F: can't relax section: %E\n"));
3121 dot
= size_input_section (prev
, output_section_statement
,
3122 output_section_statement
->fill
, dot
);
3125 case lang_input_statement_enum
:
3127 case lang_fill_statement_enum
:
3128 s
->fill_statement
.output_section
=
3129 output_section_statement
->bfd_section
;
3131 fill
= s
->fill_statement
.fill
;
3133 case lang_assignment_statement_enum
:
3135 bfd_vma newdot
= dot
;
3137 exp_fold_tree (s
->assignment_statement
.exp
,
3138 output_section_statement
,
3139 lang_allocating_phase_enum
,
3145 if (output_section_statement
== abs_output_section
)
3147 /* If we don't have an output section, then just adjust
3148 the default memory address. */
3149 lang_memory_region_lookup ("*default*")->current
= newdot
;
3153 /* Insert a pad after this statement. We can't
3154 put the pad before when relaxing, in case the
3155 assignment references dot. */
3156 insert_pad (&s
->header
.next
, fill
, (newdot
- dot
) * opb
,
3157 output_section_statement
->bfd_section
, dot
);
3159 /* Don't neuter the pad below when relaxing. */
3168 case lang_padding_statement_enum
:
3169 /* If this is the first time lang_size_sections is called,
3170 we won't have any padding statements. If this is the
3171 second or later passes when relaxing, we should allow
3172 padding to shrink. If padding is needed on this pass, it
3173 will be added back in. */
3174 s
->padding_statement
.size
= 0;
3176 /* Make sure output_offset is valid. If relaxation shrinks
3177 the section and this pad isn't needed, it's possible to
3178 have output_offset larger than the final size of the
3179 section. bfd_set_section_contents will complain even for
3180 a pad size of zero. */
3181 s
->padding_statement
.output_offset
3182 = dot
- output_section_statement
->bfd_section
->vma
;
3185 case lang_group_statement_enum
:
3186 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
3187 output_section_statement
,
3188 &s
->group_statement
.children
.head
,
3196 /* We can only get here when relaxing is turned on. */
3197 case lang_address_statement_enum
:
3200 prev
= &s
->header
.next
;
3206 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
3207 lang_statement_union_type
*s
;
3208 lang_output_section_statement_type
*output_section_statement
;
3209 lang_statement_union_type
**prev
;
3216 exp_data_seg
.phase
= exp_dataseg_none
;
3217 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
3219 if (exp_data_seg
.phase
== exp_dataseg_end_seen
)
3221 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3222 a page could be saved in the data segment. */
3223 bfd_vma first
, last
;
3225 first
= -exp_data_seg
.base
& (exp_data_seg
.pagesize
- 1);
3226 last
= exp_data_seg
.end
& (exp_data_seg
.pagesize
- 1);
3228 && ((exp_data_seg
.base
& ~(exp_data_seg
.pagesize
- 1))
3229 != (exp_data_seg
.end
& ~(exp_data_seg
.pagesize
- 1)))
3230 && first
+ last
<= exp_data_seg
.pagesize
)
3232 exp_data_seg
.phase
= exp_dataseg_adjust
;
3233 result
= lang_size_sections_1 (s
, output_section_statement
, prev
,
3242 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3243 lang_statement_union_type
*s
;
3244 lang_output_section_statement_type
*output_section_statement
;
3248 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3249 ldfile_output_machine
);
3251 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3253 switch (s
->header
.type
)
3255 case lang_constructors_statement_enum
:
3256 dot
= lang_do_assignments (constructor_list
.head
,
3257 output_section_statement
,
3262 case lang_output_section_statement_enum
:
3264 lang_output_section_statement_type
*os
;
3266 os
= &(s
->output_section_statement
);
3267 if (os
->bfd_section
!= NULL
)
3269 dot
= os
->bfd_section
->vma
;
3270 (void) lang_do_assignments (os
->children
.head
, os
,
3272 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3277 /* If nothing has been placed into the output section then
3278 it won't have a bfd_section. */
3279 if (os
->bfd_section
)
3281 os
->bfd_section
->lma
3282 = exp_get_abs_int (os
->load_base
, 0, "load base",
3283 lang_final_phase_enum
);
3288 case lang_wild_statement_enum
:
3290 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3291 output_section_statement
,
3296 case lang_object_symbols_statement_enum
:
3297 case lang_output_statement_enum
:
3298 case lang_target_statement_enum
:
3300 case lang_common_statement_enum
:
3303 case lang_data_statement_enum
:
3305 etree_value_type value
;
3307 value
= exp_fold_tree (s
->data_statement
.exp
,
3309 lang_final_phase_enum
, dot
, &dot
);
3310 s
->data_statement
.value
= value
.value
;
3311 if (value
.valid_p
== false)
3312 einfo (_("%F%P: invalid data statement\n"));
3316 switch (s
->data_statement
.type
)
3340 case lang_reloc_statement_enum
:
3342 etree_value_type value
;
3344 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3346 lang_final_phase_enum
, dot
, &dot
);
3347 s
->reloc_statement
.addend_value
= value
.value
;
3348 if (value
.valid_p
== false)
3349 einfo (_("%F%P: invalid reloc statement\n"));
3351 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3354 case lang_input_section_enum
:
3356 asection
*in
= s
->input_section
.section
;
3358 if (in
->_cooked_size
!= 0)
3359 dot
+= in
->_cooked_size
/ opb
;
3361 dot
+= in
->_raw_size
/ opb
;
3365 case lang_input_statement_enum
:
3367 case lang_fill_statement_enum
:
3368 fill
= s
->fill_statement
.fill
;
3370 case lang_assignment_statement_enum
:
3372 exp_fold_tree (s
->assignment_statement
.exp
,
3373 output_section_statement
,
3374 lang_final_phase_enum
,
3380 case lang_padding_statement_enum
:
3381 dot
+= s
->padding_statement
.size
/ opb
;
3384 case lang_group_statement_enum
:
3385 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3386 output_section_statement
,
3394 case lang_address_statement_enum
:
3402 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3403 operator .startof. (section_name), it produces an undefined symbol
3404 .startof.section_name. Similarly, when it sees
3405 .sizeof. (section_name), it produces an undefined symbol
3406 .sizeof.section_name. For all the output sections, we look for
3407 such symbols, and set them to the correct value. */
3414 if (link_info
.relocateable
)
3417 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3419 const char *secname
;
3421 struct bfd_link_hash_entry
*h
;
3423 secname
= bfd_get_section_name (output_bfd
, s
);
3424 buf
= xmalloc (10 + strlen (secname
));
3426 sprintf (buf
, ".startof.%s", secname
);
3427 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3428 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3430 h
->type
= bfd_link_hash_defined
;
3431 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3432 h
->u
.def
.section
= bfd_abs_section_ptr
;
3435 sprintf (buf
, ".sizeof.%s", secname
);
3436 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3437 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3441 opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3442 ldfile_output_machine
);
3443 h
->type
= bfd_link_hash_defined
;
3444 if (s
->_cooked_size
!= 0)
3445 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3447 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3448 h
->u
.def
.section
= bfd_abs_section_ptr
;
3458 struct bfd_link_hash_entry
*h
;
3461 if (link_info
.relocateable
|| link_info
.shared
)
3466 if (entry_symbol
== (char *) NULL
)
3468 /* No entry has been specified. Look for start, but don't warn
3469 if we don't find it. */
3470 entry_symbol
= "start";
3474 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
3475 if (h
!= (struct bfd_link_hash_entry
*) NULL
3476 && (h
->type
== bfd_link_hash_defined
3477 || h
->type
== bfd_link_hash_defweak
)
3478 && h
->u
.def
.section
->output_section
!= NULL
)
3482 val
= (h
->u
.def
.value
3483 + bfd_get_section_vma (output_bfd
,
3484 h
->u
.def
.section
->output_section
)
3485 + h
->u
.def
.section
->output_offset
);
3486 if (! bfd_set_start_address (output_bfd
, val
))
3487 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
);
3494 /* We couldn't find the entry symbol. Try parsing it as a
3496 val
= bfd_scan_vma (entry_symbol
, &send
, 0);
3499 if (! bfd_set_start_address (output_bfd
, val
))
3500 einfo (_("%P%F: can't set start address\n"));
3506 /* Can't find the entry symbol, and it's not a number. Use
3507 the first address in the text section. */
3508 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
3509 if (ts
!= (asection
*) NULL
)
3512 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3513 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
3514 if (! bfd_set_start_address (output_bfd
,
3515 bfd_get_section_vma (output_bfd
,
3517 einfo (_("%P%F: can't set start address\n"));
3522 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3529 /* This is a small function used when we want to ignore errors from
3533 #ifdef ANSI_PROTOTYPES
3534 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3536 ignore_bfd_errors (s
)
3537 const char *s ATTRIBUTE_UNUSED
;
3540 /* Don't do anything. */
3543 /* Check that the architecture of all the input files is compatible
3544 with the output file. Also call the backend to let it do any
3545 other checking that is needed. */
3550 lang_statement_union_type
*file
;
3552 const bfd_arch_info_type
*compatible
;
3554 for (file
= file_chain
.head
;
3555 file
!= (lang_statement_union_type
*) NULL
;
3556 file
= file
->input_statement
.next
)
3558 input_bfd
= file
->input_statement
.the_bfd
;
3559 compatible
= bfd_arch_get_compatible (input_bfd
,
3561 if (compatible
== NULL
)
3563 if (command_line
.warn_mismatch
)
3564 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3565 bfd_printable_name (input_bfd
), input_bfd
,
3566 bfd_printable_name (output_bfd
));
3568 else if (link_info
.relocateable
3569 /* In general it is not possible to perform a relocatable
3570 link between differing object formats when the input
3571 file has relocations, because the relocations in the
3572 input format may not have equivalent representations in
3573 the output format (and besides BFD does not translate
3574 relocs for other link purposes than a final link). */
3575 && bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
)
3576 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
3577 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3578 bfd_get_target (input_bfd
), input_bfd
,
3579 bfd_get_target (output_bfd
), output_bfd
);
3580 else if (bfd_count_sections (input_bfd
))
3582 /* If the input bfd has no contents, it shouldn't set the
3583 private data of the output bfd. */
3585 bfd_error_handler_type pfn
= NULL
;
3587 /* If we aren't supposed to warn about mismatched input
3588 files, temporarily set the BFD error handler to a
3589 function which will do nothing. We still want to call
3590 bfd_merge_private_bfd_data, since it may set up
3591 information which is needed in the output file. */
3592 if (! command_line
.warn_mismatch
)
3593 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3594 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3596 if (command_line
.warn_mismatch
)
3597 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3600 if (! command_line
.warn_mismatch
)
3601 bfd_set_error_handler (pfn
);
3606 /* Look through all the global common symbols and attach them to the
3607 correct section. The -sort-common command line switch may be used
3608 to roughly sort the entries by size. */
3613 if (command_line
.inhibit_common_definition
)
3615 if (link_info
.relocateable
3616 && ! command_line
.force_common_definition
)
3619 if (! config
.sort_common
)
3620 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3625 for (power
= 4; power
>= 0; power
--)
3626 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3631 /* Place one common symbol in the correct section. */
3634 lang_one_common (h
, info
)
3635 struct bfd_link_hash_entry
*h
;
3638 unsigned int power_of_two
;
3641 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3642 ldfile_output_machine
);
3644 if (h
->type
!= bfd_link_hash_common
)
3648 power_of_two
= h
->u
.c
.p
->alignment_power
;
3650 if (config
.sort_common
3651 && power_of_two
< (unsigned int) *(int *) info
)
3654 section
= h
->u
.c
.p
->section
;
3656 /* Increase the size of the section. */
3657 section
->_cooked_size
= ALIGN_N ((section
->_cooked_size
+ opb
- 1) / opb
,
3658 (bfd_size_type
) (1 << power_of_two
)) * opb
;
3660 /* Adjust the alignment if necessary. */
3661 if (power_of_two
> section
->alignment_power
)
3662 section
->alignment_power
= power_of_two
;
3664 /* Change the symbol from common to defined. */
3665 h
->type
= bfd_link_hash_defined
;
3666 h
->u
.def
.section
= section
;
3667 h
->u
.def
.value
= section
->_cooked_size
;
3669 /* Increase the size of the section. */
3670 section
->_cooked_size
+= size
;
3672 /* Make sure the section is allocated in memory, and make sure that
3673 it is no longer a common section. */
3674 section
->flags
|= SEC_ALLOC
;
3675 section
->flags
&= ~SEC_IS_COMMON
;
3677 if (config
.map_file
!= NULL
)
3679 static boolean header_printed
;
3684 if (! header_printed
)
3686 minfo (_("\nAllocating common symbols\n"));
3687 minfo (_("Common symbol size file\n\n"));
3688 header_printed
= true;
3691 name
= demangle (h
->root
.string
);
3693 len
= strlen (name
);
3708 if (size
<= 0xffffffff)
3709 sprintf (buf
, "%lx", (unsigned long) size
);
3711 sprintf_vma (buf
, size
);
3721 minfo ("%B\n", section
->owner
);
3727 /* Run through the input files and ensure that every input section has
3728 somewhere to go. If one is found without a destination then create
3729 an input request and place it into the statement tree. */
3732 lang_place_orphans ()
3734 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3738 for (s
= file
->the_bfd
->sections
;
3739 s
!= (asection
*) NULL
;
3742 if (s
->output_section
== (asection
*) NULL
)
3744 /* This section of the file is not attatched, root
3745 around for a sensible place for it to go. */
3747 if (file
->just_syms_flag
)
3749 /* We are only retrieving symbol values from this
3750 file. We want the symbols to act as though the
3751 values in the file are absolute. */
3752 s
->output_section
= bfd_abs_section_ptr
;
3753 s
->output_offset
= s
->vma
;
3755 else if (strcmp (s
->name
, "COMMON") == 0)
3757 /* This is a lonely common section which must have
3758 come from an archive. We attach to the section
3759 with the wildcard. */
3760 if (! link_info
.relocateable
3761 || command_line
.force_common_definition
)
3763 if (default_common_section
== NULL
)
3766 /* This message happens when using the
3767 svr3.ifile linker script, so I have
3769 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3771 default_common_section
=
3772 lang_output_section_statement_lookup (".bss");
3775 lang_add_section (&default_common_section
->children
, s
,
3776 default_common_section
, file
);
3779 else if (ldemul_place_orphan (file
, s
))
3783 lang_output_section_statement_type
*os
;
3785 os
= lang_output_section_statement_lookup (s
->name
);
3786 lang_add_section (&os
->children
, s
, os
, file
);
3794 lang_set_flags (ptr
, flags
, invert
)
3795 lang_memory_region_type
*ptr
;
3799 flagword
*ptr_flags
;
3801 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3807 *ptr_flags
|= SEC_ALLOC
;
3811 *ptr_flags
|= SEC_READONLY
;
3815 *ptr_flags
|= SEC_DATA
;
3819 *ptr_flags
|= SEC_CODE
;
3824 *ptr_flags
|= SEC_LOAD
;
3828 einfo (_("%P%F: invalid syntax in flags\n"));
3835 /* Call a function on each input file. This function will be called
3836 on an archive, but not on the elements. */
3839 lang_for_each_input_file (func
)
3840 void (*func
) PARAMS ((lang_input_statement_type
*));
3842 lang_input_statement_type
*f
;
3844 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3846 f
= (lang_input_statement_type
*) f
->next_real_file
)
3850 /* Call a function on each file. The function will be called on all
3851 the elements of an archive which are included in the link, but will
3852 not be called on the archive file itself. */
3855 lang_for_each_file (func
)
3856 void (*func
) PARAMS ((lang_input_statement_type
*));
3858 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3869 lang_for_each_input_section (func
)
3870 void (*func
) PARAMS ((bfd
*ab
, asection
*as
));
3872 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3876 for (s
= f
->the_bfd
->sections
;
3877 s
!= (asection
*) NULL
;
3880 func (f
->the_bfd
, s
);
3888 ldlang_add_file (entry
)
3889 lang_input_statement_type
*entry
;
3893 lang_statement_append (&file_chain
,
3894 (lang_statement_union_type
*) entry
,
3897 /* The BFD linker needs to have a list of all input BFDs involved in
3899 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3900 ASSERT (entry
->the_bfd
!= output_bfd
);
3901 for (pp
= &link_info
.input_bfds
;
3902 *pp
!= (bfd
*) NULL
;
3903 pp
= &(*pp
)->link_next
)
3905 *pp
= entry
->the_bfd
;
3906 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3907 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3909 /* Look through the sections and check for any which should not be
3910 included in the link. We need to do this now, so that we can
3911 notice when the backend linker tries to report multiple
3912 definition errors for symbols which are in sections we aren't
3913 going to link. FIXME: It might be better to entirely ignore
3914 symbols which are defined in sections which are going to be
3915 discarded. This would require modifying the backend linker for
3916 each backend which might set the SEC_LINK_ONCE flag. If we do
3917 this, we should probably handle SEC_EXCLUDE in the same way. */
3919 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
3923 lang_add_output (name
, from_script
)
3927 /* Make -o on command line override OUTPUT in script. */
3928 if (had_output_filename
== false || !from_script
)
3930 output_filename
= name
;
3931 had_output_filename
= true;
3935 static lang_output_section_statement_type
*current_section
;
3947 for (l
= 0; l
< 32; l
++)
3949 if (i
>= (unsigned int) x
)
3957 lang_output_section_statement_type
*
3958 lang_enter_output_section_statement (output_section_statement_name
,
3959 address_exp
, sectype
, block_value
,
3960 align
, subalign
, ebase
)
3961 const char *output_section_statement_name
;
3962 etree_type
*address_exp
;
3963 enum section_type sectype
;
3964 bfd_vma block_value
;
3966 etree_type
*subalign
;
3969 lang_output_section_statement_type
*os
;
3973 lang_output_section_statement_lookup (output_section_statement_name
);
3975 /* Add this statement to tree. */
3977 add_statement (lang_output_section_statement_enum
,
3978 output_section_statement
);
3980 /* Make next things chain into subchain of this. */
3982 if (os
->addr_tree
== (etree_type
*) NULL
)
3984 os
->addr_tree
= address_exp
;
3986 os
->sectype
= sectype
;
3987 if (sectype
!= noload_section
)
3988 os
->flags
= SEC_NO_FLAGS
;
3990 os
->flags
= SEC_NEVER_LOAD
;
3991 os
->block_value
= block_value
? block_value
: 1;
3992 stat_ptr
= &os
->children
;
3994 os
->subsection_alignment
=
3995 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
3996 os
->section_alignment
=
3997 topower (exp_get_value_int (align
, -1, "section alignment", 0));
3999 os
->load_base
= ebase
;
4006 lang_output_statement_type
*new =
4007 new_stat (lang_output_statement
, stat_ptr
);
4009 new->name
= output_filename
;
4012 /* Reset the current counters in the regions. */
4015 lang_reset_memory_regions ()
4017 lang_memory_region_type
*p
= lang_memory_region_list
;
4020 for (p
= lang_memory_region_list
;
4021 p
!= (lang_memory_region_type
*) NULL
;
4024 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
4025 p
->current
= p
->origin
;
4028 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4032 /* If the wild pattern was marked KEEP, the member sections
4033 should be as well. */
4036 gc_section_callback (ptr
, sec
, section
, file
, data
)
4037 lang_wild_statement_type
*ptr
;
4038 struct wildcard_list
*sec ATTRIBUTE_UNUSED
;
4040 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
4041 PTR data ATTRIBUTE_UNUSED
;
4043 if (ptr
->keep_sections
)
4044 section
->flags
|= SEC_KEEP
;
4047 /* Handle a wild statement, marking it against GC. */
4051 lang_wild_statement_type
*s
;
4053 walk_wild (s
, gc_section_callback
, NULL
);
4056 /* Iterate over sections marking them against GC. */
4059 lang_gc_sections_1 (s
)
4060 lang_statement_union_type
*s
;
4062 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
4064 switch (s
->header
.type
)
4066 case lang_wild_statement_enum
:
4067 lang_gc_wild (&s
->wild_statement
);
4069 case lang_constructors_statement_enum
:
4070 lang_gc_sections_1 (constructor_list
.head
);
4072 case lang_output_section_statement_enum
:
4073 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4075 case lang_group_statement_enum
:
4076 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4087 struct bfd_link_hash_entry
*h
;
4088 ldlang_undef_chain_list_type
*ulist
, fake_list_start
;
4090 /* Keep all sections so marked in the link script. */
4092 lang_gc_sections_1 (statement_list
.head
);
4094 /* Keep all sections containing symbols undefined on the command-line.
4095 Handle the entry symbol at the same time. */
4097 if (entry_symbol
!= NULL
)
4099 fake_list_start
.next
= ldlang_undef_chain_list_head
;
4100 fake_list_start
.name
= (char *) entry_symbol
;
4101 ulist
= &fake_list_start
;
4104 ulist
= ldlang_undef_chain_list_head
;
4106 for (; ulist
; ulist
= ulist
->next
)
4108 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4109 false, false, false);
4111 if (h
!= (struct bfd_link_hash_entry
*) NULL
4112 && (h
->type
== bfd_link_hash_defined
4113 || h
->type
== bfd_link_hash_defweak
)
4114 && ! bfd_is_abs_section (h
->u
.def
.section
))
4116 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4120 bfd_gc_sections (output_bfd
, &link_info
);
4126 lang_reasonable_defaults ();
4127 current_target
= default_target
;
4129 /* Open the output file. */
4130 lang_for_each_statement (ldlang_open_output
);
4132 ldemul_create_output_section_statements ();
4134 /* Add to the hash table all undefineds on the command line. */
4135 lang_place_undefineds ();
4137 already_linked_table_init ();
4139 /* Create a bfd for each input file. */
4140 current_target
= default_target
;
4141 open_input_bfds (statement_list
.head
, false);
4143 ldemul_after_open ();
4145 already_linked_table_free ();
4147 /* Make sure that we're not mixing architectures. We call this
4148 after all the input files have been opened, but before we do any
4149 other processing, so that any operations merge_private_bfd_data
4150 does on the output file will be known during the rest of the
4154 /* Handle .exports instead of a version script if we're told to do so. */
4155 if (command_line
.version_exports_section
)
4156 lang_do_version_exports_section ();
4158 /* Build all sets based on the information gathered from the input
4160 ldctor_build_sets ();
4162 /* Remove unreferenced sections if asked to. */
4163 if (command_line
.gc_sections
)
4164 lang_gc_sections ();
4166 /* If there were any SEC_MERGE sections, finish their merging, so that
4167 section sizes can be computed. This has to be done after GC of sections,
4168 so that GCed sections are not merged, but before assigning output
4169 sections, since removing whole input sections is hard then. */
4170 bfd_merge_sections (output_bfd
, &link_info
);
4172 /* Size up the common data. */
4175 /* Run through the contours of the script and attach input sections
4176 to the correct output sections. */
4177 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4178 (lang_output_section_statement_type
*) NULL
);
4180 /* Find any sections not attached explicitly and handle them. */
4181 lang_place_orphans ();
4183 ldemul_before_allocation ();
4185 /* We must record the program headers before we try to fix the
4186 section positions, since they will affect SIZEOF_HEADERS. */
4187 lang_record_phdrs ();
4189 /* Size up the sections. */
4190 lang_size_sections (statement_list
.head
,
4192 &statement_list
.head
, 0, (bfd_vma
) 0, NULL
);
4194 /* Now run around and relax if we can. */
4195 if (command_line
.relax
)
4197 /* Keep relaxing until bfd_relax_section gives up. */
4198 boolean relax_again
;
4202 lang_reset_memory_regions ();
4204 relax_again
= false;
4206 /* Note: pe-dll.c does something like this also. If you find
4207 you need to change this code, you probably need to change
4208 pe-dll.c also. DJ */
4210 /* Do all the assignments with our current guesses as to
4212 lang_do_assignments (statement_list
.head
,
4214 (fill_type
) 0, (bfd_vma
) 0);
4216 /* Perform another relax pass - this time we know where the
4217 globals are, so can make better guess. */
4218 lang_size_sections (statement_list
.head
,
4220 &(statement_list
.head
), 0, (bfd_vma
) 0,
4223 while (relax_again
);
4226 /* See if anything special should be done now we know how big
4228 ldemul_after_allocation ();
4230 /* Fix any .startof. or .sizeof. symbols. */
4231 lang_set_startof ();
4233 /* Do all the assignments, now that we know the final resting places
4234 of all the symbols. */
4236 lang_do_assignments (statement_list
.head
,
4238 (fill_type
) 0, (bfd_vma
) 0);
4240 /* Make sure that the section addresses make sense. */
4241 if (! link_info
.relocateable
4242 && command_line
.check_section_addresses
)
4243 lang_check_section_addresses ();
4251 /* EXPORTED TO YACC */
4254 lang_add_wild (filespec
, section_list
, keep_sections
)
4255 struct wildcard_spec
*filespec
;
4256 struct wildcard_list
*section_list
;
4257 boolean keep_sections
;
4259 struct wildcard_list
*curr
, *next
;
4260 lang_wild_statement_type
*new;
4262 /* Reverse the list as the parser puts it back to front. */
4263 for (curr
= section_list
, section_list
= NULL
;
4265 section_list
= curr
, curr
= next
)
4267 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
4268 placed_commons
= true;
4271 curr
->next
= section_list
;
4274 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
4276 if (strcmp (filespec
->name
, "*") == 0)
4277 filespec
->name
= NULL
;
4278 else if (! wildcardp (filespec
->name
))
4279 lang_has_input_file
= true;
4282 new = new_stat (lang_wild_statement
, stat_ptr
);
4283 new->filename
= NULL
;
4284 new->filenames_sorted
= false;
4285 if (filespec
!= NULL
)
4287 new->filename
= filespec
->name
;
4288 new->filenames_sorted
= filespec
->sorted
;
4290 new->section_list
= section_list
;
4291 new->keep_sections
= keep_sections
;
4292 lang_list_init (&new->children
);
4296 lang_section_start (name
, address
)
4298 etree_type
*address
;
4300 lang_address_statement_type
*ad
;
4302 ad
= new_stat (lang_address_statement
, stat_ptr
);
4303 ad
->section_name
= name
;
4304 ad
->address
= address
;
4307 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4308 because of a -e argument on the command line, or zero if this is
4309 called by ENTRY in a linker script. Command line arguments take
4313 lang_add_entry (name
, cmdline
)
4317 if (entry_symbol
== NULL
4319 || ! entry_from_cmdline
)
4321 entry_symbol
= name
;
4322 entry_from_cmdline
= cmdline
;
4327 lang_add_target (name
)
4330 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4346 map_option_f
= true;
4357 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4364 lang_add_data (type
, exp
)
4366 union etree_union
*exp
;
4369 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4377 /* Create a new reloc statement. RELOC is the BFD relocation type to
4378 generate. HOWTO is the corresponding howto structure (we could
4379 look this up, but the caller has already done so). SECTION is the
4380 section to generate a reloc against, or NAME is the name of the
4381 symbol to generate a reloc against. Exactly one of SECTION and
4382 NAME must be NULL. ADDEND is an expression for the addend. */
4385 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4386 bfd_reloc_code_real_type reloc
;
4387 reloc_howto_type
*howto
;
4390 union etree_union
*addend
;
4392 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4396 p
->section
= section
;
4398 p
->addend_exp
= addend
;
4400 p
->addend_value
= 0;
4401 p
->output_section
= NULL
;
4405 lang_assignment_statement_type
*
4406 lang_add_assignment (exp
)
4409 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4417 lang_add_attribute (attribute
)
4418 enum statement_enum attribute
;
4420 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4427 if (startup_file
!= (char *) NULL
)
4429 einfo (_("%P%Fmultiple STARTUP files\n"));
4431 first_file
->filename
= name
;
4432 first_file
->local_sym_name
= name
;
4433 first_file
->real
= true;
4435 startup_file
= name
;
4442 lang_float_flag
= maybe
;
4446 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4448 const char *memspec
;
4449 struct lang_output_section_phdr_list
*phdrs
;
4450 const char *lma_memspec
;
4452 current_section
->fill
= fill
;
4453 current_section
->region
= lang_memory_region_lookup (memspec
);
4454 if (strcmp (lma_memspec
, "*default*") != 0)
4456 current_section
->lma_region
= lang_memory_region_lookup (lma_memspec
);
4457 /* If no runtime region has been given, but the load region has
4458 been, use the load region. */
4459 if (strcmp (memspec
, "*default*") == 0)
4460 current_section
->region
= lang_memory_region_lookup (lma_memspec
);
4462 current_section
->phdrs
= phdrs
;
4463 stat_ptr
= &statement_list
;
4466 /* Create an absolute symbol with the given name with the value of the
4467 address of first byte of the section named.
4469 If the symbol already exists, then do nothing. */
4472 lang_abs_symbol_at_beginning_of (secname
, name
)
4473 const char *secname
;
4476 struct bfd_link_hash_entry
*h
;
4478 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4479 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4480 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4482 if (h
->type
== bfd_link_hash_new
4483 || h
->type
== bfd_link_hash_undefined
)
4487 h
->type
= bfd_link_hash_defined
;
4489 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4490 if (sec
== (asection
*) NULL
)
4493 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4495 h
->u
.def
.section
= bfd_abs_section_ptr
;
4499 /* Create an absolute symbol with the given name with the value of the
4500 address of the first byte after the end of the section named.
4502 If the symbol already exists, then do nothing. */
4505 lang_abs_symbol_at_end_of (secname
, name
)
4506 const char *secname
;
4509 struct bfd_link_hash_entry
*h
;
4511 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4512 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4513 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4515 if (h
->type
== bfd_link_hash_new
4516 || h
->type
== bfd_link_hash_undefined
)
4520 h
->type
= bfd_link_hash_defined
;
4522 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4523 if (sec
== (asection
*) NULL
)
4526 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4527 + bfd_section_size (output_bfd
, sec
) /
4528 bfd_octets_per_byte (output_bfd
));
4530 h
->u
.def
.section
= bfd_abs_section_ptr
;
4535 lang_statement_append (list
, element
, field
)
4536 lang_statement_list_type
*list
;
4537 lang_statement_union_type
*element
;
4538 lang_statement_union_type
**field
;
4540 *(list
->tail
) = element
;
4544 /* Set the output format type. -oformat overrides scripts. */
4547 lang_add_output_format (format
, big
, little
, from_script
)
4553 if (output_target
== NULL
|| !from_script
)
4555 if (command_line
.endian
== ENDIAN_BIG
4558 else if (command_line
.endian
== ENDIAN_LITTLE
4562 output_target
= format
;
4566 /* Enter a group. This creates a new lang_group_statement, and sets
4567 stat_ptr to build new statements within the group. */
4572 lang_group_statement_type
*g
;
4574 g
= new_stat (lang_group_statement
, stat_ptr
);
4575 lang_list_init (&g
->children
);
4576 stat_ptr
= &g
->children
;
4579 /* Leave a group. This just resets stat_ptr to start writing to the
4580 regular list of statements again. Note that this will not work if
4581 groups can occur inside anything else which can adjust stat_ptr,
4582 but currently they can't. */
4587 stat_ptr
= &statement_list
;
4590 /* Add a new program header. This is called for each entry in a PHDRS
4591 command in a linker script. */
4594 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4602 struct lang_phdr
*n
, **pp
;
4604 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4607 n
->type
= exp_get_value_int (type
, 0, "program header type",
4608 lang_final_phase_enum
);
4609 n
->filehdr
= filehdr
;
4614 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4619 /* Record the program header information in the output BFD. FIXME: We
4620 should not be calling an ELF specific function here. */
4623 lang_record_phdrs ()
4627 struct lang_output_section_phdr_list
*last
;
4628 struct lang_phdr
*l
;
4629 lang_statement_union_type
*u
;
4632 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4634 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4641 for (u
= lang_output_section_statement
.head
;
4643 u
= u
->output_section_statement
.next
)
4645 lang_output_section_statement_type
*os
;
4646 struct lang_output_section_phdr_list
*pl
;
4648 os
= &u
->output_section_statement
;
4655 if (os
->sectype
== noload_section
4656 || os
->bfd_section
== NULL
4657 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4662 if (os
->bfd_section
== NULL
)
4665 for (; pl
!= NULL
; pl
= pl
->next
)
4667 if (strcmp (pl
->name
, l
->name
) == 0)
4672 secs
= ((asection
**)
4673 xrealloc (secs
, alc
* sizeof (asection
*)));
4675 secs
[c
] = os
->bfd_section
;
4682 if (l
->flags
== NULL
)
4685 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4686 lang_final_phase_enum
);
4691 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4692 lang_final_phase_enum
);
4694 if (! bfd_record_phdr (output_bfd
, l
->type
,
4695 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
4696 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4697 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4702 /* Make sure all the phdr assignments succeeded. */
4703 for (u
= lang_output_section_statement
.head
;
4705 u
= u
->output_section_statement
.next
)
4707 struct lang_output_section_phdr_list
*pl
;
4709 if (u
->output_section_statement
.bfd_section
== NULL
)
4712 for (pl
= u
->output_section_statement
.phdrs
;
4715 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4716 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4717 u
->output_section_statement
.name
, pl
->name
);
4721 /* Record a list of sections which may not be cross referenced. */
4724 lang_add_nocrossref (l
)
4725 struct lang_nocrossref
*l
;
4727 struct lang_nocrossrefs
*n
;
4729 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4730 n
->next
= nocrossref_list
;
4732 nocrossref_list
= n
;
4734 /* Set notice_all so that we get informed about all symbols. */
4735 link_info
.notice_all
= true;
4738 /* Overlay handling. We handle overlays with some static variables. */
4740 /* The overlay virtual address. */
4741 static etree_type
*overlay_vma
;
4743 /* The overlay load address. */
4744 static etree_type
*overlay_lma
;
4746 /* Whether nocrossrefs is set for this overlay. */
4747 static int overlay_nocrossrefs
;
4749 /* An expression for the maximum section size seen so far. */
4750 static etree_type
*overlay_max
;
4752 /* A list of all the sections in this overlay. */
4754 struct overlay_list
{
4755 struct overlay_list
*next
;
4756 lang_output_section_statement_type
*os
;
4759 static struct overlay_list
*overlay_list
;
4761 /* Start handling an overlay. */
4764 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
4765 etree_type
*vma_expr
;
4766 etree_type
*lma_expr
;
4769 /* The grammar should prevent nested overlays from occurring. */
4770 ASSERT (overlay_vma
== NULL
4771 && overlay_lma
== NULL
4772 && overlay_list
== NULL
4773 && overlay_max
== NULL
);
4775 overlay_vma
= vma_expr
;
4776 overlay_lma
= lma_expr
;
4777 overlay_nocrossrefs
= nocrossrefs
;
4780 /* Start a section in an overlay. We handle this by calling
4781 lang_enter_output_section_statement with the correct VMA and LMA. */
4784 lang_enter_overlay_section (name
)
4787 struct overlay_list
*n
;
4790 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4791 0, 0, 0, overlay_lma
);
4793 /* If this is the first section, then base the VMA and LMA of future
4794 sections on this one. This will work correctly even if `.' is
4795 used in the addresses. */
4796 if (overlay_list
== NULL
)
4798 overlay_vma
= exp_nameop (ADDR
, name
);
4799 overlay_lma
= exp_nameop (LOADADDR
, name
);
4802 /* Remember the section. */
4803 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4804 n
->os
= current_section
;
4805 n
->next
= overlay_list
;
4808 size
= exp_nameop (SIZEOF
, name
);
4810 /* Adjust the LMA for the next section. */
4811 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
4813 /* Arrange to work out the maximum section end address. */
4814 if (overlay_max
== NULL
)
4817 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4820 /* Finish a section in an overlay. There isn't any special to do
4824 lang_leave_overlay_section (fill
, phdrs
)
4826 struct lang_output_section_phdr_list
*phdrs
;
4833 name
= current_section
->name
;
4835 lang_leave_output_section_statement (fill
, "*default*",
4836 phdrs
, "*default*");
4838 /* Define the magic symbols. */
4840 clean
= xmalloc (strlen (name
) + 1);
4842 for (s1
= name
; *s1
!= '\0'; s1
++)
4843 if (ISALNUM (*s1
) || *s1
== '_')
4847 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4848 sprintf (buf
, "__load_start_%s", clean
);
4849 lang_add_assignment (exp_assop ('=', buf
,
4850 exp_nameop (LOADADDR
, name
)));
4852 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4853 sprintf (buf
, "__load_stop_%s", clean
);
4854 lang_add_assignment (exp_assop ('=', buf
,
4856 exp_nameop (LOADADDR
, name
),
4857 exp_nameop (SIZEOF
, name
))));
4862 /* Finish an overlay. If there are any overlay wide settings, this
4863 looks through all the sections in the overlay and sets them. */
4866 lang_leave_overlay (fill
, memspec
, phdrs
, lma_memspec
)
4868 const char *memspec
;
4869 struct lang_output_section_phdr_list
*phdrs
;
4870 const char *lma_memspec
;
4872 lang_memory_region_type
*region
;
4873 lang_memory_region_type
* default_region
;
4874 lang_memory_region_type
*lma_region
;
4875 struct overlay_list
*l
;
4876 struct lang_nocrossref
*nocrossref
;
4878 default_region
= lang_memory_region_lookup ("*default*");
4880 if (memspec
== NULL
)
4883 region
= lang_memory_region_lookup (memspec
);
4885 if (lma_memspec
== NULL
)
4888 lma_region
= lang_memory_region_lookup (lma_memspec
);
4895 struct overlay_list
*next
;
4897 if (fill
!= 0 && l
->os
->fill
== 0)
4900 /* Assign a region to the sections, if one has been specified.
4901 Override the assignment of the default section, but not
4903 if (region
!= NULL
&&
4904 (l
->os
->region
== NULL
||
4905 l
->os
->region
== default_region
))
4906 l
->os
->region
= region
;
4908 /* We only set lma_region for the first overlay section, as
4909 subsequent overlay sections will have load_base set relative
4910 to the first section. Also, don't set lma_region if
4911 load_base is specified. FIXME: There should really be a test
4912 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4913 rather than letting LDADDR simply override LMA_REGION. */
4914 if (lma_region
!= NULL
&& l
->os
->lma_region
== NULL
4915 && l
->next
== NULL
&& l
->os
->load_base
== NULL
)
4916 l
->os
->lma_region
= lma_region
;
4918 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4919 l
->os
->phdrs
= phdrs
;
4921 if (overlay_nocrossrefs
)
4923 struct lang_nocrossref
*nc
;
4925 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
4926 nc
->name
= l
->os
->name
;
4927 nc
->next
= nocrossref
;
4936 if (nocrossref
!= NULL
)
4937 lang_add_nocrossref (nocrossref
);
4939 /* Update . for the end of the overlay. */
4940 lang_add_assignment (exp_assop ('=', ".",
4941 exp_binop ('+', overlay_vma
, overlay_max
)));
4945 overlay_nocrossrefs
= 0;
4946 overlay_list
= NULL
;
4950 /* Version handling. This is only useful for ELF. */
4952 /* This global variable holds the version tree that we build. */
4954 struct bfd_elf_version_tree
*lang_elf_version_info
;
4957 lang_vers_match_lang_c (expr
, sym
)
4958 struct bfd_elf_version_expr
*expr
;
4961 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4963 return fnmatch (expr
->pattern
, sym
, 0) == 0;
4967 lang_vers_match_lang_cplusplus (expr
, sym
)
4968 struct bfd_elf_version_expr
*expr
;
4974 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4977 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
4980 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4981 Should we early out false in this case? */
4982 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4986 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4994 lang_vers_match_lang_java (expr
, sym
)
4995 struct bfd_elf_version_expr
*expr
;
5001 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5004 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
5007 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5008 Should we early out false in this case? */
5009 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5013 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5020 /* This is called for each variable name or match expression. */
5022 struct bfd_elf_version_expr
*
5023 lang_new_vers_pattern (orig
, new, lang
)
5024 struct bfd_elf_version_expr
*orig
;
5028 struct bfd_elf_version_expr
*ret
;
5030 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
5034 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
5035 ret
->match
= lang_vers_match_lang_c
;
5036 else if (strcasecmp (lang
, "C++") == 0)
5037 ret
->match
= lang_vers_match_lang_cplusplus
;
5038 else if (strcasecmp (lang
, "Java") == 0)
5039 ret
->match
= lang_vers_match_lang_java
;
5042 einfo (_("%X%P: unknown language `%s' in version information\n"),
5044 ret
->match
= lang_vers_match_lang_c
;
5050 /* This is called for each set of variable names and match
5053 struct bfd_elf_version_tree
*
5054 lang_new_vers_node (globals
, locals
)
5055 struct bfd_elf_version_expr
*globals
;
5056 struct bfd_elf_version_expr
*locals
;
5058 struct bfd_elf_version_tree
*ret
;
5060 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
5064 ret
->globals
= globals
;
5065 ret
->locals
= locals
;
5067 ret
->name_indx
= (unsigned int) -1;
5072 /* This static variable keeps track of version indices. */
5074 static int version_index
;
5076 /* This is called when we know the name and dependencies of the
5080 lang_register_vers_node (name
, version
, deps
)
5082 struct bfd_elf_version_tree
*version
;
5083 struct bfd_elf_version_deps
*deps
;
5085 struct bfd_elf_version_tree
*t
, **pp
;
5086 struct bfd_elf_version_expr
*e1
;
5091 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
5092 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
5094 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5098 /* Make sure this node has a unique name. */
5099 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5100 if (strcmp (t
->name
, name
) == 0)
5101 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5103 /* Check the global and local match names, and make sure there
5104 aren't any duplicates. */
5106 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5108 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5110 struct bfd_elf_version_expr
*e2
;
5112 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5113 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5114 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5119 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
5121 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5123 struct bfd_elf_version_expr
*e2
;
5125 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
5126 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5127 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5132 version
->deps
= deps
;
5133 version
->name
= name
;
5134 if (name
[0] != '\0')
5137 version
->vernum
= version_index
;
5140 version
->vernum
= 0;
5142 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5147 /* This is called when we see a version dependency. */
5149 struct bfd_elf_version_deps
*
5150 lang_add_vers_depend (list
, name
)
5151 struct bfd_elf_version_deps
*list
;
5154 struct bfd_elf_version_deps
*ret
;
5155 struct bfd_elf_version_tree
*t
;
5157 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5160 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5162 if (strcmp (t
->name
, name
) == 0)
5164 ret
->version_needed
= t
;
5169 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5175 lang_do_version_exports_section ()
5177 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5179 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5181 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5188 len
= bfd_section_size (is
->the_bfd
, sec
);
5189 contents
= xmalloc (len
);
5190 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5191 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
5194 while (p
< contents
+ len
)
5196 greg
= lang_new_vers_pattern (greg
, p
, NULL
);
5197 p
= strchr (p
, '\0') + 1;
5200 /* Do not free the contents, as we used them creating the regex. */
5202 /* Do not include this section in the link. */
5203 bfd_set_section_flags (is
->the_bfd
, sec
,
5204 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5207 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
);
5208 lang_register_vers_node (command_line
.version_exports_section
,
5209 lang_new_vers_node (greg
, lreg
), NULL
);
5213 lang_add_unique (name
)
5216 struct unique_sections
*ent
;
5218 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5219 if (strcmp (ent
->name
, name
) == 0)
5222 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
5223 ent
->name
= xstrdup (name
);
5224 ent
->next
= unique_section_list
;
5225 unique_section_list
= ent
;