1 /* Linker command language support.
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 99, 2000
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
*));
50 static struct obstack stat_obstack
;
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
54 static const char *startup_file
;
55 static lang_statement_list_type input_file_chain
;
56 static boolean placed_commons
= false;
57 static lang_output_section_statement_type
*default_common_section
;
58 static boolean map_option_f
;
59 static bfd_vma print_dot
;
60 static lang_input_statement_type
*first_file
;
61 static const char *current_target
;
62 static const char *output_target
;
63 static lang_statement_list_type statement_list
;
64 static struct lang_phdr
*lang_phdr_list
;
66 static void lang_for_each_statement_worker
67 PARAMS ((void (*) (lang_statement_union_type
*),
68 lang_statement_union_type
*));
69 static lang_input_statement_type
*new_afile
70 PARAMS ((const char *, lang_input_file_enum_type
, const char *, boolean
));
71 static lang_memory_region_type
*lang_memory_default
PARAMS ((asection
*));
72 static void lang_map_flags
PARAMS ((flagword
));
73 static void init_os
PARAMS ((lang_output_section_statement_type
*));
74 static void exp_init_os
PARAMS ((etree_type
*));
75 static void section_already_linked
PARAMS ((bfd
*, asection
*, PTR
));
76 static struct bfd_hash_entry
*already_linked_newfunc
77 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
78 static void already_linked_table_init
PARAMS ((void));
79 static void already_linked_table_free
PARAMS ((void));
80 static boolean wildcardp
PARAMS ((const char *));
81 static lang_statement_union_type
*wild_sort
82 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
84 static void output_section_callback
85 PARAMS ((lang_wild_statement_type
*, asection
*,
86 lang_input_statement_type
*, PTR
));
87 static lang_input_statement_type
*lookup_name
PARAMS ((const char *));
88 static void load_symbols
89 PARAMS ((lang_input_statement_type
*, lang_statement_list_type
*));
91 PARAMS ((lang_wild_statement_type
*, const char *, const char *,
92 const char *, lang_output_section_statement_type
*));
93 static bfd
*open_output
PARAMS ((const char *));
94 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*));
95 static void open_input_bfds
PARAMS ((lang_statement_union_type
*, boolean
));
96 static void lang_reasonable_defaults
PARAMS ((void));
97 static void lang_place_undefineds
PARAMS ((void));
98 static void map_input_to_output_sections
99 PARAMS ((lang_statement_union_type
*, const char *,
100 lang_output_section_statement_type
*));
101 static void print_output_section_statement
102 PARAMS ((lang_output_section_statement_type
*));
103 static void print_assignment
104 PARAMS ((lang_assignment_statement_type
*,
105 lang_output_section_statement_type
*));
106 static void print_input_statement
PARAMS ((lang_input_statement_type
*));
107 static boolean print_one_symbol
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
108 static void print_input_section
PARAMS ((lang_input_section_type
*));
109 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*));
110 static void print_data_statement
PARAMS ((lang_data_statement_type
*));
111 static void print_address_statement
PARAMS ((lang_address_statement_type
*));
112 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*));
113 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*));
114 static void print_wild_statement
115 PARAMS ((lang_wild_statement_type
*, lang_output_section_statement_type
*));
116 static void print_group
117 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
118 static void print_statement
119 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
120 static void print_statement_list
121 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
122 static void print_statements
PARAMS ((void));
123 static bfd_vma insert_pad
124 PARAMS ((lang_statement_union_type
**this_ptr
, fill_type fill
,
125 unsigned int power
, asection
*output_section_statement
,
127 static bfd_vma size_input_section
128 PARAMS ((lang_statement_union_type
**this_ptr
,
129 lang_output_section_statement_type
*output_section_statement
,
130 fill_type fill
, bfd_vma dot
, boolean relax
));
131 static void lang_finish
PARAMS ((void));
132 static void ignore_bfd_errors
PARAMS ((const char *, ...));
133 static void lang_check
PARAMS ((void));
134 static void lang_common
PARAMS ((void));
135 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
136 static void lang_place_orphans
PARAMS ((void));
137 static int topower
PARAMS ((int));
138 static void lang_set_startof
PARAMS ((void));
139 static void reset_memory_regions
PARAMS ((void));
140 static void gc_section_callback
141 PARAMS ((lang_wild_statement_type
*, asection
*,
142 lang_input_statement_type
*, PTR
));
143 static void lang_record_phdrs
PARAMS ((void));
144 static void lang_gc_wild
145 PARAMS ((lang_wild_statement_type
*, const char *, const char *));
146 static void lang_gc_sections_1
PARAMS ((lang_statement_union_type
*));
147 static void lang_gc_sections
PARAMS ((void));
148 static int lang_vers_match_lang_c
149 PARAMS ((struct bfd_elf_version_expr
*, const char *));
150 static int lang_vers_match_lang_cplusplus
151 PARAMS ((struct bfd_elf_version_expr
*, const char *));
152 static int lang_vers_match_lang_java
153 PARAMS ((struct bfd_elf_version_expr
*, const char *));
154 static void lang_do_version_exports_section
PARAMS ((void));
155 static void lang_check_section_addresses
PARAMS ((void));
156 static void os_region_check
157 PARAMS ((lang_output_section_statement_type
*,
158 struct memory_region_struct
*, etree_type
*, bfd_vma
));
160 typedef void (*callback_t
) PARAMS ((lang_wild_statement_type
*,
161 asection
*, lang_input_statement_type
*,
163 static void walk_wild
164 PARAMS ((lang_wild_statement_type
*, const char *, const char *,
166 static void walk_wild_section
167 PARAMS ((lang_wild_statement_type
*, const char *,
168 lang_input_statement_type
*, callback_t
, PTR
));
169 static void walk_wild_file
170 PARAMS ((lang_wild_statement_type
*, const char *,
171 lang_input_statement_type
*, callback_t
, PTR
));
173 static int get_target
PARAMS ((const bfd_target
*, PTR
));
174 static void stricpy
PARAMS ((char *, char *));
175 static void strcut
PARAMS ((char *, char *));
176 static int name_compare
PARAMS ((char *, char *));
177 static int closest_target_match
PARAMS ((const bfd_target
*, PTR
));
178 static char * get_first_input_target
PARAMS ((void));
181 lang_output_section_statement_type
*abs_output_section
;
182 lang_statement_list_type lang_output_section_statement
;
183 lang_statement_list_type
*stat_ptr
= &statement_list
;
184 lang_statement_list_type file_chain
= { NULL
, NULL
};
185 const char *entry_symbol
= NULL
;
186 boolean entry_from_cmdline
;
187 boolean lang_has_input_file
= false;
188 boolean had_output_filename
= false;
189 boolean lang_float_flag
= false;
190 boolean delete_output_file_on_failure
= false;
191 struct lang_nocrossrefs
*nocrossref_list
;
193 etree_type
*base
; /* Relocation base - or null */
196 #if defined(__STDC__) || defined(ALMOST_STDC)
197 #define cat(a,b) a##b
199 #define cat(a,b) a/**/b
202 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
204 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
206 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
208 #define SECTION_NAME_MAP_LENGTH (16)
214 return obstack_alloc (&stat_obstack
, size
);
217 /*----------------------------------------------------------------------
218 Generic traversal routines for finding matching sections.
222 walk_wild_section (ptr
, section
, file
, callback
, data
)
223 lang_wild_statement_type
*ptr
;
225 lang_input_statement_type
*file
;
229 /* Don't process sections from files which were excluded. */
230 if (ptr
->exclude_filename_list
!= NULL
)
232 struct name_list
*list_tmp
;
233 for (list_tmp
= ptr
->exclude_filename_list
; list_tmp
; list_tmp
= list_tmp
->next
)
237 if (wildcardp (list_tmp
->name
))
238 match
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0 ? true : false;
240 match
= strcmp (list_tmp
->name
, file
->filename
) == 0 ? true : false;
247 if (file
->just_syms_flag
== false)
249 register asection
*s
;
255 wildcard
= wildcardp (section
);
257 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
267 name
= bfd_get_section_name (file
->the_bfd
, s
);
269 match
= fnmatch (section
, name
, 0) == 0 ? true : false;
271 match
= strcmp (section
, name
) == 0 ? true : false;
275 (*callback
) (ptr
, s
, file
, data
);
280 /* Handle a wild statement for a single file F. */
283 walk_wild_file (s
, section
, f
, callback
, data
)
284 lang_wild_statement_type
*s
;
286 lang_input_statement_type
*f
;
290 if (f
->the_bfd
== NULL
291 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
292 walk_wild_section (s
, section
, f
, callback
, data
);
297 /* This is an archive file. We must map each member of the
298 archive separately. */
299 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
300 while (member
!= NULL
)
302 /* When lookup_name is called, it will call the add_symbols
303 entry point for the archive. For each element of the
304 archive which is included, BFD will call ldlang_add_file,
305 which will set the usrdata field of the member to the
306 lang_input_statement. */
307 if (member
->usrdata
!= NULL
)
309 walk_wild_section (s
, section
,
310 (lang_input_statement_type
*) member
->usrdata
,
314 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
320 walk_wild (s
, section
, file
, callback
, data
)
321 lang_wild_statement_type
*s
;
327 if (file
== (char *) NULL
)
329 /* Perform the iteration over all files in the list. */
330 LANG_FOR_EACH_INPUT_STATEMENT (f
)
332 walk_wild_file (s
, section
, f
, callback
, data
);
335 else if (wildcardp (file
))
337 LANG_FOR_EACH_INPUT_STATEMENT (f
)
339 if (fnmatch (file
, f
->filename
, FNM_FILE_NAME
) == 0)
340 walk_wild_file (s
, section
, f
, callback
, data
);
345 lang_input_statement_type
*f
;
347 /* Perform the iteration over a single file. */
348 f
= lookup_name (file
);
349 walk_wild_file (s
, section
, f
, callback
, data
);
353 /*----------------------------------------------------------------------
354 lang_for_each_statement walks the parse tree and calls the provided
355 function for each node
359 lang_for_each_statement_worker (func
, s
)
360 void (*func
) PARAMS ((lang_statement_union_type
*));
361 lang_statement_union_type
*s
;
363 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
367 switch (s
->header
.type
)
369 case lang_constructors_statement_enum
:
370 lang_for_each_statement_worker (func
, constructor_list
.head
);
372 case lang_output_section_statement_enum
:
373 lang_for_each_statement_worker
375 s
->output_section_statement
.children
.head
);
377 case lang_wild_statement_enum
:
378 lang_for_each_statement_worker
380 s
->wild_statement
.children
.head
);
382 case lang_group_statement_enum
:
383 lang_for_each_statement_worker (func
,
384 s
->group_statement
.children
.head
);
386 case lang_data_statement_enum
:
387 case lang_reloc_statement_enum
:
388 case lang_object_symbols_statement_enum
:
389 case lang_output_statement_enum
:
390 case lang_target_statement_enum
:
391 case lang_input_section_enum
:
392 case lang_input_statement_enum
:
393 case lang_assignment_statement_enum
:
394 case lang_padding_statement_enum
:
395 case lang_address_statement_enum
:
396 case lang_fill_statement_enum
:
406 lang_for_each_statement (func
)
407 void (*func
) PARAMS ((lang_statement_union_type
*));
409 lang_for_each_statement_worker (func
,
410 statement_list
.head
);
413 /*----------------------------------------------------------------------*/
415 lang_list_init (list
)
416 lang_statement_list_type
*list
;
418 list
->head
= (lang_statement_union_type
*) NULL
;
419 list
->tail
= &list
->head
;
422 /*----------------------------------------------------------------------
424 build a new statement node for the parse tree
429 lang_statement_union_type
*
430 new_statement (type
, size
, list
)
431 enum statement_enum type
;
433 lang_statement_list_type
* list
;
435 lang_statement_union_type
*new = (lang_statement_union_type
*)
438 new->header
.type
= type
;
439 new->header
.next
= (lang_statement_union_type
*) NULL
;
440 lang_statement_append (list
, new, &new->header
.next
);
445 Build a new input file node for the language. There are several ways
446 in which we treat an input file, eg, we only look at symbols, or
447 prefix it with a -l etc.
449 We can be supplied with requests for input files more than once;
450 they may, for example be split over serveral lines like foo.o(.text)
451 foo.o(.data) etc, so when asked for a file we check that we havn't
452 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 */
556 obstack_begin (&stat_obstack
, 1000);
558 stat_ptr
= &statement_list
;
560 lang_list_init (stat_ptr
);
562 lang_list_init (&input_file_chain
);
563 lang_list_init (&lang_output_section_statement
);
564 lang_list_init (&file_chain
);
565 first_file
= lang_add_input_file ((char *) NULL
,
566 lang_input_file_is_marker_enum
,
568 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
570 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
574 /*----------------------------------------------------------------------
575 A region is an area of memory declared with the
576 MEMORY { name:org=exp, len=exp ... }
579 We maintain a list of all the regions here
581 If no regions are specified in the script, then the default is used
582 which is created when looked up to be the entire data space
585 static lang_memory_region_type
*lang_memory_region_list
;
586 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
588 lang_memory_region_type
*
589 lang_memory_region_lookup (name
)
590 const char *const name
;
592 lang_memory_region_type
*p
;
594 for (p
= lang_memory_region_list
;
595 p
!= (lang_memory_region_type
*) NULL
;
598 if (strcmp (p
->name
, name
) == 0)
605 /* This code used to always use the first region in the list as the
606 default region. I changed it to instead use a region
607 encompassing all of memory as the default region. This permits
608 NOLOAD sections to work reasonably without requiring a region.
609 People should specify what region they mean, if they really want
611 if (strcmp (name
, "*default*") == 0)
613 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
615 return lang_memory_region_list
;
621 lang_memory_region_type
*new =
622 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
624 new->name
= buystring (name
);
625 new->next
= (lang_memory_region_type
*) NULL
;
627 *lang_memory_region_list_tail
= new;
628 lang_memory_region_list_tail
= &new->next
;
632 new->length
= ~(bfd_size_type
)0;
634 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
;
918 section_already_linked (abfd
, sec
, data
)
923 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
926 struct already_linked
*l
;
927 struct already_linked_hash_entry
*already_linked_list
;
929 /* If we are only reading symbols from this object, then we want to
930 discard all sections. */
931 if (entry
->just_syms_flag
)
933 sec
->output_section
= bfd_abs_section_ptr
;
934 sec
->output_offset
= sec
->vma
;
938 flags
= bfd_get_section_flags (abfd
, sec
);
940 if ((flags
& SEC_LINK_ONCE
) == 0)
943 /* FIXME: When doing a relocateable link, we may have trouble
944 copying relocations in other sections that refer to local symbols
945 in the section being discarded. Those relocations will have to
946 be converted somehow; as of this writing I'm not sure that any of
947 the backends handle that correctly.
949 It is tempting to instead not discard link once sections when
950 doing a relocateable link (technically, they should be discarded
951 whenever we are building constructors). However, that fails,
952 because the linker winds up combining all the link once sections
953 into a single large link once section, which defeats the purpose
954 of having link once sections in the first place.
956 Also, not merging link once sections in a relocateable link
957 causes trouble for MIPS ELF, which relies in link once semantics
958 to handle the .reginfo section correctly. */
960 name
= bfd_get_section_name (abfd
, sec
);
962 already_linked_list
=
963 ((struct already_linked_hash_entry
*)
964 bfd_hash_lookup (&already_linked_table
, name
, true, false));
966 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
968 if (sec
->comdat
== NULL
969 || l
->sec
->comdat
== NULL
970 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
972 /* The section has already been linked. See if we should
974 switch (flags
& SEC_LINK_DUPLICATES
)
979 case SEC_LINK_DUPLICATES_DISCARD
:
982 case SEC_LINK_DUPLICATES_ONE_ONLY
:
983 if (sec
->comdat
== NULL
)
984 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
987 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
988 abfd
, name
, sec
->comdat
->name
);
991 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
992 /* FIXME: We should really dig out the contents of both
993 sections and memcmp them. The COFF/PE spec says that
994 the Microsoft linker does not implement this
995 correctly, so I'm not going to bother doing it
998 case SEC_LINK_DUPLICATES_SAME_SIZE
:
999 if (bfd_section_size (abfd
, sec
)
1000 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1001 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1006 /* Set the output_section field so that wild_doit does not
1007 create a lang_input_section structure for this section.
1008 Since there might be a symbol in the section being
1009 discarded, we must retain a pointer to the section which
1010 we are really going to use. */
1011 sec
->output_section
= bfd_abs_section_ptr
;
1012 if (sec
->comdat
!= NULL
)
1013 sec
->comdat
->sec
= l
->sec
;
1019 /* This is the first section with this name. Record it. Allocate
1020 the memory from the same obstack as the hash table is kept in. */
1022 l
= ((struct already_linked
*)
1023 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1026 l
->next
= already_linked_list
->entry
;
1027 already_linked_list
->entry
= l
;
1030 /* Support routines for the hash table used by section_already_linked,
1031 initialize the table, fill in an entry and remove the table. */
1033 static struct bfd_hash_entry
*
1034 already_linked_newfunc (entry
, table
, string
)
1035 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1036 struct bfd_hash_table
*table
;
1037 const char *string ATTRIBUTE_UNUSED
;
1039 struct already_linked_hash_entry
*ret
=
1040 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1044 return (struct bfd_hash_entry
*) ret
;
1048 already_linked_table_init ()
1050 if (! bfd_hash_table_init_n (&already_linked_table
,
1051 already_linked_newfunc
,
1053 einfo (_("%P%F: Failed to create hash table\n"));
1057 already_linked_table_free ()
1059 bfd_hash_table_free (&already_linked_table
);
1062 /* The wild routines.
1064 These expand statements like *(.text) and foo.o to a list of
1065 explicit actions, like foo.o(.text), bar.o(.text) and
1066 foo.o(.text, .data). */
1068 /* Return true if the PATTERN argument is a wildcard pattern.
1069 Although backslashes are treated specially if a pattern contains
1070 wildcards, we do not consider the mere presence of a backslash to
1071 be enough to cause the the pattern to be treated as a wildcard.
1072 That lets us handle DOS filenames more naturally. */
1076 const char *pattern
;
1080 for (s
= pattern
; *s
!= '\0'; ++s
)
1088 /* Add SECTION to the output section OUTPUT. Do this by creating a
1089 lang_input_section statement which is placed at PTR. FILE is the
1090 input file which holds SECTION. */
1093 wild_doit (ptr
, section
, output
, file
)
1094 lang_statement_list_type
*ptr
;
1096 lang_output_section_statement_type
*output
;
1097 lang_input_statement_type
*file
;
1102 flags
= bfd_get_section_flags (section
->owner
, section
);
1106 /* If we are doing a final link, discard sections marked with
1108 if (! link_info
.relocateable
1109 && (flags
& SEC_EXCLUDE
) != 0)
1112 /* Discard input sections which are assigned to a section named
1113 DISCARD_SECTION_NAME. */
1114 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1117 /* Discard debugging sections if we are stripping debugging
1119 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1120 && (flags
& SEC_DEBUGGING
) != 0)
1125 if (section
->output_section
== NULL
)
1127 /* This prevents future calls from assigning this section. */
1128 section
->output_section
= bfd_abs_section_ptr
;
1133 if (section
->output_section
== NULL
)
1136 lang_input_section_type
*new;
1139 if (output
->bfd_section
== NULL
)
1147 /* Add a section reference to the list */
1148 new = new_stat (lang_input_section
, ptr
);
1150 new->section
= section
;
1152 section
->output_section
= output
->bfd_section
;
1154 flags
= section
->flags
;
1156 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1157 to an output section, because we want to be able to include a
1158 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1159 section (I don't know why we want to do this, but we do).
1160 build_link_order in ldwrite.c handles this case by turning
1161 the embedded SEC_NEVER_LOAD section into a fill. */
1163 flags
&= ~ SEC_NEVER_LOAD
;
1165 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1166 already been processed. One reason to do this is that on pe
1167 format targets, .text$foo sections go into .text and it's odd
1168 to see .text with SEC_LINK_ONCE set. */
1170 if (! link_info
.relocateable
)
1171 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1173 /* If this is not the first input section, and the SEC_READONLY
1174 flag is not currently set, then don't set it just because the
1175 input section has it set. */
1177 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1178 flags
&= ~ SEC_READONLY
;
1180 section
->output_section
->flags
|= flags
;
1182 /* If SEC_READONLY is not set in the input section, then clear
1183 it from the output section. */
1184 if ((section
->flags
& SEC_READONLY
) == 0)
1185 section
->output_section
->flags
&= ~SEC_READONLY
;
1187 switch (output
->sectype
)
1189 case normal_section
:
1194 case overlay_section
:
1195 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1197 case noload_section
:
1198 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1199 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1203 /* Copy over SEC_SMALL_DATA. */
1204 if (section
->flags
& SEC_SMALL_DATA
)
1205 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1207 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1208 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1210 /* If supplied an aligment, then force it. */
1211 if (output
->section_alignment
!= -1)
1212 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1214 if (section
->flags
& SEC_BLOCK
)
1216 section
->output_section
->flags
|= SEC_BLOCK
;
1217 /* FIXME: This value should really be obtained from the bfd... */
1218 output
->block_value
= 128;
1223 /* Handle wildcard sorting. This returns the lang_input_section which
1224 should follow the one we are going to create for SECTION and FILE,
1225 based on the sorting requirements of WILD. It returns NULL if the
1226 new section should just go at the end of the current list. */
1228 static lang_statement_union_type
*
1229 wild_sort (wild
, file
, section
)
1230 lang_wild_statement_type
*wild
;
1231 lang_input_statement_type
*file
;
1234 const char *section_name
;
1235 lang_statement_union_type
*l
;
1237 if (! wild
->filenames_sorted
&& ! wild
->sections_sorted
)
1240 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1241 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->next
)
1243 lang_input_section_type
*ls
;
1245 if (l
->header
.type
!= lang_input_section_enum
)
1247 ls
= &l
->input_section
;
1249 /* Sorting by filename takes precedence over sorting by section
1252 if (wild
->filenames_sorted
)
1254 const char *fn
, *ln
;
1258 /* The PE support for the .idata section as generated by
1259 dlltool assumes that files will be sorted by the name of
1260 the archive and then the name of the file within the
1263 if (file
->the_bfd
!= NULL
1264 && bfd_my_archive (file
->the_bfd
) != NULL
)
1266 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1271 fn
= file
->filename
;
1275 if (ls
->ifile
->the_bfd
!= NULL
1276 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1278 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1283 ln
= ls
->ifile
->filename
;
1287 i
= strcmp (fn
, ln
);
1296 fn
= file
->filename
;
1298 ln
= ls
->ifile
->filename
;
1300 i
= strcmp (fn
, ln
);
1308 /* Here either the files are not sorted by name, or we are
1309 looking at the sections for this file. */
1311 if (wild
->sections_sorted
)
1313 if (strcmp (section_name
,
1314 bfd_get_section_name (ls
->ifile
->the_bfd
,
1324 /* Expand a wild statement for a particular FILE. SECTION may be
1325 NULL, in which case it is a wild card. */
1328 output_section_callback (ptr
, section
, file
, output
)
1329 lang_wild_statement_type
*ptr
;
1331 lang_input_statement_type
*file
;
1334 lang_statement_union_type
*before
;
1336 /* If the wild pattern was marked KEEP, the member sections
1337 should be as well. */
1338 if (ptr
->keep_sections
)
1339 section
->flags
|= SEC_KEEP
;
1341 before
= wild_sort (ptr
, file
, section
);
1343 /* Here BEFORE points to the lang_input_section which
1344 should follow the one we are about to add. If BEFORE
1345 is NULL, then the section should just go at the end
1346 of the current list. */
1349 wild_doit (&ptr
->children
, section
,
1350 (lang_output_section_statement_type
*) output
,
1354 lang_statement_list_type list
;
1355 lang_statement_union_type
**pp
;
1357 lang_list_init (&list
);
1358 wild_doit (&list
, section
,
1359 (lang_output_section_statement_type
*) output
,
1362 /* If we are discarding the section, LIST.HEAD will
1364 if (list
.head
!= NULL
)
1366 ASSERT (list
.head
->next
== NULL
);
1368 for (pp
= &ptr
->children
.head
;
1371 ASSERT (*pp
!= NULL
);
1373 list
.head
->next
= *pp
;
1379 /* This is passed a file name which must have been seen already and
1380 added to the statement tree. We will see if it has been opened
1381 already and had its symbols read. If not then we'll read it. */
1383 static lang_input_statement_type
*
1387 lang_input_statement_type
*search
;
1389 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1390 search
!= (lang_input_statement_type
*) NULL
;
1391 search
= (lang_input_statement_type
*) search
->next_real_file
)
1393 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1395 if (search
->filename
!= (char *) NULL
1396 && name
!= (char *) NULL
1397 && strcmp (search
->filename
, name
) == 0)
1401 if (search
== (lang_input_statement_type
*) NULL
)
1402 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1405 /* If we have already added this file, or this file is not real
1406 (FIXME: can that ever actually happen?) or the name is NULL
1407 (FIXME: can that ever actually happen?) don't add this file. */
1410 || search
->filename
== (const char *) NULL
)
1413 load_symbols (search
, (lang_statement_list_type
*) NULL
);
1418 /* Get the symbols for an input file. */
1421 load_symbols (entry
, place
)
1422 lang_input_statement_type
*entry
;
1423 lang_statement_list_type
*place
;
1430 ldfile_open_file (entry
);
1432 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1433 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1436 lang_statement_list_type
*hold
;
1438 err
= bfd_get_error ();
1439 if (err
== bfd_error_file_ambiguously_recognized
)
1443 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1444 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1445 for (p
= matching
; *p
!= NULL
; p
++)
1449 else if (err
!= bfd_error_file_not_recognized
1451 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1453 bfd_close (entry
->the_bfd
);
1454 entry
->the_bfd
= NULL
;
1456 /* See if the emulation has some special knowledge. */
1458 if (ldemul_unrecognized_file (entry
))
1461 /* Try to interpret the file as a linker script. */
1463 ldfile_open_command_file (entry
->filename
);
1468 ldfile_assumed_script
= true;
1469 parser_input
= input_script
;
1471 ldfile_assumed_script
= false;
1478 if (ldemul_recognized_file (entry
))
1481 /* We don't call ldlang_add_file for an archive. Instead, the
1482 add_symbols entry point will call ldlang_add_file, via the
1483 add_archive_element callback, for each element of the archive
1485 switch (bfd_get_format (entry
->the_bfd
))
1491 ldlang_add_file (entry
);
1492 if (trace_files
|| trace_file_tries
)
1493 info_msg ("%I\n", entry
);
1497 if (entry
->whole_archive
)
1499 bfd
*member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1501 while (member
!= NULL
)
1503 if (! bfd_check_format (member
, bfd_object
))
1504 einfo (_("%F%B: object %B in archive is not object\n"),
1505 entry
->the_bfd
, member
);
1506 if (! ((*link_info
.callbacks
->add_archive_element
)
1507 (&link_info
, member
, "--whole-archive")))
1509 if (! bfd_link_add_symbols (member
, &link_info
))
1510 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1511 member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1515 entry
->loaded
= true;
1521 if (! bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1522 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1524 entry
->loaded
= true;
1529 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1530 indicating that it is a wildcard. Separate lang_input_section
1531 statements are created for each part of the expansion; they are
1532 added after the wild statement S. OUTPUT is the output section. */
1535 wild (s
, section
, file
, target
, output
)
1536 lang_wild_statement_type
*s
;
1537 const char *section
;
1539 const char *target ATTRIBUTE_UNUSED
;
1540 lang_output_section_statement_type
*output
;
1542 walk_wild (s
, section
, file
, output_section_callback
, (PTR
) output
);
1544 if (section
!= (char *) NULL
1545 && strcmp (section
, "COMMON") == 0
1546 && default_common_section
== NULL
)
1548 /* Remember the section that common is going to in case we later
1549 get something which doesn't know where to put it. */
1550 default_common_section
= output
;
1554 /* Return true iff target is the sought target. */
1556 get_target (target
, data
)
1557 const bfd_target
* target
;
1560 const char * sought
= (const char *) data
;
1562 return strcmp (target
->name
, sought
) == 0;
1565 /* Like strcpy() but convert to lower case as well. */
1573 while ((c
= * src
++) != 0)
1575 if (isupper ((unsigned char) c
))
1584 /* Remove the first occurance of needle (if any) in haystack
1587 strcut (haystack
, needle
)
1591 haystack
= strstr (haystack
, needle
);
1597 for (src
= haystack
+ strlen (needle
); * src
;)
1598 * haystack
++ = * src
++;
1604 /* Compare two target format name strings.
1605 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. */
1651 closest_target_match (target
, data
)
1652 const bfd_target
* target
;
1655 const bfd_target
* original
= (const bfd_target
*) data
;
1657 if (command_line
.endian
== ENDIAN_BIG
&& target
->byteorder
!= BFD_ENDIAN_BIG
)
1660 if (command_line
.endian
== ENDIAN_LITTLE
&& target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1663 /* Must be the same flavour. */
1664 if (target
->flavour
!= original
->flavour
)
1667 /* If we have not found a potential winner yet, then record this one. */
1674 /* Oh dear, we now have two potential candidates for a successful match.
1675 Compare their names and choose the better one. */
1676 if (name_compare (target
->name
, original
->name
) > name_compare (winner
->name
, original
->name
))
1679 /* Keep on searching until wqe have checked them all. */
1683 /* Return the BFD target format of the first input file. */
1685 get_first_input_target ()
1687 char * target
= NULL
;
1689 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1691 if (s
->header
.type
== lang_input_statement_enum
1694 ldfile_open_file (s
);
1696 if (s
->the_bfd
!= NULL
1697 && bfd_check_format (s
->the_bfd
, bfd_object
))
1699 target
= bfd_get_target (s
->the_bfd
);
1710 /* Open the output file. */
1718 /* Has the user told us which output format to use ? */
1719 if (output_target
== (char *) NULL
)
1721 /* No - has the current target been set to something other than the default ? */
1722 if (current_target
!= default_target
)
1723 output_target
= current_target
;
1725 /* No - can we determine the format of the first input file ? */
1728 output_target
= get_first_input_target ();
1730 /* Failed - use the default output target. */
1731 if (output_target
== NULL
)
1732 output_target
= default_target
;
1736 /* Has the user requested a particular endianness on the command line ? */
1737 if (command_line
.endian
!= ENDIAN_UNSET
)
1739 const bfd_target
* target
;
1740 enum bfd_endian desired_endian
;
1742 /* Get the chosen target. */
1743 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1745 /* If the target is not supported, we cannot do anything. */
1748 if (command_line
.endian
== ENDIAN_BIG
)
1749 desired_endian
= BFD_ENDIAN_BIG
;
1751 desired_endian
= BFD_ENDIAN_LITTLE
;
1753 /* See if the target has the wrong endianness. This should
1754 not happen if the linker script has provided big and
1755 little endian alternatives, but some scrips don't do
1757 if (target
->byteorder
!= desired_endian
)
1759 /* If it does, then see if the target provides
1760 an alternative with the correct endianness. */
1761 if (target
->alternative_target
!= NULL
1762 && (target
->alternative_target
->byteorder
== desired_endian
))
1763 output_target
= target
->alternative_target
->name
;
1766 /* Try to find a target as similar as possible to
1767 the default target, but which has the desired
1768 endian characteristic. */
1769 (void) bfd_search_for_target (closest_target_match
, (PTR
) target
);
1771 /* Oh dear - we could not find any targets that
1772 satisfy our requirements. */
1774 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1776 output_target
= winner
->name
;
1782 output
= bfd_openw (name
, output_target
);
1784 if (output
== (bfd
*) NULL
)
1786 if (bfd_get_error () == bfd_error_invalid_target
)
1787 einfo (_("%P%F: target %s not found\n"), output_target
);
1789 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1792 delete_output_file_on_failure
= true;
1794 /* output->flags |= D_PAGED;*/
1796 if (! bfd_set_format (output
, bfd_object
))
1797 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1798 if (! bfd_set_arch_mach (output
,
1799 ldfile_output_architecture
,
1800 ldfile_output_machine
))
1801 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1803 link_info
.hash
= bfd_link_hash_table_create (output
);
1804 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1805 einfo (_("%P%F: can not create link hash table: %E\n"));
1807 bfd_set_gp_size (output
, g_switch_value
);
1812 ldlang_open_output (statement
)
1813 lang_statement_union_type
* statement
;
1815 switch (statement
->header
.type
)
1817 case lang_output_statement_enum
:
1818 ASSERT (output_bfd
== (bfd
*) NULL
);
1819 output_bfd
= open_output (statement
->output_statement
.name
);
1820 ldemul_set_output_arch ();
1821 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1822 output_bfd
->flags
|= D_PAGED
;
1824 output_bfd
->flags
&= ~D_PAGED
;
1825 if (config
.text_read_only
)
1826 output_bfd
->flags
|= WP_TEXT
;
1828 output_bfd
->flags
&= ~WP_TEXT
;
1829 if (link_info
.traditional_format
)
1830 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1832 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1835 case lang_target_statement_enum
:
1836 current_target
= statement
->target_statement
.target
;
1843 /* Open all the input files. */
1846 open_input_bfds (s
, force
)
1847 lang_statement_union_type
*s
;
1850 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1852 switch (s
->header
.type
)
1854 case lang_constructors_statement_enum
:
1855 open_input_bfds (constructor_list
.head
, force
);
1857 case lang_output_section_statement_enum
:
1858 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1860 case lang_wild_statement_enum
:
1861 /* Maybe we should load the file's symbols */
1862 if (s
->wild_statement
.filename
1863 && ! wildcardp (s
->wild_statement
.filename
))
1864 (void) lookup_name (s
->wild_statement
.filename
);
1865 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1867 case lang_group_statement_enum
:
1869 struct bfd_link_hash_entry
*undefs
;
1871 /* We must continually search the entries in the group
1872 until no new symbols are added to the list of undefined
1877 undefs
= link_info
.hash
->undefs_tail
;
1878 open_input_bfds (s
->group_statement
.children
.head
, true);
1880 while (undefs
!= link_info
.hash
->undefs_tail
);
1883 case lang_target_statement_enum
:
1884 current_target
= s
->target_statement
.target
;
1886 case lang_input_statement_enum
:
1887 if (s
->input_statement
.real
)
1889 lang_statement_list_type add
;
1891 s
->input_statement
.target
= current_target
;
1893 /* If we are being called from within a group, and this
1894 is an archive which has already been searched, then
1895 force it to be researched unless the whole archive
1896 has been loaded already. */
1898 && !s
->input_statement
.whole_archive
1899 && s
->input_statement
.loaded
1900 && bfd_check_format (s
->input_statement
.the_bfd
,
1902 s
->input_statement
.loaded
= false;
1904 lang_list_init (&add
);
1906 load_symbols (&s
->input_statement
, &add
);
1908 if (add
.head
!= NULL
)
1910 *add
.tail
= s
->next
;
1921 /* If there are [COMMONS] statements, put a wild one into the bss section */
1924 lang_reasonable_defaults ()
1927 lang_output_section_statement_lookup (".text");
1928 lang_output_section_statement_lookup (".data");
1930 default_common_section
=
1931 lang_output_section_statement_lookup (".bss");
1934 if (placed_commons
== false)
1936 lang_wild_statement_type
*new =
1937 new_stat (lang_wild_statement
,
1938 &default_common_section
->children
);
1940 new->section_name
= "COMMON";
1941 new->filename
= (char *) NULL
;
1942 lang_list_init (&new->children
);
1949 Add the supplied name to the symbol table as an undefined reference.
1950 Remove items from the chain as we open input bfds
1952 typedef struct ldlang_undef_chain_list
1954 struct ldlang_undef_chain_list
*next
;
1956 } ldlang_undef_chain_list_type
;
1958 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
1961 ldlang_add_undef (name
)
1962 const char *const name
;
1964 ldlang_undef_chain_list_type
*new =
1965 ((ldlang_undef_chain_list_type
*)
1966 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
1968 new->next
= ldlang_undef_chain_list_head
;
1969 ldlang_undef_chain_list_head
= new;
1971 new->name
= buystring (name
);
1974 /* Run through the list of undefineds created above and place them
1975 into the linker hash table as undefined symbols belonging to the
1979 lang_place_undefineds ()
1981 ldlang_undef_chain_list_type
*ptr
;
1983 for (ptr
= ldlang_undef_chain_list_head
;
1984 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
1987 struct bfd_link_hash_entry
*h
;
1989 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
1990 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1991 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1992 if (h
->type
== bfd_link_hash_new
)
1994 h
->type
= bfd_link_hash_undefined
;
1995 h
->u
.undef
.abfd
= NULL
;
1996 bfd_link_add_undef (link_info
.hash
, h
);
2001 /* Open input files and attatch to output sections */
2003 map_input_to_output_sections (s
, target
, output_section_statement
)
2004 lang_statement_union_type
* s
;
2006 lang_output_section_statement_type
* output_section_statement
;
2008 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2010 switch (s
->header
.type
)
2014 case lang_wild_statement_enum
:
2015 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
2016 s
->wild_statement
.filename
, target
,
2017 output_section_statement
);
2020 case lang_constructors_statement_enum
:
2021 map_input_to_output_sections (constructor_list
.head
,
2023 output_section_statement
);
2025 case lang_output_section_statement_enum
:
2026 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2028 &s
->output_section_statement
);
2030 case lang_output_statement_enum
:
2032 case lang_target_statement_enum
:
2033 target
= s
->target_statement
.target
;
2035 case lang_group_statement_enum
:
2036 map_input_to_output_sections (s
->group_statement
.children
.head
,
2038 output_section_statement
);
2040 case lang_fill_statement_enum
:
2041 case lang_input_section_enum
:
2042 case lang_object_symbols_statement_enum
:
2043 case lang_data_statement_enum
:
2044 case lang_reloc_statement_enum
:
2045 case lang_padding_statement_enum
:
2046 case lang_input_statement_enum
:
2047 if (output_section_statement
!= NULL
2048 && output_section_statement
->bfd_section
== NULL
)
2049 init_os (output_section_statement
);
2051 case lang_assignment_statement_enum
:
2052 if (output_section_statement
!= NULL
2053 && output_section_statement
->bfd_section
== NULL
)
2054 init_os (output_section_statement
);
2056 /* Make sure that any sections mentioned in the assignment
2058 exp_init_os (s
->assignment_statement
.exp
);
2060 case lang_afile_asection_pair_statement_enum
:
2063 case lang_address_statement_enum
:
2064 /* Mark the specified section with the supplied address */
2066 lang_output_section_statement_type
*os
=
2067 lang_output_section_statement_lookup
2068 (s
->address_statement
.section_name
);
2070 if (os
->bfd_section
== NULL
)
2072 os
->addr_tree
= s
->address_statement
.address
;
2080 print_output_section_statement (output_section_statement
)
2081 lang_output_section_statement_type
* output_section_statement
;
2083 asection
*section
= output_section_statement
->bfd_section
;
2086 if (output_section_statement
!= abs_output_section
)
2088 minfo ("\n%s", output_section_statement
->name
);
2090 if (section
!= NULL
)
2092 print_dot
= section
->vma
;
2094 len
= strlen (output_section_statement
->name
);
2095 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2100 while (len
< SECTION_NAME_MAP_LENGTH
)
2106 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2108 if (output_section_statement
->load_base
!= NULL
)
2112 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2113 "load base", lang_final_phase_enum
);
2114 minfo (_(" load address 0x%V"), addr
);
2121 print_statement_list (output_section_statement
->children
.head
,
2122 output_section_statement
);
2126 print_assignment (assignment
, output_section
)
2127 lang_assignment_statement_type
* assignment
;
2128 lang_output_section_statement_type
* output_section
;
2131 etree_value_type result
;
2133 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2136 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2137 lang_final_phase_enum
, print_dot
, &print_dot
);
2139 minfo ("0x%V", result
.value
+ result
.section
->bfd_section
->vma
);
2150 exp_print_tree (assignment
->exp
);
2156 print_input_statement (statm
)
2157 lang_input_statement_type
* statm
;
2159 if (statm
->filename
!= (char *) NULL
)
2161 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2165 /* Print all symbols defined in a particular section. This is called
2166 via bfd_link_hash_traverse. */
2169 print_one_symbol (hash_entry
, ptr
)
2170 struct bfd_link_hash_entry
*hash_entry
;
2173 asection
*sec
= (asection
*) ptr
;
2175 if ((hash_entry
->type
== bfd_link_hash_defined
2176 || hash_entry
->type
== bfd_link_hash_defweak
)
2177 && sec
== hash_entry
->u
.def
.section
)
2181 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2184 (hash_entry
->u
.def
.value
2185 + hash_entry
->u
.def
.section
->output_offset
2186 + hash_entry
->u
.def
.section
->output_section
->vma
));
2188 minfo (" %T\n", hash_entry
->root
.string
);
2194 /* Print information about an input section to the map file. */
2197 print_input_section (in
)
2198 lang_input_section_type
* in
;
2200 asection
*i
= in
->section
;
2201 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2202 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2203 ldfile_output_machine
);
2208 minfo ("%s", i
->name
);
2210 if (i
->output_section
!= NULL
)
2214 len
= 1 + strlen (i
->name
);
2215 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2220 while (len
< SECTION_NAME_MAP_LENGTH
)
2226 minfo ("0x%V %W %B\n",
2227 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2230 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2232 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2244 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2247 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2249 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2255 print_fill_statement (fill
)
2256 lang_fill_statement_type
* fill
;
2258 fprintf (config
.map_file
, " FILL mask 0x%x\n", fill
->fill
);
2262 print_data_statement (data
)
2263 lang_data_statement_type
* data
;
2269 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2270 ldfile_output_machine
);
2272 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2275 addr
= data
->output_vma
;
2276 if (data
->output_section
!= NULL
)
2277 addr
+= data
->output_section
->vma
;
2305 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2307 if (data
->exp
->type
.node_class
!= etree_value
)
2310 exp_print_tree (data
->exp
);
2315 print_dot
= addr
+ size
/ opb
;
2319 /* Print an address statement. These are generated by options like
2323 print_address_statement (address
)
2324 lang_address_statement_type
*address
;
2326 minfo (_("Address of section %s set to "), address
->section_name
);
2327 exp_print_tree (address
->address
);
2331 /* Print a reloc statement. */
2334 print_reloc_statement (reloc
)
2335 lang_reloc_statement_type
*reloc
;
2340 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2341 ldfile_output_machine
);
2343 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2346 addr
= reloc
->output_vma
;
2347 if (reloc
->output_section
!= NULL
)
2348 addr
+= reloc
->output_section
->vma
;
2350 size
= bfd_get_reloc_size (reloc
->howto
);
2352 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2354 if (reloc
->name
!= NULL
)
2355 minfo ("%s+", reloc
->name
);
2357 minfo ("%s+", reloc
->section
->name
);
2359 exp_print_tree (reloc
->addend_exp
);
2363 print_dot
= addr
+ size
/ opb
;
2367 print_padding_statement (s
)
2368 lang_padding_statement_type
*s
;
2372 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2373 ldfile_output_machine
);
2377 len
= sizeof " *fill*" - 1;
2378 while (len
< SECTION_NAME_MAP_LENGTH
)
2384 addr
= s
->output_offset
;
2385 if (s
->output_section
!= NULL
)
2386 addr
+= s
->output_section
->vma
;
2387 minfo ("0x%V %W", addr
, s
->size
);
2390 minfo (" %u", s
->fill
);
2394 print_dot
= addr
+ s
->size
/ opb
;
2398 print_wild_statement (w
, os
)
2399 lang_wild_statement_type
* w
;
2400 lang_output_section_statement_type
* os
;
2404 if (w
->filenames_sorted
)
2406 if (w
->exclude_filename_list
!= NULL
)
2409 minfo ("EXCLUDE_FILE ( %s", w
->exclude_filename_list
->name
);
2410 for (tmp
=w
->exclude_filename_list
->next
; tmp
; tmp
= tmp
->next
)
2411 minfo (", %s", tmp
->name
);
2414 if (w
->filename
!= NULL
)
2415 minfo ("%s", w
->filename
);
2418 if (w
->filenames_sorted
)
2422 if (w
->sections_sorted
)
2424 if (w
->section_name
!= NULL
)
2425 minfo ("%s", w
->section_name
);
2428 if (w
->sections_sorted
)
2434 print_statement_list (w
->children
.head
, os
);
2437 /* Print a group statement. */
2441 lang_group_statement_type
*s
;
2442 lang_output_section_statement_type
*os
;
2444 fprintf (config
.map_file
, "START GROUP\n");
2445 print_statement_list (s
->children
.head
, os
);
2446 fprintf (config
.map_file
, "END GROUP\n");
2449 /* Print the list of statements in S.
2450 This can be called for any statement type. */
2453 print_statement_list (s
, os
)
2454 lang_statement_union_type
*s
;
2455 lang_output_section_statement_type
*os
;
2459 print_statement (s
, os
);
2464 /* Print the first statement in statement list S.
2465 This can be called for any statement type. */
2468 print_statement (s
, os
)
2469 lang_statement_union_type
*s
;
2470 lang_output_section_statement_type
*os
;
2472 switch (s
->header
.type
)
2475 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2478 case lang_constructors_statement_enum
:
2479 if (constructor_list
.head
!= NULL
)
2481 if (constructors_sorted
)
2482 minfo (" SORT (CONSTRUCTORS)\n");
2484 minfo (" CONSTRUCTORS\n");
2485 print_statement_list (constructor_list
.head
, os
);
2488 case lang_wild_statement_enum
:
2489 print_wild_statement (&s
->wild_statement
, os
);
2491 case lang_address_statement_enum
:
2492 print_address_statement (&s
->address_statement
);
2494 case lang_object_symbols_statement_enum
:
2495 minfo (" CREATE_OBJECT_SYMBOLS\n");
2497 case lang_fill_statement_enum
:
2498 print_fill_statement (&s
->fill_statement
);
2500 case lang_data_statement_enum
:
2501 print_data_statement (&s
->data_statement
);
2503 case lang_reloc_statement_enum
:
2504 print_reloc_statement (&s
->reloc_statement
);
2506 case lang_input_section_enum
:
2507 print_input_section (&s
->input_section
);
2509 case lang_padding_statement_enum
:
2510 print_padding_statement (&s
->padding_statement
);
2512 case lang_output_section_statement_enum
:
2513 print_output_section_statement (&s
->output_section_statement
);
2515 case lang_assignment_statement_enum
:
2516 print_assignment (&s
->assignment_statement
, os
);
2518 case lang_target_statement_enum
:
2519 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2521 case lang_output_statement_enum
:
2522 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2523 if (output_target
!= NULL
)
2524 minfo (" %s", output_target
);
2527 case lang_input_statement_enum
:
2528 print_input_statement (&s
->input_statement
);
2530 case lang_group_statement_enum
:
2531 print_group (&s
->group_statement
, os
);
2533 case lang_afile_asection_pair_statement_enum
:
2542 print_statement_list (statement_list
.head
, abs_output_section
);
2545 /* Print the first N statements in statement list S to STDERR.
2546 If N == 0, nothing is printed.
2547 If N < 0, the entire list is printed.
2548 Intended to be called from GDB. */
2551 dprint_statement (s
, n
)
2552 lang_statement_union_type
* s
;
2555 FILE *map_save
= config
.map_file
;
2557 config
.map_file
= stderr
;
2560 print_statement_list (s
, abs_output_section
);
2563 while (s
&& --n
>= 0)
2565 print_statement (s
, abs_output_section
);
2570 config
.map_file
= map_save
;
2574 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
2575 lang_statement_union_type
** this_ptr
;
2578 asection
* output_section_statement
;
2581 /* Align this section first to the
2582 input sections requirement, then
2583 to the output section's requirement.
2584 If this alignment is > than any seen before,
2585 then record it too. Perform the alignment by
2586 inserting a magic 'padding' statement.
2589 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2590 ldfile_output_machine
);
2591 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
2593 if (alignment_needed
!= 0)
2595 lang_statement_union_type
*new =
2596 ((lang_statement_union_type
*)
2597 stat_alloc (sizeof (lang_padding_statement_type
)));
2599 /* Link into existing chain */
2600 new->header
.next
= *this_ptr
;
2602 new->header
.type
= lang_padding_statement_enum
;
2603 new->padding_statement
.output_section
= output_section_statement
;
2604 new->padding_statement
.output_offset
=
2605 dot
- output_section_statement
->vma
;
2606 new->padding_statement
.fill
= fill
;
2607 new->padding_statement
.size
= alignment_needed
* opb
;
2611 /* Remember the most restrictive alignment */
2612 if (power
> output_section_statement
->alignment_power
)
2614 output_section_statement
->alignment_power
= power
;
2616 output_section_statement
->_raw_size
+= alignment_needed
* opb
;
2618 return dot
+ alignment_needed
;
2621 /* Work out how much this section will move the dot point */
2623 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
2624 lang_statement_union_type
** this_ptr
;
2625 lang_output_section_statement_type
* output_section_statement
;
2628 boolean relax ATTRIBUTE_UNUSED
;
2630 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2631 asection
*i
= is
->section
;
2632 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2633 ldfile_output_machine
);
2635 if (is
->ifile
->just_syms_flag
== false)
2637 if (output_section_statement
->subsection_alignment
!= -1)
2638 i
->alignment_power
=
2639 output_section_statement
->subsection_alignment
;
2641 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
2642 output_section_statement
->bfd_section
, dot
);
2644 /* Remember where in the output section this input section goes */
2646 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
2648 /* Mark how big the output section must be to contain this now
2650 if (i
->_cooked_size
!= 0)
2651 dot
+= i
->_cooked_size
/ opb
;
2653 dot
+= i
->_raw_size
/ opb
;
2654 output_section_statement
->bfd_section
->_raw_size
=
2655 (dot
- output_section_statement
->bfd_section
->vma
) * opb
;
2659 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2665 #define IGNORE_SECTION(bfd, s) \
2666 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) != (SEC_ALLOC | SEC_LOAD)) \
2667 || bfd_section_size (bfd, s) == 0)
2669 /* Check to see if any allocated sections overlap with other allocated
2670 sections. This can happen when the linker script specifically specifies
2671 the output section addresses of the two sections. */
2673 lang_check_section_addresses ()
2676 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2678 /* Scan all sections in the output list. */
2679 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2683 /* Ignore sections which are not loaded or which have no contents. */
2684 if (IGNORE_SECTION (output_bfd
, s
))
2687 /* Once we reach section 's' stop our seach. This prevents two
2688 warning messages from being produced, one for 'section A overlaps
2689 section B' and one for 'section B overlaps section A'. */
2690 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2697 /* Only consider loadable sections with real contents. */
2698 if (IGNORE_SECTION (output_bfd
, os
))
2701 /* We must check the sections' LMA addresses not their
2702 VMA addresses because overlay sections can have
2703 overlapping VMAs but they must have distinct LMAs. */
2704 s_start
= bfd_section_lma (output_bfd
, s
);
2705 os_start
= bfd_section_lma (output_bfd
, os
);
2706 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2707 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2709 /* Look for an overlap. */
2710 if ((s_end
< os_start
) || (s_start
> os_end
))
2714 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2715 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2717 /* Once we have found one overlap for this section,
2718 stop looking for others. */
2724 /* This variable indicates whether bfd_relax_section should be called
2727 static boolean relax_again
;
2729 /* Make sure the new address is within the region. We explicitly permit the
2730 current address to be at the exact end of the region when the address is
2731 non-zero, in case the region is at the end of addressable memory and the
2732 calculation wraps around. */
2735 os_region_check (os
, region
, tree
, base
)
2736 lang_output_section_statement_type
*os
;
2737 struct memory_region_struct
*region
;
2741 if ((region
->current
< region
->origin
2742 || (region
->current
- region
->origin
> region
->length
))
2743 && ((region
->current
!= region
->origin
+ region
->length
)
2746 if (tree
!= (etree_type
*) NULL
)
2748 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2750 os
->bfd_section
->owner
,
2751 os
->bfd_section
->name
,
2756 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2758 os
->bfd_section
->owner
,
2759 os
->bfd_section
->name
);
2761 /* Reset the region pointer. */
2762 region
->current
= region
->origin
;
2766 /* Set the sizes for all the output sections. */
2769 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2770 lang_statement_union_type
* s
;
2771 lang_output_section_statement_type
* output_section_statement
;
2772 lang_statement_union_type
** prev
;
2777 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2778 ldfile_output_machine
);
2780 /* Size up the sections from their constituent parts. */
2781 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2783 switch (s
->header
.type
)
2785 case lang_output_section_statement_enum
:
2788 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
2790 if (os
->bfd_section
== NULL
)
2791 /* This section was never actually created. */
2794 /* If this is a COFF shared library section, use the size and
2795 address from the input section. FIXME: This is COFF
2796 specific; it would be cleaner if there were some other way
2797 to do this, but nothing simple comes to mind. */
2798 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2802 if (os
->children
.head
== NULL
2803 || os
->children
.head
->next
!= NULL
2804 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2805 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2808 input
= os
->children
.head
->input_section
.section
;
2809 bfd_set_section_vma (os
->bfd_section
->owner
,
2811 bfd_section_vma (input
->owner
, input
));
2812 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2816 if (bfd_is_abs_section (os
->bfd_section
))
2818 /* No matter what happens, an abs section starts at zero. */
2819 ASSERT (os
->bfd_section
->vma
== 0);
2823 if (os
->addr_tree
== (etree_type
*) NULL
)
2825 /* No address specified for this section, get one
2826 from the region specification. */
2827 if (os
->region
== (lang_memory_region_type
*) NULL
2828 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2829 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2830 && os
->region
->name
[0] == '*'
2831 && strcmp (os
->region
->name
, "*default*") == 0))
2833 os
->region
= lang_memory_default (os
->bfd_section
);
2836 /* If a loadable section is using the default memory
2837 region, and some non default memory regions were
2838 defined, issue a warning. */
2839 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2840 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2841 && ! link_info
.relocateable
2842 && strcmp (os
->region
->name
, "*default*") == 0
2843 && lang_memory_region_list
!= NULL
2844 && (strcmp (lang_memory_region_list
->name
, "*default*") != 0
2845 || lang_memory_region_list
->next
!= NULL
))
2846 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2847 bfd_get_section_name (output_bfd
, os
->bfd_section
));
2849 dot
= os
->region
->current
;
2851 if (os
->section_alignment
== -1)
2856 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
2858 if (dot
!= olddot
&& config
.warn_section_align
)
2859 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2860 os
->name
, (unsigned int) (dot
- olddot
));
2867 r
= exp_fold_tree (os
->addr_tree
,
2869 lang_allocating_phase_enum
,
2871 if (r
.valid_p
== false)
2873 einfo (_("%F%S: non constant address expression for section %s\n"),
2876 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2879 /* The section starts here.
2880 First, align to what the section needs. */
2882 if (os
->section_alignment
!= -1)
2883 dot
= align_power (dot
, os
->section_alignment
);
2885 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2887 os
->bfd_section
->output_offset
= 0;
2890 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
2891 os
->fill
, dot
, relax
);
2893 /* put the section within the requested block size, or align at
2894 the block boundary */
2895 after
= ALIGN_N (os
->bfd_section
->vma
2896 + os
->bfd_section
->_raw_size
/ opb
,
2897 /* The coercion here is important, see ld.h. */
2898 (bfd_vma
) os
->block_value
);
2900 if (bfd_is_abs_section (os
->bfd_section
))
2901 ASSERT (after
== os
->bfd_section
->vma
);
2903 os
->bfd_section
->_raw_size
=
2904 (after
- os
->bfd_section
->vma
) * opb
;
2905 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
2906 os
->processed
= true;
2908 /* Update dot in the region ?
2909 We only do this if the section is going to be allocated,
2910 since unallocated sections do not contribute to the region's
2911 overall size in memory.
2913 If the SEC_NEVER_LOAD bit is not set, it will affect the
2914 addresses of sections after it. We have to update
2916 if (os
->region
!= (lang_memory_region_type
*) NULL
2917 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2918 & SEC_NEVER_LOAD
) == 0
2919 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2920 & (SEC_ALLOC
| SEC_LOAD
))))
2922 os
->region
->current
= dot
;
2924 /* Make sure the new address is within the region. */
2925 os_region_check (os
, os
->region
, os
->addr_tree
,
2926 os
->bfd_section
->vma
);
2928 /* if there's no load address specified, use the run region as
2930 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
2931 os
->lma_region
= os
->region
;
2933 if (os
->lma_region
!= NULL
)
2935 if (os
->load_base
!= NULL
)
2937 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
2941 /* don't allocate twice */
2942 if (os
->lma_region
!= os
->region
)
2944 /* set load_base, which will be handled later */
2945 os
->load_base
= exp_intop (os
->lma_region
->current
);
2946 os
->lma_region
->current
+=
2947 os
->bfd_section
->_raw_size
/ opb
;
2948 os_region_check (os
, os
->lma_region
, NULL
,
2949 os
->bfd_section
->lma
);
2957 case lang_constructors_statement_enum
:
2958 dot
= lang_size_sections (constructor_list
.head
,
2959 output_section_statement
,
2960 &s
->wild_statement
.children
.head
,
2965 case lang_data_statement_enum
:
2967 unsigned int size
= 0;
2969 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
2970 s
->data_statement
.output_section
=
2971 output_section_statement
->bfd_section
;
2973 switch (s
->data_statement
.type
)
2994 output_section_statement
->bfd_section
->_raw_size
+= size
;
2995 /* The output section gets contents, and then we inspect for
2996 any flags set in the input script which override any ALLOC. */
2997 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
2998 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
)) {
2999 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
| SEC_LOAD
;
3004 case lang_reloc_statement_enum
:
3008 s
->reloc_statement
.output_vma
=
3009 dot
- output_section_statement
->bfd_section
->vma
;
3010 s
->reloc_statement
.output_section
=
3011 output_section_statement
->bfd_section
;
3012 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3014 output_section_statement
->bfd_section
->_raw_size
+= size
;
3018 case lang_wild_statement_enum
:
3020 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
3021 output_section_statement
,
3022 &s
->wild_statement
.children
.head
,
3028 case lang_object_symbols_statement_enum
:
3029 link_info
.create_object_symbols_section
=
3030 output_section_statement
->bfd_section
;
3032 case lang_output_statement_enum
:
3033 case lang_target_statement_enum
:
3035 case lang_input_section_enum
:
3039 i
= (*prev
)->input_section
.section
;
3042 if (i
->_cooked_size
== 0)
3043 i
->_cooked_size
= i
->_raw_size
;
3049 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3050 einfo (_("%P%F: can't relax section: %E\n"));
3054 dot
= size_input_section (prev
,
3055 output_section_statement
,
3056 output_section_statement
->fill
,
3060 case lang_input_statement_enum
:
3062 case lang_fill_statement_enum
:
3063 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
3065 fill
= s
->fill_statement
.fill
;
3067 case lang_assignment_statement_enum
:
3069 bfd_vma newdot
= dot
;
3071 exp_fold_tree (s
->assignment_statement
.exp
,
3072 output_section_statement
,
3073 lang_allocating_phase_enum
,
3079 /* The assignment changed dot. Insert a pad. */
3080 if (output_section_statement
== abs_output_section
)
3082 /* If we don't have an output section, then just adjust
3083 the default memory address. */
3084 lang_memory_region_lookup ("*default*")->current
= newdot
;
3088 lang_statement_union_type
*new =
3089 ((lang_statement_union_type
*)
3090 stat_alloc (sizeof (lang_padding_statement_type
)));
3092 /* Link into existing chain. */
3093 new->header
.next
= *prev
;
3095 new->header
.type
= lang_padding_statement_enum
;
3096 new->padding_statement
.output_section
=
3097 output_section_statement
->bfd_section
;
3098 new->padding_statement
.output_offset
=
3099 dot
- output_section_statement
->bfd_section
->vma
;
3100 new->padding_statement
.fill
= fill
;
3101 new->padding_statement
.size
= (newdot
- dot
) * opb
;
3102 output_section_statement
->bfd_section
->_raw_size
+=
3103 new->padding_statement
.size
;
3111 case lang_padding_statement_enum
:
3112 /* If we are relaxing, and this is not the first pass, some
3113 padding statements may have been inserted during previous
3114 passes. We may have to move the padding statement to a new
3115 location if dot has a different value at this point in this
3116 pass than it did at this point in the previous pass. */
3117 s
->padding_statement
.output_offset
=
3118 dot
- output_section_statement
->bfd_section
->vma
;
3119 dot
+= s
->padding_statement
.size
/ opb
;
3120 output_section_statement
->bfd_section
->_raw_size
+=
3121 s
->padding_statement
.size
;
3124 case lang_group_statement_enum
:
3125 dot
= lang_size_sections (s
->group_statement
.children
.head
,
3126 output_section_statement
,
3127 &s
->group_statement
.children
.head
,
3135 /* This can only get here when relaxing is turned on. */
3137 case lang_address_statement_enum
:
3140 prev
= &s
->header
.next
;
3146 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3147 lang_statement_union_type
* s
;
3148 lang_output_section_statement_type
* output_section_statement
;
3152 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3153 ldfile_output_machine
);
3155 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
3157 switch (s
->header
.type
)
3159 case lang_constructors_statement_enum
:
3160 dot
= lang_do_assignments (constructor_list
.head
,
3161 output_section_statement
,
3166 case lang_output_section_statement_enum
:
3168 lang_output_section_statement_type
*os
=
3169 &(s
->output_section_statement
);
3171 if (os
->bfd_section
!= NULL
)
3173 dot
= os
->bfd_section
->vma
;
3174 (void) lang_do_assignments (os
->children
.head
, os
,
3176 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3181 /* If nothing has been placed into the output section then
3182 it won't have a bfd_section. */
3183 if (os
->bfd_section
)
3185 os
->bfd_section
->lma
3186 = exp_get_abs_int(os
->load_base
, 0,"load base",
3187 lang_final_phase_enum
);
3192 case lang_wild_statement_enum
:
3194 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3195 output_section_statement
,
3200 case lang_object_symbols_statement_enum
:
3201 case lang_output_statement_enum
:
3202 case lang_target_statement_enum
:
3204 case lang_common_statement_enum
:
3207 case lang_data_statement_enum
:
3209 etree_value_type value
;
3211 value
= exp_fold_tree (s
->data_statement
.exp
,
3213 lang_final_phase_enum
, dot
, &dot
);
3214 s
->data_statement
.value
= value
.value
;
3215 if (value
.valid_p
== false)
3216 einfo (_("%F%P: invalid data statement\n"));
3220 switch (s
->data_statement
.type
)
3244 case lang_reloc_statement_enum
:
3246 etree_value_type value
;
3248 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3250 lang_final_phase_enum
, dot
, &dot
);
3251 s
->reloc_statement
.addend_value
= value
.value
;
3252 if (value
.valid_p
== false)
3253 einfo (_("%F%P: invalid reloc statement\n"));
3255 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3258 case lang_input_section_enum
:
3260 asection
*in
= s
->input_section
.section
;
3262 if (in
->_cooked_size
!= 0)
3263 dot
+= in
->_cooked_size
/ opb
;
3265 dot
+= in
->_raw_size
/ opb
;
3269 case lang_input_statement_enum
:
3271 case lang_fill_statement_enum
:
3272 fill
= s
->fill_statement
.fill
;
3274 case lang_assignment_statement_enum
:
3276 exp_fold_tree (s
->assignment_statement
.exp
,
3277 output_section_statement
,
3278 lang_final_phase_enum
,
3284 case lang_padding_statement_enum
:
3285 dot
+= s
->padding_statement
.size
/ opb
;
3288 case lang_group_statement_enum
:
3289 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3290 output_section_statement
,
3298 case lang_address_statement_enum
:
3306 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3307 operator .startof. (section_name), it produces an undefined symbol
3308 .startof.section_name. Similarly, when it sees
3309 .sizeof. (section_name), it produces an undefined symbol
3310 .sizeof.section_name. For all the output sections, we look for
3311 such symbols, and set them to the correct value. */
3318 if (link_info
.relocateable
)
3321 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3323 const char *secname
;
3325 struct bfd_link_hash_entry
*h
;
3327 secname
= bfd_get_section_name (output_bfd
, s
);
3328 buf
= xmalloc (10 + strlen (secname
));
3330 sprintf (buf
, ".startof.%s", secname
);
3331 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3332 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3334 h
->type
= bfd_link_hash_defined
;
3335 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3336 h
->u
.def
.section
= bfd_abs_section_ptr
;
3339 sprintf (buf
, ".sizeof.%s", secname
);
3340 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3341 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3343 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3344 ldfile_output_machine
);
3345 h
->type
= bfd_link_hash_defined
;
3346 if (s
->_cooked_size
!= 0)
3347 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3349 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3350 h
->u
.def
.section
= bfd_abs_section_ptr
;
3360 struct bfd_link_hash_entry
*h
;
3363 if (link_info
.relocateable
|| link_info
.shared
)
3368 if (entry_symbol
== (char *) NULL
)
3370 /* No entry has been specified. Look for start, but don't warn
3371 if we don't find it. */
3372 entry_symbol
= "start";
3376 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
3377 if (h
!= (struct bfd_link_hash_entry
*) NULL
3378 && (h
->type
== bfd_link_hash_defined
3379 || h
->type
== bfd_link_hash_defweak
)
3380 && h
->u
.def
.section
->output_section
!= NULL
)
3384 val
= (h
->u
.def
.value
3385 + bfd_get_section_vma (output_bfd
,
3386 h
->u
.def
.section
->output_section
)
3387 + h
->u
.def
.section
->output_offset
);
3388 if (! bfd_set_start_address (output_bfd
, val
))
3389 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
);
3396 /* We couldn't find the entry symbol. Try parsing it as a
3398 val
= bfd_scan_vma (entry_symbol
, &send
, 0);
3401 if (! bfd_set_start_address (output_bfd
, val
))
3402 einfo (_("%P%F: can't set start address\n"));
3408 /* Can't find the entry symbol, and it's not a number. Use
3409 the first address in the text section. */
3410 ts
= bfd_get_section_by_name (output_bfd
, ".text");
3411 if (ts
!= (asection
*) NULL
)
3414 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3415 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
3416 if (! bfd_set_start_address (output_bfd
,
3417 bfd_get_section_vma (output_bfd
,
3419 einfo (_("%P%F: can't set start address\n"));
3424 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3431 /* This is a small function used when we want to ignore errors from
3435 #ifdef ANSI_PROTOTYPES
3436 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3438 ignore_bfd_errors (s
)
3439 const char *s ATTRIBUTE_UNUSED
;
3442 /* Don't do anything. */
3445 /* Check that the architecture of all the input files is compatible
3446 with the output file. Also call the backend to let it do any
3447 other checking that is needed. */
3452 lang_statement_union_type
*file
;
3454 const bfd_arch_info_type
*compatible
;
3456 for (file
= file_chain
.head
;
3457 file
!= (lang_statement_union_type
*) NULL
;
3458 file
= file
->input_statement
.next
)
3460 input_bfd
= file
->input_statement
.the_bfd
;
3461 compatible
= bfd_arch_get_compatible (input_bfd
,
3463 if (compatible
== NULL
)
3465 if (command_line
.warn_mismatch
)
3466 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3467 bfd_printable_name (input_bfd
), input_bfd
,
3468 bfd_printable_name (output_bfd
));
3472 bfd_error_handler_type pfn
= NULL
;
3474 /* If we aren't supposed to warn about mismatched input
3475 files, temporarily set the BFD error handler to a
3476 function which will do nothing. We still want to call
3477 bfd_merge_private_bfd_data, since it may set up
3478 information which is needed in the output file. */
3479 if (! command_line
.warn_mismatch
)
3480 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3481 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3483 if (command_line
.warn_mismatch
)
3484 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3487 if (! command_line
.warn_mismatch
)
3488 bfd_set_error_handler (pfn
);
3493 /* Look through all the global common symbols and attach them to the
3494 correct section. The -sort-common command line switch may be used
3495 to roughly sort the entries by size. */
3500 if (link_info
.relocateable
3501 && ! command_line
.force_common_definition
)
3504 if (! config
.sort_common
)
3505 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3510 for (power
= 4; power
>= 0; power
--)
3511 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3516 /* Place one common symbol in the correct section. */
3519 lang_one_common (h
, info
)
3520 struct bfd_link_hash_entry
*h
;
3523 unsigned int power_of_two
;
3526 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3527 ldfile_output_machine
);
3529 if (h
->type
!= bfd_link_hash_common
)
3533 power_of_two
= h
->u
.c
.p
->alignment_power
;
3535 if (config
.sort_common
3536 && power_of_two
< (unsigned int) *(int *) info
)
3539 section
= h
->u
.c
.p
->section
;
3541 /* Increase the size of the section. */
3542 section
->_cooked_size
= ALIGN_N ((section
->_cooked_size
+ opb
- 1) / opb
,
3543 (bfd_size_type
) (1 << power_of_two
)) * opb
;
3545 /* Adjust the alignment if necessary. */
3546 if (power_of_two
> section
->alignment_power
)
3547 section
->alignment_power
= power_of_two
;
3549 /* Change the symbol from common to defined. */
3550 h
->type
= bfd_link_hash_defined
;
3551 h
->u
.def
.section
= section
;
3552 h
->u
.def
.value
= section
->_cooked_size
;
3554 /* Increase the size of the section. */
3555 section
->_cooked_size
+= size
;
3557 /* Make sure the section is allocated in memory, and make sure that
3558 it is no longer a common section. */
3559 section
->flags
|= SEC_ALLOC
;
3560 section
->flags
&= ~ SEC_IS_COMMON
;
3562 if (config
.map_file
!= NULL
)
3564 static boolean header_printed
;
3569 if (! header_printed
)
3571 minfo (_("\nAllocating common symbols\n"));
3572 minfo (_("Common symbol size file\n\n"));
3573 header_printed
= true;
3576 name
= demangle (h
->root
.string
);
3578 len
= strlen (name
);
3593 if (size
<= 0xffffffff)
3594 sprintf (buf
, "%lx", (unsigned long) size
);
3596 sprintf_vma (buf
, size
);
3606 minfo ("%B\n", section
->owner
);
3613 run through the input files and ensure that every input
3614 section has somewhere to go. If one is found without
3615 a destination then create an input request and place it
3616 into the statement tree.
3620 lang_place_orphans ()
3622 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3626 for (s
= file
->the_bfd
->sections
;
3627 s
!= (asection
*) NULL
;
3630 if (s
->output_section
== (asection
*) NULL
)
3632 /* This section of the file is not attatched, root
3633 around for a sensible place for it to go */
3635 if (file
->just_syms_flag
)
3637 /* We are only retrieving symbol values from this
3638 file. We want the symbols to act as though the
3639 values in the file are absolute. */
3640 s
->output_section
= bfd_abs_section_ptr
;
3641 s
->output_offset
= s
->vma
;
3643 else if (strcmp (s
->name
, "COMMON") == 0)
3645 /* This is a lonely common section which must have
3646 come from an archive. We attach to the section
3647 with the wildcard. */
3648 if (! link_info
.relocateable
3649 || command_line
.force_common_definition
)
3651 if (default_common_section
== NULL
)
3654 /* This message happens when using the
3655 svr3.ifile linker script, so I have
3657 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3659 default_common_section
=
3660 lang_output_section_statement_lookup (".bss");
3663 wild_doit (&default_common_section
->children
, s
,
3664 default_common_section
, file
);
3667 else if (ldemul_place_orphan (file
, s
))
3671 lang_output_section_statement_type
*os
=
3672 lang_output_section_statement_lookup (s
->name
);
3674 wild_doit (&os
->children
, s
, os
, file
);
3683 lang_set_flags (ptr
, flags
, invert
)
3684 lang_memory_region_type
*ptr
;
3688 flagword
*ptr_flags
;
3690 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3696 *ptr_flags
|= SEC_ALLOC
;
3700 *ptr_flags
|= SEC_READONLY
;
3704 *ptr_flags
|= SEC_DATA
;
3708 *ptr_flags
|= SEC_CODE
;
3713 *ptr_flags
|= SEC_LOAD
;
3717 einfo (_("%P%F: invalid syntax in flags\n"));
3724 /* Call a function on each input file. This function will be called
3725 on an archive, but not on the elements. */
3728 lang_for_each_input_file (func
)
3729 void (*func
) PARAMS ((lang_input_statement_type
*));
3731 lang_input_statement_type
*f
;
3733 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3735 f
= (lang_input_statement_type
*) f
->next_real_file
)
3739 /* Call a function on each file. The function will be called on all
3740 the elements of an archive which are included in the link, but will
3741 not be called on the archive file itself. */
3744 lang_for_each_file (func
)
3745 void (*func
) PARAMS ((lang_input_statement_type
*));
3747 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3758 lang_for_each_input_section (func
)
3759 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
3761 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3765 for (s
= f
->the_bfd
->sections
;
3766 s
!= (asection
*) NULL
;
3769 func (f
->the_bfd
, s
);
3777 ldlang_add_file (entry
)
3778 lang_input_statement_type
* entry
;
3782 lang_statement_append (&file_chain
,
3783 (lang_statement_union_type
*) entry
,
3786 /* The BFD linker needs to have a list of all input BFDs involved in
3788 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3789 ASSERT (entry
->the_bfd
!= output_bfd
);
3790 for (pp
= &link_info
.input_bfds
;
3791 *pp
!= (bfd
*) NULL
;
3792 pp
= &(*pp
)->link_next
)
3794 *pp
= entry
->the_bfd
;
3795 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3796 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3798 /* Look through the sections and check for any which should not be
3799 included in the link. We need to do this now, so that we can
3800 notice when the backend linker tries to report multiple
3801 definition errors for symbols which are in sections we aren't
3802 going to link. FIXME: It might be better to entirely ignore
3803 symbols which are defined in sections which are going to be
3804 discarded. This would require modifying the backend linker for
3805 each backend which might set the SEC_LINK_ONCE flag. If we do
3806 this, we should probably handle SEC_EXCLUDE in the same way. */
3808 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
3812 lang_add_output (name
, from_script
)
3816 /* Make -o on command line override OUTPUT in script. */
3817 if (had_output_filename
== false || !from_script
)
3819 output_filename
= name
;
3820 had_output_filename
= true;
3825 static lang_output_section_statement_type
*current_section
;
3837 for (l
= 0; l
< 32; l
++)
3839 if (i
>= (unsigned int) x
)
3847 lang_output_section_statement_type
*
3848 lang_enter_output_section_statement (output_section_statement_name
,
3849 address_exp
, sectype
, block_value
,
3850 align
, subalign
, ebase
)
3851 const char *output_section_statement_name
;
3852 etree_type
* address_exp
;
3853 enum section_type sectype
;
3854 bfd_vma block_value
;
3856 etree_type
*subalign
;
3859 lang_output_section_statement_type
*os
;
3863 lang_output_section_statement_lookup (output_section_statement_name
);
3867 /* Add this statement to tree */
3868 /* add_statement(lang_output_section_statement_enum,
3869 output_section_statement);*/
3870 /* Make next things chain into subchain of this */
3872 if (os
->addr_tree
==
3873 (etree_type
*) NULL
)
3878 os
->sectype
= sectype
;
3879 if (sectype
!= noload_section
)
3880 os
->flags
= SEC_NO_FLAGS
;
3882 os
->flags
= SEC_NEVER_LOAD
;
3883 os
->block_value
= block_value
? block_value
: 1;
3884 stat_ptr
= &os
->children
;
3886 os
->subsection_alignment
= topower(
3887 exp_get_value_int(subalign
, -1,
3888 "subsection alignment",
3890 os
->section_alignment
= topower(
3891 exp_get_value_int(align
, -1,
3892 "section alignment", 0));
3894 os
->load_base
= ebase
;
3901 lang_output_statement_type
*new =
3902 new_stat (lang_output_statement
, stat_ptr
);
3904 new->name
= output_filename
;
3907 /* Reset the current counters in the regions */
3909 reset_memory_regions ()
3911 lang_memory_region_type
*p
= lang_memory_region_list
;
3913 for (p
= lang_memory_region_list
;
3914 p
!= (lang_memory_region_type
*) NULL
;
3917 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
3918 p
->current
= p
->origin
;
3922 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3923 as needed. SECTION may be NULL, in which case it is a wild card. */
3926 gc_section_callback (ptr
, section
, file
, data
)
3927 lang_wild_statement_type
*ptr
;
3929 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
3930 PTR data ATTRIBUTE_UNUSED
;
3932 /* If the wild pattern was marked KEEP, the member sections
3933 should be as well. */
3934 if (ptr
->keep_sections
)
3935 section
->flags
|= SEC_KEEP
;
3938 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
3939 may be NULL, indicating that it is a wildcard. */
3942 lang_gc_wild (s
, section
, file
)
3943 lang_wild_statement_type
*s
;
3944 const char *section
;
3947 walk_wild (s
, section
, file
, gc_section_callback
, NULL
);
3950 /* Iterate over sections marking them against GC. */
3953 lang_gc_sections_1 (s
)
3954 lang_statement_union_type
* s
;
3956 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
3958 switch (s
->header
.type
)
3960 case lang_wild_statement_enum
:
3961 lang_gc_wild (&s
->wild_statement
,
3962 s
->wild_statement
.section_name
,
3963 s
->wild_statement
.filename
);
3965 case lang_constructors_statement_enum
:
3966 lang_gc_sections_1 (constructor_list
.head
);
3968 case lang_output_section_statement_enum
:
3969 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
3971 case lang_group_statement_enum
:
3972 lang_gc_sections_1 (s
->group_statement
.children
.head
);
3983 struct bfd_link_hash_entry
*h
;
3984 ldlang_undef_chain_list_type
*ulist
, fake_list_start
;
3986 /* Keep all sections so marked in the link script. */
3988 lang_gc_sections_1 (statement_list
.head
);
3990 /* Keep all sections containing symbols undefined on the command-line.
3991 Handle the entry symbol at the same time. */
3993 if (entry_symbol
!= NULL
)
3995 fake_list_start
.next
= ldlang_undef_chain_list_head
;
3996 fake_list_start
.name
= (char *) entry_symbol
;
3997 ulist
= &fake_list_start
;
4000 ulist
= ldlang_undef_chain_list_head
;
4002 for (; ulist
; ulist
= ulist
->next
)
4004 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4005 false, false, false);
4007 if (h
!= (struct bfd_link_hash_entry
*) NULL
4008 && (h
->type
== bfd_link_hash_defined
4009 || h
->type
== bfd_link_hash_defweak
)
4010 && ! bfd_is_abs_section (h
->u
.def
.section
))
4012 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4016 bfd_gc_sections (output_bfd
, &link_info
);
4022 lang_reasonable_defaults ();
4023 current_target
= default_target
;
4025 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
4027 ldemul_create_output_section_statements ();
4029 /* Add to the hash table all undefineds on the command line */
4030 lang_place_undefineds ();
4032 already_linked_table_init ();
4034 /* Create a bfd for each input file */
4035 current_target
= default_target
;
4036 open_input_bfds (statement_list
.head
, false);
4038 ldemul_after_open ();
4040 already_linked_table_free ();
4042 /* Make sure that we're not mixing architectures. We call this
4043 after all the input files have been opened, but before we do any
4044 other processing, so that any operations merge_private_bfd_data
4045 does on the output file will be known during the rest of the
4049 /* Handle .exports instead of a version script if we're told to do so. */
4050 if (command_line
.version_exports_section
)
4051 lang_do_version_exports_section ();
4053 /* Build all sets based on the information gathered from the input
4055 ldctor_build_sets ();
4057 /* Remove unreferenced sections if asked to. */
4058 if (command_line
.gc_sections
)
4059 lang_gc_sections ();
4061 /* Size up the common data */
4064 /* Run through the contours of the script and attach input sections
4065 to the correct output sections
4067 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4068 (lang_output_section_statement_type
*) NULL
);
4071 /* Find any sections not attached explicitly and handle them */
4072 lang_place_orphans ();
4074 ldemul_before_allocation ();
4076 /* We must record the program headers before we try to fix the
4077 section positions, since they will affect SIZEOF_HEADERS. */
4078 lang_record_phdrs ();
4080 /* Now run around and relax if we can */
4081 if (command_line
.relax
)
4083 /* First time round is a trial run to get the 'worst case'
4084 addresses of the objects if there was no relaxing. */
4085 lang_size_sections (statement_list
.head
,
4087 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
4089 /* Keep relaxing until bfd_relax_section gives up. */
4092 reset_memory_regions ();
4094 relax_again
= false;
4096 /* Note: pe-dll.c does something like this also. If you find
4097 you need to change this code, you probably need to change
4098 pe-dll.c also. DJ */
4100 /* Do all the assignments with our current guesses as to
4102 lang_do_assignments (statement_list
.head
,
4104 (fill_type
) 0, (bfd_vma
) 0);
4106 /* Perform another relax pass - this time we know where the
4107 globals are, so can make better guess. */
4108 lang_size_sections (statement_list
.head
,
4110 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
4112 while (relax_again
);
4116 /* Size up the sections. */
4117 lang_size_sections (statement_list
.head
,
4119 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
4122 /* See if anything special should be done now we know how big
4124 ldemul_after_allocation ();
4126 /* Fix any .startof. or .sizeof. symbols. */
4127 lang_set_startof ();
4129 /* Do all the assignments, now that we know the final restingplaces
4130 of all the symbols */
4132 lang_do_assignments (statement_list
.head
,
4134 (fill_type
) 0, (bfd_vma
) 0);
4136 /* Make sure that the section addresses make sense. */
4137 if (! link_info
.relocateable
4138 && command_line
.check_section_addresses
)
4139 lang_check_section_addresses ();
4147 /* EXPORTED TO YACC */
4150 lang_add_wild (section_name
, sections_sorted
, filename
, filenames_sorted
,
4151 keep_sections
, exclude_filename_list
)
4152 const char *const section_name
;
4153 boolean sections_sorted
;
4154 const char *const filename
;
4155 boolean filenames_sorted
;
4156 boolean keep_sections
;
4157 struct name_list
*exclude_filename_list
;
4159 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
4162 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
4164 placed_commons
= true;
4166 if (filename
!= NULL
&& ! wildcardp (filename
))
4168 lang_has_input_file
= true;
4170 new->section_name
= section_name
;
4171 new->sections_sorted
= sections_sorted
;
4172 new->filename
= filename
;
4173 new->filenames_sorted
= filenames_sorted
;
4174 new->keep_sections
= keep_sections
;
4175 new->exclude_filename_list
= exclude_filename_list
;
4176 lang_list_init (&new->children
);
4180 lang_section_start (name
, address
)
4182 etree_type
* address
;
4184 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
4186 ad
->section_name
= name
;
4187 ad
->address
= address
;
4190 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4191 because of a -e argument on the command line, or zero if this is
4192 called by ENTRY in a linker script. Command line arguments take
4196 lang_add_entry (name
, cmdline
)
4200 if (entry_symbol
== NULL
4202 || ! entry_from_cmdline
)
4204 entry_symbol
= name
;
4205 entry_from_cmdline
= cmdline
;
4210 lang_add_target (name
)
4213 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4229 map_option_f
= true;
4240 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4247 lang_add_data (type
, exp
)
4249 union etree_union
*exp
;
4252 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4260 /* Create a new reloc statement. RELOC is the BFD relocation type to
4261 generate. HOWTO is the corresponding howto structure (we could
4262 look this up, but the caller has already done so). SECTION is the
4263 section to generate a reloc against, or NAME is the name of the
4264 symbol to generate a reloc against. Exactly one of SECTION and
4265 NAME must be NULL. ADDEND is an expression for the addend. */
4268 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4269 bfd_reloc_code_real_type reloc
;
4270 reloc_howto_type
*howto
;
4273 union etree_union
*addend
;
4275 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4279 p
->section
= section
;
4281 p
->addend_exp
= addend
;
4283 p
->addend_value
= 0;
4284 p
->output_section
= NULL
;
4288 lang_assignment_statement_type
*
4289 lang_add_assignment (exp
)
4292 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4300 lang_add_attribute (attribute
)
4301 enum statement_enum attribute
;
4303 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4310 if (startup_file
!= (char *) NULL
)
4312 einfo (_("%P%Fmultiple STARTUP files\n"));
4314 first_file
->filename
= name
;
4315 first_file
->local_sym_name
= name
;
4316 first_file
->real
= true;
4318 startup_file
= name
;
4325 lang_float_flag
= maybe
;
4329 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4331 const char *memspec
;
4332 struct lang_output_section_phdr_list
*phdrs
;
4333 const char *lma_memspec
;
4335 current_section
->fill
= fill
;
4336 current_section
->region
= lang_memory_region_lookup (memspec
);
4337 if (strcmp (lma_memspec
, "*default*") != 0)
4339 current_section
->lma_region
= lang_memory_region_lookup (lma_memspec
);
4340 /* if no runtime region has been given, but the load region has been,
4341 use the load region */
4342 if (strcmp (memspec
, "*default*") == 0)
4343 current_section
->region
= lang_memory_region_lookup (lma_memspec
);
4345 current_section
->phdrs
= phdrs
;
4346 stat_ptr
= &statement_list
;
4350 Create an absolute symbol with the given name with the value of the
4351 address of first byte of the section named.
4353 If the symbol already exists, then do nothing.
4356 lang_abs_symbol_at_beginning_of (secname
, name
)
4357 const char *secname
;
4360 struct bfd_link_hash_entry
*h
;
4362 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4363 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4364 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4366 if (h
->type
== bfd_link_hash_new
4367 || h
->type
== bfd_link_hash_undefined
)
4371 h
->type
= bfd_link_hash_defined
;
4373 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4374 if (sec
== (asection
*) NULL
)
4377 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4379 h
->u
.def
.section
= bfd_abs_section_ptr
;
4384 Create an absolute symbol with the given name with the value of the
4385 address of the first byte after the end of the section named.
4387 If the symbol already exists, then do nothing.
4390 lang_abs_symbol_at_end_of (secname
, name
)
4391 const char *secname
;
4394 struct bfd_link_hash_entry
*h
;
4396 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4397 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4398 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4400 if (h
->type
== bfd_link_hash_new
4401 || h
->type
== bfd_link_hash_undefined
)
4405 h
->type
= bfd_link_hash_defined
;
4407 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4408 if (sec
== (asection
*) NULL
)
4411 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4412 + bfd_section_size (output_bfd
, sec
) /
4413 bfd_octets_per_byte (output_bfd
));
4415 h
->u
.def
.section
= bfd_abs_section_ptr
;
4420 lang_statement_append (list
, element
, field
)
4421 lang_statement_list_type
* list
;
4422 lang_statement_union_type
* element
;
4423 lang_statement_union_type
** field
;
4425 *(list
->tail
) = element
;
4429 /* Set the output format type. -oformat overrides scripts. */
4432 lang_add_output_format (format
, big
, little
, from_script
)
4438 if (output_target
== NULL
|| !from_script
)
4440 if (command_line
.endian
== ENDIAN_BIG
4443 else if (command_line
.endian
== ENDIAN_LITTLE
4447 output_target
= format
;
4451 /* Enter a group. This creates a new lang_group_statement, and sets
4452 stat_ptr to build new statements within the group. */
4457 lang_group_statement_type
*g
;
4459 g
= new_stat (lang_group_statement
, stat_ptr
);
4460 lang_list_init (&g
->children
);
4461 stat_ptr
= &g
->children
;
4464 /* Leave a group. This just resets stat_ptr to start writing to the
4465 regular list of statements again. Note that this will not work if
4466 groups can occur inside anything else which can adjust stat_ptr,
4467 but currently they can't. */
4472 stat_ptr
= &statement_list
;
4475 /* Add a new program header. This is called for each entry in a PHDRS
4476 command in a linker script. */
4479 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4487 struct lang_phdr
*n
, **pp
;
4489 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4492 n
->type
= exp_get_value_int (type
, 0, "program header type",
4493 lang_final_phase_enum
);
4494 n
->filehdr
= filehdr
;
4499 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4504 /* Record the program header information in the output BFD. FIXME: We
4505 should not be calling an ELF specific function here. */
4508 lang_record_phdrs ()
4512 struct lang_output_section_phdr_list
*last
;
4513 struct lang_phdr
*l
;
4514 lang_statement_union_type
*u
;
4517 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4519 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4526 for (u
= lang_output_section_statement
.head
;
4528 u
= u
->output_section_statement
.next
)
4530 lang_output_section_statement_type
*os
;
4531 struct lang_output_section_phdr_list
*pl
;
4533 os
= &u
->output_section_statement
;
4540 if (os
->sectype
== noload_section
4541 || os
->bfd_section
== NULL
4542 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4547 if (os
->bfd_section
== NULL
)
4550 for (; pl
!= NULL
; pl
= pl
->next
)
4552 if (strcmp (pl
->name
, l
->name
) == 0)
4557 secs
= ((asection
**)
4558 xrealloc (secs
, alc
* sizeof (asection
*)));
4560 secs
[c
] = os
->bfd_section
;
4567 if (l
->flags
== NULL
)
4570 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4571 lang_final_phase_enum
);
4576 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4577 lang_final_phase_enum
);
4579 if (! bfd_record_phdr (output_bfd
, l
->type
,
4580 l
->flags
== NULL
? false : true,
4582 l
->at
== NULL
? false : true,
4583 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4584 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4589 /* Make sure all the phdr assignments succeeded. */
4590 for (u
= lang_output_section_statement
.head
;
4592 u
= u
->output_section_statement
.next
)
4594 struct lang_output_section_phdr_list
*pl
;
4596 if (u
->output_section_statement
.bfd_section
== NULL
)
4599 for (pl
= u
->output_section_statement
.phdrs
;
4602 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4603 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4604 u
->output_section_statement
.name
, pl
->name
);
4608 /* Record a list of sections which may not be cross referenced. */
4611 lang_add_nocrossref (l
)
4612 struct lang_nocrossref
*l
;
4614 struct lang_nocrossrefs
*n
;
4616 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4617 n
->next
= nocrossref_list
;
4619 nocrossref_list
= n
;
4621 /* Set notice_all so that we get informed about all symbols. */
4622 link_info
.notice_all
= true;
4625 /* Overlay handling. We handle overlays with some static variables. */
4627 /* The overlay virtual address. */
4628 static etree_type
*overlay_vma
;
4630 /* The overlay load address. */
4631 static etree_type
*overlay_lma
;
4633 /* Whether nocrossrefs is set for this overlay. */
4634 static int overlay_nocrossrefs
;
4636 /* An expression for the maximum section size seen so far. */
4637 static etree_type
*overlay_max
;
4639 /* A list of all the sections in this overlay. */
4643 struct overlay_list
*next
;
4644 lang_output_section_statement_type
*os
;
4647 static struct overlay_list
*overlay_list
;
4649 /* Start handling an overlay. */
4652 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
4653 etree_type
*vma_expr
;
4654 etree_type
*lma_expr
;
4657 /* The grammar should prevent nested overlays from occurring. */
4658 ASSERT (overlay_vma
== NULL
4659 && overlay_lma
== NULL
4660 && overlay_list
== NULL
4661 && overlay_max
== NULL
);
4663 overlay_vma
= vma_expr
;
4664 overlay_lma
= lma_expr
;
4665 overlay_nocrossrefs
= nocrossrefs
;
4668 /* Start a section in an overlay. We handle this by calling
4669 lang_enter_output_section_statement with the correct VMA and LMA. */
4672 lang_enter_overlay_section (name
)
4675 struct overlay_list
*n
;
4678 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4679 0, 0, 0, overlay_lma
);
4681 /* If this is the first section, then base the VMA and LMA of future
4682 sections on this one. This will work correctly even if `.' is
4683 used in the addresses. */
4684 if (overlay_list
== NULL
)
4686 overlay_vma
= exp_nameop (ADDR
, name
);
4687 overlay_lma
= exp_nameop (LOADADDR
, name
);
4690 /* Remember the section. */
4691 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4692 n
->os
= current_section
;
4693 n
->next
= overlay_list
;
4696 size
= exp_nameop (SIZEOF
, name
);
4698 /* Adjust the LMA for the next section. */
4699 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
4701 /* Arrange to work out the maximum section end address. */
4702 if (overlay_max
== NULL
)
4705 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4708 /* Finish a section in an overlay. There isn't any special to do
4712 lang_leave_overlay_section (fill
, phdrs
)
4714 struct lang_output_section_phdr_list
*phdrs
;
4721 name
= current_section
->name
;
4723 lang_leave_output_section_statement (fill
, "*default*",
4724 phdrs
, "*default*");
4726 /* Define the magic symbols. */
4728 clean
= xmalloc (strlen (name
) + 1);
4730 for (s1
= name
; *s1
!= '\0'; s1
++)
4731 if (isalnum ((unsigned char) *s1
) || *s1
== '_')
4735 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4736 sprintf (buf
, "__load_start_%s", clean
);
4737 lang_add_assignment (exp_assop ('=', buf
,
4738 exp_nameop (LOADADDR
, name
)));
4740 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4741 sprintf (buf
, "__load_stop_%s", clean
);
4742 lang_add_assignment (exp_assop ('=', buf
,
4744 exp_nameop (LOADADDR
, name
),
4745 exp_nameop (SIZEOF
, name
))));
4750 /* Finish an overlay. If there are any overlay wide settings, this
4751 looks through all the sections in the overlay and sets them. */
4754 lang_leave_overlay (fill
, memspec
, phdrs
, lma_memspec
)
4756 const char *memspec
;
4757 struct lang_output_section_phdr_list
*phdrs
;
4758 const char *lma_memspec
;
4760 lang_memory_region_type
*region
;
4761 lang_memory_region_type
*lma_region
;
4762 struct overlay_list
*l
;
4763 struct lang_nocrossref
*nocrossref
;
4765 if (memspec
== NULL
)
4768 region
= lang_memory_region_lookup (memspec
);
4770 if (lma_memspec
== NULL
)
4773 lma_region
= lang_memory_region_lookup (lma_memspec
);
4780 struct overlay_list
*next
;
4782 if (fill
!= 0 && l
->os
->fill
== 0)
4784 if (region
!= NULL
&& l
->os
->region
== NULL
)
4785 l
->os
->region
= region
;
4786 if (lma_region
!= NULL
&& l
->os
->lma_region
== NULL
)
4787 l
->os
->lma_region
= lma_region
;
4788 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4789 l
->os
->phdrs
= phdrs
;
4791 if (overlay_nocrossrefs
)
4793 struct lang_nocrossref
*nc
;
4795 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
4796 nc
->name
= l
->os
->name
;
4797 nc
->next
= nocrossref
;
4806 if (nocrossref
!= NULL
)
4807 lang_add_nocrossref (nocrossref
);
4809 /* Update . for the end of the overlay. */
4810 lang_add_assignment (exp_assop ('=', ".",
4811 exp_binop ('+', overlay_vma
, overlay_max
)));
4815 overlay_nocrossrefs
= 0;
4816 overlay_list
= NULL
;
4820 /* Version handling. This is only useful for ELF. */
4822 /* This global variable holds the version tree that we build. */
4824 struct bfd_elf_version_tree
*lang_elf_version_info
;
4827 lang_vers_match_lang_c (expr
, sym
)
4828 struct bfd_elf_version_expr
*expr
;
4831 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4833 return fnmatch (expr
->pattern
, sym
, 0) == 0;
4837 lang_vers_match_lang_cplusplus (expr
, sym
)
4838 struct bfd_elf_version_expr
*expr
;
4844 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4847 alt_sym
= cplus_demangle(sym
, /* DMGL_NO_TPARAMS */ 0);
4850 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4851 Should we early out false in this case? */
4852 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4856 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4864 lang_vers_match_lang_java (expr
, sym
)
4865 struct bfd_elf_version_expr
*expr
;
4871 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4874 alt_sym
= cplus_demangle(sym
, DMGL_JAVA
);
4877 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4878 Should we early out false in this case? */
4879 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4883 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4890 /* This is called for each variable name or match expression. */
4892 struct bfd_elf_version_expr
*
4893 lang_new_vers_regex (orig
, new, lang
)
4894 struct bfd_elf_version_expr
*orig
;
4898 struct bfd_elf_version_expr
*ret
;
4900 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
4904 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
4905 ret
->match
= lang_vers_match_lang_c
;
4906 else if (strcasecmp (lang
, "C++") == 0)
4907 ret
->match
= lang_vers_match_lang_cplusplus
;
4908 else if (strcasecmp (lang
, "Java") == 0)
4909 ret
->match
= lang_vers_match_lang_java
;
4912 einfo (_("%X%P: unknown language `%s' in version information\n"),
4914 ret
->match
= lang_vers_match_lang_c
;
4920 /* This is called for each set of variable names and match
4923 struct bfd_elf_version_tree
*
4924 lang_new_vers_node (globals
, locals
)
4925 struct bfd_elf_version_expr
*globals
;
4926 struct bfd_elf_version_expr
*locals
;
4928 struct bfd_elf_version_tree
*ret
;
4930 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
4934 ret
->globals
= globals
;
4935 ret
->locals
= locals
;
4937 ret
->name_indx
= (unsigned int) -1;
4942 /* This static variable keeps track of version indices. */
4944 static int version_index
;
4946 /* This is called when we know the name and dependencies of the
4950 lang_register_vers_node (name
, version
, deps
)
4952 struct bfd_elf_version_tree
*version
;
4953 struct bfd_elf_version_deps
*deps
;
4955 struct bfd_elf_version_tree
*t
, **pp
;
4956 struct bfd_elf_version_expr
*e1
;
4958 /* Make sure this node has a unique name. */
4959 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4960 if (strcmp (t
->name
, name
) == 0)
4961 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
4963 /* Check the global and local match names, and make sure there
4964 aren't any duplicates. */
4966 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
4968 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4970 struct bfd_elf_version_expr
*e2
;
4972 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
4973 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
4974 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4979 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
4981 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4983 struct bfd_elf_version_expr
*e2
;
4985 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
4986 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
4987 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4992 version
->deps
= deps
;
4993 version
->name
= name
;
4995 version
->vernum
= version_index
;
4997 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5002 /* This is called when we see a version dependency. */
5004 struct bfd_elf_version_deps
*
5005 lang_add_vers_depend (list
, name
)
5006 struct bfd_elf_version_deps
*list
;
5009 struct bfd_elf_version_deps
*ret
;
5010 struct bfd_elf_version_tree
*t
;
5012 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5015 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5017 if (strcmp (t
->name
, name
) == 0)
5019 ret
->version_needed
= t
;
5024 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5030 lang_do_version_exports_section ()
5032 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5034 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5036 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5043 len
= bfd_section_size (is
->the_bfd
, sec
);
5044 contents
= xmalloc (len
);
5045 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5046 einfo (_("%X%P: unable to read .exports section contents"), sec
);
5049 while (p
< contents
+len
)
5051 greg
= lang_new_vers_regex (greg
, p
, NULL
);
5052 p
= strchr (p
, '\0') + 1;
5055 /* Do not free the contents, as we used them creating the regex. */
5057 /* Do not include this section in the link. */
5058 bfd_set_section_flags (is
->the_bfd
, sec
,
5059 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5062 lreg
= lang_new_vers_regex (NULL
, "*", NULL
);
5063 lang_register_vers_node (command_line
.version_exports_section
,
5064 lang_new_vers_node (greg
, lreg
), NULL
);