1 /* Linker command language support.
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GLD, the Gnu Linker.
7 GLD is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GLD is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GLD; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "libiberty.h"
44 static lang_statement_union_type
*new_statement
PARAMS ((enum statement_enum
,
46 lang_statement_list_type
*));
49 static struct obstack stat_obstack
;
51 #define obstack_chunk_alloc xmalloc
52 #define obstack_chunk_free free
53 static const char *startup_file
;
54 static lang_statement_list_type input_file_chain
;
55 static boolean placed_commons
= false;
56 static lang_output_section_statement_type
*default_common_section
;
57 static boolean map_option_f
;
58 static bfd_vma print_dot
;
59 static lang_input_statement_type
*first_file
;
60 static const char *current_target
;
61 static const char *output_target
;
62 static lang_statement_list_type statement_list
;
63 static struct lang_phdr
*lang_phdr_list
;
65 static void lang_for_each_statement_worker
66 PARAMS ((void (*) (lang_statement_union_type
*),
67 lang_statement_union_type
*));
68 static lang_input_statement_type
*new_afile
69 PARAMS ((const char *, lang_input_file_enum_type
, const char *, boolean
));
70 static lang_memory_region_type
*lang_memory_default
PARAMS ((asection
*));
71 static void lang_map_flags
PARAMS ((flagword
));
72 static void init_os
PARAMS ((lang_output_section_statement_type
*));
73 static void exp_init_os
PARAMS ((etree_type
*));
74 static void section_already_linked
PARAMS ((bfd
*, asection
*, PTR
));
75 static struct bfd_hash_entry
*already_linked_newfunc
76 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
77 static void already_linked_table_init
PARAMS ((void));
78 static void already_linked_table_free
PARAMS ((void));
79 static boolean wildcardp
PARAMS ((const char *));
80 static lang_statement_union_type
*wild_sort
81 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
83 static void output_section_callback
84 PARAMS ((lang_wild_statement_type
*, asection
*,
85 lang_input_statement_type
*, PTR
));
86 static lang_input_statement_type
*lookup_name
PARAMS ((const char *));
87 static void load_symbols
88 PARAMS ((lang_input_statement_type
*, lang_statement_list_type
*));
90 PARAMS ((lang_wild_statement_type
*, const char *, const char *,
91 const char *, lang_output_section_statement_type
*));
92 static bfd
*open_output
PARAMS ((const char *));
93 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*));
94 static void open_input_bfds
PARAMS ((lang_statement_union_type
*, boolean
));
95 static void lang_reasonable_defaults
PARAMS ((void));
96 static void lang_place_undefineds
PARAMS ((void));
97 static void map_input_to_output_sections
98 PARAMS ((lang_statement_union_type
*, const char *,
99 lang_output_section_statement_type
*));
100 static void print_output_section_statement
101 PARAMS ((lang_output_section_statement_type
*));
102 static void print_assignment
103 PARAMS ((lang_assignment_statement_type
*,
104 lang_output_section_statement_type
*));
105 static void print_input_statement
PARAMS ((lang_input_statement_type
*));
106 static boolean print_one_symbol
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
107 static void print_input_section
PARAMS ((lang_input_section_type
*));
108 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*));
109 static void print_data_statement
PARAMS ((lang_data_statement_type
*));
110 static void print_address_statement
PARAMS ((lang_address_statement_type
*));
111 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*));
112 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*));
113 static void print_wild_statement
114 PARAMS ((lang_wild_statement_type
*, lang_output_section_statement_type
*));
115 static void print_group
116 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
117 static void print_statement
118 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
119 static void print_statement_list
120 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
121 static void print_statements
PARAMS ((void));
122 static bfd_vma insert_pad
123 PARAMS ((lang_statement_union_type
**, fill_type
,
124 unsigned int, asection
*, bfd_vma
));
125 static bfd_vma size_input_section
126 PARAMS ((lang_statement_union_type
**, lang_output_section_statement_type
*,
127 fill_type
, bfd_vma
, boolean
));
128 static void lang_finish
PARAMS ((void));
129 static void ignore_bfd_errors
PARAMS ((const char *, ...));
130 static void record_bfd_errors
PARAMS ((const char *, ...));
131 static void lang_check
PARAMS ((void));
132 static void lang_common
PARAMS ((void));
133 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
134 static void lang_place_orphans
PARAMS ((void));
135 static int topower
PARAMS ((int));
136 static void lang_set_startof
PARAMS ((void));
137 static void reset_memory_regions
PARAMS ((void));
138 static void gc_section_callback
139 PARAMS ((lang_wild_statement_type
*, asection
*,
140 lang_input_statement_type
*, PTR
));
141 static void lang_record_phdrs
PARAMS ((void));
142 static void lang_gc_wild
143 PARAMS ((lang_wild_statement_type
*, const char *, const char *));
144 static void lang_gc_sections_1
PARAMS ((lang_statement_union_type
*));
145 static void lang_gc_sections
PARAMS ((void));
146 static int lang_vers_match_lang_c
147 PARAMS ((struct bfd_elf_version_expr
*, const char *));
148 static int lang_vers_match_lang_cplusplus
149 PARAMS ((struct bfd_elf_version_expr
*, const char *));
150 static int lang_vers_match_lang_java
151 PARAMS ((struct bfd_elf_version_expr
*, const char *));
152 static void lang_do_version_exports_section
PARAMS ((void));
153 static void lang_check_section_addresses
PARAMS ((void));
154 static void os_region_check
155 PARAMS ((lang_output_section_statement_type
*,
156 struct memory_region_struct
*, etree_type
*, bfd_vma
));
158 typedef void (*callback_t
) PARAMS ((lang_wild_statement_type
*,
159 asection
*, lang_input_statement_type
*,
161 static void walk_wild
162 PARAMS ((lang_wild_statement_type
*, const char *, const char *,
164 static void walk_wild_section
165 PARAMS ((lang_wild_statement_type
*, const char *,
166 lang_input_statement_type
*, callback_t
, PTR
));
167 static void walk_wild_file
168 PARAMS ((lang_wild_statement_type
*, const char *,
169 lang_input_statement_type
*, callback_t
, PTR
));
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 boolean entry_from_cmdline
;
185 boolean lang_has_input_file
= false;
186 boolean had_output_filename
= false;
187 boolean lang_float_flag
= false;
188 boolean delete_output_file_on_failure
= false;
189 struct lang_nocrossrefs
*nocrossref_list
;
190 struct unique_sections
*unique_section_list
;
192 etree_type
*base
; /* Relocation base - or null */
194 #if defined(__STDC__) || defined(ALMOST_STDC)
195 #define cat(a,b) a##b
197 #define cat(a,b) a/**/b
200 /* Don't beautify the line below with "innocent" whitespace, it breaks the K&R C preprocessor! */
201 #define new_stat(x, y) (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
203 #define outside_section_address(q) ((q)->output_offset + (q)->output_section->vma)
205 #define outside_symbol_address(q) ((q)->value + outside_section_address (q->section))
207 #define SECTION_NAME_MAP_LENGTH (16)
213 return obstack_alloc (&stat_obstack
, size
);
217 unique_section_p (secnam
)
220 struct unique_sections
*unam
;
222 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
223 if (wildcardp (unam
->name
)
224 ? fnmatch (unam
->name
, secnam
, 0) == 0
225 : strcmp (unam
->name
, secnam
) == 0)
233 /* Generic traversal routines for finding matching sections. */
236 walk_wild_section (ptr
, section
, file
, callback
, data
)
237 lang_wild_statement_type
*ptr
;
239 lang_input_statement_type
*file
;
243 /* Don't process sections from files which were excluded. */
244 if (ptr
->exclude_filename_list
!= NULL
)
246 struct name_list
*list_tmp
;
247 for (list_tmp
= ptr
->exclude_filename_list
; list_tmp
; list_tmp
= list_tmp
->next
)
251 if (wildcardp (list_tmp
->name
))
252 match
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0 ? true : false;
254 match
= strcmp (list_tmp
->name
, file
->filename
) == 0 ? true : false;
261 if (file
->just_syms_flag
== false)
263 register asection
*s
;
264 boolean wildcard
= false;
267 wildcard
= wildcardp (section
);
269 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
272 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
277 match
= fnmatch (section
, sname
, 0) == 0 ? true : false;
279 match
= strcmp (section
, sname
) == 0 ? true : false;
281 /* If this is a wild-card output section statement, exclude
282 sections that match UNIQUE_SECTION_LIST. */
283 if (match
&& (data
== NULL
|| !unique_section_p (sname
)))
284 (*callback
) (ptr
, s
, file
, data
);
289 /* Handle a wild statement for a single file F. */
292 walk_wild_file (s
, section
, f
, callback
, data
)
293 lang_wild_statement_type
*s
;
295 lang_input_statement_type
*f
;
299 if (f
->the_bfd
== NULL
300 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
301 walk_wild_section (s
, section
, f
, callback
, data
);
306 /* This is an archive file. We must map each member of the
307 archive separately. */
308 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
309 while (member
!= NULL
)
311 /* When lookup_name is called, it will call the add_symbols
312 entry point for the archive. For each element of the
313 archive which is included, BFD will call ldlang_add_file,
314 which will set the usrdata field of the member to the
315 lang_input_statement. */
316 if (member
->usrdata
!= NULL
)
318 walk_wild_section (s
, section
,
319 (lang_input_statement_type
*) member
->usrdata
,
323 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
329 walk_wild (s
, section
, file
, callback
, data
)
330 lang_wild_statement_type
*s
;
336 if (file
== (char *) NULL
)
338 /* Perform the iteration over all files in the list. */
339 LANG_FOR_EACH_INPUT_STATEMENT (f
)
341 walk_wild_file (s
, section
, f
, callback
, data
);
344 else if (wildcardp (file
))
346 LANG_FOR_EACH_INPUT_STATEMENT (f
)
348 if (fnmatch (file
, f
->filename
, FNM_FILE_NAME
) == 0)
349 walk_wild_file (s
, section
, f
, callback
, data
);
354 lang_input_statement_type
*f
;
356 /* Perform the iteration over a single file. */
357 f
= lookup_name (file
);
358 walk_wild_file (s
, section
, f
, callback
, data
);
362 /* lang_for_each_statement walks the parse tree and calls the provided
363 function for each node. */
366 lang_for_each_statement_worker (func
, s
)
367 void (*func
) PARAMS ((lang_statement_union_type
*));
368 lang_statement_union_type
*s
;
370 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
374 switch (s
->header
.type
)
376 case lang_constructors_statement_enum
:
377 lang_for_each_statement_worker (func
, constructor_list
.head
);
379 case lang_output_section_statement_enum
:
380 lang_for_each_statement_worker
382 s
->output_section_statement
.children
.head
);
384 case lang_wild_statement_enum
:
385 lang_for_each_statement_worker
387 s
->wild_statement
.children
.head
);
389 case lang_group_statement_enum
:
390 lang_for_each_statement_worker (func
,
391 s
->group_statement
.children
.head
);
393 case lang_data_statement_enum
:
394 case lang_reloc_statement_enum
:
395 case lang_object_symbols_statement_enum
:
396 case lang_output_statement_enum
:
397 case lang_target_statement_enum
:
398 case lang_input_section_enum
:
399 case lang_input_statement_enum
:
400 case lang_assignment_statement_enum
:
401 case lang_padding_statement_enum
:
402 case lang_address_statement_enum
:
403 case lang_fill_statement_enum
:
413 lang_for_each_statement (func
)
414 void (*func
) PARAMS ((lang_statement_union_type
*));
416 lang_for_each_statement_worker (func
, statement_list
.head
);
419 /*----------------------------------------------------------------------*/
422 lang_list_init (list
)
423 lang_statement_list_type
*list
;
425 list
->head
= (lang_statement_union_type
*) NULL
;
426 list
->tail
= &list
->head
;
429 /* Build a new statement node for the parse tree. */
431 static lang_statement_union_type
*
432 new_statement (type
, size
, list
)
433 enum statement_enum type
;
435 lang_statement_list_type
*list
;
437 lang_statement_union_type
*new = (lang_statement_union_type
*)
440 new->header
.type
= type
;
441 new->header
.next
= (lang_statement_union_type
*) NULL
;
442 lang_statement_append (list
, new, &new->header
.next
);
446 /* Build a new input file node for the language. There are several
447 ways in which we treat an input file, eg, we only look at symbols,
448 or prefix it with a -l etc.
450 We can be supplied with requests for input files more than once;
451 they may, for example be split over serveral lines like foo.o(.text)
452 foo.o(.data) etc, so when asked for a file we check that we havn't
453 got it already so we don't duplicate the bfd. */
455 static lang_input_statement_type
*
456 new_afile (name
, file_type
, target
, add_to_list
)
458 lang_input_file_enum_type file_type
;
462 lang_input_statement_type
*p
;
465 p
= new_stat (lang_input_statement
, stat_ptr
);
468 p
= ((lang_input_statement_type
*)
469 stat_alloc (sizeof (lang_input_statement_type
)));
470 p
->header
.next
= NULL
;
473 lang_has_input_file
= true;
477 case lang_input_file_is_symbols_only_enum
:
479 p
->is_archive
= false;
481 p
->local_sym_name
= name
;
482 p
->just_syms_flag
= true;
483 p
->search_dirs_flag
= false;
485 case lang_input_file_is_fake_enum
:
487 p
->is_archive
= false;
489 p
->local_sym_name
= name
;
490 p
->just_syms_flag
= false;
491 p
->search_dirs_flag
= false;
493 case lang_input_file_is_l_enum
:
494 p
->is_archive
= true;
497 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
498 p
->just_syms_flag
= false;
499 p
->search_dirs_flag
= true;
501 case lang_input_file_is_marker_enum
:
503 p
->is_archive
= false;
505 p
->local_sym_name
= name
;
506 p
->just_syms_flag
= false;
507 p
->search_dirs_flag
= true;
509 case lang_input_file_is_search_file_enum
:
511 p
->is_archive
= false;
513 p
->local_sym_name
= name
;
514 p
->just_syms_flag
= false;
515 p
->search_dirs_flag
= true;
517 case lang_input_file_is_file_enum
:
519 p
->is_archive
= false;
521 p
->local_sym_name
= name
;
522 p
->just_syms_flag
= false;
523 p
->search_dirs_flag
= false;
528 p
->the_bfd
= (bfd
*) NULL
;
529 p
->asymbols
= (asymbol
**) NULL
;
530 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
531 p
->next
= (lang_statement_union_type
*) NULL
;
533 p
->dynamic
= config
.dynamic_link
;
534 p
->whole_archive
= whole_archive
;
536 lang_statement_append (&input_file_chain
,
537 (lang_statement_union_type
*) p
,
542 lang_input_statement_type
*
543 lang_add_input_file (name
, file_type
, target
)
545 lang_input_file_enum_type file_type
;
548 lang_has_input_file
= true;
549 return new_afile (name
, file_type
, target
, true);
552 /* Build enough state so that the parser can build its tree. */
557 obstack_begin (&stat_obstack
, 1000);
559 stat_ptr
= &statement_list
;
561 lang_list_init (stat_ptr
);
563 lang_list_init (&input_file_chain
);
564 lang_list_init (&lang_output_section_statement
);
565 lang_list_init (&file_chain
);
566 first_file
= lang_add_input_file ((char *) NULL
,
567 lang_input_file_is_marker_enum
,
570 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
572 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
576 /*----------------------------------------------------------------------
577 A region is an area of memory declared with the
578 MEMORY { name:org=exp, len=exp ... }
581 We maintain a list of all the regions here.
583 If no regions are specified in the script, then the default is used
584 which is created when looked up to be the entire data space. */
586 static lang_memory_region_type
*lang_memory_region_list
;
587 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
589 lang_memory_region_type
*
590 lang_memory_region_lookup (name
)
591 const char *const name
;
593 lang_memory_region_type
*p
;
595 for (p
= lang_memory_region_list
;
596 p
!= (lang_memory_region_type
*) NULL
;
599 if (strcmp (p
->name
, name
) == 0)
606 /* This code used to always use the first region in the list as the
607 default region. I changed it to instead use a region
608 encompassing all of memory as the default region. This permits
609 NOLOAD sections to work reasonably without requiring a region.
610 People should specify what region they mean, if they really want
612 if (strcmp (name
, "*default*") == 0)
614 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
616 return lang_memory_region_list
;
622 lang_memory_region_type
*new =
623 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
625 new->name
= buystring (name
);
626 new->next
= (lang_memory_region_type
*) NULL
;
628 *lang_memory_region_list_tail
= new;
629 lang_memory_region_list_tail
= &new->next
;
633 new->length
= ~(bfd_size_type
) 0;
635 new->had_full_message
= false;
641 static lang_memory_region_type
*
642 lang_memory_default (section
)
645 lang_memory_region_type
*p
;
647 flagword sec_flags
= section
->flags
;
649 /* Override SEC_DATA to mean a writable section. */
650 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
651 sec_flags
|= SEC_DATA
;
653 for (p
= lang_memory_region_list
;
654 p
!= (lang_memory_region_type
*) NULL
;
657 if ((p
->flags
& sec_flags
) != 0
658 && (p
->not_flags
& sec_flags
) == 0)
663 return lang_memory_region_lookup ("*default*");
666 lang_output_section_statement_type
*
667 lang_output_section_find (name
)
668 const char *const name
;
670 lang_statement_union_type
*u
;
671 lang_output_section_statement_type
*lookup
;
673 for (u
= lang_output_section_statement
.head
;
674 u
!= (lang_statement_union_type
*) NULL
;
677 lookup
= &u
->output_section_statement
;
678 if (strcmp (name
, lookup
->name
) == 0)
683 return (lang_output_section_statement_type
*) NULL
;
686 lang_output_section_statement_type
*
687 lang_output_section_statement_lookup (name
)
688 const char *const name
;
690 lang_output_section_statement_type
*lookup
;
692 lookup
= lang_output_section_find (name
);
693 if (lookup
== (lang_output_section_statement_type
*) NULL
)
696 lookup
= (lang_output_section_statement_type
*)
697 new_stat (lang_output_section_statement
, stat_ptr
);
698 lookup
->region
= (lang_memory_region_type
*) NULL
;
699 lookup
->lma_region
= (lang_memory_region_type
*) NULL
;
701 lookup
->block_value
= 1;
704 lookup
->next
= (lang_statement_union_type
*) NULL
;
705 lookup
->bfd_section
= (asection
*) NULL
;
706 lookup
->processed
= false;
707 lookup
->sectype
= normal_section
;
708 lookup
->addr_tree
= (etree_type
*) NULL
;
709 lang_list_init (&lookup
->children
);
711 lookup
->memspec
= (const char *) NULL
;
713 lookup
->subsection_alignment
= -1;
714 lookup
->section_alignment
= -1;
715 lookup
->load_base
= (union etree_union
*) NULL
;
716 lookup
->phdrs
= NULL
;
718 lang_statement_append (&lang_output_section_statement
,
719 (lang_statement_union_type
*) lookup
,
726 lang_map_flags (flag
)
729 if (flag
& SEC_ALLOC
)
735 if (flag
& SEC_READONLY
)
748 lang_memory_region_type
*m
;
750 minfo (_("\nMemory Configuration\n\n"));
751 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
752 _("Name"), _("Origin"), _("Length"), _("Attributes"));
754 for (m
= lang_memory_region_list
;
755 m
!= (lang_memory_region_type
*) NULL
;
761 fprintf (config
.map_file
, "%-16s ", m
->name
);
763 sprintf_vma (buf
, m
->origin
);
764 minfo ("0x%s ", buf
);
772 minfo ("0x%V", m
->length
);
773 if (m
->flags
|| m
->not_flags
)
781 lang_map_flags (m
->flags
);
787 lang_map_flags (m
->not_flags
);
794 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
799 /* Initialize an output section. */
803 lang_output_section_statement_type
*s
;
805 section_userdata_type
*new;
807 if (s
->bfd_section
!= NULL
)
810 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
811 einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME
);
813 new = ((section_userdata_type
*)
814 stat_alloc (sizeof (section_userdata_type
)));
816 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
817 if (s
->bfd_section
== (asection
*) NULL
)
818 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
819 if (s
->bfd_section
== (asection
*) NULL
)
821 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
822 output_bfd
->xvec
->name
, s
->name
);
824 s
->bfd_section
->output_section
= s
->bfd_section
;
826 /* We initialize an output sections output offset to minus its own
827 vma to allow us to output a section through itself. */
828 s
->bfd_section
->output_offset
= 0;
829 get_userdata (s
->bfd_section
) = (PTR
) new;
831 /* If there is a base address, make sure that any sections it might
832 mention are initialized. */
833 if (s
->addr_tree
!= NULL
)
834 exp_init_os (s
->addr_tree
);
837 /* Make sure that all output sections mentioned in an expression are
844 switch (exp
->type
.node_class
)
847 exp_init_os (exp
->assign
.src
);
851 exp_init_os (exp
->binary
.lhs
);
852 exp_init_os (exp
->binary
.rhs
);
856 exp_init_os (exp
->trinary
.cond
);
857 exp_init_os (exp
->trinary
.lhs
);
858 exp_init_os (exp
->trinary
.rhs
);
862 exp_init_os (exp
->unary
.child
);
866 switch (exp
->type
.node_code
)
872 lang_output_section_statement_type
*os
;
874 os
= lang_output_section_find (exp
->name
.name
);
875 if (os
!= NULL
&& os
->bfd_section
== NULL
)
886 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
887 once into the output. This routine checks each section, and
888 arrange to discard it if a section of the same name has already
889 been linked. If the section has COMDAT information, then it uses
890 that to decide whether the section should be included. This code
891 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
892 that is, it does not depend solely upon the section name.
893 section_already_linked is called via bfd_map_over_sections. */
895 /* This is the shape of the elements inside the already_linked hash
896 table. It maps a name onto a list of already_linked elements with
897 the same name. It's possible to get more than one element in a
898 list if the COMDAT sections have different names. */
900 struct already_linked_hash_entry
902 struct bfd_hash_entry root
;
903 struct already_linked
*entry
;
906 struct already_linked
908 struct already_linked
*next
;
912 /* The hash table. */
914 static struct bfd_hash_table already_linked_table
;
917 section_already_linked (abfd
, sec
, data
)
922 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
925 struct already_linked
*l
;
926 struct already_linked_hash_entry
*already_linked_list
;
928 /* If we are only reading symbols from this object, then we want to
929 discard all sections. */
930 if (entry
->just_syms_flag
)
932 sec
->output_section
= bfd_abs_section_ptr
;
933 sec
->output_offset
= sec
->vma
;
937 flags
= bfd_get_section_flags (abfd
, sec
);
939 if ((flags
& SEC_LINK_ONCE
) == 0)
942 /* FIXME: When doing a relocatable link, we may have trouble
943 copying relocations in other sections that refer to local symbols
944 in the section being discarded. Those relocations will have to
945 be converted somehow; as of this writing I'm not sure that any of
946 the backends handle that correctly.
948 It is tempting to instead not discard link once sections when
949 doing a relocatable link (technically, they should be discarded
950 whenever we are building constructors). However, that fails,
951 because the linker winds up combining all the link once sections
952 into a single large link once section, which defeats the purpose
953 of having link once sections in the first place.
955 Also, not merging link once sections in a relocatable link
956 causes trouble for MIPS ELF, which relies in link once semantics
957 to handle the .reginfo section correctly. */
959 name
= bfd_get_section_name (abfd
, sec
);
961 already_linked_list
=
962 ((struct already_linked_hash_entry
*)
963 bfd_hash_lookup (&already_linked_table
, name
, true, false));
965 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
967 if (sec
->comdat
== NULL
968 || l
->sec
->comdat
== NULL
969 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
971 /* The section has already been linked. See if we should
973 switch (flags
& SEC_LINK_DUPLICATES
)
978 case SEC_LINK_DUPLICATES_DISCARD
:
981 case SEC_LINK_DUPLICATES_ONE_ONLY
:
982 if (sec
->comdat
== NULL
)
983 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
986 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
987 abfd
, name
, sec
->comdat
->name
);
990 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
991 /* FIXME: We should really dig out the contents of both
992 sections and memcmp them. The COFF/PE spec says that
993 the Microsoft linker does not implement this
994 correctly, so I'm not going to bother doing it
997 case SEC_LINK_DUPLICATES_SAME_SIZE
:
998 if (bfd_section_size (abfd
, sec
)
999 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1000 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1005 /* Set the output_section field so that wild_doit does not
1006 create a lang_input_section structure for this section.
1007 Since there might be a symbol in the section being
1008 discarded, we must retain a pointer to the section which
1009 we are really going to use. */
1010 sec
->output_section
= bfd_abs_section_ptr
;
1011 sec
->kept_section
= l
->sec
;
1017 /* This is the first section with this name. Record it. Allocate
1018 the memory from the same obstack as the hash table is kept in. */
1020 l
= ((struct already_linked
*)
1021 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1024 l
->next
= already_linked_list
->entry
;
1025 already_linked_list
->entry
= l
;
1028 /* Support routines for the hash table used by section_already_linked,
1029 initialize the table, fill in an entry and remove the table. */
1031 static struct bfd_hash_entry
*
1032 already_linked_newfunc (entry
, table
, string
)
1033 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1034 struct bfd_hash_table
*table
;
1035 const char *string ATTRIBUTE_UNUSED
;
1037 struct already_linked_hash_entry
*ret
=
1038 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1042 return (struct bfd_hash_entry
*) ret
;
1046 already_linked_table_init ()
1048 if (! bfd_hash_table_init_n (&already_linked_table
,
1049 already_linked_newfunc
,
1051 einfo (_("%P%F: Failed to create hash table\n"));
1055 already_linked_table_free ()
1057 bfd_hash_table_free (&already_linked_table
);
1060 /* The wild routines.
1062 These expand statements like *(.text) and foo.o to a list of
1063 explicit actions, like foo.o(.text), bar.o(.text) and
1064 foo.o(.text, .data). */
1066 /* Return true if the PATTERN argument is a wildcard pattern.
1067 Although backslashes are treated specially if a pattern contains
1068 wildcards, we do not consider the mere presence of a backslash to
1069 be enough to cause the the pattern to be treated as a wildcard.
1070 That lets us handle DOS filenames more naturally. */
1074 const char *pattern
;
1078 for (s
= pattern
; *s
!= '\0'; ++s
)
1086 /* Add SECTION to the output section OUTPUT. Do this by creating a
1087 lang_input_section statement which is placed at PTR. FILE is the
1088 input file which holds SECTION. */
1091 wild_doit (ptr
, section
, output
, file
)
1092 lang_statement_list_type
*ptr
;
1094 lang_output_section_statement_type
*output
;
1095 lang_input_statement_type
*file
;
1100 flags
= bfd_get_section_flags (section
->owner
, section
);
1104 /* If we are doing a final link, discard sections marked with
1106 if (! link_info
.relocateable
1107 && (flags
& SEC_EXCLUDE
) != 0)
1110 /* Discard input sections which are assigned to a section named
1111 DISCARD_SECTION_NAME. */
1112 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1115 /* Discard debugging sections if we are stripping debugging
1117 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1118 && (flags
& SEC_DEBUGGING
) != 0)
1123 if (section
->output_section
== NULL
)
1125 /* This prevents future calls from assigning this section. */
1126 section
->output_section
= bfd_abs_section_ptr
;
1131 if (section
->output_section
== NULL
)
1134 lang_input_section_type
*new;
1137 if (output
->bfd_section
== NULL
)
1145 /* Add a section reference to the list. */
1146 new = new_stat (lang_input_section
, ptr
);
1148 new->section
= section
;
1150 section
->output_section
= output
->bfd_section
;
1152 flags
= section
->flags
;
1154 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1155 to an output section, because we want to be able to include a
1156 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1157 section (I don't know why we want to do this, but we do).
1158 build_link_order in ldwrite.c handles this case by turning
1159 the embedded SEC_NEVER_LOAD section into a fill. */
1161 flags
&= ~ SEC_NEVER_LOAD
;
1163 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1164 already been processed. One reason to do this is that on pe
1165 format targets, .text$foo sections go into .text and it's odd
1166 to see .text with SEC_LINK_ONCE set. */
1168 if (! link_info
.relocateable
)
1169 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1171 /* If this is not the first input section, and the SEC_READONLY
1172 flag is not currently set, then don't set it just because the
1173 input section has it set. */
1175 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1176 flags
&= ~ SEC_READONLY
;
1178 section
->output_section
->flags
|= flags
;
1180 /* If SEC_READONLY is not set in the input section, then clear
1181 it from the output section. */
1182 if ((section
->flags
& SEC_READONLY
) == 0)
1183 section
->output_section
->flags
&= ~SEC_READONLY
;
1185 switch (output
->sectype
)
1187 case normal_section
:
1192 case overlay_section
:
1193 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1195 case noload_section
:
1196 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1197 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1201 /* Copy over SEC_SMALL_DATA. */
1202 if (section
->flags
& SEC_SMALL_DATA
)
1203 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1205 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1206 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1208 /* If supplied an aligment, then force it. */
1209 if (output
->section_alignment
!= -1)
1210 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1212 if (section
->flags
& SEC_BLOCK
)
1214 section
->output_section
->flags
|= SEC_BLOCK
;
1215 /* FIXME: This value should really be obtained from the bfd... */
1216 output
->block_value
= 128;
1221 /* Handle wildcard sorting. This returns the lang_input_section which
1222 should follow the one we are going to create for SECTION and FILE,
1223 based on the sorting requirements of WILD. It returns NULL if the
1224 new section should just go at the end of the current list. */
1226 static lang_statement_union_type
*
1227 wild_sort (wild
, file
, section
)
1228 lang_wild_statement_type
*wild
;
1229 lang_input_statement_type
*file
;
1232 const char *section_name
;
1233 lang_statement_union_type
*l
;
1235 if (! wild
->filenames_sorted
&& ! wild
->sections_sorted
)
1238 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1239 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->next
)
1241 lang_input_section_type
*ls
;
1243 if (l
->header
.type
!= lang_input_section_enum
)
1245 ls
= &l
->input_section
;
1247 /* Sorting by filename takes precedence over sorting by section
1250 if (wild
->filenames_sorted
)
1252 const char *fn
, *ln
;
1256 /* The PE support for the .idata section as generated by
1257 dlltool assumes that files will be sorted by the name of
1258 the archive and then the name of the file within the
1261 if (file
->the_bfd
!= NULL
1262 && bfd_my_archive (file
->the_bfd
) != NULL
)
1264 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1269 fn
= file
->filename
;
1273 if (ls
->ifile
->the_bfd
!= NULL
1274 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1276 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1281 ln
= ls
->ifile
->filename
;
1285 i
= strcmp (fn
, ln
);
1294 fn
= file
->filename
;
1296 ln
= ls
->ifile
->filename
;
1298 i
= strcmp (fn
, ln
);
1306 /* Here either the files are not sorted by name, or we are
1307 looking at the sections for this file. */
1309 if (wild
->sections_sorted
)
1311 if (strcmp (section_name
,
1312 bfd_get_section_name (ls
->ifile
->the_bfd
,
1322 /* Expand a wild statement for a particular FILE. SECTION may be
1323 NULL, in which case it is a wild card. */
1326 output_section_callback (ptr
, section
, file
, output
)
1327 lang_wild_statement_type
*ptr
;
1329 lang_input_statement_type
*file
;
1332 lang_statement_union_type
*before
;
1334 /* If the wild pattern was marked KEEP, the member sections
1335 should be as well. */
1336 if (ptr
->keep_sections
)
1337 section
->flags
|= SEC_KEEP
;
1339 before
= wild_sort (ptr
, file
, section
);
1341 /* Here BEFORE points to the lang_input_section which
1342 should follow the one we are about to add. If BEFORE
1343 is NULL, then the section should just go at the end
1344 of the current list. */
1347 wild_doit (&ptr
->children
, section
,
1348 (lang_output_section_statement_type
*) output
,
1352 lang_statement_list_type list
;
1353 lang_statement_union_type
**pp
;
1355 lang_list_init (&list
);
1356 wild_doit (&list
, section
,
1357 (lang_output_section_statement_type
*) output
,
1360 /* If we are discarding the section, LIST.HEAD will
1362 if (list
.head
!= NULL
)
1364 ASSERT (list
.head
->next
== NULL
);
1366 for (pp
= &ptr
->children
.head
;
1369 ASSERT (*pp
!= NULL
);
1371 list
.head
->next
= *pp
;
1377 /* This is passed a file name which must have been seen already and
1378 added to the statement tree. We will see if it has been opened
1379 already and had its symbols read. If not then we'll read it. */
1381 static lang_input_statement_type
*
1385 lang_input_statement_type
*search
;
1387 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1388 search
!= (lang_input_statement_type
*) NULL
;
1389 search
= (lang_input_statement_type
*) search
->next_real_file
)
1391 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1393 if (search
->filename
!= (char *) NULL
1394 && name
!= (char *) NULL
1395 && strcmp (search
->filename
, name
) == 0)
1399 if (search
== (lang_input_statement_type
*) NULL
)
1400 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1403 /* If we have already added this file, or this file is not real
1404 (FIXME: can that ever actually happen?) or the name is NULL
1405 (FIXME: can that ever actually happen?) don't add this file. */
1408 || search
->filename
== (const char *) NULL
)
1411 load_symbols (search
, (lang_statement_list_type
*) NULL
);
1416 /* Get the symbols for an input file. */
1419 load_symbols (entry
, place
)
1420 lang_input_statement_type
*entry
;
1421 lang_statement_list_type
*place
;
1428 ldfile_open_file (entry
);
1430 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1431 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1434 lang_statement_list_type
*hold
;
1436 err
= bfd_get_error ();
1437 if (err
== bfd_error_file_ambiguously_recognized
)
1441 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1442 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1443 for (p
= matching
; *p
!= NULL
; p
++)
1447 else if (err
!= bfd_error_file_not_recognized
1449 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1451 bfd_close (entry
->the_bfd
);
1452 entry
->the_bfd
= NULL
;
1454 /* See if the emulation has some special knowledge. */
1456 if (ldemul_unrecognized_file (entry
))
1459 /* Try to interpret the file as a linker script. */
1461 ldfile_open_command_file (entry
->filename
);
1466 ldfile_assumed_script
= true;
1467 parser_input
= input_script
;
1469 ldfile_assumed_script
= false;
1476 if (ldemul_recognized_file (entry
))
1479 /* We don't call ldlang_add_file for an archive. Instead, the
1480 add_symbols entry point will call ldlang_add_file, via the
1481 add_archive_element callback, for each element of the archive
1483 switch (bfd_get_format (entry
->the_bfd
))
1489 ldlang_add_file (entry
);
1490 if (trace_files
|| trace_file_tries
)
1491 info_msg ("%I\n", entry
);
1495 if (entry
->whole_archive
)
1497 bfd
*member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1499 while (member
!= NULL
)
1501 if (! bfd_check_format (member
, bfd_object
))
1502 einfo (_("%F%B: object %B in archive is not object\n"),
1503 entry
->the_bfd
, member
);
1504 if (! ((*link_info
.callbacks
->add_archive_element
)
1505 (&link_info
, member
, "--whole-archive")))
1507 if (! bfd_link_add_symbols (member
, &link_info
))
1508 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1509 member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1513 entry
->loaded
= true;
1519 if (! bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1520 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1522 entry
->loaded
= true;
1525 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1526 indicating that it is a wildcard. Separate lang_input_section
1527 statements are created for each part of the expansion; they are
1528 added after the wild statement S. OUTPUT is the output section. */
1531 wild (s
, section
, file
, target
, output
)
1532 lang_wild_statement_type
*s
;
1533 const char *section
;
1535 const char *target ATTRIBUTE_UNUSED
;
1536 lang_output_section_statement_type
*output
;
1538 walk_wild (s
, section
, file
, output_section_callback
, (PTR
) output
);
1540 if (section
!= (char *) NULL
1541 && strcmp (section
, "COMMON") == 0
1542 && default_common_section
== NULL
)
1544 /* Remember the section that common is going to in case we later
1545 get something which doesn't know where to put it. */
1546 default_common_section
= output
;
1550 /* Return true iff target is the sought target. */
1553 get_target (target
, data
)
1554 const bfd_target
*target
;
1557 const char *sought
= (const char *) data
;
1559 return strcmp (target
->name
, sought
) == 0;
1562 /* Like strcpy() but convert to lower case as well. */
1571 while ((c
= *src
++) != 0)
1573 if (isupper ((unsigned char) c
))
1582 /* Remove the first occurance of needle (if any) in haystack
1586 strcut (haystack
, needle
)
1590 haystack
= strstr (haystack
, needle
);
1596 for (src
= haystack
+ strlen (needle
); *src
;)
1597 *haystack
++ = *src
++;
1603 /* Compare two target format name strings.
1604 Return a value indicating how "similar" they are. */
1607 name_compare (first
, second
)
1615 copy1
= xmalloc (strlen (first
) + 1);
1616 copy2
= xmalloc (strlen (second
) + 1);
1618 /* Convert the names to lower case. */
1619 stricpy (copy1
, first
);
1620 stricpy (copy2
, second
);
1622 /* Remove and endian strings from the name. */
1623 strcut (copy1
, "big");
1624 strcut (copy1
, "little");
1625 strcut (copy2
, "big");
1626 strcut (copy2
, "little");
1628 /* Return a value based on how many characters match,
1629 starting from the beginning. If both strings are
1630 the same then return 10 * their length. */
1631 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1632 if (copy1
[result
] == 0)
1644 /* Set by closest_target_match() below. */
1645 static const bfd_target
*winner
;
1647 /* Scan all the valid bfd targets looking for one that has the endianness
1648 requirement that was specified on the command line, and is the nearest
1649 match to the original output target. */
1652 closest_target_match (target
, data
)
1653 const bfd_target
*target
;
1656 const bfd_target
*original
= (const bfd_target
*) data
;
1658 if (command_line
.endian
== ENDIAN_BIG
1659 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1662 if (command_line
.endian
== ENDIAN_LITTLE
1663 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1666 /* Must be the same flavour. */
1667 if (target
->flavour
!= original
->flavour
)
1670 /* If we have not found a potential winner yet, then record this one. */
1677 /* Oh dear, we now have two potential candidates for a successful match.
1678 Compare their names and choose the better one. */
1679 if (name_compare (target
->name
, original
->name
) > name_compare (winner
->name
, original
->name
))
1682 /* Keep on searching until wqe have checked them all. */
1686 /* Return the BFD target format of the first input file. */
1689 get_first_input_target ()
1691 char *target
= NULL
;
1693 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1695 if (s
->header
.type
== lang_input_statement_enum
1698 ldfile_open_file (s
);
1700 if (s
->the_bfd
!= NULL
1701 && bfd_check_format (s
->the_bfd
, bfd_object
))
1703 target
= bfd_get_target (s
->the_bfd
);
1714 /* Open the output file. */
1722 /* Has the user told us which output format to use? */
1723 if (output_target
== (char *) NULL
)
1725 /* No - has the current target been set to something other than
1727 if (current_target
!= default_target
)
1728 output_target
= current_target
;
1730 /* No - can we determine the format of the first input file? */
1733 output_target
= get_first_input_target ();
1735 /* Failed - use the default output target. */
1736 if (output_target
== NULL
)
1737 output_target
= default_target
;
1741 /* Has the user requested a particular endianness on the command
1743 if (command_line
.endian
!= ENDIAN_UNSET
)
1745 const bfd_target
*target
;
1746 enum bfd_endian desired_endian
;
1748 /* Get the chosen target. */
1749 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1751 /* If the target is not supported, we cannot do anything. */
1754 if (command_line
.endian
== ENDIAN_BIG
)
1755 desired_endian
= BFD_ENDIAN_BIG
;
1757 desired_endian
= BFD_ENDIAN_LITTLE
;
1759 /* See if the target has the wrong endianness. This should
1760 not happen if the linker script has provided big and
1761 little endian alternatives, but some scrips don't do
1763 if (target
->byteorder
!= desired_endian
)
1765 /* If it does, then see if the target provides
1766 an alternative with the correct endianness. */
1767 if (target
->alternative_target
!= NULL
1768 && (target
->alternative_target
->byteorder
== desired_endian
))
1769 output_target
= target
->alternative_target
->name
;
1772 /* Try to find a target as similar as possible to
1773 the default target, but which has the desired
1774 endian characteristic. */
1775 (void) bfd_search_for_target (closest_target_match
, (PTR
) target
);
1777 /* Oh dear - we could not find any targets that
1778 satisfy our requirements. */
1780 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1782 output_target
= winner
->name
;
1788 output
= bfd_openw (name
, output_target
);
1790 if (output
== (bfd
*) NULL
)
1792 if (bfd_get_error () == bfd_error_invalid_target
)
1793 einfo (_("%P%F: target %s not found\n"), output_target
);
1795 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1798 delete_output_file_on_failure
= true;
1801 output
->flags
|= D_PAGED
;
1804 if (! bfd_set_format (output
, bfd_object
))
1805 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1806 if (! bfd_set_arch_mach (output
,
1807 ldfile_output_architecture
,
1808 ldfile_output_machine
))
1809 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1811 link_info
.hash
= bfd_link_hash_table_create (output
);
1812 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1813 einfo (_("%P%F: can not create link hash table: %E\n"));
1815 bfd_set_gp_size (output
, g_switch_value
);
1820 ldlang_open_output (statement
)
1821 lang_statement_union_type
*statement
;
1823 switch (statement
->header
.type
)
1825 case lang_output_statement_enum
:
1826 ASSERT (output_bfd
== (bfd
*) NULL
);
1827 output_bfd
= open_output (statement
->output_statement
.name
);
1828 ldemul_set_output_arch ();
1829 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1830 output_bfd
->flags
|= D_PAGED
;
1832 output_bfd
->flags
&= ~D_PAGED
;
1833 if (config
.text_read_only
)
1834 output_bfd
->flags
|= WP_TEXT
;
1836 output_bfd
->flags
&= ~WP_TEXT
;
1837 if (link_info
.traditional_format
)
1838 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1840 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1843 case lang_target_statement_enum
:
1844 current_target
= statement
->target_statement
.target
;
1851 /* Open all the input files. */
1854 open_input_bfds (s
, force
)
1855 lang_statement_union_type
*s
;
1858 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1860 switch (s
->header
.type
)
1862 case lang_constructors_statement_enum
:
1863 open_input_bfds (constructor_list
.head
, force
);
1865 case lang_output_section_statement_enum
:
1866 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1868 case lang_wild_statement_enum
:
1869 /* Maybe we should load the file's symbols. */
1870 if (s
->wild_statement
.filename
1871 && ! wildcardp (s
->wild_statement
.filename
))
1872 (void) lookup_name (s
->wild_statement
.filename
);
1873 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1875 case lang_group_statement_enum
:
1877 struct bfd_link_hash_entry
*undefs
;
1879 /* We must continually search the entries in the group
1880 until no new symbols are added to the list of undefined
1885 undefs
= link_info
.hash
->undefs_tail
;
1886 open_input_bfds (s
->group_statement
.children
.head
, true);
1888 while (undefs
!= link_info
.hash
->undefs_tail
);
1891 case lang_target_statement_enum
:
1892 current_target
= s
->target_statement
.target
;
1894 case lang_input_statement_enum
:
1895 if (s
->input_statement
.real
)
1897 lang_statement_list_type add
;
1898 bfd_error_handler_type pfn
;
1900 s
->input_statement
.target
= current_target
;
1902 /* If we are being called from within a group, and this
1903 is an archive which has already been searched, then
1904 force it to be researched unless the whole archive
1905 has been loaded already. */
1907 && !s
->input_statement
.whole_archive
1908 && s
->input_statement
.loaded
1909 && bfd_check_format (s
->input_statement
.the_bfd
,
1911 s
->input_statement
.loaded
= false;
1913 lang_list_init (& add
);
1915 /* We need to know if an error occurs whilst loading the
1916 symbols, since this means that a valid executable can
1918 pfn
= bfd_set_error_handler (record_bfd_errors
);
1920 load_symbols (&s
->input_statement
, &add
);
1922 bfd_set_error_handler (pfn
);
1924 if (add
.head
!= NULL
)
1926 *add
.tail
= s
->next
;
1937 /* If there are [COMMONS] statements, put a wild one into the bss
1941 lang_reasonable_defaults ()
1944 lang_output_section_statement_lookup (".text");
1945 lang_output_section_statement_lookup (".data");
1947 default_common_section
= lang_output_section_statement_lookup (".bss");
1949 if (placed_commons
== false)
1951 lang_wild_statement_type
*new =
1952 new_stat (lang_wild_statement
,
1953 &default_common_section
->children
);
1955 new->section_name
= "COMMON";
1956 new->filename
= (char *) NULL
;
1957 lang_list_init (&new->children
);
1962 /* Add the supplied name to the symbol table as an undefined reference.
1963 Remove items from the chain as we open input bfds. */
1964 typedef struct ldlang_undef_chain_list
1966 struct ldlang_undef_chain_list
*next
;
1968 } ldlang_undef_chain_list_type
;
1970 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
1973 ldlang_add_undef (name
)
1974 const char *const name
;
1976 ldlang_undef_chain_list_type
*new =
1977 ((ldlang_undef_chain_list_type
*)
1978 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
1980 new->next
= ldlang_undef_chain_list_head
;
1981 ldlang_undef_chain_list_head
= new;
1983 new->name
= buystring (name
);
1986 /* Run through the list of undefineds created above and place them
1987 into the linker hash table as undefined symbols belonging to the
1991 lang_place_undefineds ()
1993 ldlang_undef_chain_list_type
*ptr
;
1995 for (ptr
= ldlang_undef_chain_list_head
;
1996 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
1999 struct bfd_link_hash_entry
*h
;
2001 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
2002 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2003 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2004 if (h
->type
== bfd_link_hash_new
)
2006 h
->type
= bfd_link_hash_undefined
;
2007 h
->u
.undef
.abfd
= NULL
;
2008 bfd_link_add_undef (link_info
.hash
, h
);
2013 /* Open input files and attatch to output sections. */
2016 map_input_to_output_sections (s
, target
, output_section_statement
)
2017 lang_statement_union_type
*s
;
2019 lang_output_section_statement_type
*output_section_statement
;
2021 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2023 switch (s
->header
.type
)
2026 case lang_wild_statement_enum
:
2027 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
2028 s
->wild_statement
.filename
, target
,
2029 output_section_statement
);
2032 case lang_constructors_statement_enum
:
2033 map_input_to_output_sections (constructor_list
.head
,
2035 output_section_statement
);
2037 case lang_output_section_statement_enum
:
2038 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2040 &s
->output_section_statement
);
2042 case lang_output_statement_enum
:
2044 case lang_target_statement_enum
:
2045 target
= s
->target_statement
.target
;
2047 case lang_group_statement_enum
:
2048 map_input_to_output_sections (s
->group_statement
.children
.head
,
2050 output_section_statement
);
2052 case lang_fill_statement_enum
:
2053 case lang_input_section_enum
:
2054 case lang_object_symbols_statement_enum
:
2055 case lang_data_statement_enum
:
2056 case lang_reloc_statement_enum
:
2057 case lang_padding_statement_enum
:
2058 case lang_input_statement_enum
:
2059 if (output_section_statement
!= NULL
2060 && output_section_statement
->bfd_section
== NULL
)
2061 init_os (output_section_statement
);
2063 case lang_assignment_statement_enum
:
2064 if (output_section_statement
!= NULL
2065 && output_section_statement
->bfd_section
== NULL
)
2066 init_os (output_section_statement
);
2068 /* Make sure that any sections mentioned in the assignment
2070 exp_init_os (s
->assignment_statement
.exp
);
2072 case lang_afile_asection_pair_statement_enum
:
2075 case lang_address_statement_enum
:
2076 /* Mark the specified section with the supplied address. */
2078 lang_output_section_statement_type
*os
=
2079 lang_output_section_statement_lookup
2080 (s
->address_statement
.section_name
);
2082 if (os
->bfd_section
== NULL
)
2084 os
->addr_tree
= s
->address_statement
.address
;
2092 print_output_section_statement (output_section_statement
)
2093 lang_output_section_statement_type
*output_section_statement
;
2095 asection
*section
= output_section_statement
->bfd_section
;
2098 if (output_section_statement
!= abs_output_section
)
2100 minfo ("\n%s", output_section_statement
->name
);
2102 if (section
!= NULL
)
2104 print_dot
= section
->vma
;
2106 len
= strlen (output_section_statement
->name
);
2107 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2112 while (len
< SECTION_NAME_MAP_LENGTH
)
2118 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2120 if (output_section_statement
->load_base
!= NULL
)
2124 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2125 "load base", lang_final_phase_enum
);
2126 minfo (_(" load address 0x%V"), addr
);
2133 print_statement_list (output_section_statement
->children
.head
,
2134 output_section_statement
);
2138 print_assignment (assignment
, output_section
)
2139 lang_assignment_statement_type
*assignment
;
2140 lang_output_section_statement_type
*output_section
;
2143 etree_value_type result
;
2145 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2148 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2149 lang_final_phase_enum
, print_dot
, &print_dot
);
2151 minfo ("0x%V", result
.value
+ result
.section
->bfd_section
->vma
);
2162 exp_print_tree (assignment
->exp
);
2168 print_input_statement (statm
)
2169 lang_input_statement_type
*statm
;
2171 if (statm
->filename
!= (char *) NULL
)
2173 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2177 /* Print all symbols defined in a particular section. This is called
2178 via bfd_link_hash_traverse. */
2181 print_one_symbol (hash_entry
, ptr
)
2182 struct bfd_link_hash_entry
*hash_entry
;
2185 asection
*sec
= (asection
*) ptr
;
2187 if ((hash_entry
->type
== bfd_link_hash_defined
2188 || hash_entry
->type
== bfd_link_hash_defweak
)
2189 && sec
== hash_entry
->u
.def
.section
)
2193 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2196 (hash_entry
->u
.def
.value
2197 + hash_entry
->u
.def
.section
->output_offset
2198 + hash_entry
->u
.def
.section
->output_section
->vma
));
2200 minfo (" %T\n", hash_entry
->root
.string
);
2206 /* Print information about an input section to the map file. */
2209 print_input_section (in
)
2210 lang_input_section_type
*in
;
2212 asection
*i
= in
->section
;
2213 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2214 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2215 ldfile_output_machine
);
2220 minfo ("%s", i
->name
);
2222 if (i
->output_section
!= NULL
)
2226 len
= 1 + strlen (i
->name
);
2227 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2232 while (len
< SECTION_NAME_MAP_LENGTH
)
2238 minfo ("0x%V %W %B\n",
2239 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2242 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2244 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2256 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2259 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2261 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2267 print_fill_statement (fill
)
2268 lang_fill_statement_type
*fill
;
2270 fprintf (config
.map_file
, " FILL mask 0x%x\n", fill
->fill
);
2274 print_data_statement (data
)
2275 lang_data_statement_type
*data
;
2281 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2282 ldfile_output_machine
);
2284 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2287 addr
= data
->output_vma
;
2288 if (data
->output_section
!= NULL
)
2289 addr
+= data
->output_section
->vma
;
2317 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2319 if (data
->exp
->type
.node_class
!= etree_value
)
2322 exp_print_tree (data
->exp
);
2327 print_dot
= addr
+ size
/ opb
;
2331 /* Print an address statement. These are generated by options like
2335 print_address_statement (address
)
2336 lang_address_statement_type
*address
;
2338 minfo (_("Address of section %s set to "), address
->section_name
);
2339 exp_print_tree (address
->address
);
2343 /* Print a reloc statement. */
2346 print_reloc_statement (reloc
)
2347 lang_reloc_statement_type
*reloc
;
2352 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2353 ldfile_output_machine
);
2355 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2358 addr
= reloc
->output_vma
;
2359 if (reloc
->output_section
!= NULL
)
2360 addr
+= reloc
->output_section
->vma
;
2362 size
= bfd_get_reloc_size (reloc
->howto
);
2364 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2366 if (reloc
->name
!= NULL
)
2367 minfo ("%s+", reloc
->name
);
2369 minfo ("%s+", reloc
->section
->name
);
2371 exp_print_tree (reloc
->addend_exp
);
2375 print_dot
= addr
+ size
/ opb
;
2379 print_padding_statement (s
)
2380 lang_padding_statement_type
*s
;
2384 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2385 ldfile_output_machine
);
2389 len
= sizeof " *fill*" - 1;
2390 while (len
< SECTION_NAME_MAP_LENGTH
)
2396 addr
= s
->output_offset
;
2397 if (s
->output_section
!= NULL
)
2398 addr
+= s
->output_section
->vma
;
2399 minfo ("0x%V %W", addr
, s
->size
);
2402 minfo (" %u", s
->fill
);
2406 print_dot
= addr
+ s
->size
/ opb
;
2410 print_wild_statement (w
, os
)
2411 lang_wild_statement_type
*w
;
2412 lang_output_section_statement_type
*os
;
2416 if (w
->filenames_sorted
)
2418 if (w
->exclude_filename_list
!= NULL
)
2421 minfo ("EXCLUDE_FILE ( %s", w
->exclude_filename_list
->name
);
2422 for (tmp
= w
->exclude_filename_list
->next
; tmp
; tmp
= tmp
->next
)
2423 minfo (", %s", tmp
->name
);
2426 if (w
->filename
!= NULL
)
2427 minfo ("%s", w
->filename
);
2430 if (w
->filenames_sorted
)
2434 if (w
->sections_sorted
)
2436 if (w
->section_name
!= NULL
)
2437 minfo ("%s", w
->section_name
);
2440 if (w
->sections_sorted
)
2446 print_statement_list (w
->children
.head
, os
);
2449 /* Print a group statement. */
2453 lang_group_statement_type
*s
;
2454 lang_output_section_statement_type
*os
;
2456 fprintf (config
.map_file
, "START GROUP\n");
2457 print_statement_list (s
->children
.head
, os
);
2458 fprintf (config
.map_file
, "END GROUP\n");
2461 /* Print the list of statements in S.
2462 This can be called for any statement type. */
2465 print_statement_list (s
, os
)
2466 lang_statement_union_type
*s
;
2467 lang_output_section_statement_type
*os
;
2471 print_statement (s
, os
);
2476 /* Print the first statement in statement list S.
2477 This can be called for any statement type. */
2480 print_statement (s
, os
)
2481 lang_statement_union_type
*s
;
2482 lang_output_section_statement_type
*os
;
2484 switch (s
->header
.type
)
2487 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2490 case lang_constructors_statement_enum
:
2491 if (constructor_list
.head
!= NULL
)
2493 if (constructors_sorted
)
2494 minfo (" SORT (CONSTRUCTORS)\n");
2496 minfo (" CONSTRUCTORS\n");
2497 print_statement_list (constructor_list
.head
, os
);
2500 case lang_wild_statement_enum
:
2501 print_wild_statement (&s
->wild_statement
, os
);
2503 case lang_address_statement_enum
:
2504 print_address_statement (&s
->address_statement
);
2506 case lang_object_symbols_statement_enum
:
2507 minfo (" CREATE_OBJECT_SYMBOLS\n");
2509 case lang_fill_statement_enum
:
2510 print_fill_statement (&s
->fill_statement
);
2512 case lang_data_statement_enum
:
2513 print_data_statement (&s
->data_statement
);
2515 case lang_reloc_statement_enum
:
2516 print_reloc_statement (&s
->reloc_statement
);
2518 case lang_input_section_enum
:
2519 print_input_section (&s
->input_section
);
2521 case lang_padding_statement_enum
:
2522 print_padding_statement (&s
->padding_statement
);
2524 case lang_output_section_statement_enum
:
2525 print_output_section_statement (&s
->output_section_statement
);
2527 case lang_assignment_statement_enum
:
2528 print_assignment (&s
->assignment_statement
, os
);
2530 case lang_target_statement_enum
:
2531 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2533 case lang_output_statement_enum
:
2534 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2535 if (output_target
!= NULL
)
2536 minfo (" %s", output_target
);
2539 case lang_input_statement_enum
:
2540 print_input_statement (&s
->input_statement
);
2542 case lang_group_statement_enum
:
2543 print_group (&s
->group_statement
, os
);
2545 case lang_afile_asection_pair_statement_enum
:
2554 print_statement_list (statement_list
.head
, abs_output_section
);
2557 /* Print the first N statements in statement list S to STDERR.
2558 If N == 0, nothing is printed.
2559 If N < 0, the entire list is printed.
2560 Intended to be called from GDB. */
2563 dprint_statement (s
, n
)
2564 lang_statement_union_type
*s
;
2567 FILE *map_save
= config
.map_file
;
2569 config
.map_file
= stderr
;
2572 print_statement_list (s
, abs_output_section
);
2575 while (s
&& --n
>= 0)
2577 print_statement (s
, abs_output_section
);
2582 config
.map_file
= map_save
;
2586 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
2587 lang_statement_union_type
**this_ptr
;
2590 asection
*output_section_statement
;
2593 /* Align this section first to the
2594 input sections requirement, then
2595 to the output section's requirement.
2596 If this alignment is > than any seen before,
2597 then record it too. Perform the alignment by
2598 inserting a magic 'padding' statement. */
2600 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2601 ldfile_output_machine
);
2602 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
2604 if (alignment_needed
!= 0)
2606 lang_statement_union_type
*new =
2607 ((lang_statement_union_type
*)
2608 stat_alloc (sizeof (lang_padding_statement_type
)));
2610 /* Link into existing chain. */
2611 new->header
.next
= *this_ptr
;
2613 new->header
.type
= lang_padding_statement_enum
;
2614 new->padding_statement
.output_section
= output_section_statement
;
2615 new->padding_statement
.output_offset
=
2616 dot
- output_section_statement
->vma
;
2617 new->padding_statement
.fill
= fill
;
2618 new->padding_statement
.size
= alignment_needed
* opb
;
2621 /* Remember the most restrictive alignment. */
2622 if (power
> output_section_statement
->alignment_power
)
2624 output_section_statement
->alignment_power
= power
;
2626 output_section_statement
->_raw_size
+= alignment_needed
* opb
;
2628 return dot
+ alignment_needed
;
2631 /* Work out how much this section will move the dot point. */
2634 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
2635 lang_statement_union_type
**this_ptr
;
2636 lang_output_section_statement_type
*output_section_statement
;
2639 boolean relax ATTRIBUTE_UNUSED
;
2641 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2642 asection
*i
= is
->section
;
2643 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2644 ldfile_output_machine
);
2646 if (is
->ifile
->just_syms_flag
== false)
2648 if (output_section_statement
->subsection_alignment
!= -1)
2649 i
->alignment_power
=
2650 output_section_statement
->subsection_alignment
;
2652 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
2653 output_section_statement
->bfd_section
, dot
);
2655 /* Remember where in the output section this input section goes. */
2657 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
2659 /* Mark how big the output section must be to contain this now. */
2660 if (i
->_cooked_size
!= 0)
2661 dot
+= i
->_cooked_size
/ opb
;
2663 dot
+= i
->_raw_size
/ opb
;
2664 output_section_statement
->bfd_section
->_raw_size
=
2665 (dot
- output_section_statement
->bfd_section
->vma
) * opb
;
2669 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2675 #define IGNORE_SECTION(bfd, s) \
2676 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) != (SEC_ALLOC | SEC_LOAD)) \
2677 || bfd_section_size (bfd, s) == 0)
2679 /* Check to see if any allocated sections overlap with other allocated
2680 sections. This can happen when the linker script specifically specifies
2681 the output section addresses of the two sections. */
2684 lang_check_section_addresses ()
2687 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2689 /* Scan all sections in the output list. */
2690 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2694 /* Ignore sections which are not loaded or which have no contents. */
2695 if (IGNORE_SECTION (output_bfd
, s
))
2698 /* Once we reach section 's' stop our seach. This prevents two
2699 warning messages from being produced, one for 'section A overlaps
2700 section B' and one for 'section B overlaps section A'. */
2701 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2708 /* Only consider loadable sections with real contents. */
2709 if (IGNORE_SECTION (output_bfd
, os
))
2712 /* We must check the sections' LMA addresses not their
2713 VMA addresses because overlay sections can have
2714 overlapping VMAs but they must have distinct LMAs. */
2715 s_start
= bfd_section_lma (output_bfd
, s
);
2716 os_start
= bfd_section_lma (output_bfd
, os
);
2717 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2718 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2720 /* Look for an overlap. */
2721 if ((s_end
< os_start
) || (s_start
> os_end
))
2725 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2726 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2728 /* Once we have found one overlap for this section,
2729 stop looking for others. */
2735 /* This variable indicates whether bfd_relax_section should be called
2738 static boolean relax_again
;
2740 /* Make sure the new address is within the region. We explicitly permit the
2741 current address to be at the exact end of the region when the address is
2742 non-zero, in case the region is at the end of addressable memory and the
2743 calculation wraps around. */
2746 os_region_check (os
, region
, tree
, base
)
2747 lang_output_section_statement_type
*os
;
2748 struct memory_region_struct
*region
;
2752 if ((region
->current
< region
->origin
2753 || (region
->current
- region
->origin
> region
->length
))
2754 && ((region
->current
!= region
->origin
+ region
->length
)
2757 if (tree
!= (etree_type
*) NULL
)
2759 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2761 os
->bfd_section
->owner
,
2762 os
->bfd_section
->name
,
2767 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2769 os
->bfd_section
->owner
,
2770 os
->bfd_section
->name
);
2772 /* Reset the region pointer. */
2773 region
->current
= region
->origin
;
2777 /* Set the sizes for all the output sections. */
2780 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2781 lang_statement_union_type
*s
;
2782 lang_output_section_statement_type
*output_section_statement
;
2783 lang_statement_union_type
**prev
;
2788 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2789 ldfile_output_machine
);
2791 /* Size up the sections from their constituent parts. */
2792 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2794 switch (s
->header
.type
)
2796 case lang_output_section_statement_enum
:
2799 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
2801 if (os
->bfd_section
== NULL
)
2802 /* This section was never actually created. */
2805 /* If this is a COFF shared library section, use the size and
2806 address from the input section. FIXME: This is COFF
2807 specific; it would be cleaner if there were some other way
2808 to do this, but nothing simple comes to mind. */
2809 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2813 if (os
->children
.head
== NULL
2814 || os
->children
.head
->next
!= NULL
2815 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2816 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2819 input
= os
->children
.head
->input_section
.section
;
2820 bfd_set_section_vma (os
->bfd_section
->owner
,
2822 bfd_section_vma (input
->owner
, input
));
2823 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2827 if (bfd_is_abs_section (os
->bfd_section
))
2829 /* No matter what happens, an abs section starts at zero. */
2830 ASSERT (os
->bfd_section
->vma
== 0);
2834 if (os
->addr_tree
== (etree_type
*) NULL
)
2836 /* No address specified for this section, get one
2837 from the region specification. */
2838 if (os
->region
== (lang_memory_region_type
*) NULL
2839 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2840 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2841 && os
->region
->name
[0] == '*'
2842 && strcmp (os
->region
->name
, "*default*") == 0))
2844 os
->region
= lang_memory_default (os
->bfd_section
);
2847 /* If a loadable section is using the default memory
2848 region, and some non default memory regions were
2849 defined, issue a warning. */
2850 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2851 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2852 && ! link_info
.relocateable
2853 && strcmp (os
->region
->name
, "*default*") == 0
2854 && lang_memory_region_list
!= NULL
2855 && (strcmp (lang_memory_region_list
->name
, "*default*") != 0
2856 || lang_memory_region_list
->next
!= NULL
))
2857 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2858 bfd_get_section_name (output_bfd
, os
->bfd_section
));
2860 dot
= os
->region
->current
;
2862 if (os
->section_alignment
== -1)
2867 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
2869 if (dot
!= olddot
&& config
.warn_section_align
)
2870 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2871 os
->name
, (unsigned int) (dot
- olddot
));
2878 r
= exp_fold_tree (os
->addr_tree
,
2880 lang_allocating_phase_enum
,
2882 if (r
.valid_p
== false)
2884 einfo (_("%F%S: non constant address expression for section %s\n"),
2887 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2890 /* The section starts here.
2891 First, align to what the section needs. */
2893 if (os
->section_alignment
!= -1)
2894 dot
= align_power (dot
, os
->section_alignment
);
2896 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2898 os
->bfd_section
->output_offset
= 0;
2901 (void) lang_size_sections (os
->children
.head
, os
,
2903 os
->fill
, dot
, relax
);
2905 /* Put the section within the requested block size, or
2906 align at the block boundary. */
2907 after
= ALIGN_N (os
->bfd_section
->vma
2908 + os
->bfd_section
->_raw_size
/ opb
,
2909 /* The coercion here is important, see ld.h. */
2910 (bfd_vma
) os
->block_value
);
2912 if (bfd_is_abs_section (os
->bfd_section
))
2913 ASSERT (after
== os
->bfd_section
->vma
);
2915 os
->bfd_section
->_raw_size
=
2916 (after
- os
->bfd_section
->vma
) * opb
;
2917 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
2918 os
->processed
= true;
2920 /* Update dot in the region ?
2921 We only do this if the section is going to be allocated,
2922 since unallocated sections do not contribute to the region's
2923 overall size in memory.
2925 If the SEC_NEVER_LOAD bit is not set, it will affect the
2926 addresses of sections after it. We have to update
2928 if (os
->region
!= (lang_memory_region_type
*) NULL
2929 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2930 & SEC_NEVER_LOAD
) == 0
2931 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2932 & (SEC_ALLOC
| SEC_LOAD
))))
2934 os
->region
->current
= dot
;
2936 /* Make sure the new address is within the region. */
2937 os_region_check (os
, os
->region
, os
->addr_tree
,
2938 os
->bfd_section
->vma
);
2940 /* If there's no load address specified, use the run
2941 region as the load region. */
2942 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
2943 os
->lma_region
= os
->region
;
2945 if (os
->lma_region
!= NULL
)
2947 if (os
->load_base
!= NULL
)
2949 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
2953 /* Don't allocate twice. */
2954 if (os
->lma_region
!= os
->region
)
2956 /* Set load_base, which will be handled later. */
2958 exp_intop (os
->lma_region
->current
);
2959 os
->lma_region
->current
+=
2960 os
->bfd_section
->_raw_size
/ opb
;
2961 os_region_check (os
, os
->lma_region
, NULL
,
2962 os
->bfd_section
->lma
);
2970 case lang_constructors_statement_enum
:
2971 dot
= lang_size_sections (constructor_list
.head
,
2972 output_section_statement
,
2973 &s
->wild_statement
.children
.head
,
2978 case lang_data_statement_enum
:
2980 unsigned int size
= 0;
2982 s
->data_statement
.output_vma
=
2983 dot
- output_section_statement
->bfd_section
->vma
;
2984 s
->data_statement
.output_section
=
2985 output_section_statement
->bfd_section
;
2987 switch (s
->data_statement
.type
)
3008 output_section_statement
->bfd_section
->_raw_size
+= size
;
3009 /* The output section gets contents, and then we inspect for
3010 any flags set in the input script which override any ALLOC. */
3011 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3012 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3014 output_section_statement
->bfd_section
->flags
|=
3015 SEC_ALLOC
| SEC_LOAD
;
3020 case lang_reloc_statement_enum
:
3024 s
->reloc_statement
.output_vma
=
3025 dot
- output_section_statement
->bfd_section
->vma
;
3026 s
->reloc_statement
.output_section
=
3027 output_section_statement
->bfd_section
;
3028 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3030 output_section_statement
->bfd_section
->_raw_size
+= size
;
3034 case lang_wild_statement_enum
:
3036 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
3037 output_section_statement
,
3038 &s
->wild_statement
.children
.head
,
3043 case lang_object_symbols_statement_enum
:
3044 link_info
.create_object_symbols_section
=
3045 output_section_statement
->bfd_section
;
3047 case lang_output_statement_enum
:
3048 case lang_target_statement_enum
:
3050 case lang_input_section_enum
:
3054 i
= (*prev
)->input_section
.section
;
3057 if (i
->_cooked_size
== 0)
3058 i
->_cooked_size
= i
->_raw_size
;
3064 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3065 einfo (_("%P%F: can't relax section: %E\n"));
3069 dot
= size_input_section (prev
,
3070 output_section_statement
,
3071 output_section_statement
->fill
,
3075 case lang_input_statement_enum
:
3077 case lang_fill_statement_enum
:
3078 s
->fill_statement
.output_section
=
3079 output_section_statement
->bfd_section
;
3081 fill
= s
->fill_statement
.fill
;
3083 case lang_assignment_statement_enum
:
3085 bfd_vma newdot
= dot
;
3087 exp_fold_tree (s
->assignment_statement
.exp
,
3088 output_section_statement
,
3089 lang_allocating_phase_enum
,
3095 /* The assignment changed dot. Insert a pad. */
3096 if (output_section_statement
== abs_output_section
)
3098 /* If we don't have an output section, then just adjust
3099 the default memory address. */
3100 lang_memory_region_lookup ("*default*")->current
= newdot
;
3104 lang_statement_union_type
*new =
3105 ((lang_statement_union_type
*)
3106 stat_alloc (sizeof (lang_padding_statement_type
)));
3108 /* Link into existing chain. */
3109 new->header
.next
= *prev
;
3111 new->header
.type
= lang_padding_statement_enum
;
3112 new->padding_statement
.output_section
=
3113 output_section_statement
->bfd_section
;
3114 new->padding_statement
.output_offset
=
3115 dot
- output_section_statement
->bfd_section
->vma
;
3116 new->padding_statement
.fill
= fill
;
3117 new->padding_statement
.size
= (newdot
- dot
) * opb
;
3118 output_section_statement
->bfd_section
->_raw_size
+=
3119 new->padding_statement
.size
;
3127 case lang_padding_statement_enum
:
3128 /* If we are relaxing, and this is not the first pass, some
3129 padding statements may have been inserted during previous
3130 passes. We may have to move the padding statement to a new
3131 location if dot has a different value at this point in this
3132 pass than it did at this point in the previous pass. */
3133 s
->padding_statement
.output_offset
=
3134 dot
- output_section_statement
->bfd_section
->vma
;
3135 dot
+= s
->padding_statement
.size
/ opb
;
3136 output_section_statement
->bfd_section
->_raw_size
+=
3137 s
->padding_statement
.size
;
3140 case lang_group_statement_enum
:
3141 dot
= lang_size_sections (s
->group_statement
.children
.head
,
3142 output_section_statement
,
3143 &s
->group_statement
.children
.head
,
3151 /* This can only get here when relaxing is turned on. */
3153 case lang_address_statement_enum
:
3156 prev
= &s
->header
.next
;
3162 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3163 lang_statement_union_type
*s
;
3164 lang_output_section_statement_type
*output_section_statement
;
3168 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3169 ldfile_output_machine
);
3171 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
3173 switch (s
->header
.type
)
3175 case lang_constructors_statement_enum
:
3176 dot
= lang_do_assignments (constructor_list
.head
,
3177 output_section_statement
,
3182 case lang_output_section_statement_enum
:
3184 lang_output_section_statement_type
*os
=
3185 &(s
->output_section_statement
);
3187 if (os
->bfd_section
!= NULL
)
3189 dot
= os
->bfd_section
->vma
;
3190 (void) lang_do_assignments (os
->children
.head
, os
,
3192 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3197 /* If nothing has been placed into the output section then
3198 it won't have a bfd_section. */
3199 if (os
->bfd_section
)
3201 os
->bfd_section
->lma
3202 = exp_get_abs_int (os
->load_base
, 0, "load base",
3203 lang_final_phase_enum
);
3208 case lang_wild_statement_enum
:
3210 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3211 output_section_statement
,
3216 case lang_object_symbols_statement_enum
:
3217 case lang_output_statement_enum
:
3218 case lang_target_statement_enum
:
3220 case lang_common_statement_enum
:
3223 case lang_data_statement_enum
:
3225 etree_value_type value
;
3227 value
= exp_fold_tree (s
->data_statement
.exp
,
3229 lang_final_phase_enum
, dot
, &dot
);
3230 s
->data_statement
.value
= value
.value
;
3231 if (value
.valid_p
== false)
3232 einfo (_("%F%P: invalid data statement\n"));
3236 switch (s
->data_statement
.type
)
3260 case lang_reloc_statement_enum
:
3262 etree_value_type value
;
3264 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3266 lang_final_phase_enum
, dot
, &dot
);
3267 s
->reloc_statement
.addend_value
= value
.value
;
3268 if (value
.valid_p
== false)
3269 einfo (_("%F%P: invalid reloc statement\n"));
3271 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3274 case lang_input_section_enum
:
3276 asection
*in
= s
->input_section
.section
;
3278 if (in
->_cooked_size
!= 0)
3279 dot
+= in
->_cooked_size
/ opb
;
3281 dot
+= in
->_raw_size
/ opb
;
3285 case lang_input_statement_enum
:
3287 case lang_fill_statement_enum
:
3288 fill
= s
->fill_statement
.fill
;
3290 case lang_assignment_statement_enum
:
3292 exp_fold_tree (s
->assignment_statement
.exp
,
3293 output_section_statement
,
3294 lang_final_phase_enum
,
3300 case lang_padding_statement_enum
:
3301 dot
+= s
->padding_statement
.size
/ opb
;
3304 case lang_group_statement_enum
:
3305 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3306 output_section_statement
,
3314 case lang_address_statement_enum
:
3322 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3323 operator .startof. (section_name), it produces an undefined symbol
3324 .startof.section_name. Similarly, when it sees
3325 .sizeof. (section_name), it produces an undefined symbol
3326 .sizeof.section_name. For all the output sections, we look for
3327 such symbols, and set them to the correct value. */
3334 if (link_info
.relocateable
)
3337 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3339 const char *secname
;
3341 struct bfd_link_hash_entry
*h
;
3343 secname
= bfd_get_section_name (output_bfd
, s
);
3344 buf
= xmalloc (10 + strlen (secname
));
3346 sprintf (buf
, ".startof.%s", secname
);
3347 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3348 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3350 h
->type
= bfd_link_hash_defined
;
3351 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3352 h
->u
.def
.section
= bfd_abs_section_ptr
;
3355 sprintf (buf
, ".sizeof.%s", secname
);
3356 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3357 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3359 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3360 ldfile_output_machine
);
3361 h
->type
= bfd_link_hash_defined
;
3362 if (s
->_cooked_size
!= 0)
3363 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3365 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3366 h
->u
.def
.section
= bfd_abs_section_ptr
;
3376 struct bfd_link_hash_entry
*h
;
3379 if (link_info
.relocateable
|| link_info
.shared
)
3384 if (entry_symbol
== (char *) NULL
)
3386 /* No entry has been specified. Look for start, but don't warn
3387 if we don't find it. */
3388 entry_symbol
= "start";
3392 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
3393 if (h
!= (struct bfd_link_hash_entry
*) NULL
3394 && (h
->type
== bfd_link_hash_defined
3395 || h
->type
== bfd_link_hash_defweak
)
3396 && h
->u
.def
.section
->output_section
!= NULL
)
3400 val
= (h
->u
.def
.value
3401 + bfd_get_section_vma (output_bfd
,
3402 h
->u
.def
.section
->output_section
)
3403 + h
->u
.def
.section
->output_offset
);
3404 if (! bfd_set_start_address (output_bfd
, val
))
3405 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
);
3412 /* We couldn't find the entry symbol. Try parsing it as a
3414 val
= bfd_scan_vma (entry_symbol
, &send
, 0);
3417 if (! bfd_set_start_address (output_bfd
, val
))
3418 einfo (_("%P%F: can't set start address\n"));
3424 /* Can't find the entry symbol, and it's not a number. Use
3425 the first address in the text section. */
3426 ts
= bfd_get_section_by_name (output_bfd
, ".text");
3427 if (ts
!= (asection
*) NULL
)
3430 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3431 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
3432 if (! bfd_set_start_address (output_bfd
,
3433 bfd_get_section_vma (output_bfd
,
3435 einfo (_("%P%F: can't set start address\n"));
3440 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3448 /* This is the routine to handle BFD error messages. */
3450 #ifdef ANSI_PROTOTYPES
3453 record_bfd_errors (const char *s
, ...)
3461 vfprintf (stderr
, s
, p
);
3465 fprintf (stderr
, "\n");
3470 #else /* ! defined (ANSI_PROTOTYPES) */
3473 record_bfd_errors (va_alist
)
3483 s
= va_arg (p
, const char *);
3484 vfprintf (stderr
, s
, p
);
3488 fprintf (stderr
, "\n");
3493 #endif /* ! defined (ANSI_PROTOTYPES) */
3494 /* This is a small function used when we want to ignore errors from
3498 #ifdef ANSI_PROTOTYPES
3499 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3501 ignore_bfd_errors (s
)
3502 const char *s ATTRIBUTE_UNUSED
;
3505 /* Don't do anything. */
3508 /* Check that the architecture of all the input files is compatible
3509 with the output file. Also call the backend to let it do any
3510 other checking that is needed. */
3515 lang_statement_union_type
*file
;
3517 const bfd_arch_info_type
*compatible
;
3519 for (file
= file_chain
.head
;
3520 file
!= (lang_statement_union_type
*) NULL
;
3521 file
= file
->input_statement
.next
)
3523 input_bfd
= file
->input_statement
.the_bfd
;
3524 compatible
= bfd_arch_get_compatible (input_bfd
,
3526 if (compatible
== NULL
)
3528 if (command_line
.warn_mismatch
)
3529 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3530 bfd_printable_name (input_bfd
), input_bfd
,
3531 bfd_printable_name (output_bfd
));
3533 else if (bfd_count_sections (input_bfd
))
3535 /* If the input bfd has no contents, it shouldn't set the
3536 private data of the output bfd. */
3538 bfd_error_handler_type pfn
= NULL
;
3540 /* If we aren't supposed to warn about mismatched input
3541 files, temporarily set the BFD error handler to a
3542 function which will do nothing. We still want to call
3543 bfd_merge_private_bfd_data, since it may set up
3544 information which is needed in the output file. */
3545 if (! command_line
.warn_mismatch
)
3546 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3547 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3549 if (command_line
.warn_mismatch
)
3550 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3553 if (! command_line
.warn_mismatch
)
3554 bfd_set_error_handler (pfn
);
3559 /* Look through all the global common symbols and attach them to the
3560 correct section. The -sort-common command line switch may be used
3561 to roughly sort the entries by size. */
3566 if (link_info
.relocateable
3567 && ! command_line
.force_common_definition
)
3570 if (! config
.sort_common
)
3571 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3576 for (power
= 4; power
>= 0; power
--)
3577 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3582 /* Place one common symbol in the correct section. */
3585 lang_one_common (h
, info
)
3586 struct bfd_link_hash_entry
*h
;
3589 unsigned int power_of_two
;
3592 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3593 ldfile_output_machine
);
3595 if (h
->type
!= bfd_link_hash_common
)
3599 power_of_two
= h
->u
.c
.p
->alignment_power
;
3601 if (config
.sort_common
3602 && power_of_two
< (unsigned int) *(int *) info
)
3605 section
= h
->u
.c
.p
->section
;
3607 /* Increase the size of the section. */
3608 section
->_cooked_size
= ALIGN_N ((section
->_cooked_size
+ opb
- 1) / opb
,
3609 (bfd_size_type
) (1 << power_of_two
)) * opb
;
3611 /* Adjust the alignment if necessary. */
3612 if (power_of_two
> section
->alignment_power
)
3613 section
->alignment_power
= power_of_two
;
3615 /* Change the symbol from common to defined. */
3616 h
->type
= bfd_link_hash_defined
;
3617 h
->u
.def
.section
= section
;
3618 h
->u
.def
.value
= section
->_cooked_size
;
3620 /* Increase the size of the section. */
3621 section
->_cooked_size
+= size
;
3623 /* Make sure the section is allocated in memory, and make sure that
3624 it is no longer a common section. */
3625 section
->flags
|= SEC_ALLOC
;
3626 section
->flags
&= ~SEC_IS_COMMON
;
3628 if (config
.map_file
!= NULL
)
3630 static boolean header_printed
;
3635 if (! header_printed
)
3637 minfo (_("\nAllocating common symbols\n"));
3638 minfo (_("Common symbol size file\n\n"));
3639 header_printed
= true;
3642 name
= demangle (h
->root
.string
);
3644 len
= strlen (name
);
3659 if (size
<= 0xffffffff)
3660 sprintf (buf
, "%lx", (unsigned long) size
);
3662 sprintf_vma (buf
, size
);
3672 minfo ("%B\n", section
->owner
);
3678 /* Run through the input files and ensure that every input section has
3679 somewhere to go. If one is found without a destination then create
3680 an input request and place it into the statement tree. */
3683 lang_place_orphans ()
3685 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3689 for (s
= file
->the_bfd
->sections
;
3690 s
!= (asection
*) NULL
;
3693 if (s
->output_section
== (asection
*) NULL
)
3695 /* This section of the file is not attatched, root
3696 around for a sensible place for it to go. */
3698 if (file
->just_syms_flag
)
3700 /* We are only retrieving symbol values from this
3701 file. We want the symbols to act as though the
3702 values in the file are absolute. */
3703 s
->output_section
= bfd_abs_section_ptr
;
3704 s
->output_offset
= s
->vma
;
3706 else if (strcmp (s
->name
, "COMMON") == 0)
3708 /* This is a lonely common section which must have
3709 come from an archive. We attach to the section
3710 with the wildcard. */
3711 if (! link_info
.relocateable
3712 || command_line
.force_common_definition
)
3714 if (default_common_section
== NULL
)
3717 /* This message happens when using the
3718 svr3.ifile linker script, so I have
3720 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3722 default_common_section
=
3723 lang_output_section_statement_lookup (".bss");
3726 wild_doit (&default_common_section
->children
, s
,
3727 default_common_section
, file
);
3730 else if (ldemul_place_orphan (file
, s
))
3734 lang_output_section_statement_type
*os
=
3735 lang_output_section_statement_lookup (s
->name
);
3737 wild_doit (&os
->children
, s
, os
, file
);
3745 lang_set_flags (ptr
, flags
, invert
)
3746 lang_memory_region_type
*ptr
;
3750 flagword
*ptr_flags
;
3752 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3758 *ptr_flags
|= SEC_ALLOC
;
3762 *ptr_flags
|= SEC_READONLY
;
3766 *ptr_flags
|= SEC_DATA
;
3770 *ptr_flags
|= SEC_CODE
;
3775 *ptr_flags
|= SEC_LOAD
;
3779 einfo (_("%P%F: invalid syntax in flags\n"));
3786 /* Call a function on each input file. This function will be called
3787 on an archive, but not on the elements. */
3790 lang_for_each_input_file (func
)
3791 void (*func
) PARAMS ((lang_input_statement_type
*));
3793 lang_input_statement_type
*f
;
3795 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3797 f
= (lang_input_statement_type
*) f
->next_real_file
)
3801 /* Call a function on each file. The function will be called on all
3802 the elements of an archive which are included in the link, but will
3803 not be called on the archive file itself. */
3806 lang_for_each_file (func
)
3807 void (*func
) PARAMS ((lang_input_statement_type
*));
3809 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3820 lang_for_each_input_section (func
)
3821 void (*func
) PARAMS ((bfd
*ab
, asection
*as
));
3823 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3827 for (s
= f
->the_bfd
->sections
;
3828 s
!= (asection
*) NULL
;
3831 func (f
->the_bfd
, s
);
3839 ldlang_add_file (entry
)
3840 lang_input_statement_type
*entry
;
3844 lang_statement_append (&file_chain
,
3845 (lang_statement_union_type
*) entry
,
3848 /* The BFD linker needs to have a list of all input BFDs involved in
3850 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3851 ASSERT (entry
->the_bfd
!= output_bfd
);
3852 for (pp
= &link_info
.input_bfds
;
3853 *pp
!= (bfd
*) NULL
;
3854 pp
= &(*pp
)->link_next
)
3856 *pp
= entry
->the_bfd
;
3857 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3858 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3860 /* Look through the sections and check for any which should not be
3861 included in the link. We need to do this now, so that we can
3862 notice when the backend linker tries to report multiple
3863 definition errors for symbols which are in sections we aren't
3864 going to link. FIXME: It might be better to entirely ignore
3865 symbols which are defined in sections which are going to be
3866 discarded. This would require modifying the backend linker for
3867 each backend which might set the SEC_LINK_ONCE flag. If we do
3868 this, we should probably handle SEC_EXCLUDE in the same way. */
3870 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
3874 lang_add_output (name
, from_script
)
3878 /* Make -o on command line override OUTPUT in script. */
3879 if (had_output_filename
== false || !from_script
)
3881 output_filename
= name
;
3882 had_output_filename
= true;
3886 static lang_output_section_statement_type
*current_section
;
3898 for (l
= 0; l
< 32; l
++)
3900 if (i
>= (unsigned int) x
)
3908 lang_output_section_statement_type
*
3909 lang_enter_output_section_statement (output_section_statement_name
,
3910 address_exp
, sectype
, block_value
,
3911 align
, subalign
, ebase
)
3912 const char *output_section_statement_name
;
3913 etree_type
*address_exp
;
3914 enum section_type sectype
;
3915 bfd_vma block_value
;
3917 etree_type
*subalign
;
3920 lang_output_section_statement_type
*os
;
3924 lang_output_section_statement_lookup (output_section_statement_name
);
3926 /* Add this statement to tree. */
3928 add_statement (lang_output_section_statement_enum
,
3929 output_section_statement
);
3931 /* Make next things chain into subchain of this. */
3933 if (os
->addr_tree
== (etree_type
*) NULL
)
3935 os
->addr_tree
= address_exp
;
3937 os
->sectype
= sectype
;
3938 if (sectype
!= noload_section
)
3939 os
->flags
= SEC_NO_FLAGS
;
3941 os
->flags
= SEC_NEVER_LOAD
;
3942 os
->block_value
= block_value
? block_value
: 1;
3943 stat_ptr
= &os
->children
;
3945 os
->subsection_alignment
=
3946 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
3947 os
->section_alignment
=
3948 topower (exp_get_value_int (align
, -1, "section alignment", 0));
3950 os
->load_base
= ebase
;
3957 lang_output_statement_type
*new =
3958 new_stat (lang_output_statement
, stat_ptr
);
3960 new->name
= output_filename
;
3963 /* Reset the current counters in the regions. */
3966 reset_memory_regions ()
3968 lang_memory_region_type
*p
= lang_memory_region_list
;
3970 for (p
= lang_memory_region_list
;
3971 p
!= (lang_memory_region_type
*) NULL
;
3974 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
3975 p
->current
= p
->origin
;
3979 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3980 as needed. SECTION may be NULL, in which case it is a wild card. */
3983 gc_section_callback (ptr
, section
, file
, data
)
3984 lang_wild_statement_type
*ptr
;
3986 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
3987 PTR data ATTRIBUTE_UNUSED
;
3989 /* If the wild pattern was marked KEEP, the member sections
3990 should be as well. */
3991 if (ptr
->keep_sections
)
3992 section
->flags
|= SEC_KEEP
;
3995 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
3996 may be NULL, indicating that it is a wildcard. */
3999 lang_gc_wild (s
, section
, file
)
4000 lang_wild_statement_type
*s
;
4001 const char *section
;
4004 walk_wild (s
, section
, file
, gc_section_callback
, NULL
);
4007 /* Iterate over sections marking them against GC. */
4010 lang_gc_sections_1 (s
)
4011 lang_statement_union_type
*s
;
4013 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
4015 switch (s
->header
.type
)
4017 case lang_wild_statement_enum
:
4018 lang_gc_wild (&s
->wild_statement
,
4019 s
->wild_statement
.section_name
,
4020 s
->wild_statement
.filename
);
4022 case lang_constructors_statement_enum
:
4023 lang_gc_sections_1 (constructor_list
.head
);
4025 case lang_output_section_statement_enum
:
4026 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4028 case lang_group_statement_enum
:
4029 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4040 struct bfd_link_hash_entry
*h
;
4041 ldlang_undef_chain_list_type
*ulist
, fake_list_start
;
4043 /* Keep all sections so marked in the link script. */
4045 lang_gc_sections_1 (statement_list
.head
);
4047 /* Keep all sections containing symbols undefined on the command-line.
4048 Handle the entry symbol at the same time. */
4050 if (entry_symbol
!= NULL
)
4052 fake_list_start
.next
= ldlang_undef_chain_list_head
;
4053 fake_list_start
.name
= (char *) entry_symbol
;
4054 ulist
= &fake_list_start
;
4057 ulist
= ldlang_undef_chain_list_head
;
4059 for (; ulist
; ulist
= ulist
->next
)
4061 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4062 false, false, false);
4064 if (h
!= (struct bfd_link_hash_entry
*) NULL
4065 && (h
->type
== bfd_link_hash_defined
4066 || h
->type
== bfd_link_hash_defweak
)
4067 && ! bfd_is_abs_section (h
->u
.def
.section
))
4069 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4073 bfd_gc_sections (output_bfd
, &link_info
);
4079 lang_reasonable_defaults ();
4080 current_target
= default_target
;
4082 /* Open the output file. */
4083 lang_for_each_statement (ldlang_open_output
);
4085 ldemul_create_output_section_statements ();
4087 /* Add to the hash table all undefineds on the command line. */
4088 lang_place_undefineds ();
4090 already_linked_table_init ();
4092 /* Create a bfd for each input file. */
4093 current_target
= default_target
;
4094 open_input_bfds (statement_list
.head
, false);
4096 ldemul_after_open ();
4098 already_linked_table_free ();
4100 /* Make sure that we're not mixing architectures. We call this
4101 after all the input files have been opened, but before we do any
4102 other processing, so that any operations merge_private_bfd_data
4103 does on the output file will be known during the rest of the
4107 /* Handle .exports instead of a version script if we're told to do so. */
4108 if (command_line
.version_exports_section
)
4109 lang_do_version_exports_section ();
4111 /* Build all sets based on the information gathered from the input
4113 ldctor_build_sets ();
4115 /* Remove unreferenced sections if asked to. */
4116 if (command_line
.gc_sections
)
4117 lang_gc_sections ();
4119 /* Size up the common data. */
4122 /* Run through the contours of the script and attach input sections
4123 to the correct output sections. */
4124 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4125 (lang_output_section_statement_type
*) NULL
);
4127 /* Find any sections not attached explicitly and handle them. */
4128 lang_place_orphans ();
4130 ldemul_before_allocation ();
4132 /* We must record the program headers before we try to fix the
4133 section positions, since they will affect SIZEOF_HEADERS. */
4134 lang_record_phdrs ();
4136 /* Now run around and relax if we can. */
4137 if (command_line
.relax
)
4139 /* First time round is a trial run to get the 'worst case'
4140 addresses of the objects if there was no relaxing. */
4141 lang_size_sections (statement_list
.head
,
4143 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
4145 /* Keep relaxing until bfd_relax_section gives up. */
4148 reset_memory_regions ();
4150 relax_again
= false;
4152 /* Note: pe-dll.c does something like this also. If you find
4153 you need to change this code, you probably need to change
4154 pe-dll.c also. DJ */
4156 /* Do all the assignments with our current guesses as to
4158 lang_do_assignments (statement_list
.head
,
4160 (fill_type
) 0, (bfd_vma
) 0);
4162 /* Perform another relax pass - this time we know where the
4163 globals are, so can make better guess. */
4164 lang_size_sections (statement_list
.head
,
4166 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
4168 while (relax_again
);
4172 /* Size up the sections. */
4173 lang_size_sections (statement_list
.head
,
4175 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
4178 /* See if anything special should be done now we know how big
4180 ldemul_after_allocation ();
4182 /* Fix any .startof. or .sizeof. symbols. */
4183 lang_set_startof ();
4185 /* Do all the assignments, now that we know the final resting places
4186 of all the symbols. */
4188 lang_do_assignments (statement_list
.head
,
4190 (fill_type
) 0, (bfd_vma
) 0);
4192 /* Make sure that the section addresses make sense. */
4193 if (! link_info
.relocateable
4194 && command_line
.check_section_addresses
)
4195 lang_check_section_addresses ();
4203 /* EXPORTED TO YACC */
4206 lang_add_wild (section_name
, sections_sorted
, filename
, filenames_sorted
,
4207 keep_sections
, exclude_filename_list
)
4208 const char *const section_name
;
4209 boolean sections_sorted
;
4210 const char *const filename
;
4211 boolean filenames_sorted
;
4212 boolean keep_sections
;
4213 struct name_list
*exclude_filename_list
;
4215 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
4218 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
4220 placed_commons
= true;
4222 if (filename
!= NULL
&& ! wildcardp (filename
))
4224 lang_has_input_file
= true;
4226 new->section_name
= section_name
;
4227 new->sections_sorted
= sections_sorted
;
4228 new->filename
= filename
;
4229 new->filenames_sorted
= filenames_sorted
;
4230 new->keep_sections
= keep_sections
;
4231 new->exclude_filename_list
= exclude_filename_list
;
4232 lang_list_init (&new->children
);
4236 lang_section_start (name
, address
)
4238 etree_type
*address
;
4240 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
4242 ad
->section_name
= name
;
4243 ad
->address
= address
;
4246 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4247 because of a -e argument on the command line, or zero if this is
4248 called by ENTRY in a linker script. Command line arguments take
4252 lang_add_entry (name
, cmdline
)
4256 if (entry_symbol
== NULL
4258 || ! entry_from_cmdline
)
4260 entry_symbol
= name
;
4261 entry_from_cmdline
= cmdline
;
4266 lang_add_target (name
)
4269 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4285 map_option_f
= true;
4296 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4303 lang_add_data (type
, exp
)
4305 union etree_union
*exp
;
4308 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4316 /* Create a new reloc statement. RELOC is the BFD relocation type to
4317 generate. HOWTO is the corresponding howto structure (we could
4318 look this up, but the caller has already done so). SECTION is the
4319 section to generate a reloc against, or NAME is the name of the
4320 symbol to generate a reloc against. Exactly one of SECTION and
4321 NAME must be NULL. ADDEND is an expression for the addend. */
4324 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4325 bfd_reloc_code_real_type reloc
;
4326 reloc_howto_type
*howto
;
4329 union etree_union
*addend
;
4331 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4335 p
->section
= section
;
4337 p
->addend_exp
= addend
;
4339 p
->addend_value
= 0;
4340 p
->output_section
= NULL
;
4344 lang_assignment_statement_type
*
4345 lang_add_assignment (exp
)
4348 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4356 lang_add_attribute (attribute
)
4357 enum statement_enum attribute
;
4359 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4366 if (startup_file
!= (char *) NULL
)
4368 einfo (_("%P%Fmultiple STARTUP files\n"));
4370 first_file
->filename
= name
;
4371 first_file
->local_sym_name
= name
;
4372 first_file
->real
= true;
4374 startup_file
= name
;
4381 lang_float_flag
= maybe
;
4385 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4387 const char *memspec
;
4388 struct lang_output_section_phdr_list
*phdrs
;
4389 const char *lma_memspec
;
4391 current_section
->fill
= fill
;
4392 current_section
->region
= lang_memory_region_lookup (memspec
);
4393 if (strcmp (lma_memspec
, "*default*") != 0)
4395 current_section
->lma_region
= lang_memory_region_lookup (lma_memspec
);
4396 /* If no runtime region has been given, but the load region has
4397 been, use the load region. */
4398 if (strcmp (memspec
, "*default*") == 0)
4399 current_section
->region
= lang_memory_region_lookup (lma_memspec
);
4401 current_section
->phdrs
= phdrs
;
4402 stat_ptr
= &statement_list
;
4405 /* Create an absolute symbol with the given name with the value of the
4406 address of first byte of the section named.
4408 If the symbol already exists, then do nothing. */
4411 lang_abs_symbol_at_beginning_of (secname
, name
)
4412 const char *secname
;
4415 struct bfd_link_hash_entry
*h
;
4417 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4418 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4419 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4421 if (h
->type
== bfd_link_hash_new
4422 || h
->type
== bfd_link_hash_undefined
)
4426 h
->type
= bfd_link_hash_defined
;
4428 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4429 if (sec
== (asection
*) NULL
)
4432 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4434 h
->u
.def
.section
= bfd_abs_section_ptr
;
4438 /* Create an absolute symbol with the given name with the value of the
4439 address of the first byte after the end of the section named.
4441 If the symbol already exists, then do nothing. */
4444 lang_abs_symbol_at_end_of (secname
, name
)
4445 const char *secname
;
4448 struct bfd_link_hash_entry
*h
;
4450 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4451 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4452 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4454 if (h
->type
== bfd_link_hash_new
4455 || h
->type
== bfd_link_hash_undefined
)
4459 h
->type
= bfd_link_hash_defined
;
4461 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4462 if (sec
== (asection
*) NULL
)
4465 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4466 + bfd_section_size (output_bfd
, sec
) /
4467 bfd_octets_per_byte (output_bfd
));
4469 h
->u
.def
.section
= bfd_abs_section_ptr
;
4474 lang_statement_append (list
, element
, field
)
4475 lang_statement_list_type
*list
;
4476 lang_statement_union_type
*element
;
4477 lang_statement_union_type
**field
;
4479 *(list
->tail
) = element
;
4483 /* Set the output format type. -oformat overrides scripts. */
4486 lang_add_output_format (format
, big
, little
, from_script
)
4492 if (output_target
== NULL
|| !from_script
)
4494 if (command_line
.endian
== ENDIAN_BIG
4497 else if (command_line
.endian
== ENDIAN_LITTLE
4501 output_target
= format
;
4505 /* Enter a group. This creates a new lang_group_statement, and sets
4506 stat_ptr to build new statements within the group. */
4511 lang_group_statement_type
*g
;
4513 g
= new_stat (lang_group_statement
, stat_ptr
);
4514 lang_list_init (&g
->children
);
4515 stat_ptr
= &g
->children
;
4518 /* Leave a group. This just resets stat_ptr to start writing to the
4519 regular list of statements again. Note that this will not work if
4520 groups can occur inside anything else which can adjust stat_ptr,
4521 but currently they can't. */
4526 stat_ptr
= &statement_list
;
4529 /* Add a new program header. This is called for each entry in a PHDRS
4530 command in a linker script. */
4533 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4541 struct lang_phdr
*n
, **pp
;
4543 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4546 n
->type
= exp_get_value_int (type
, 0, "program header type",
4547 lang_final_phase_enum
);
4548 n
->filehdr
= filehdr
;
4553 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4558 /* Record the program header information in the output BFD. FIXME: We
4559 should not be calling an ELF specific function here. */
4562 lang_record_phdrs ()
4566 struct lang_output_section_phdr_list
*last
;
4567 struct lang_phdr
*l
;
4568 lang_statement_union_type
*u
;
4571 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4573 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4580 for (u
= lang_output_section_statement
.head
;
4582 u
= u
->output_section_statement
.next
)
4584 lang_output_section_statement_type
*os
;
4585 struct lang_output_section_phdr_list
*pl
;
4587 os
= &u
->output_section_statement
;
4594 if (os
->sectype
== noload_section
4595 || os
->bfd_section
== NULL
4596 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4601 if (os
->bfd_section
== NULL
)
4604 for (; pl
!= NULL
; pl
= pl
->next
)
4606 if (strcmp (pl
->name
, l
->name
) == 0)
4611 secs
= ((asection
**)
4612 xrealloc (secs
, alc
* sizeof (asection
*)));
4614 secs
[c
] = os
->bfd_section
;
4621 if (l
->flags
== NULL
)
4624 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4625 lang_final_phase_enum
);
4630 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4631 lang_final_phase_enum
);
4633 if (! bfd_record_phdr (output_bfd
, l
->type
,
4634 l
->flags
== NULL
? false : true,
4636 l
->at
== NULL
? false : true,
4637 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4638 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4643 /* Make sure all the phdr assignments succeeded. */
4644 for (u
= lang_output_section_statement
.head
;
4646 u
= u
->output_section_statement
.next
)
4648 struct lang_output_section_phdr_list
*pl
;
4650 if (u
->output_section_statement
.bfd_section
== NULL
)
4653 for (pl
= u
->output_section_statement
.phdrs
;
4656 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4657 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4658 u
->output_section_statement
.name
, pl
->name
);
4662 /* Record a list of sections which may not be cross referenced. */
4665 lang_add_nocrossref (l
)
4666 struct lang_nocrossref
*l
;
4668 struct lang_nocrossrefs
*n
;
4670 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4671 n
->next
= nocrossref_list
;
4673 nocrossref_list
= n
;
4675 /* Set notice_all so that we get informed about all symbols. */
4676 link_info
.notice_all
= true;
4679 /* Overlay handling. We handle overlays with some static variables. */
4681 /* The overlay virtual address. */
4682 static etree_type
*overlay_vma
;
4684 /* The overlay load address. */
4685 static etree_type
*overlay_lma
;
4687 /* Whether nocrossrefs is set for this overlay. */
4688 static int overlay_nocrossrefs
;
4690 /* An expression for the maximum section size seen so far. */
4691 static etree_type
*overlay_max
;
4693 /* A list of all the sections in this overlay. */
4695 struct overlay_list
{
4696 struct overlay_list
*next
;
4697 lang_output_section_statement_type
*os
;
4700 static struct overlay_list
*overlay_list
;
4702 /* Start handling an overlay. */
4705 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
4706 etree_type
*vma_expr
;
4707 etree_type
*lma_expr
;
4710 /* The grammar should prevent nested overlays from occurring. */
4711 ASSERT (overlay_vma
== NULL
4712 && overlay_lma
== NULL
4713 && overlay_list
== NULL
4714 && overlay_max
== NULL
);
4716 overlay_vma
= vma_expr
;
4717 overlay_lma
= lma_expr
;
4718 overlay_nocrossrefs
= nocrossrefs
;
4721 /* Start a section in an overlay. We handle this by calling
4722 lang_enter_output_section_statement with the correct VMA and LMA. */
4725 lang_enter_overlay_section (name
)
4728 struct overlay_list
*n
;
4731 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4732 0, 0, 0, overlay_lma
);
4734 /* If this is the first section, then base the VMA and LMA of future
4735 sections on this one. This will work correctly even if `.' is
4736 used in the addresses. */
4737 if (overlay_list
== NULL
)
4739 overlay_vma
= exp_nameop (ADDR
, name
);
4740 overlay_lma
= exp_nameop (LOADADDR
, name
);
4743 /* Remember the section. */
4744 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4745 n
->os
= current_section
;
4746 n
->next
= overlay_list
;
4749 size
= exp_nameop (SIZEOF
, name
);
4751 /* Adjust the LMA for the next section. */
4752 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
4754 /* Arrange to work out the maximum section end address. */
4755 if (overlay_max
== NULL
)
4758 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4761 /* Finish a section in an overlay. There isn't any special to do
4765 lang_leave_overlay_section (fill
, phdrs
)
4767 struct lang_output_section_phdr_list
*phdrs
;
4774 name
= current_section
->name
;
4776 lang_leave_output_section_statement (fill
, "*default*",
4777 phdrs
, "*default*");
4779 /* Define the magic symbols. */
4781 clean
= xmalloc (strlen (name
) + 1);
4783 for (s1
= name
; *s1
!= '\0'; s1
++)
4784 if (isalnum ((unsigned char) *s1
) || *s1
== '_')
4788 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4789 sprintf (buf
, "__load_start_%s", clean
);
4790 lang_add_assignment (exp_assop ('=', buf
,
4791 exp_nameop (LOADADDR
, name
)));
4793 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4794 sprintf (buf
, "__load_stop_%s", clean
);
4795 lang_add_assignment (exp_assop ('=', buf
,
4797 exp_nameop (LOADADDR
, name
),
4798 exp_nameop (SIZEOF
, name
))));
4803 /* Finish an overlay. If there are any overlay wide settings, this
4804 looks through all the sections in the overlay and sets them. */
4807 lang_leave_overlay (fill
, memspec
, phdrs
, lma_memspec
)
4809 const char *memspec
;
4810 struct lang_output_section_phdr_list
*phdrs
;
4811 const char *lma_memspec
;
4813 lang_memory_region_type
*region
;
4814 lang_memory_region_type
*lma_region
;
4815 struct overlay_list
*l
;
4816 struct lang_nocrossref
*nocrossref
;
4818 if (memspec
== NULL
)
4821 region
= lang_memory_region_lookup (memspec
);
4823 if (lma_memspec
== NULL
)
4826 lma_region
= lang_memory_region_lookup (lma_memspec
);
4833 struct overlay_list
*next
;
4835 if (fill
!= 0 && l
->os
->fill
== 0)
4837 if (region
!= NULL
&& l
->os
->region
== NULL
)
4838 l
->os
->region
= region
;
4839 /* We only set lma_region for the first overlay section, as
4840 subsequent overlay sections will have load_base set relative
4841 to the first section. Also, don't set lma_region if
4842 load_base is specified. FIXME: There should really be a test
4843 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4844 rather than letting LDADDR simply override LMA_REGION. */
4845 if (lma_region
!= NULL
&& l
->os
->lma_region
== NULL
4846 && l
->next
== NULL
&& l
->os
->load_base
== NULL
)
4847 l
->os
->lma_region
= lma_region
;
4848 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4849 l
->os
->phdrs
= phdrs
;
4851 if (overlay_nocrossrefs
)
4853 struct lang_nocrossref
*nc
;
4855 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
4856 nc
->name
= l
->os
->name
;
4857 nc
->next
= nocrossref
;
4866 if (nocrossref
!= NULL
)
4867 lang_add_nocrossref (nocrossref
);
4869 /* Update . for the end of the overlay. */
4870 lang_add_assignment (exp_assop ('=', ".",
4871 exp_binop ('+', overlay_vma
, overlay_max
)));
4875 overlay_nocrossrefs
= 0;
4876 overlay_list
= NULL
;
4880 /* Version handling. This is only useful for ELF. */
4882 /* This global variable holds the version tree that we build. */
4884 struct bfd_elf_version_tree
*lang_elf_version_info
;
4887 lang_vers_match_lang_c (expr
, sym
)
4888 struct bfd_elf_version_expr
*expr
;
4891 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4893 return fnmatch (expr
->pattern
, sym
, 0) == 0;
4897 lang_vers_match_lang_cplusplus (expr
, sym
)
4898 struct bfd_elf_version_expr
*expr
;
4904 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4907 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
4910 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4911 Should we early out false in this case? */
4912 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4916 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4924 lang_vers_match_lang_java (expr
, sym
)
4925 struct bfd_elf_version_expr
*expr
;
4931 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4934 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
4937 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4938 Should we early out false in this case? */
4939 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4943 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4950 /* This is called for each variable name or match expression. */
4952 struct bfd_elf_version_expr
*
4953 lang_new_vers_regex (orig
, new, lang
)
4954 struct bfd_elf_version_expr
*orig
;
4958 struct bfd_elf_version_expr
*ret
;
4960 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
4964 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
4965 ret
->match
= lang_vers_match_lang_c
;
4966 else if (strcasecmp (lang
, "C++") == 0)
4967 ret
->match
= lang_vers_match_lang_cplusplus
;
4968 else if (strcasecmp (lang
, "Java") == 0)
4969 ret
->match
= lang_vers_match_lang_java
;
4972 einfo (_("%X%P: unknown language `%s' in version information\n"),
4974 ret
->match
= lang_vers_match_lang_c
;
4980 /* This is called for each set of variable names and match
4983 struct bfd_elf_version_tree
*
4984 lang_new_vers_node (globals
, locals
)
4985 struct bfd_elf_version_expr
*globals
;
4986 struct bfd_elf_version_expr
*locals
;
4988 struct bfd_elf_version_tree
*ret
;
4990 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
4994 ret
->globals
= globals
;
4995 ret
->locals
= locals
;
4997 ret
->name_indx
= (unsigned int) -1;
5002 /* This static variable keeps track of version indices. */
5004 static int version_index
;
5006 /* This is called when we know the name and dependencies of the
5010 lang_register_vers_node (name
, version
, deps
)
5012 struct bfd_elf_version_tree
*version
;
5013 struct bfd_elf_version_deps
*deps
;
5015 struct bfd_elf_version_tree
*t
, **pp
;
5016 struct bfd_elf_version_expr
*e1
;
5018 /* Make sure this node has a unique name. */
5019 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5020 if (strcmp (t
->name
, name
) == 0)
5021 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5023 /* Check the global and local match names, and make sure there
5024 aren't any duplicates. */
5026 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5028 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5030 struct bfd_elf_version_expr
*e2
;
5032 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5033 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5034 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5039 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
5041 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5043 struct bfd_elf_version_expr
*e2
;
5045 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
5046 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5047 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5052 version
->deps
= deps
;
5053 version
->name
= name
;
5055 version
->vernum
= version_index
;
5057 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5062 /* This is called when we see a version dependency. */
5064 struct bfd_elf_version_deps
*
5065 lang_add_vers_depend (list
, name
)
5066 struct bfd_elf_version_deps
*list
;
5069 struct bfd_elf_version_deps
*ret
;
5070 struct bfd_elf_version_tree
*t
;
5072 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5075 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5077 if (strcmp (t
->name
, name
) == 0)
5079 ret
->version_needed
= t
;
5084 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5090 lang_do_version_exports_section ()
5092 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5094 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5096 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5103 len
= bfd_section_size (is
->the_bfd
, sec
);
5104 contents
= xmalloc (len
);
5105 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5106 einfo (_("%X%P: unable to read .exports section contents"), sec
);
5109 while (p
< contents
+ len
)
5111 greg
= lang_new_vers_regex (greg
, p
, NULL
);
5112 p
= strchr (p
, '\0') + 1;
5115 /* Do not free the contents, as we used them creating the regex. */
5117 /* Do not include this section in the link. */
5118 bfd_set_section_flags (is
->the_bfd
, sec
,
5119 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5122 lreg
= lang_new_vers_regex (NULL
, "*", NULL
);
5123 lang_register_vers_node (command_line
.version_exports_section
,
5124 lang_new_vers_node (greg
, lreg
), NULL
);
5128 lang_add_unique (name
)
5131 struct unique_sections
*ent
;
5133 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5134 if (strcmp (ent
->name
, name
) == 0)
5137 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
5138 ent
->name
= xstrdup (name
);
5139 ent
->next
= unique_section_list
;
5140 unique_section_list
= ent
;