1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
6 This file is part of GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
26 #include "safe-ctype.h"
44 static lang_statement_union_type
*new_statement
45 PARAMS ((enum statement_enum
, size_t, lang_statement_list_type
*));
48 static struct obstack stat_obstack
;
50 #define obstack_chunk_alloc xmalloc
51 #define obstack_chunk_free free
52 static const char *startup_file
;
53 static lang_statement_list_type input_file_chain
;
54 static boolean placed_commons
= false;
55 static lang_output_section_statement_type
*default_common_section
;
56 static boolean map_option_f
;
57 static bfd_vma print_dot
;
58 static lang_input_statement_type
*first_file
;
59 static const char *current_target
;
60 static const char *output_target
;
61 static lang_statement_list_type statement_list
;
62 static struct lang_phdr
*lang_phdr_list
;
64 static void lang_for_each_statement_worker
65 PARAMS ((void (*) (lang_statement_union_type
*),
66 lang_statement_union_type
*));
67 static lang_input_statement_type
*new_afile
68 PARAMS ((const char *, lang_input_file_enum_type
, const char *, boolean
));
69 static lang_memory_region_type
*lang_memory_default
PARAMS ((asection
*));
70 static void lang_map_flags
PARAMS ((flagword
));
71 static void init_os
PARAMS ((lang_output_section_statement_type
*));
72 static void exp_init_os
PARAMS ((etree_type
*));
73 static void section_already_linked
PARAMS ((bfd
*, asection
*, PTR
));
74 static struct bfd_hash_entry
*already_linked_newfunc
75 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
76 static void already_linked_table_init
PARAMS ((void));
77 static void already_linked_table_free
PARAMS ((void));
78 static boolean wildcardp
PARAMS ((const char *));
79 static lang_statement_union_type
*wild_sort
80 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*,
81 lang_input_statement_type
*, asection
*));
82 static void output_section_callback
83 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
84 lang_input_statement_type
*, PTR
));
85 static lang_input_statement_type
*lookup_name
PARAMS ((const char *));
86 static boolean load_symbols
87 PARAMS ((lang_input_statement_type
*, lang_statement_list_type
*));
89 PARAMS ((lang_wild_statement_type
*,
90 const char *, lang_output_section_statement_type
*));
91 static bfd
*open_output
PARAMS ((const char *));
92 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*));
93 static void open_input_bfds
PARAMS ((lang_statement_union_type
*, boolean
));
94 static void lang_reasonable_defaults
PARAMS ((void));
95 static void lang_place_undefineds
PARAMS ((void));
96 static void map_input_to_output_sections
97 PARAMS ((lang_statement_union_type
*, const char *,
98 lang_output_section_statement_type
*));
99 static void print_output_section_statement
100 PARAMS ((lang_output_section_statement_type
*));
101 static void print_assignment
102 PARAMS ((lang_assignment_statement_type
*,
103 lang_output_section_statement_type
*));
104 static void print_input_statement
PARAMS ((lang_input_statement_type
*));
105 static boolean print_one_symbol
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
106 static void print_input_section
PARAMS ((lang_input_section_type
*));
107 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*));
108 static void print_data_statement
PARAMS ((lang_data_statement_type
*));
109 static void print_address_statement
PARAMS ((lang_address_statement_type
*));
110 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*));
111 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*));
112 static void print_wild_statement
113 PARAMS ((lang_wild_statement_type
*, lang_output_section_statement_type
*));
114 static void print_group
115 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
116 static void print_statement
117 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
118 static void print_statement_list
119 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
120 static void print_statements
PARAMS ((void));
121 static void insert_pad
122 PARAMS ((lang_statement_union_type
**, fill_type
,
123 unsigned int, asection
*, bfd_vma
));
124 static bfd_vma size_input_section
125 PARAMS ((lang_statement_union_type
**, lang_output_section_statement_type
*,
126 fill_type
, bfd_vma
));
127 static void lang_finish
PARAMS ((void));
128 static void ignore_bfd_errors
PARAMS ((const char *, ...));
129 static void lang_check
PARAMS ((void));
130 static void lang_common
PARAMS ((void));
131 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
132 static void lang_place_orphans
PARAMS ((void));
133 static int topower
PARAMS ((int));
134 static void lang_set_startof
PARAMS ((void));
135 static void reset_memory_regions
PARAMS ((void));
136 static void gc_section_callback
137 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
138 lang_input_statement_type
*, PTR
));
139 static void lang_record_phdrs
PARAMS ((void));
140 static void lang_gc_wild
PARAMS ((lang_wild_statement_type
*));
141 static void lang_gc_sections_1
PARAMS ((lang_statement_union_type
*));
142 static void lang_gc_sections
PARAMS ((void));
143 static int lang_vers_match_lang_c
144 PARAMS ((struct bfd_elf_version_expr
*, const char *));
145 static int lang_vers_match_lang_cplusplus
146 PARAMS ((struct bfd_elf_version_expr
*, const char *));
147 static int lang_vers_match_lang_java
148 PARAMS ((struct bfd_elf_version_expr
*, const char *));
149 static void lang_do_version_exports_section
PARAMS ((void));
150 static void lang_check_section_addresses
PARAMS ((void));
151 static void os_region_check
152 PARAMS ((lang_output_section_statement_type
*,
153 struct memory_region_struct
*, etree_type
*, bfd_vma
));
155 typedef void (*callback_t
) PARAMS ((lang_wild_statement_type
*,
156 struct wildcard_list
*,
158 lang_input_statement_type
*,
160 static void walk_wild
161 PARAMS ((lang_wild_statement_type
*, callback_t
, PTR
));
162 static void walk_wild_section
163 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
165 static void walk_wild_file
166 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
169 static int get_target
PARAMS ((const bfd_target
*, PTR
));
170 static void stricpy
PARAMS ((char *, char *));
171 static void strcut
PARAMS ((char *, char *));
172 static int name_compare
PARAMS ((char *, char *));
173 static int closest_target_match
PARAMS ((const bfd_target
*, PTR
));
174 static char * get_first_input_target
PARAMS ((void));
177 lang_output_section_statement_type
*abs_output_section
;
178 lang_statement_list_type lang_output_section_statement
;
179 lang_statement_list_type
*stat_ptr
= &statement_list
;
180 lang_statement_list_type file_chain
= { NULL
, NULL
};
181 const char *entry_symbol
= NULL
;
182 boolean entry_from_cmdline
;
183 boolean lang_has_input_file
= false;
184 boolean had_output_filename
= false;
185 boolean lang_float_flag
= false;
186 boolean delete_output_file_on_failure
= false;
187 struct lang_nocrossrefs
*nocrossref_list
;
188 struct unique_sections
*unique_section_list
;
190 etree_type
*base
; /* Relocation base - or null */
192 #if defined (__STDC__) || defined (ALMOST_STDC)
193 #define cat(a,b) a##b
195 #define cat(a,b) a/**/b
198 /* Don't beautify the line below with "innocent" whitespace, it breaks
199 the K&R C preprocessor! */
200 #define new_stat(x, y) \
201 (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
203 #define outside_section_address(q) \
204 ((q)->output_offset + (q)->output_section->vma)
206 #define outside_symbol_address(q) \
207 ((q)->value + outside_section_address (q->section))
209 #define SECTION_NAME_MAP_LENGTH (16)
215 return obstack_alloc (&stat_obstack
, size
);
219 unique_section_p (secnam
)
222 struct unique_sections
*unam
;
224 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
225 if (wildcardp (unam
->name
)
226 ? fnmatch (unam
->name
, secnam
, 0) == 0
227 : strcmp (unam
->name
, secnam
) == 0)
235 /* Generic traversal routines for finding matching sections. */
238 walk_wild_section (ptr
, file
, callback
, data
)
239 lang_wild_statement_type
*ptr
;
240 lang_input_statement_type
*file
;
246 if (file
->just_syms_flag
)
249 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
251 struct wildcard_list
*sec
;
253 sec
= ptr
->section_list
;
256 boolean skip
= false;
260 struct name_list
*list_tmp
;
262 /* Don't process sections from files which were
264 for (list_tmp
= sec
->spec
.exclude_name_list
;
266 list_tmp
= list_tmp
->next
)
268 if (wildcardp (list_tmp
->name
))
269 skip
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
271 skip
= strcmp (list_tmp
->name
, file
->filename
) == 0;
277 if (!skip
&& sec
->spec
.name
!= NULL
)
279 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
281 if (wildcardp (sec
->spec
.name
))
282 skip
= fnmatch (sec
->spec
.name
, sname
, 0) != 0;
284 skip
= strcmp (sec
->spec
.name
, sname
) != 0;
289 (*callback
) (ptr
, sec
, s
, file
, data
);
298 /* Handle a wild statement for a single file F. */
301 walk_wild_file (s
, f
, callback
, data
)
302 lang_wild_statement_type
*s
;
303 lang_input_statement_type
*f
;
307 if (f
->the_bfd
== NULL
308 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
309 walk_wild_section (s
, f
, callback
, data
);
314 /* This is an archive file. We must map each member of the
315 archive separately. */
316 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
317 while (member
!= NULL
)
319 /* When lookup_name is called, it will call the add_symbols
320 entry point for the archive. For each element of the
321 archive which is included, BFD will call ldlang_add_file,
322 which will set the usrdata field of the member to the
323 lang_input_statement. */
324 if (member
->usrdata
!= NULL
)
326 walk_wild_section (s
,
327 (lang_input_statement_type
*) member
->usrdata
,
331 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
337 walk_wild (s
, callback
, data
)
338 lang_wild_statement_type
*s
;
342 const char *file_spec
= s
->filename
;
344 if (file_spec
== NULL
)
346 /* Perform the iteration over all files in the list. */
347 LANG_FOR_EACH_INPUT_STATEMENT (f
)
349 walk_wild_file (s
, f
, callback
, data
);
352 else if (wildcardp (file_spec
))
354 LANG_FOR_EACH_INPUT_STATEMENT (f
)
356 if (fnmatch (file_spec
, f
->filename
, FNM_FILE_NAME
) == 0)
357 walk_wild_file (s
, f
, callback
, data
);
362 lang_input_statement_type
*f
;
364 /* Perform the iteration over a single file. */
365 f
= lookup_name (file_spec
);
367 walk_wild_file (s
, f
, callback
, data
);
371 /* lang_for_each_statement walks the parse tree and calls the provided
372 function for each node. */
375 lang_for_each_statement_worker (func
, s
)
376 void (*func
) PARAMS ((lang_statement_union_type
*));
377 lang_statement_union_type
*s
;
379 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
383 switch (s
->header
.type
)
385 case lang_constructors_statement_enum
:
386 lang_for_each_statement_worker (func
, constructor_list
.head
);
388 case lang_output_section_statement_enum
:
389 lang_for_each_statement_worker
391 s
->output_section_statement
.children
.head
);
393 case lang_wild_statement_enum
:
394 lang_for_each_statement_worker
396 s
->wild_statement
.children
.head
);
398 case lang_group_statement_enum
:
399 lang_for_each_statement_worker (func
,
400 s
->group_statement
.children
.head
);
402 case lang_data_statement_enum
:
403 case lang_reloc_statement_enum
:
404 case lang_object_symbols_statement_enum
:
405 case lang_output_statement_enum
:
406 case lang_target_statement_enum
:
407 case lang_input_section_enum
:
408 case lang_input_statement_enum
:
409 case lang_assignment_statement_enum
:
410 case lang_padding_statement_enum
:
411 case lang_address_statement_enum
:
412 case lang_fill_statement_enum
:
422 lang_for_each_statement (func
)
423 void (*func
) PARAMS ((lang_statement_union_type
*));
425 lang_for_each_statement_worker (func
, statement_list
.head
);
428 /*----------------------------------------------------------------------*/
431 lang_list_init (list
)
432 lang_statement_list_type
*list
;
434 list
->head
= (lang_statement_union_type
*) NULL
;
435 list
->tail
= &list
->head
;
438 /* Build a new statement node for the parse tree. */
440 static lang_statement_union_type
*
441 new_statement (type
, size
, list
)
442 enum statement_enum type
;
444 lang_statement_list_type
*list
;
446 lang_statement_union_type
*new = (lang_statement_union_type
*)
449 new->header
.type
= type
;
450 new->header
.next
= (lang_statement_union_type
*) NULL
;
451 lang_statement_append (list
, new, &new->header
.next
);
455 /* Build a new input file node for the language. There are several
456 ways in which we treat an input file, eg, we only look at symbols,
457 or prefix it with a -l etc.
459 We can be supplied with requests for input files more than once;
460 they may, for example be split over serveral lines like foo.o(.text)
461 foo.o(.data) etc, so when asked for a file we check that we haven't
462 got it already so we don't duplicate the bfd. */
464 static lang_input_statement_type
*
465 new_afile (name
, file_type
, target
, add_to_list
)
467 lang_input_file_enum_type file_type
;
471 lang_input_statement_type
*p
;
474 p
= new_stat (lang_input_statement
, stat_ptr
);
477 p
= ((lang_input_statement_type
*)
478 stat_alloc (sizeof (lang_input_statement_type
)));
479 p
->header
.next
= NULL
;
482 lang_has_input_file
= true;
486 case lang_input_file_is_symbols_only_enum
:
488 p
->is_archive
= false;
490 p
->local_sym_name
= name
;
491 p
->just_syms_flag
= true;
492 p
->search_dirs_flag
= false;
494 case lang_input_file_is_fake_enum
:
496 p
->is_archive
= false;
498 p
->local_sym_name
= name
;
499 p
->just_syms_flag
= false;
500 p
->search_dirs_flag
= false;
502 case lang_input_file_is_l_enum
:
503 p
->is_archive
= true;
506 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
507 p
->just_syms_flag
= false;
508 p
->search_dirs_flag
= true;
510 case lang_input_file_is_marker_enum
:
512 p
->is_archive
= false;
514 p
->local_sym_name
= name
;
515 p
->just_syms_flag
= false;
516 p
->search_dirs_flag
= true;
518 case lang_input_file_is_search_file_enum
:
520 p
->is_archive
= false;
522 p
->local_sym_name
= name
;
523 p
->just_syms_flag
= false;
524 p
->search_dirs_flag
= true;
526 case lang_input_file_is_file_enum
:
528 p
->is_archive
= false;
530 p
->local_sym_name
= name
;
531 p
->just_syms_flag
= false;
532 p
->search_dirs_flag
= false;
537 p
->the_bfd
= (bfd
*) NULL
;
538 p
->asymbols
= (asymbol
**) NULL
;
539 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
540 p
->next
= (lang_statement_union_type
*) NULL
;
542 p
->dynamic
= config
.dynamic_link
;
543 p
->whole_archive
= whole_archive
;
545 lang_statement_append (&input_file_chain
,
546 (lang_statement_union_type
*) p
,
551 lang_input_statement_type
*
552 lang_add_input_file (name
, file_type
, target
)
554 lang_input_file_enum_type file_type
;
557 lang_has_input_file
= true;
558 return new_afile (name
, file_type
, target
, true);
561 /* Build enough state so that the parser can build its tree. */
566 obstack_begin (&stat_obstack
, 1000);
568 stat_ptr
= &statement_list
;
570 lang_list_init (stat_ptr
);
572 lang_list_init (&input_file_chain
);
573 lang_list_init (&lang_output_section_statement
);
574 lang_list_init (&file_chain
);
575 first_file
= lang_add_input_file ((char *) NULL
,
576 lang_input_file_is_marker_enum
,
579 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
581 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
585 /*----------------------------------------------------------------------
586 A region is an area of memory declared with the
587 MEMORY { name:org=exp, len=exp ... }
590 We maintain a list of all the regions here.
592 If no regions are specified in the script, then the default is used
593 which is created when looked up to be the entire data space. */
595 static lang_memory_region_type
*lang_memory_region_list
;
596 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
598 lang_memory_region_type
*
599 lang_memory_region_lookup (name
)
600 const char *const name
;
602 lang_memory_region_type
*p
;
604 for (p
= lang_memory_region_list
;
605 p
!= (lang_memory_region_type
*) NULL
;
608 if (strcmp (p
->name
, name
) == 0)
615 /* This code used to always use the first region in the list as the
616 default region. I changed it to instead use a region
617 encompassing all of memory as the default region. This permits
618 NOLOAD sections to work reasonably without requiring a region.
619 People should specify what region they mean, if they really want
621 if (strcmp (name
, "*default*") == 0)
623 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
625 return lang_memory_region_list
;
631 lang_memory_region_type
*new =
632 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
634 new->name
= xstrdup (name
);
635 new->next
= (lang_memory_region_type
*) NULL
;
637 *lang_memory_region_list_tail
= new;
638 lang_memory_region_list_tail
= &new->next
;
642 new->length
= ~(bfd_size_type
) 0;
644 new->had_full_message
= false;
650 static lang_memory_region_type
*
651 lang_memory_default (section
)
654 lang_memory_region_type
*p
;
656 flagword sec_flags
= section
->flags
;
658 /* Override SEC_DATA to mean a writable section. */
659 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
660 sec_flags
|= SEC_DATA
;
662 for (p
= lang_memory_region_list
;
663 p
!= (lang_memory_region_type
*) NULL
;
666 if ((p
->flags
& sec_flags
) != 0
667 && (p
->not_flags
& sec_flags
) == 0)
672 return lang_memory_region_lookup ("*default*");
675 lang_output_section_statement_type
*
676 lang_output_section_find (name
)
677 const char *const name
;
679 lang_statement_union_type
*u
;
680 lang_output_section_statement_type
*lookup
;
682 for (u
= lang_output_section_statement
.head
;
683 u
!= (lang_statement_union_type
*) NULL
;
686 lookup
= &u
->output_section_statement
;
687 if (strcmp (name
, lookup
->name
) == 0)
692 return (lang_output_section_statement_type
*) NULL
;
695 lang_output_section_statement_type
*
696 lang_output_section_statement_lookup (name
)
697 const char *const name
;
699 lang_output_section_statement_type
*lookup
;
701 lookup
= lang_output_section_find (name
);
702 if (lookup
== (lang_output_section_statement_type
*) NULL
)
705 lookup
= (lang_output_section_statement_type
*)
706 new_stat (lang_output_section_statement
, stat_ptr
);
707 lookup
->region
= (lang_memory_region_type
*) NULL
;
708 lookup
->lma_region
= (lang_memory_region_type
*) NULL
;
710 lookup
->block_value
= 1;
713 lookup
->next
= (lang_statement_union_type
*) NULL
;
714 lookup
->bfd_section
= (asection
*) NULL
;
715 lookup
->processed
= false;
716 lookup
->sectype
= normal_section
;
717 lookup
->addr_tree
= (etree_type
*) NULL
;
718 lang_list_init (&lookup
->children
);
720 lookup
->memspec
= (const char *) NULL
;
722 lookup
->subsection_alignment
= -1;
723 lookup
->section_alignment
= -1;
724 lookup
->load_base
= (union etree_union
*) NULL
;
725 lookup
->phdrs
= NULL
;
727 lang_statement_append (&lang_output_section_statement
,
728 (lang_statement_union_type
*) lookup
,
735 lang_map_flags (flag
)
738 if (flag
& SEC_ALLOC
)
744 if (flag
& SEC_READONLY
)
757 lang_memory_region_type
*m
;
759 minfo (_("\nMemory Configuration\n\n"));
760 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
761 _("Name"), _("Origin"), _("Length"), _("Attributes"));
763 for (m
= lang_memory_region_list
;
764 m
!= (lang_memory_region_type
*) NULL
;
770 fprintf (config
.map_file
, "%-16s ", m
->name
);
772 sprintf_vma (buf
, m
->origin
);
773 minfo ("0x%s ", buf
);
781 minfo ("0x%V", m
->length
);
782 if (m
->flags
|| m
->not_flags
)
790 lang_map_flags (m
->flags
);
796 lang_map_flags (m
->not_flags
);
803 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
808 /* Initialize an output section. */
812 lang_output_section_statement_type
*s
;
814 section_userdata_type
*new;
816 if (s
->bfd_section
!= NULL
)
819 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
820 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
822 new = ((section_userdata_type
*)
823 stat_alloc (sizeof (section_userdata_type
)));
825 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
826 if (s
->bfd_section
== (asection
*) NULL
)
827 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
828 if (s
->bfd_section
== (asection
*) NULL
)
830 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
831 output_bfd
->xvec
->name
, s
->name
);
833 s
->bfd_section
->output_section
= s
->bfd_section
;
835 /* We initialize an output sections output offset to minus its own
836 vma to allow us to output a section through itself. */
837 s
->bfd_section
->output_offset
= 0;
838 get_userdata (s
->bfd_section
) = (PTR
) new;
840 /* If there is a base address, make sure that any sections it might
841 mention are initialized. */
842 if (s
->addr_tree
!= NULL
)
843 exp_init_os (s
->addr_tree
);
846 /* Make sure that all output sections mentioned in an expression are
853 switch (exp
->type
.node_class
)
856 exp_init_os (exp
->assign
.src
);
860 exp_init_os (exp
->binary
.lhs
);
861 exp_init_os (exp
->binary
.rhs
);
865 exp_init_os (exp
->trinary
.cond
);
866 exp_init_os (exp
->trinary
.lhs
);
867 exp_init_os (exp
->trinary
.rhs
);
871 exp_init_os (exp
->unary
.child
);
875 switch (exp
->type
.node_code
)
881 lang_output_section_statement_type
*os
;
883 os
= lang_output_section_find (exp
->name
.name
);
884 if (os
!= NULL
&& os
->bfd_section
== NULL
)
895 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
896 once into the output. This routine checks each section, and
897 arrange to discard it if a section of the same name has already
898 been linked. If the section has COMDAT information, then it uses
899 that to decide whether the section should be included. This code
900 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
901 that is, it does not depend solely upon the section name.
902 section_already_linked is called via bfd_map_over_sections. */
904 /* This is the shape of the elements inside the already_linked hash
905 table. It maps a name onto a list of already_linked elements with
906 the same name. It's possible to get more than one element in a
907 list if the COMDAT sections have different names. */
909 struct already_linked_hash_entry
911 struct bfd_hash_entry root
;
912 struct already_linked
*entry
;
915 struct already_linked
917 struct already_linked
*next
;
921 /* The hash table. */
923 static struct bfd_hash_table already_linked_table
;
926 section_already_linked (abfd
, sec
, data
)
931 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
934 struct already_linked
*l
;
935 struct already_linked_hash_entry
*already_linked_list
;
937 /* If we are only reading symbols from this object, then we want to
938 discard all sections. */
939 if (entry
->just_syms_flag
)
941 sec
->output_section
= bfd_abs_section_ptr
;
942 sec
->output_offset
= sec
->vma
;
946 flags
= bfd_get_section_flags (abfd
, sec
);
948 if ((flags
& SEC_LINK_ONCE
) == 0)
951 /* FIXME: When doing a relocatable link, we may have trouble
952 copying relocations in other sections that refer to local symbols
953 in the section being discarded. Those relocations will have to
954 be converted somehow; as of this writing I'm not sure that any of
955 the backends handle that correctly.
957 It is tempting to instead not discard link once sections when
958 doing a relocatable link (technically, they should be discarded
959 whenever we are building constructors). However, that fails,
960 because the linker winds up combining all the link once sections
961 into a single large link once section, which defeats the purpose
962 of having link once sections in the first place.
964 Also, not merging link once sections in a relocatable link
965 causes trouble for MIPS ELF, which relies in link once semantics
966 to handle the .reginfo section correctly. */
968 name
= bfd_get_section_name (abfd
, sec
);
970 already_linked_list
=
971 ((struct already_linked_hash_entry
*)
972 bfd_hash_lookup (&already_linked_table
, name
, true, false));
974 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
976 if (sec
->comdat
== NULL
977 || l
->sec
->comdat
== NULL
978 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
980 /* The section has already been linked. See if we should
982 switch (flags
& SEC_LINK_DUPLICATES
)
987 case SEC_LINK_DUPLICATES_DISCARD
:
990 case SEC_LINK_DUPLICATES_ONE_ONLY
:
991 if (sec
->comdat
== NULL
)
992 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
995 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
996 abfd
, name
, sec
->comdat
->name
);
999 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
1000 /* FIXME: We should really dig out the contents of both
1001 sections and memcmp them. The COFF/PE spec says that
1002 the Microsoft linker does not implement this
1003 correctly, so I'm not going to bother doing it
1006 case SEC_LINK_DUPLICATES_SAME_SIZE
:
1007 if (bfd_section_size (abfd
, sec
)
1008 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1009 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1014 /* Set the output_section field so that lang_add_section
1015 does not create a lang_input_section structure for this
1016 section. Since there might be a symbol in the section
1017 being discarded, we must retain a pointer to the section
1018 which we are really going to use. */
1019 sec
->output_section
= bfd_abs_section_ptr
;
1020 sec
->kept_section
= l
->sec
;
1026 /* This is the first section with this name. Record it. Allocate
1027 the memory from the same obstack as the hash table is kept in. */
1029 l
= ((struct already_linked
*)
1030 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1033 l
->next
= already_linked_list
->entry
;
1034 already_linked_list
->entry
= l
;
1037 /* Support routines for the hash table used by section_already_linked,
1038 initialize the table, fill in an entry and remove the table. */
1040 static struct bfd_hash_entry
*
1041 already_linked_newfunc (entry
, table
, string
)
1042 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1043 struct bfd_hash_table
*table
;
1044 const char *string ATTRIBUTE_UNUSED
;
1046 struct already_linked_hash_entry
*ret
=
1047 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1051 return (struct bfd_hash_entry
*) ret
;
1055 already_linked_table_init ()
1057 if (! bfd_hash_table_init_n (&already_linked_table
,
1058 already_linked_newfunc
,
1060 einfo (_("%P%F: Failed to create hash table\n"));
1064 already_linked_table_free ()
1066 bfd_hash_table_free (&already_linked_table
);
1069 /* The wild routines.
1071 These expand statements like *(.text) and foo.o to a list of
1072 explicit actions, like foo.o(.text), bar.o(.text) and
1073 foo.o(.text, .data). */
1075 /* Return true if the PATTERN argument is a wildcard pattern.
1076 Although backslashes are treated specially if a pattern contains
1077 wildcards, we do not consider the mere presence of a backslash to
1078 be enough to cause the the pattern to be treated as a wildcard.
1079 That lets us handle DOS filenames more naturally. */
1083 const char *pattern
;
1087 for (s
= pattern
; *s
!= '\0'; ++s
)
1095 /* Add SECTION to the output section OUTPUT. Do this by creating a
1096 lang_input_section statement which is placed at PTR. FILE is the
1097 input file which holds SECTION. */
1100 lang_add_section (ptr
, section
, output
, file
)
1101 lang_statement_list_type
*ptr
;
1103 lang_output_section_statement_type
*output
;
1104 lang_input_statement_type
*file
;
1109 flags
= bfd_get_section_flags (section
->owner
, section
);
1113 /* If we are doing a final link, discard sections marked with
1115 if (! link_info
.relocateable
1116 && (flags
& SEC_EXCLUDE
) != 0)
1119 /* Discard input sections which are assigned to a section named
1120 DISCARD_SECTION_NAME. */
1121 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1124 /* Discard debugging sections if we are stripping debugging
1126 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1127 && (flags
& SEC_DEBUGGING
) != 0)
1132 if (section
->output_section
== NULL
)
1134 /* This prevents future calls from assigning this section. */
1135 section
->output_section
= bfd_abs_section_ptr
;
1140 if (section
->output_section
== NULL
)
1143 lang_input_section_type
*new;
1146 if (output
->bfd_section
== NULL
)
1149 first
= ! output
->bfd_section
->linker_has_input
;
1150 output
->bfd_section
->linker_has_input
= 1;
1152 /* Add a section reference to the list. */
1153 new = new_stat (lang_input_section
, ptr
);
1155 new->section
= section
;
1157 section
->output_section
= output
->bfd_section
;
1159 flags
= section
->flags
;
1161 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1162 to an output section, because we want to be able to include a
1163 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1164 section (I don't know why we want to do this, but we do).
1165 build_link_order in ldwrite.c handles this case by turning
1166 the embedded SEC_NEVER_LOAD section into a fill. */
1168 flags
&= ~ SEC_NEVER_LOAD
;
1170 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1171 already been processed. One reason to do this is that on pe
1172 format targets, .text$foo sections go into .text and it's odd
1173 to see .text with SEC_LINK_ONCE set. */
1175 if (! link_info
.relocateable
)
1176 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1178 /* If this is not the first input section, and the SEC_READONLY
1179 flag is not currently set, then don't set it just because the
1180 input section has it set. */
1182 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1183 flags
&= ~ SEC_READONLY
;
1185 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1187 && ((section
->output_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1188 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1189 || ((flags
& SEC_MERGE
)
1190 && section
->output_section
->entsize
!= section
->entsize
)))
1192 section
->output_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1193 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1196 section
->output_section
->flags
|= flags
;
1198 if (flags
& SEC_MERGE
)
1199 section
->output_section
->entsize
= section
->entsize
;
1201 /* If SEC_READONLY is not set in the input section, then clear
1202 it from the output section. */
1203 if ((section
->flags
& SEC_READONLY
) == 0)
1204 section
->output_section
->flags
&= ~SEC_READONLY
;
1206 switch (output
->sectype
)
1208 case normal_section
:
1213 case overlay_section
:
1214 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1216 case noload_section
:
1217 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1218 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1222 /* Copy over SEC_SMALL_DATA. */
1223 if (section
->flags
& SEC_SMALL_DATA
)
1224 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1226 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1227 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1229 /* If supplied an aligment, then force it. */
1230 if (output
->section_alignment
!= -1)
1231 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1233 if (section
->flags
& SEC_BLOCK
)
1235 section
->output_section
->flags
|= SEC_BLOCK
;
1236 /* FIXME: This value should really be obtained from the bfd... */
1237 output
->block_value
= 128;
1242 /* Handle wildcard sorting. This returns the lang_input_section which
1243 should follow the one we are going to create for SECTION and FILE,
1244 based on the sorting requirements of WILD. It returns NULL if the
1245 new section should just go at the end of the current list. */
1247 static lang_statement_union_type
*
1248 wild_sort (wild
, sec
, file
, section
)
1249 lang_wild_statement_type
*wild
;
1250 struct wildcard_list
*sec
;
1251 lang_input_statement_type
*file
;
1254 const char *section_name
;
1255 lang_statement_union_type
*l
;
1257 if (!wild
->filenames_sorted
&& (sec
== NULL
|| !sec
->spec
.sorted
))
1260 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1261 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
1263 lang_input_section_type
*ls
;
1265 if (l
->header
.type
!= lang_input_section_enum
)
1267 ls
= &l
->input_section
;
1269 /* Sorting by filename takes precedence over sorting by section
1272 if (wild
->filenames_sorted
)
1274 const char *fn
, *ln
;
1278 /* The PE support for the .idata section as generated by
1279 dlltool assumes that files will be sorted by the name of
1280 the archive and then the name of the file within the
1283 if (file
->the_bfd
!= NULL
1284 && bfd_my_archive (file
->the_bfd
) != NULL
)
1286 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1291 fn
= file
->filename
;
1295 if (ls
->ifile
->the_bfd
!= NULL
1296 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1298 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1303 ln
= ls
->ifile
->filename
;
1307 i
= strcmp (fn
, ln
);
1316 fn
= file
->filename
;
1318 ln
= ls
->ifile
->filename
;
1320 i
= strcmp (fn
, ln
);
1328 /* Here either the files are not sorted by name, or we are
1329 looking at the sections for this file. */
1331 if (sec
!= NULL
&& sec
->spec
.sorted
)
1333 if (strcmp (section_name
,
1334 bfd_get_section_name (ls
->ifile
->the_bfd
,
1344 /* Expand a wild statement for a particular FILE. SECTION may be
1345 NULL, in which case it is a wild card. */
1348 output_section_callback (ptr
, sec
, section
, file
, output
)
1349 lang_wild_statement_type
*ptr
;
1350 struct wildcard_list
*sec
;
1352 lang_input_statement_type
*file
;
1355 lang_statement_union_type
*before
;
1357 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1358 if (unique_section_p (bfd_get_section_name (file
->the_bfd
, section
)))
1361 /* If the wild pattern was marked KEEP, the member sections
1362 should be as well. */
1363 if (ptr
->keep_sections
)
1364 section
->flags
|= SEC_KEEP
;
1366 before
= wild_sort (ptr
, sec
, file
, section
);
1368 /* Here BEFORE points to the lang_input_section which
1369 should follow the one we are about to add. If BEFORE
1370 is NULL, then the section should just go at the end
1371 of the current list. */
1374 lang_add_section (&ptr
->children
, section
,
1375 (lang_output_section_statement_type
*) output
,
1379 lang_statement_list_type list
;
1380 lang_statement_union_type
**pp
;
1382 lang_list_init (&list
);
1383 lang_add_section (&list
, section
,
1384 (lang_output_section_statement_type
*) output
,
1387 /* If we are discarding the section, LIST.HEAD will
1389 if (list
.head
!= NULL
)
1391 ASSERT (list
.head
->header
.next
== NULL
);
1393 for (pp
= &ptr
->children
.head
;
1395 pp
= &(*pp
)->header
.next
)
1396 ASSERT (*pp
!= NULL
);
1398 list
.head
->header
.next
= *pp
;
1404 /* This is passed a file name which must have been seen already and
1405 added to the statement tree. We will see if it has been opened
1406 already and had its symbols read. If not then we'll read it. */
1408 static lang_input_statement_type
*
1412 lang_input_statement_type
*search
;
1414 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1415 search
!= (lang_input_statement_type
*) NULL
;
1416 search
= (lang_input_statement_type
*) search
->next_real_file
)
1418 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1420 if (search
->filename
!= (char *) NULL
1421 && name
!= (char *) NULL
1422 && strcmp (search
->filename
, name
) == 0)
1426 if (search
== (lang_input_statement_type
*) NULL
)
1427 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1430 /* If we have already added this file, or this file is not real
1431 (FIXME: can that ever actually happen?) or the name is NULL
1432 (FIXME: can that ever actually happen?) don't add this file. */
1435 || search
->filename
== (const char *) NULL
)
1438 if (! load_symbols (search
, (lang_statement_list_type
*) NULL
))
1444 /* Get the symbols for an input file. */
1447 load_symbols (entry
, place
)
1448 lang_input_statement_type
*entry
;
1449 lang_statement_list_type
*place
;
1456 ldfile_open_file (entry
);
1458 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1459 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1462 lang_statement_list_type
*hold
;
1463 boolean bad_load
= true;
1465 err
= bfd_get_error ();
1467 /* See if the emulation has some special knowledge. */
1468 if (ldemul_unrecognized_file (entry
))
1471 if (err
== bfd_error_file_ambiguously_recognized
)
1475 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1476 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1477 for (p
= matching
; *p
!= NULL
; p
++)
1481 else if (err
!= bfd_error_file_not_recognized
1483 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1487 bfd_close (entry
->the_bfd
);
1488 entry
->the_bfd
= NULL
;
1490 /* Try to interpret the file as a linker script. */
1491 ldfile_open_command_file (entry
->filename
);
1496 ldfile_assumed_script
= true;
1497 parser_input
= input_script
;
1499 ldfile_assumed_script
= false;
1506 if (ldemul_recognized_file (entry
))
1509 /* We don't call ldlang_add_file for an archive. Instead, the
1510 add_symbols entry point will call ldlang_add_file, via the
1511 add_archive_element callback, for each element of the archive
1513 switch (bfd_get_format (entry
->the_bfd
))
1519 ldlang_add_file (entry
);
1520 if (trace_files
|| trace_file_tries
)
1521 info_msg ("%I\n", entry
);
1525 if (entry
->whole_archive
)
1527 bfd
* member
= NULL
;
1528 boolean loaded
= true;
1532 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
1537 if (! bfd_check_format (member
, bfd_object
))
1539 einfo (_("%F%B: member %B in archive is not an object\n"),
1540 entry
->the_bfd
, member
);
1544 if (! ((*link_info
.callbacks
->add_archive_element
)
1545 (&link_info
, member
, "--whole-archive")))
1548 if (! bfd_link_add_symbols (member
, &link_info
))
1550 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1555 entry
->loaded
= loaded
;
1561 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1562 entry
->loaded
= true;
1564 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1566 return entry
->loaded
;
1569 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1570 may be NULL, indicating that it is a wildcard. Separate
1571 lang_input_section statements are created for each part of the
1572 expansion; they are added after the wild statement S. OUTPUT is
1573 the output section. */
1576 wild (s
, target
, output
)
1577 lang_wild_statement_type
*s
;
1578 const char *target ATTRIBUTE_UNUSED
;
1579 lang_output_section_statement_type
*output
;
1581 struct wildcard_list
*sec
;
1583 walk_wild (s
, output_section_callback
, (PTR
) output
);
1585 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
1587 if (default_common_section
!= NULL
)
1589 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
1591 /* Remember the section that common is going to in case we
1592 later get something which doesn't know where to put it. */
1593 default_common_section
= output
;
1598 /* Return true iff target is the sought target. */
1601 get_target (target
, data
)
1602 const bfd_target
*target
;
1605 const char *sought
= (const char *) data
;
1607 return strcmp (target
->name
, sought
) == 0;
1610 /* Like strcpy() but convert to lower case as well. */
1619 while ((c
= *src
++) != 0)
1620 *dest
++ = TOLOWER (c
);
1625 /* Remove the first occurance of needle (if any) in haystack
1629 strcut (haystack
, needle
)
1633 haystack
= strstr (haystack
, needle
);
1639 for (src
= haystack
+ strlen (needle
); *src
;)
1640 *haystack
++ = *src
++;
1646 /* Compare two target format name strings.
1647 Return a value indicating how "similar" they are. */
1650 name_compare (first
, second
)
1658 copy1
= xmalloc (strlen (first
) + 1);
1659 copy2
= xmalloc (strlen (second
) + 1);
1661 /* Convert the names to lower case. */
1662 stricpy (copy1
, first
);
1663 stricpy (copy2
, second
);
1665 /* Remove and endian strings from the name. */
1666 strcut (copy1
, "big");
1667 strcut (copy1
, "little");
1668 strcut (copy2
, "big");
1669 strcut (copy2
, "little");
1671 /* Return a value based on how many characters match,
1672 starting from the beginning. If both strings are
1673 the same then return 10 * their length. */
1674 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1675 if (copy1
[result
] == 0)
1687 /* Set by closest_target_match() below. */
1688 static const bfd_target
*winner
;
1690 /* Scan all the valid bfd targets looking for one that has the endianness
1691 requirement that was specified on the command line, and is the nearest
1692 match to the original output target. */
1695 closest_target_match (target
, data
)
1696 const bfd_target
*target
;
1699 const bfd_target
*original
= (const bfd_target
*) data
;
1701 if (command_line
.endian
== ENDIAN_BIG
1702 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1705 if (command_line
.endian
== ENDIAN_LITTLE
1706 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1709 /* Must be the same flavour. */
1710 if (target
->flavour
!= original
->flavour
)
1713 /* If we have not found a potential winner yet, then record this one. */
1720 /* Oh dear, we now have two potential candidates for a successful match.
1721 Compare their names and choose the better one. */
1722 if (name_compare (target
->name
, original
->name
)
1723 > name_compare (winner
->name
, original
->name
))
1726 /* Keep on searching until wqe have checked them all. */
1730 /* Return the BFD target format of the first input file. */
1733 get_first_input_target ()
1735 char *target
= NULL
;
1737 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1739 if (s
->header
.type
== lang_input_statement_enum
1742 ldfile_open_file (s
);
1744 if (s
->the_bfd
!= NULL
1745 && bfd_check_format (s
->the_bfd
, bfd_object
))
1747 target
= bfd_get_target (s
->the_bfd
);
1758 /* Open the output file. */
1766 /* Has the user told us which output format to use? */
1767 if (output_target
== (char *) NULL
)
1769 /* No - has the current target been set to something other than
1771 if (current_target
!= default_target
)
1772 output_target
= current_target
;
1774 /* No - can we determine the format of the first input file? */
1777 output_target
= get_first_input_target ();
1779 /* Failed - use the default output target. */
1780 if (output_target
== NULL
)
1781 output_target
= default_target
;
1785 /* Has the user requested a particular endianness on the command
1787 if (command_line
.endian
!= ENDIAN_UNSET
)
1789 const bfd_target
*target
;
1790 enum bfd_endian desired_endian
;
1792 /* Get the chosen target. */
1793 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1795 /* If the target is not supported, we cannot do anything. */
1798 if (command_line
.endian
== ENDIAN_BIG
)
1799 desired_endian
= BFD_ENDIAN_BIG
;
1801 desired_endian
= BFD_ENDIAN_LITTLE
;
1803 /* See if the target has the wrong endianness. This should
1804 not happen if the linker script has provided big and
1805 little endian alternatives, but some scrips don't do
1807 if (target
->byteorder
!= desired_endian
)
1809 /* If it does, then see if the target provides
1810 an alternative with the correct endianness. */
1811 if (target
->alternative_target
!= NULL
1812 && (target
->alternative_target
->byteorder
== desired_endian
))
1813 output_target
= target
->alternative_target
->name
;
1816 /* Try to find a target as similar as possible to
1817 the default target, but which has the desired
1818 endian characteristic. */
1819 (void) bfd_search_for_target (closest_target_match
,
1822 /* Oh dear - we could not find any targets that
1823 satisfy our requirements. */
1825 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1827 output_target
= winner
->name
;
1833 output
= bfd_openw (name
, output_target
);
1835 if (output
== (bfd
*) NULL
)
1837 if (bfd_get_error () == bfd_error_invalid_target
)
1838 einfo (_("%P%F: target %s not found\n"), output_target
);
1840 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1843 delete_output_file_on_failure
= true;
1846 output
->flags
|= D_PAGED
;
1849 if (! bfd_set_format (output
, bfd_object
))
1850 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1851 if (! bfd_set_arch_mach (output
,
1852 ldfile_output_architecture
,
1853 ldfile_output_machine
))
1854 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1856 link_info
.hash
= bfd_link_hash_table_create (output
);
1857 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1858 einfo (_("%P%F: can not create link hash table: %E\n"));
1860 bfd_set_gp_size (output
, g_switch_value
);
1865 ldlang_open_output (statement
)
1866 lang_statement_union_type
*statement
;
1868 switch (statement
->header
.type
)
1870 case lang_output_statement_enum
:
1871 ASSERT (output_bfd
== (bfd
*) NULL
);
1872 output_bfd
= open_output (statement
->output_statement
.name
);
1873 ldemul_set_output_arch ();
1874 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1875 output_bfd
->flags
|= D_PAGED
;
1877 output_bfd
->flags
&= ~D_PAGED
;
1878 if (config
.text_read_only
)
1879 output_bfd
->flags
|= WP_TEXT
;
1881 output_bfd
->flags
&= ~WP_TEXT
;
1882 if (link_info
.traditional_format
)
1883 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1885 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1888 case lang_target_statement_enum
:
1889 current_target
= statement
->target_statement
.target
;
1896 /* Open all the input files. */
1899 open_input_bfds (s
, force
)
1900 lang_statement_union_type
*s
;
1903 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
1905 switch (s
->header
.type
)
1907 case lang_constructors_statement_enum
:
1908 open_input_bfds (constructor_list
.head
, force
);
1910 case lang_output_section_statement_enum
:
1911 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1913 case lang_wild_statement_enum
:
1914 /* Maybe we should load the file's symbols. */
1915 if (s
->wild_statement
.filename
1916 && ! wildcardp (s
->wild_statement
.filename
))
1917 (void) lookup_name (s
->wild_statement
.filename
);
1918 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1920 case lang_group_statement_enum
:
1922 struct bfd_link_hash_entry
*undefs
;
1924 /* We must continually search the entries in the group
1925 until no new symbols are added to the list of undefined
1930 undefs
= link_info
.hash
->undefs_tail
;
1931 open_input_bfds (s
->group_statement
.children
.head
, true);
1933 while (undefs
!= link_info
.hash
->undefs_tail
);
1936 case lang_target_statement_enum
:
1937 current_target
= s
->target_statement
.target
;
1939 case lang_input_statement_enum
:
1940 if (s
->input_statement
.real
)
1942 lang_statement_list_type add
;
1944 s
->input_statement
.target
= current_target
;
1946 /* If we are being called from within a group, and this
1947 is an archive which has already been searched, then
1948 force it to be researched unless the whole archive
1949 has been loaded already. */
1951 && !s
->input_statement
.whole_archive
1952 && s
->input_statement
.loaded
1953 && bfd_check_format (s
->input_statement
.the_bfd
,
1955 s
->input_statement
.loaded
= false;
1957 lang_list_init (&add
);
1959 if (! load_symbols (&s
->input_statement
, &add
))
1960 config
.make_executable
= false;
1962 if (add
.head
!= NULL
)
1964 *add
.tail
= s
->header
.next
;
1965 s
->header
.next
= add
.head
;
1975 /* If there are [COMMONS] statements, put a wild one into the bss
1979 lang_reasonable_defaults ()
1982 lang_output_section_statement_lookup (".text");
1983 lang_output_section_statement_lookup (".data");
1985 default_common_section
= lang_output_section_statement_lookup (".bss");
1987 if (placed_commons
== false)
1989 lang_wild_statement_type
*new =
1990 new_stat (lang_wild_statement
,
1991 &default_common_section
->children
);
1993 new->section_name
= "COMMON";
1994 new->filename
= (char *) NULL
;
1995 lang_list_init (&new->children
);
2000 /* Add the supplied name to the symbol table as an undefined reference.
2001 Remove items from the chain as we open input bfds. */
2002 typedef struct ldlang_undef_chain_list
2004 struct ldlang_undef_chain_list
*next
;
2006 } ldlang_undef_chain_list_type
;
2008 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
2011 ldlang_add_undef (name
)
2012 const char *const name
;
2014 ldlang_undef_chain_list_type
*new =
2015 ((ldlang_undef_chain_list_type
*)
2016 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
2018 new->next
= ldlang_undef_chain_list_head
;
2019 ldlang_undef_chain_list_head
= new;
2021 new->name
= xstrdup (name
);
2024 /* Run through the list of undefineds created above and place them
2025 into the linker hash table as undefined symbols belonging to the
2029 lang_place_undefineds ()
2031 ldlang_undef_chain_list_type
*ptr
;
2033 for (ptr
= ldlang_undef_chain_list_head
;
2034 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
2037 struct bfd_link_hash_entry
*h
;
2039 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
2040 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2041 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2042 if (h
->type
== bfd_link_hash_new
)
2044 h
->type
= bfd_link_hash_undefined
;
2045 h
->u
.undef
.abfd
= NULL
;
2046 bfd_link_add_undef (link_info
.hash
, h
);
2051 /* Open input files and attatch to output sections. */
2054 map_input_to_output_sections (s
, target
, output_section_statement
)
2055 lang_statement_union_type
*s
;
2057 lang_output_section_statement_type
*output_section_statement
;
2059 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2061 switch (s
->header
.type
)
2063 case lang_wild_statement_enum
:
2064 wild (&s
->wild_statement
, target
, output_section_statement
);
2065 case lang_constructors_statement_enum
:
2066 map_input_to_output_sections (constructor_list
.head
,
2068 output_section_statement
);
2070 case lang_output_section_statement_enum
:
2071 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2073 &s
->output_section_statement
);
2075 case lang_output_statement_enum
:
2077 case lang_target_statement_enum
:
2078 target
= s
->target_statement
.target
;
2080 case lang_group_statement_enum
:
2081 map_input_to_output_sections (s
->group_statement
.children
.head
,
2083 output_section_statement
);
2085 case lang_fill_statement_enum
:
2086 case lang_input_section_enum
:
2087 case lang_object_symbols_statement_enum
:
2088 case lang_data_statement_enum
:
2089 case lang_reloc_statement_enum
:
2090 case lang_padding_statement_enum
:
2091 case lang_input_statement_enum
:
2092 if (output_section_statement
!= NULL
2093 && output_section_statement
->bfd_section
== NULL
)
2094 init_os (output_section_statement
);
2096 case lang_assignment_statement_enum
:
2097 if (output_section_statement
!= NULL
2098 && output_section_statement
->bfd_section
== NULL
)
2099 init_os (output_section_statement
);
2101 /* Make sure that any sections mentioned in the assignment
2103 exp_init_os (s
->assignment_statement
.exp
);
2105 case lang_afile_asection_pair_statement_enum
:
2108 case lang_address_statement_enum
:
2109 /* Mark the specified section with the supplied address. */
2111 lang_output_section_statement_type
*os
=
2112 lang_output_section_statement_lookup
2113 (s
->address_statement
.section_name
);
2115 if (os
->bfd_section
== NULL
)
2117 os
->addr_tree
= s
->address_statement
.address
;
2125 print_output_section_statement (output_section_statement
)
2126 lang_output_section_statement_type
*output_section_statement
;
2128 asection
*section
= output_section_statement
->bfd_section
;
2131 if (output_section_statement
!= abs_output_section
)
2133 minfo ("\n%s", output_section_statement
->name
);
2135 if (section
!= NULL
)
2137 print_dot
= section
->vma
;
2139 len
= strlen (output_section_statement
->name
);
2140 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2145 while (len
< SECTION_NAME_MAP_LENGTH
)
2151 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2153 if (output_section_statement
->load_base
!= NULL
)
2157 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2158 "load base", lang_final_phase_enum
);
2159 minfo (_(" load address 0x%V"), addr
);
2166 print_statement_list (output_section_statement
->children
.head
,
2167 output_section_statement
);
2171 print_assignment (assignment
, output_section
)
2172 lang_assignment_statement_type
*assignment
;
2173 lang_output_section_statement_type
*output_section
;
2176 etree_value_type result
;
2178 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2181 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2182 lang_final_phase_enum
, print_dot
, &print_dot
);
2184 minfo ("0x%V", result
.value
+ result
.section
->bfd_section
->vma
);
2195 exp_print_tree (assignment
->exp
);
2201 print_input_statement (statm
)
2202 lang_input_statement_type
*statm
;
2204 if (statm
->filename
!= (char *) NULL
)
2206 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2210 /* Print all symbols defined in a particular section. This is called
2211 via bfd_link_hash_traverse. */
2214 print_one_symbol (hash_entry
, ptr
)
2215 struct bfd_link_hash_entry
*hash_entry
;
2218 asection
*sec
= (asection
*) ptr
;
2220 if ((hash_entry
->type
== bfd_link_hash_defined
2221 || hash_entry
->type
== bfd_link_hash_defweak
)
2222 && sec
== hash_entry
->u
.def
.section
)
2226 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2229 (hash_entry
->u
.def
.value
2230 + hash_entry
->u
.def
.section
->output_offset
2231 + hash_entry
->u
.def
.section
->output_section
->vma
));
2233 minfo (" %T\n", hash_entry
->root
.string
);
2239 /* Print information about an input section to the map file. */
2242 print_input_section (in
)
2243 lang_input_section_type
*in
;
2245 asection
*i
= in
->section
;
2246 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2247 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2248 ldfile_output_machine
);
2253 minfo ("%s", i
->name
);
2255 if (i
->output_section
!= NULL
)
2259 len
= 1 + strlen (i
->name
);
2260 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2265 while (len
< SECTION_NAME_MAP_LENGTH
)
2271 minfo ("0x%V %W %B\n",
2272 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2275 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2277 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2289 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2292 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2294 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2300 print_fill_statement (fill
)
2301 lang_fill_statement_type
*fill
;
2303 fprintf (config
.map_file
, " FILL mask 0x%x\n", fill
->fill
);
2307 print_data_statement (data
)
2308 lang_data_statement_type
*data
;
2314 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2315 ldfile_output_machine
);
2317 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2320 addr
= data
->output_vma
;
2321 if (data
->output_section
!= NULL
)
2322 addr
+= data
->output_section
->vma
;
2350 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2352 if (data
->exp
->type
.node_class
!= etree_value
)
2355 exp_print_tree (data
->exp
);
2360 print_dot
= addr
+ size
/ opb
;
2364 /* Print an address statement. These are generated by options like
2368 print_address_statement (address
)
2369 lang_address_statement_type
*address
;
2371 minfo (_("Address of section %s set to "), address
->section_name
);
2372 exp_print_tree (address
->address
);
2376 /* Print a reloc statement. */
2379 print_reloc_statement (reloc
)
2380 lang_reloc_statement_type
*reloc
;
2385 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2386 ldfile_output_machine
);
2388 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2391 addr
= reloc
->output_vma
;
2392 if (reloc
->output_section
!= NULL
)
2393 addr
+= reloc
->output_section
->vma
;
2395 size
= bfd_get_reloc_size (reloc
->howto
);
2397 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2399 if (reloc
->name
!= NULL
)
2400 minfo ("%s+", reloc
->name
);
2402 minfo ("%s+", reloc
->section
->name
);
2404 exp_print_tree (reloc
->addend_exp
);
2408 print_dot
= addr
+ size
/ opb
;
2412 print_padding_statement (s
)
2413 lang_padding_statement_type
*s
;
2417 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2418 ldfile_output_machine
);
2422 len
= sizeof " *fill*" - 1;
2423 while (len
< SECTION_NAME_MAP_LENGTH
)
2429 addr
= s
->output_offset
;
2430 if (s
->output_section
!= NULL
)
2431 addr
+= s
->output_section
->vma
;
2432 minfo ("0x%V %W", addr
, s
->size
);
2435 minfo (" %u", s
->fill
);
2439 print_dot
= addr
+ s
->size
/ opb
;
2443 print_wild_statement (w
, os
)
2444 lang_wild_statement_type
*w
;
2445 lang_output_section_statement_type
*os
;
2447 struct wildcard_list
*sec
;
2451 if (w
->filenames_sorted
)
2453 if (w
->filename
!= NULL
)
2454 minfo ("%s", w
->filename
);
2457 if (w
->filenames_sorted
)
2461 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
2463 if (sec
->spec
.sorted
)
2465 if (sec
->spec
.exclude_name_list
!= NULL
)
2468 minfo ("EXCLUDE_FILE ( %s", sec
->spec
.exclude_name_list
->name
);
2469 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
2470 minfo (", %s", tmp
->name
);
2473 if (sec
->spec
.name
!= NULL
)
2474 minfo ("%s", sec
->spec
.name
);
2477 if (sec
->spec
.sorted
)
2484 print_statement_list (w
->children
.head
, os
);
2487 /* Print a group statement. */
2491 lang_group_statement_type
*s
;
2492 lang_output_section_statement_type
*os
;
2494 fprintf (config
.map_file
, "START GROUP\n");
2495 print_statement_list (s
->children
.head
, os
);
2496 fprintf (config
.map_file
, "END GROUP\n");
2499 /* Print the list of statements in S.
2500 This can be called for any statement type. */
2503 print_statement_list (s
, os
)
2504 lang_statement_union_type
*s
;
2505 lang_output_section_statement_type
*os
;
2509 print_statement (s
, os
);
2514 /* Print the first statement in statement list S.
2515 This can be called for any statement type. */
2518 print_statement (s
, os
)
2519 lang_statement_union_type
*s
;
2520 lang_output_section_statement_type
*os
;
2522 switch (s
->header
.type
)
2525 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2528 case lang_constructors_statement_enum
:
2529 if (constructor_list
.head
!= NULL
)
2531 if (constructors_sorted
)
2532 minfo (" SORT (CONSTRUCTORS)\n");
2534 minfo (" CONSTRUCTORS\n");
2535 print_statement_list (constructor_list
.head
, os
);
2538 case lang_wild_statement_enum
:
2539 print_wild_statement (&s
->wild_statement
, os
);
2541 case lang_address_statement_enum
:
2542 print_address_statement (&s
->address_statement
);
2544 case lang_object_symbols_statement_enum
:
2545 minfo (" CREATE_OBJECT_SYMBOLS\n");
2547 case lang_fill_statement_enum
:
2548 print_fill_statement (&s
->fill_statement
);
2550 case lang_data_statement_enum
:
2551 print_data_statement (&s
->data_statement
);
2553 case lang_reloc_statement_enum
:
2554 print_reloc_statement (&s
->reloc_statement
);
2556 case lang_input_section_enum
:
2557 print_input_section (&s
->input_section
);
2559 case lang_padding_statement_enum
:
2560 print_padding_statement (&s
->padding_statement
);
2562 case lang_output_section_statement_enum
:
2563 print_output_section_statement (&s
->output_section_statement
);
2565 case lang_assignment_statement_enum
:
2566 print_assignment (&s
->assignment_statement
, os
);
2568 case lang_target_statement_enum
:
2569 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2571 case lang_output_statement_enum
:
2572 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2573 if (output_target
!= NULL
)
2574 minfo (" %s", output_target
);
2577 case lang_input_statement_enum
:
2578 print_input_statement (&s
->input_statement
);
2580 case lang_group_statement_enum
:
2581 print_group (&s
->group_statement
, os
);
2583 case lang_afile_asection_pair_statement_enum
:
2592 print_statement_list (statement_list
.head
, abs_output_section
);
2595 /* Print the first N statements in statement list S to STDERR.
2596 If N == 0, nothing is printed.
2597 If N < 0, the entire list is printed.
2598 Intended to be called from GDB. */
2601 dprint_statement (s
, n
)
2602 lang_statement_union_type
*s
;
2605 FILE *map_save
= config
.map_file
;
2607 config
.map_file
= stderr
;
2610 print_statement_list (s
, abs_output_section
);
2613 while (s
&& --n
>= 0)
2615 print_statement (s
, abs_output_section
);
2620 config
.map_file
= map_save
;
2624 insert_pad (ptr
, fill
, alignment_needed
, output_section
, dot
)
2625 lang_statement_union_type
**ptr
;
2627 unsigned int alignment_needed
;
2628 asection
*output_section
;
2631 lang_statement_union_type
*pad
;
2633 pad
= ((lang_statement_union_type
*)
2634 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
2635 if (ptr
!= &statement_list
.head
2636 && pad
->header
.type
== lang_padding_statement_enum
2637 && pad
->padding_statement
.output_section
== output_section
)
2639 /* Use the existing pad statement. The above test on output
2640 section is probably redundant, but it doesn't hurt to check. */
2644 /* Make a new padding statement, linked into existing chain. */
2645 pad
= ((lang_statement_union_type
*)
2646 stat_alloc (sizeof (lang_padding_statement_type
)));
2647 pad
->header
.next
= *ptr
;
2649 pad
->header
.type
= lang_padding_statement_enum
;
2650 pad
->padding_statement
.output_section
= output_section
;
2651 pad
->padding_statement
.fill
= fill
;
2653 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
2654 pad
->padding_statement
.size
= alignment_needed
;
2655 output_section
->_raw_size
+= alignment_needed
;
2658 /* Work out how much this section will move the dot point. */
2661 size_input_section (this_ptr
, output_section_statement
, fill
, dot
)
2662 lang_statement_union_type
**this_ptr
;
2663 lang_output_section_statement_type
*output_section_statement
;
2667 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2668 asection
*i
= is
->section
;
2670 if (is
->ifile
->just_syms_flag
== false)
2672 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2673 ldfile_output_machine
);
2674 unsigned int alignment_needed
;
2677 /* Align this section first to the input sections requirement,
2678 then to the output section's requirement. If this alignment
2679 is greater than any seen before, then record it too. Perform
2680 the alignment by inserting a magic 'padding' statement. */
2682 if (output_section_statement
->subsection_alignment
!= -1)
2683 i
->alignment_power
= output_section_statement
->subsection_alignment
;
2685 o
= output_section_statement
->bfd_section
;
2686 if (o
->alignment_power
< i
->alignment_power
)
2687 o
->alignment_power
= i
->alignment_power
;
2689 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
2691 if (alignment_needed
!= 0)
2693 insert_pad (this_ptr
, fill
, alignment_needed
* opb
, o
, dot
);
2694 dot
+= alignment_needed
;
2697 /* Remember where in the output section this input section goes. */
2699 i
->output_offset
= dot
- o
->vma
;
2701 /* Mark how big the output section must be to contain this now. */
2702 if (i
->_cooked_size
!= 0)
2703 dot
+= i
->_cooked_size
/ opb
;
2705 dot
+= i
->_raw_size
/ opb
;
2706 o
->_raw_size
= (dot
- o
->vma
) * opb
;
2710 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2716 #define IGNORE_SECTION(bfd, s) \
2717 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2718 != (SEC_ALLOC | SEC_LOAD)) \
2719 || bfd_section_size (bfd, s) == 0)
2721 /* Check to see if any allocated sections overlap with other allocated
2722 sections. This can happen when the linker script specifically specifies
2723 the output section addresses of the two sections. */
2726 lang_check_section_addresses ()
2729 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2731 /* Scan all sections in the output list. */
2732 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2736 /* Ignore sections which are not loaded or which have no contents. */
2737 if (IGNORE_SECTION (output_bfd
, s
))
2740 /* Once we reach section 's' stop our seach. This prevents two
2741 warning messages from being produced, one for 'section A overlaps
2742 section B' and one for 'section B overlaps section A'. */
2743 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2750 /* Only consider loadable sections with real contents. */
2751 if (IGNORE_SECTION (output_bfd
, os
))
2754 /* We must check the sections' LMA addresses not their
2755 VMA addresses because overlay sections can have
2756 overlapping VMAs but they must have distinct LMAs. */
2757 s_start
= bfd_section_lma (output_bfd
, s
);
2758 os_start
= bfd_section_lma (output_bfd
, os
);
2759 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2760 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2762 /* Look for an overlap. */
2763 if ((s_end
< os_start
) || (s_start
> os_end
))
2767 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2768 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2770 /* Once we have found one overlap for this section,
2771 stop looking for others. */
2777 /* Make sure the new address is within the region. We explicitly permit the
2778 current address to be at the exact end of the region when the address is
2779 non-zero, in case the region is at the end of addressable memory and the
2780 calculation wraps around. */
2783 os_region_check (os
, region
, tree
, base
)
2784 lang_output_section_statement_type
*os
;
2785 struct memory_region_struct
*region
;
2789 if ((region
->current
< region
->origin
2790 || (region
->current
- region
->origin
> region
->length
))
2791 && ((region
->current
!= region
->origin
+ region
->length
)
2794 if (tree
!= (etree_type
*) NULL
)
2796 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2798 os
->bfd_section
->owner
,
2799 os
->bfd_section
->name
,
2804 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2806 os
->bfd_section
->owner
,
2807 os
->bfd_section
->name
);
2809 /* Reset the region pointer. */
2810 region
->current
= region
->origin
;
2814 /* Set the sizes for all the output sections. */
2817 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2818 lang_statement_union_type
*s
;
2819 lang_output_section_statement_type
*output_section_statement
;
2820 lang_statement_union_type
**prev
;
2825 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2826 ldfile_output_machine
);
2828 /* Size up the sections from their constituent parts. */
2829 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2831 switch (s
->header
.type
)
2833 case lang_output_section_statement_enum
:
2836 lang_output_section_statement_type
*os
;
2838 os
= &s
->output_section_statement
;
2839 if (os
->bfd_section
== NULL
)
2840 /* This section was never actually created. */
2843 /* If this is a COFF shared library section, use the size and
2844 address from the input section. FIXME: This is COFF
2845 specific; it would be cleaner if there were some other way
2846 to do this, but nothing simple comes to mind. */
2847 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2851 if (os
->children
.head
== NULL
2852 || os
->children
.head
->header
.next
!= NULL
2853 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2854 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2857 input
= os
->children
.head
->input_section
.section
;
2858 bfd_set_section_vma (os
->bfd_section
->owner
,
2860 bfd_section_vma (input
->owner
, input
));
2861 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2865 if (bfd_is_abs_section (os
->bfd_section
))
2867 /* No matter what happens, an abs section starts at zero. */
2868 ASSERT (os
->bfd_section
->vma
== 0);
2872 if (os
->addr_tree
== (etree_type
*) NULL
)
2874 /* No address specified for this section, get one
2875 from the region specification. */
2876 if (os
->region
== (lang_memory_region_type
*) NULL
2877 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2878 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2879 && os
->region
->name
[0] == '*'
2880 && strcmp (os
->region
->name
, "*default*") == 0))
2882 os
->region
= lang_memory_default (os
->bfd_section
);
2885 /* If a loadable section is using the default memory
2886 region, and some non default memory regions were
2887 defined, issue a warning. */
2888 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2889 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2890 && ! link_info
.relocateable
2891 && strcmp (os
->region
->name
, "*default*") == 0
2892 && lang_memory_region_list
!= NULL
2893 && (strcmp (lang_memory_region_list
->name
,
2895 || lang_memory_region_list
->next
!= NULL
))
2896 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2897 bfd_get_section_name (output_bfd
,
2900 dot
= os
->region
->current
;
2902 if (os
->section_alignment
== -1)
2907 dot
= align_power (dot
,
2908 os
->bfd_section
->alignment_power
);
2910 if (dot
!= olddot
&& config
.warn_section_align
)
2911 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2912 os
->name
, (unsigned int) (dot
- olddot
));
2919 r
= exp_fold_tree (os
->addr_tree
,
2921 lang_allocating_phase_enum
,
2923 if (r
.valid_p
== false)
2925 einfo (_("%F%S: non constant address expression for section %s\n"),
2928 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2931 /* The section starts here.
2932 First, align to what the section needs. */
2934 if (os
->section_alignment
!= -1)
2935 dot
= align_power (dot
, os
->section_alignment
);
2937 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2939 os
->bfd_section
->output_offset
= 0;
2942 lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
2943 os
->fill
, dot
, relax
);
2945 /* Put the section within the requested block size, or
2946 align at the block boundary. */
2947 after
= ALIGN_N (os
->bfd_section
->vma
2948 + os
->bfd_section
->_raw_size
/ opb
,
2949 /* The coercion here is important, see ld.h. */
2950 (bfd_vma
) os
->block_value
);
2952 if (bfd_is_abs_section (os
->bfd_section
))
2953 ASSERT (after
== os
->bfd_section
->vma
);
2955 os
->bfd_section
->_raw_size
=
2956 (after
- os
->bfd_section
->vma
) * opb
;
2957 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
2958 os
->processed
= true;
2960 /* Update dot in the region ?
2961 We only do this if the section is going to be allocated,
2962 since unallocated sections do not contribute to the region's
2963 overall size in memory.
2965 If the SEC_NEVER_LOAD bit is not set, it will affect the
2966 addresses of sections after it. We have to update
2968 if (os
->region
!= (lang_memory_region_type
*) NULL
2969 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2970 & SEC_NEVER_LOAD
) == 0
2971 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2972 & (SEC_ALLOC
| SEC_LOAD
))))
2974 os
->region
->current
= dot
;
2976 /* Make sure the new address is within the region. */
2977 os_region_check (os
, os
->region
, os
->addr_tree
,
2978 os
->bfd_section
->vma
);
2980 /* If there's no load address specified, use the run
2981 region as the load region. */
2982 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
2983 os
->lma_region
= os
->region
;
2985 if (os
->lma_region
!= NULL
)
2987 if (os
->load_base
!= NULL
)
2989 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
2993 /* Don't allocate twice. */
2994 if (os
->lma_region
!= os
->region
)
2996 /* Set load_base, which will be handled later. */
2998 exp_intop (os
->lma_region
->current
);
2999 os
->lma_region
->current
+=
3000 os
->bfd_section
->_raw_size
/ opb
;
3001 os_region_check (os
, os
->lma_region
, NULL
,
3002 os
->bfd_section
->lma
);
3010 case lang_constructors_statement_enum
:
3011 dot
= lang_size_sections (constructor_list
.head
,
3012 output_section_statement
,
3013 &s
->wild_statement
.children
.head
,
3017 case lang_data_statement_enum
:
3019 unsigned int size
= 0;
3021 s
->data_statement
.output_vma
=
3022 dot
- output_section_statement
->bfd_section
->vma
;
3023 s
->data_statement
.output_section
=
3024 output_section_statement
->bfd_section
;
3026 switch (s
->data_statement
.type
)
3047 output_section_statement
->bfd_section
->_raw_size
+= size
;
3048 /* The output section gets contents, and then we inspect for
3049 any flags set in the input script which override any ALLOC. */
3050 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3051 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3053 output_section_statement
->bfd_section
->flags
|=
3054 SEC_ALLOC
| SEC_LOAD
;
3059 case lang_reloc_statement_enum
:
3063 s
->reloc_statement
.output_vma
=
3064 dot
- output_section_statement
->bfd_section
->vma
;
3065 s
->reloc_statement
.output_section
=
3066 output_section_statement
->bfd_section
;
3067 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3069 output_section_statement
->bfd_section
->_raw_size
+= size
;
3073 case lang_wild_statement_enum
:
3075 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
3076 output_section_statement
,
3077 &s
->wild_statement
.children
.head
,
3082 case lang_object_symbols_statement_enum
:
3083 link_info
.create_object_symbols_section
=
3084 output_section_statement
->bfd_section
;
3086 case lang_output_statement_enum
:
3087 case lang_target_statement_enum
:
3089 case lang_input_section_enum
:
3093 i
= (*prev
)->input_section
.section
;
3096 if (i
->_cooked_size
== 0)
3097 i
->_cooked_size
= i
->_raw_size
;
3103 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3104 einfo (_("%P%F: can't relax section: %E\n"));
3108 dot
= size_input_section (prev
, output_section_statement
,
3109 output_section_statement
->fill
, dot
);
3112 case lang_input_statement_enum
:
3114 case lang_fill_statement_enum
:
3115 s
->fill_statement
.output_section
=
3116 output_section_statement
->bfd_section
;
3118 fill
= s
->fill_statement
.fill
;
3120 case lang_assignment_statement_enum
:
3122 bfd_vma newdot
= dot
;
3124 exp_fold_tree (s
->assignment_statement
.exp
,
3125 output_section_statement
,
3126 lang_allocating_phase_enum
,
3132 if (output_section_statement
== abs_output_section
)
3134 /* If we don't have an output section, then just adjust
3135 the default memory address. */
3136 lang_memory_region_lookup ("*default*")->current
= newdot
;
3140 /* Insert a pad after this statement. We can't
3141 put the pad before when relaxing, in case the
3142 assignment references dot. */
3143 insert_pad (&s
->header
.next
, fill
, (newdot
- dot
) * opb
,
3144 output_section_statement
->bfd_section
, dot
);
3146 /* Don't neuter the pad below when relaxing. */
3155 case lang_padding_statement_enum
:
3156 /* If this is the first time lang_size_sections is called,
3157 we won't have any padding statements. If this is the
3158 second or later passes when relaxing, we should allow
3159 padding to shrink. If padding is needed on this pass, it
3160 will be added back in. */
3161 s
->padding_statement
.size
= 0;
3164 case lang_group_statement_enum
:
3165 dot
= lang_size_sections (s
->group_statement
.children
.head
,
3166 output_section_statement
,
3167 &s
->group_statement
.children
.head
,
3175 /* We can only get here when relaxing is turned on. */
3176 case lang_address_statement_enum
:
3179 prev
= &s
->header
.next
;
3185 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3186 lang_statement_union_type
*s
;
3187 lang_output_section_statement_type
*output_section_statement
;
3191 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3192 ldfile_output_machine
);
3194 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3196 switch (s
->header
.type
)
3198 case lang_constructors_statement_enum
:
3199 dot
= lang_do_assignments (constructor_list
.head
,
3200 output_section_statement
,
3205 case lang_output_section_statement_enum
:
3207 lang_output_section_statement_type
*os
;
3209 os
= &(s
->output_section_statement
);
3210 if (os
->bfd_section
!= NULL
)
3212 dot
= os
->bfd_section
->vma
;
3213 (void) lang_do_assignments (os
->children
.head
, os
,
3215 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3220 /* If nothing has been placed into the output section then
3221 it won't have a bfd_section. */
3222 if (os
->bfd_section
)
3224 os
->bfd_section
->lma
3225 = exp_get_abs_int (os
->load_base
, 0, "load base",
3226 lang_final_phase_enum
);
3231 case lang_wild_statement_enum
:
3233 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3234 output_section_statement
,
3239 case lang_object_symbols_statement_enum
:
3240 case lang_output_statement_enum
:
3241 case lang_target_statement_enum
:
3243 case lang_common_statement_enum
:
3246 case lang_data_statement_enum
:
3248 etree_value_type value
;
3250 value
= exp_fold_tree (s
->data_statement
.exp
,
3252 lang_final_phase_enum
, dot
, &dot
);
3253 s
->data_statement
.value
= value
.value
;
3254 if (value
.valid_p
== false)
3255 einfo (_("%F%P: invalid data statement\n"));
3259 switch (s
->data_statement
.type
)
3283 case lang_reloc_statement_enum
:
3285 etree_value_type value
;
3287 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3289 lang_final_phase_enum
, dot
, &dot
);
3290 s
->reloc_statement
.addend_value
= value
.value
;
3291 if (value
.valid_p
== false)
3292 einfo (_("%F%P: invalid reloc statement\n"));
3294 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3297 case lang_input_section_enum
:
3299 asection
*in
= s
->input_section
.section
;
3301 if (in
->_cooked_size
!= 0)
3302 dot
+= in
->_cooked_size
/ opb
;
3304 dot
+= in
->_raw_size
/ opb
;
3308 case lang_input_statement_enum
:
3310 case lang_fill_statement_enum
:
3311 fill
= s
->fill_statement
.fill
;
3313 case lang_assignment_statement_enum
:
3315 exp_fold_tree (s
->assignment_statement
.exp
,
3316 output_section_statement
,
3317 lang_final_phase_enum
,
3323 case lang_padding_statement_enum
:
3324 dot
+= s
->padding_statement
.size
/ opb
;
3327 case lang_group_statement_enum
:
3328 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3329 output_section_statement
,
3337 case lang_address_statement_enum
:
3345 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3346 operator .startof. (section_name), it produces an undefined symbol
3347 .startof.section_name. Similarly, when it sees
3348 .sizeof. (section_name), it produces an undefined symbol
3349 .sizeof.section_name. For all the output sections, we look for
3350 such symbols, and set them to the correct value. */
3357 if (link_info
.relocateable
)
3360 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3362 const char *secname
;
3364 struct bfd_link_hash_entry
*h
;
3366 secname
= bfd_get_section_name (output_bfd
, s
);
3367 buf
= xmalloc (10 + strlen (secname
));
3369 sprintf (buf
, ".startof.%s", secname
);
3370 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3371 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3373 h
->type
= bfd_link_hash_defined
;
3374 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3375 h
->u
.def
.section
= bfd_abs_section_ptr
;
3378 sprintf (buf
, ".sizeof.%s", secname
);
3379 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3380 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3384 opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3385 ldfile_output_machine
);
3386 h
->type
= bfd_link_hash_defined
;
3387 if (s
->_cooked_size
!= 0)
3388 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3390 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3391 h
->u
.def
.section
= bfd_abs_section_ptr
;
3401 struct bfd_link_hash_entry
*h
;
3404 if (link_info
.relocateable
|| link_info
.shared
)
3409 if (entry_symbol
== (char *) NULL
)
3411 /* No entry has been specified. Look for start, but don't warn
3412 if we don't find it. */
3413 entry_symbol
= "start";
3417 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
3418 if (h
!= (struct bfd_link_hash_entry
*) NULL
3419 && (h
->type
== bfd_link_hash_defined
3420 || h
->type
== bfd_link_hash_defweak
)
3421 && h
->u
.def
.section
->output_section
!= NULL
)
3425 val
= (h
->u
.def
.value
3426 + bfd_get_section_vma (output_bfd
,
3427 h
->u
.def
.section
->output_section
)
3428 + h
->u
.def
.section
->output_offset
);
3429 if (! bfd_set_start_address (output_bfd
, val
))
3430 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
);
3437 /* We couldn't find the entry symbol. Try parsing it as a
3439 val
= bfd_scan_vma (entry_symbol
, &send
, 0);
3442 if (! bfd_set_start_address (output_bfd
, val
))
3443 einfo (_("%P%F: can't set start address\n"));
3449 /* Can't find the entry symbol, and it's not a number. Use
3450 the first address in the text section. */
3451 ts
= bfd_get_section_by_name (output_bfd
, ".text");
3452 if (ts
!= (asection
*) NULL
)
3455 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3456 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
3457 if (! bfd_set_start_address (output_bfd
,
3458 bfd_get_section_vma (output_bfd
,
3460 einfo (_("%P%F: can't set start address\n"));
3465 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3472 /* This is a small function used when we want to ignore errors from
3476 #ifdef ANSI_PROTOTYPES
3477 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3479 ignore_bfd_errors (s
)
3480 const char *s ATTRIBUTE_UNUSED
;
3483 /* Don't do anything. */
3486 /* Check that the architecture of all the input files is compatible
3487 with the output file. Also call the backend to let it do any
3488 other checking that is needed. */
3493 lang_statement_union_type
*file
;
3495 const bfd_arch_info_type
*compatible
;
3497 for (file
= file_chain
.head
;
3498 file
!= (lang_statement_union_type
*) NULL
;
3499 file
= file
->input_statement
.next
)
3501 input_bfd
= file
->input_statement
.the_bfd
;
3502 compatible
= bfd_arch_get_compatible (input_bfd
,
3504 if (compatible
== NULL
)
3506 if (command_line
.warn_mismatch
)
3507 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3508 bfd_printable_name (input_bfd
), input_bfd
,
3509 bfd_printable_name (output_bfd
));
3511 else if (link_info
.relocateable
3512 /* In general it is not possible to perform a relocatable
3513 link between differing object formats when the input
3514 file has relocations, because the relocations in the
3515 input format may not have equivalent representations in
3516 the output format (and besides BFD does not translate
3517 relocs for other link purposes than a final link). */
3518 && bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
)
3519 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
3520 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3521 bfd_get_target (input_bfd
), input_bfd
,
3522 bfd_get_target (output_bfd
), output_bfd
);
3523 else if (bfd_count_sections (input_bfd
))
3525 /* If the input bfd has no contents, it shouldn't set the
3526 private data of the output bfd. */
3528 bfd_error_handler_type pfn
= NULL
;
3530 /* If we aren't supposed to warn about mismatched input
3531 files, temporarily set the BFD error handler to a
3532 function which will do nothing. We still want to call
3533 bfd_merge_private_bfd_data, since it may set up
3534 information which is needed in the output file. */
3535 if (! command_line
.warn_mismatch
)
3536 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3537 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3539 if (command_line
.warn_mismatch
)
3540 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3543 if (! command_line
.warn_mismatch
)
3544 bfd_set_error_handler (pfn
);
3549 /* Look through all the global common symbols and attach them to the
3550 correct section. The -sort-common command line switch may be used
3551 to roughly sort the entries by size. */
3556 if (link_info
.relocateable
3557 && ! command_line
.force_common_definition
)
3560 if (! config
.sort_common
)
3561 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3566 for (power
= 4; power
>= 0; power
--)
3567 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3572 /* Place one common symbol in the correct section. */
3575 lang_one_common (h
, info
)
3576 struct bfd_link_hash_entry
*h
;
3579 unsigned int power_of_two
;
3582 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3583 ldfile_output_machine
);
3585 if (h
->type
!= bfd_link_hash_common
)
3589 power_of_two
= h
->u
.c
.p
->alignment_power
;
3591 if (config
.sort_common
3592 && power_of_two
< (unsigned int) *(int *) info
)
3595 section
= h
->u
.c
.p
->section
;
3597 /* Increase the size of the section. */
3598 section
->_cooked_size
= ALIGN_N ((section
->_cooked_size
+ opb
- 1) / opb
,
3599 (bfd_size_type
) (1 << power_of_two
)) * opb
;
3601 /* Adjust the alignment if necessary. */
3602 if (power_of_two
> section
->alignment_power
)
3603 section
->alignment_power
= power_of_two
;
3605 /* Change the symbol from common to defined. */
3606 h
->type
= bfd_link_hash_defined
;
3607 h
->u
.def
.section
= section
;
3608 h
->u
.def
.value
= section
->_cooked_size
;
3610 /* Increase the size of the section. */
3611 section
->_cooked_size
+= size
;
3613 /* Make sure the section is allocated in memory, and make sure that
3614 it is no longer a common section. */
3615 section
->flags
|= SEC_ALLOC
;
3616 section
->flags
&= ~SEC_IS_COMMON
;
3618 if (config
.map_file
!= NULL
)
3620 static boolean header_printed
;
3625 if (! header_printed
)
3627 minfo (_("\nAllocating common symbols\n"));
3628 minfo (_("Common symbol size file\n\n"));
3629 header_printed
= true;
3632 name
= demangle (h
->root
.string
);
3634 len
= strlen (name
);
3649 if (size
<= 0xffffffff)
3650 sprintf (buf
, "%lx", (unsigned long) size
);
3652 sprintf_vma (buf
, size
);
3662 minfo ("%B\n", section
->owner
);
3668 /* Run through the input files and ensure that every input section has
3669 somewhere to go. If one is found without a destination then create
3670 an input request and place it into the statement tree. */
3673 lang_place_orphans ()
3675 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3679 for (s
= file
->the_bfd
->sections
;
3680 s
!= (asection
*) NULL
;
3683 if (s
->output_section
== (asection
*) NULL
)
3685 /* This section of the file is not attatched, root
3686 around for a sensible place for it to go. */
3688 if (file
->just_syms_flag
)
3690 /* We are only retrieving symbol values from this
3691 file. We want the symbols to act as though the
3692 values in the file are absolute. */
3693 s
->output_section
= bfd_abs_section_ptr
;
3694 s
->output_offset
= s
->vma
;
3696 else if (strcmp (s
->name
, "COMMON") == 0)
3698 /* This is a lonely common section which must have
3699 come from an archive. We attach to the section
3700 with the wildcard. */
3701 if (! link_info
.relocateable
3702 || command_line
.force_common_definition
)
3704 if (default_common_section
== NULL
)
3707 /* This message happens when using the
3708 svr3.ifile linker script, so I have
3710 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3712 default_common_section
=
3713 lang_output_section_statement_lookup (".bss");
3716 lang_add_section (&default_common_section
->children
, s
,
3717 default_common_section
, file
);
3720 else if (ldemul_place_orphan (file
, s
))
3724 lang_output_section_statement_type
*os
;
3726 os
= lang_output_section_statement_lookup (s
->name
);
3727 lang_add_section (&os
->children
, s
, os
, file
);
3735 lang_set_flags (ptr
, flags
, invert
)
3736 lang_memory_region_type
*ptr
;
3740 flagword
*ptr_flags
;
3742 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3748 *ptr_flags
|= SEC_ALLOC
;
3752 *ptr_flags
|= SEC_READONLY
;
3756 *ptr_flags
|= SEC_DATA
;
3760 *ptr_flags
|= SEC_CODE
;
3765 *ptr_flags
|= SEC_LOAD
;
3769 einfo (_("%P%F: invalid syntax in flags\n"));
3776 /* Call a function on each input file. This function will be called
3777 on an archive, but not on the elements. */
3780 lang_for_each_input_file (func
)
3781 void (*func
) PARAMS ((lang_input_statement_type
*));
3783 lang_input_statement_type
*f
;
3785 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3787 f
= (lang_input_statement_type
*) f
->next_real_file
)
3791 /* Call a function on each file. The function will be called on all
3792 the elements of an archive which are included in the link, but will
3793 not be called on the archive file itself. */
3796 lang_for_each_file (func
)
3797 void (*func
) PARAMS ((lang_input_statement_type
*));
3799 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3810 lang_for_each_input_section (func
)
3811 void (*func
) PARAMS ((bfd
*ab
, asection
*as
));
3813 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3817 for (s
= f
->the_bfd
->sections
;
3818 s
!= (asection
*) NULL
;
3821 func (f
->the_bfd
, s
);
3829 ldlang_add_file (entry
)
3830 lang_input_statement_type
*entry
;
3834 lang_statement_append (&file_chain
,
3835 (lang_statement_union_type
*) entry
,
3838 /* The BFD linker needs to have a list of all input BFDs involved in
3840 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3841 ASSERT (entry
->the_bfd
!= output_bfd
);
3842 for (pp
= &link_info
.input_bfds
;
3843 *pp
!= (bfd
*) NULL
;
3844 pp
= &(*pp
)->link_next
)
3846 *pp
= entry
->the_bfd
;
3847 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3848 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3850 /* Look through the sections and check for any which should not be
3851 included in the link. We need to do this now, so that we can
3852 notice when the backend linker tries to report multiple
3853 definition errors for symbols which are in sections we aren't
3854 going to link. FIXME: It might be better to entirely ignore
3855 symbols which are defined in sections which are going to be
3856 discarded. This would require modifying the backend linker for
3857 each backend which might set the SEC_LINK_ONCE flag. If we do
3858 this, we should probably handle SEC_EXCLUDE in the same way. */
3860 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
3864 lang_add_output (name
, from_script
)
3868 /* Make -o on command line override OUTPUT in script. */
3869 if (had_output_filename
== false || !from_script
)
3871 output_filename
= name
;
3872 had_output_filename
= true;
3876 static lang_output_section_statement_type
*current_section
;
3888 for (l
= 0; l
< 32; l
++)
3890 if (i
>= (unsigned int) x
)
3898 lang_output_section_statement_type
*
3899 lang_enter_output_section_statement (output_section_statement_name
,
3900 address_exp
, sectype
, block_value
,
3901 align
, subalign
, ebase
)
3902 const char *output_section_statement_name
;
3903 etree_type
*address_exp
;
3904 enum section_type sectype
;
3905 bfd_vma block_value
;
3907 etree_type
*subalign
;
3910 lang_output_section_statement_type
*os
;
3914 lang_output_section_statement_lookup (output_section_statement_name
);
3916 /* Add this statement to tree. */
3918 add_statement (lang_output_section_statement_enum
,
3919 output_section_statement
);
3921 /* Make next things chain into subchain of this. */
3923 if (os
->addr_tree
== (etree_type
*) NULL
)
3925 os
->addr_tree
= address_exp
;
3927 os
->sectype
= sectype
;
3928 if (sectype
!= noload_section
)
3929 os
->flags
= SEC_NO_FLAGS
;
3931 os
->flags
= SEC_NEVER_LOAD
;
3932 os
->block_value
= block_value
? block_value
: 1;
3933 stat_ptr
= &os
->children
;
3935 os
->subsection_alignment
=
3936 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
3937 os
->section_alignment
=
3938 topower (exp_get_value_int (align
, -1, "section alignment", 0));
3940 os
->load_base
= ebase
;
3947 lang_output_statement_type
*new =
3948 new_stat (lang_output_statement
, stat_ptr
);
3950 new->name
= output_filename
;
3953 /* Reset the current counters in the regions. */
3956 reset_memory_regions ()
3958 lang_memory_region_type
*p
= lang_memory_region_list
;
3961 for (p
= lang_memory_region_list
;
3962 p
!= (lang_memory_region_type
*) NULL
;
3965 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
3966 p
->current
= p
->origin
;
3969 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3973 /* If the wild pattern was marked KEEP, the member sections
3974 should be as well. */
3977 gc_section_callback (ptr
, sec
, section
, file
, data
)
3978 lang_wild_statement_type
*ptr
;
3979 struct wildcard_list
*sec ATTRIBUTE_UNUSED
;
3981 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
3982 PTR data ATTRIBUTE_UNUSED
;
3984 if (ptr
->keep_sections
)
3985 section
->flags
|= SEC_KEEP
;
3988 /* Handle a wild statement, marking it against GC. */
3992 lang_wild_statement_type
*s
;
3994 walk_wild (s
, gc_section_callback
, NULL
);
3997 /* Iterate over sections marking them against GC. */
4000 lang_gc_sections_1 (s
)
4001 lang_statement_union_type
*s
;
4003 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
4005 switch (s
->header
.type
)
4007 case lang_wild_statement_enum
:
4008 lang_gc_wild (&s
->wild_statement
);
4009 case lang_constructors_statement_enum
:
4010 lang_gc_sections_1 (constructor_list
.head
);
4012 case lang_output_section_statement_enum
:
4013 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4015 case lang_group_statement_enum
:
4016 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4027 struct bfd_link_hash_entry
*h
;
4028 ldlang_undef_chain_list_type
*ulist
, fake_list_start
;
4030 /* Keep all sections so marked in the link script. */
4032 lang_gc_sections_1 (statement_list
.head
);
4034 /* Keep all sections containing symbols undefined on the command-line.
4035 Handle the entry symbol at the same time. */
4037 if (entry_symbol
!= NULL
)
4039 fake_list_start
.next
= ldlang_undef_chain_list_head
;
4040 fake_list_start
.name
= (char *) entry_symbol
;
4041 ulist
= &fake_list_start
;
4044 ulist
= ldlang_undef_chain_list_head
;
4046 for (; ulist
; ulist
= ulist
->next
)
4048 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4049 false, false, false);
4051 if (h
!= (struct bfd_link_hash_entry
*) NULL
4052 && (h
->type
== bfd_link_hash_defined
4053 || h
->type
== bfd_link_hash_defweak
)
4054 && ! bfd_is_abs_section (h
->u
.def
.section
))
4056 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4060 bfd_gc_sections (output_bfd
, &link_info
);
4066 lang_reasonable_defaults ();
4067 current_target
= default_target
;
4069 /* Open the output file. */
4070 lang_for_each_statement (ldlang_open_output
);
4072 ldemul_create_output_section_statements ();
4074 /* Add to the hash table all undefineds on the command line. */
4075 lang_place_undefineds ();
4077 already_linked_table_init ();
4079 /* Create a bfd for each input file. */
4080 current_target
= default_target
;
4081 open_input_bfds (statement_list
.head
, false);
4083 ldemul_after_open ();
4085 already_linked_table_free ();
4087 /* Make sure that we're not mixing architectures. We call this
4088 after all the input files have been opened, but before we do any
4089 other processing, so that any operations merge_private_bfd_data
4090 does on the output file will be known during the rest of the
4094 /* Handle .exports instead of a version script if we're told to do so. */
4095 if (command_line
.version_exports_section
)
4096 lang_do_version_exports_section ();
4098 /* Build all sets based on the information gathered from the input
4100 ldctor_build_sets ();
4102 /* Remove unreferenced sections if asked to. */
4103 if (command_line
.gc_sections
)
4104 lang_gc_sections ();
4106 /* If there were any SEC_MERGE sections, finish their merging, so that
4107 section sizes can be computed. This has to be done after GC of sections,
4108 so that GCed sections are not merged, but before assigning output
4109 sections, since removing whole input sections is hard then. */
4110 bfd_merge_sections (output_bfd
, &link_info
);
4112 /* Size up the common data. */
4115 /* Run through the contours of the script and attach input sections
4116 to the correct output sections. */
4117 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4118 (lang_output_section_statement_type
*) NULL
);
4120 /* Find any sections not attached explicitly and handle them. */
4121 lang_place_orphans ();
4123 ldemul_before_allocation ();
4125 /* We must record the program headers before we try to fix the
4126 section positions, since they will affect SIZEOF_HEADERS. */
4127 lang_record_phdrs ();
4129 /* Size up the sections. */
4130 lang_size_sections (statement_list
.head
,
4132 &statement_list
.head
, 0, (bfd_vma
) 0, NULL
);
4134 /* Now run around and relax if we can. */
4135 if (command_line
.relax
)
4137 /* Keep relaxing until bfd_relax_section gives up. */
4138 boolean relax_again
;
4142 reset_memory_regions ();
4144 relax_again
= false;
4146 /* Note: pe-dll.c does something like this also. If you find
4147 you need to change this code, you probably need to change
4148 pe-dll.c also. DJ */
4150 /* Do all the assignments with our current guesses as to
4152 lang_do_assignments (statement_list
.head
,
4154 (fill_type
) 0, (bfd_vma
) 0);
4156 /* Perform another relax pass - this time we know where the
4157 globals are, so can make better guess. */
4158 lang_size_sections (statement_list
.head
,
4160 &(statement_list
.head
), 0, (bfd_vma
) 0,
4163 while (relax_again
);
4166 /* See if anything special should be done now we know how big
4168 ldemul_after_allocation ();
4170 /* Fix any .startof. or .sizeof. symbols. */
4171 lang_set_startof ();
4173 /* Do all the assignments, now that we know the final resting places
4174 of all the symbols. */
4176 lang_do_assignments (statement_list
.head
,
4178 (fill_type
) 0, (bfd_vma
) 0);
4180 /* Make sure that the section addresses make sense. */
4181 if (! link_info
.relocateable
4182 && command_line
.check_section_addresses
)
4183 lang_check_section_addresses ();
4191 /* EXPORTED TO YACC */
4194 lang_add_wild (filespec
, section_list
, keep_sections
)
4195 struct wildcard_spec
*filespec
;
4196 struct wildcard_list
*section_list
;
4197 boolean keep_sections
;
4199 struct wildcard_list
*curr
, *next
;
4200 lang_wild_statement_type
*new;
4202 /* Reverse the list as the parser puts it back to front. */
4203 for (curr
= section_list
, section_list
= NULL
;
4205 section_list
= curr
, curr
= next
)
4207 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
4208 placed_commons
= true;
4211 curr
->next
= section_list
;
4214 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
4216 if (strcmp (filespec
->name
, "*") == 0)
4217 filespec
->name
= NULL
;
4218 else if (! wildcardp (filespec
->name
))
4219 lang_has_input_file
= true;
4222 new = new_stat (lang_wild_statement
, stat_ptr
);
4223 new->filename
= NULL
;
4224 new->filenames_sorted
= false;
4225 if (filespec
!= NULL
)
4227 new->filename
= filespec
->name
;
4228 new->filenames_sorted
= filespec
->sorted
;
4230 new->section_list
= section_list
;
4231 new->keep_sections
= keep_sections
;
4232 lang_list_init (&new->children
);
4236 lang_section_start (name
, address
)
4238 etree_type
*address
;
4240 lang_address_statement_type
*ad
;
4242 ad
= new_stat (lang_address_statement
, stat_ptr
);
4243 ad
->section_name
= name
;
4244 ad
->address
= address
;
4247 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4248 because of a -e argument on the command line, or zero if this is
4249 called by ENTRY in a linker script. Command line arguments take
4253 lang_add_entry (name
, cmdline
)
4257 if (entry_symbol
== NULL
4259 || ! entry_from_cmdline
)
4261 entry_symbol
= name
;
4262 entry_from_cmdline
= cmdline
;
4267 lang_add_target (name
)
4270 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4286 map_option_f
= true;
4297 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4304 lang_add_data (type
, exp
)
4306 union etree_union
*exp
;
4309 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4317 /* Create a new reloc statement. RELOC is the BFD relocation type to
4318 generate. HOWTO is the corresponding howto structure (we could
4319 look this up, but the caller has already done so). SECTION is the
4320 section to generate a reloc against, or NAME is the name of the
4321 symbol to generate a reloc against. Exactly one of SECTION and
4322 NAME must be NULL. ADDEND is an expression for the addend. */
4325 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4326 bfd_reloc_code_real_type reloc
;
4327 reloc_howto_type
*howto
;
4330 union etree_union
*addend
;
4332 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4336 p
->section
= section
;
4338 p
->addend_exp
= addend
;
4340 p
->addend_value
= 0;
4341 p
->output_section
= NULL
;
4345 lang_assignment_statement_type
*
4346 lang_add_assignment (exp
)
4349 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4357 lang_add_attribute (attribute
)
4358 enum statement_enum attribute
;
4360 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4367 if (startup_file
!= (char *) NULL
)
4369 einfo (_("%P%Fmultiple STARTUP files\n"));
4371 first_file
->filename
= name
;
4372 first_file
->local_sym_name
= name
;
4373 first_file
->real
= true;
4375 startup_file
= name
;
4382 lang_float_flag
= maybe
;
4386 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4388 const char *memspec
;
4389 struct lang_output_section_phdr_list
*phdrs
;
4390 const char *lma_memspec
;
4392 current_section
->fill
= fill
;
4393 current_section
->region
= lang_memory_region_lookup (memspec
);
4394 if (strcmp (lma_memspec
, "*default*") != 0)
4396 current_section
->lma_region
= lang_memory_region_lookup (lma_memspec
);
4397 /* If no runtime region has been given, but the load region has
4398 been, use the load region. */
4399 if (strcmp (memspec
, "*default*") == 0)
4400 current_section
->region
= lang_memory_region_lookup (lma_memspec
);
4402 current_section
->phdrs
= phdrs
;
4403 stat_ptr
= &statement_list
;
4406 /* Create an absolute symbol with the given name with the value of the
4407 address of first byte of the section named.
4409 If the symbol already exists, then do nothing. */
4412 lang_abs_symbol_at_beginning_of (secname
, name
)
4413 const char *secname
;
4416 struct bfd_link_hash_entry
*h
;
4418 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4419 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4420 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4422 if (h
->type
== bfd_link_hash_new
4423 || h
->type
== bfd_link_hash_undefined
)
4427 h
->type
= bfd_link_hash_defined
;
4429 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4430 if (sec
== (asection
*) NULL
)
4433 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4435 h
->u
.def
.section
= bfd_abs_section_ptr
;
4439 /* Create an absolute symbol with the given name with the value of the
4440 address of the first byte after the end of the section named.
4442 If the symbol already exists, then do nothing. */
4445 lang_abs_symbol_at_end_of (secname
, name
)
4446 const char *secname
;
4449 struct bfd_link_hash_entry
*h
;
4451 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4452 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4453 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4455 if (h
->type
== bfd_link_hash_new
4456 || h
->type
== bfd_link_hash_undefined
)
4460 h
->type
= bfd_link_hash_defined
;
4462 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4463 if (sec
== (asection
*) NULL
)
4466 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4467 + bfd_section_size (output_bfd
, sec
) /
4468 bfd_octets_per_byte (output_bfd
));
4470 h
->u
.def
.section
= bfd_abs_section_ptr
;
4475 lang_statement_append (list
, element
, field
)
4476 lang_statement_list_type
*list
;
4477 lang_statement_union_type
*element
;
4478 lang_statement_union_type
**field
;
4480 *(list
->tail
) = element
;
4484 /* Set the output format type. -oformat overrides scripts. */
4487 lang_add_output_format (format
, big
, little
, from_script
)
4493 if (output_target
== NULL
|| !from_script
)
4495 if (command_line
.endian
== ENDIAN_BIG
4498 else if (command_line
.endian
== ENDIAN_LITTLE
4502 output_target
= format
;
4506 /* Enter a group. This creates a new lang_group_statement, and sets
4507 stat_ptr to build new statements within the group. */
4512 lang_group_statement_type
*g
;
4514 g
= new_stat (lang_group_statement
, stat_ptr
);
4515 lang_list_init (&g
->children
);
4516 stat_ptr
= &g
->children
;
4519 /* Leave a group. This just resets stat_ptr to start writing to the
4520 regular list of statements again. Note that this will not work if
4521 groups can occur inside anything else which can adjust stat_ptr,
4522 but currently they can't. */
4527 stat_ptr
= &statement_list
;
4530 /* Add a new program header. This is called for each entry in a PHDRS
4531 command in a linker script. */
4534 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4542 struct lang_phdr
*n
, **pp
;
4544 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4547 n
->type
= exp_get_value_int (type
, 0, "program header type",
4548 lang_final_phase_enum
);
4549 n
->filehdr
= filehdr
;
4554 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4559 /* Record the program header information in the output BFD. FIXME: We
4560 should not be calling an ELF specific function here. */
4563 lang_record_phdrs ()
4567 struct lang_output_section_phdr_list
*last
;
4568 struct lang_phdr
*l
;
4569 lang_statement_union_type
*u
;
4572 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4574 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4581 for (u
= lang_output_section_statement
.head
;
4583 u
= u
->output_section_statement
.next
)
4585 lang_output_section_statement_type
*os
;
4586 struct lang_output_section_phdr_list
*pl
;
4588 os
= &u
->output_section_statement
;
4595 if (os
->sectype
== noload_section
4596 || os
->bfd_section
== NULL
4597 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4602 if (os
->bfd_section
== NULL
)
4605 for (; pl
!= NULL
; pl
= pl
->next
)
4607 if (strcmp (pl
->name
, l
->name
) == 0)
4612 secs
= ((asection
**)
4613 xrealloc (secs
, alc
* sizeof (asection
*)));
4615 secs
[c
] = os
->bfd_section
;
4622 if (l
->flags
== NULL
)
4625 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4626 lang_final_phase_enum
);
4631 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4632 lang_final_phase_enum
);
4634 if (! bfd_record_phdr (output_bfd
, l
->type
,
4635 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
4636 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4637 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4642 /* Make sure all the phdr assignments succeeded. */
4643 for (u
= lang_output_section_statement
.head
;
4645 u
= u
->output_section_statement
.next
)
4647 struct lang_output_section_phdr_list
*pl
;
4649 if (u
->output_section_statement
.bfd_section
== NULL
)
4652 for (pl
= u
->output_section_statement
.phdrs
;
4655 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4656 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4657 u
->output_section_statement
.name
, pl
->name
);
4661 /* Record a list of sections which may not be cross referenced. */
4664 lang_add_nocrossref (l
)
4665 struct lang_nocrossref
*l
;
4667 struct lang_nocrossrefs
*n
;
4669 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4670 n
->next
= nocrossref_list
;
4672 nocrossref_list
= n
;
4674 /* Set notice_all so that we get informed about all symbols. */
4675 link_info
.notice_all
= true;
4678 /* Overlay handling. We handle overlays with some static variables. */
4680 /* The overlay virtual address. */
4681 static etree_type
*overlay_vma
;
4683 /* The overlay load address. */
4684 static etree_type
*overlay_lma
;
4686 /* Whether nocrossrefs is set for this overlay. */
4687 static int overlay_nocrossrefs
;
4689 /* An expression for the maximum section size seen so far. */
4690 static etree_type
*overlay_max
;
4692 /* A list of all the sections in this overlay. */
4694 struct overlay_list
{
4695 struct overlay_list
*next
;
4696 lang_output_section_statement_type
*os
;
4699 static struct overlay_list
*overlay_list
;
4701 /* Start handling an overlay. */
4704 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
4705 etree_type
*vma_expr
;
4706 etree_type
*lma_expr
;
4709 /* The grammar should prevent nested overlays from occurring. */
4710 ASSERT (overlay_vma
== NULL
4711 && overlay_lma
== NULL
4712 && overlay_list
== NULL
4713 && overlay_max
== NULL
);
4715 overlay_vma
= vma_expr
;
4716 overlay_lma
= lma_expr
;
4717 overlay_nocrossrefs
= nocrossrefs
;
4720 /* Start a section in an overlay. We handle this by calling
4721 lang_enter_output_section_statement with the correct VMA and LMA. */
4724 lang_enter_overlay_section (name
)
4727 struct overlay_list
*n
;
4730 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4731 0, 0, 0, overlay_lma
);
4733 /* If this is the first section, then base the VMA and LMA of future
4734 sections on this one. This will work correctly even if `.' is
4735 used in the addresses. */
4736 if (overlay_list
== NULL
)
4738 overlay_vma
= exp_nameop (ADDR
, name
);
4739 overlay_lma
= exp_nameop (LOADADDR
, name
);
4742 /* Remember the section. */
4743 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4744 n
->os
= current_section
;
4745 n
->next
= overlay_list
;
4748 size
= exp_nameop (SIZEOF
, name
);
4750 /* Adjust the LMA for the next section. */
4751 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
4753 /* Arrange to work out the maximum section end address. */
4754 if (overlay_max
== NULL
)
4757 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4760 /* Finish a section in an overlay. There isn't any special to do
4764 lang_leave_overlay_section (fill
, phdrs
)
4766 struct lang_output_section_phdr_list
*phdrs
;
4773 name
= current_section
->name
;
4775 lang_leave_output_section_statement (fill
, "*default*",
4776 phdrs
, "*default*");
4778 /* Define the magic symbols. */
4780 clean
= xmalloc (strlen (name
) + 1);
4782 for (s1
= name
; *s1
!= '\0'; s1
++)
4783 if (ISALNUM (*s1
) || *s1
== '_')
4787 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4788 sprintf (buf
, "__load_start_%s", clean
);
4789 lang_add_assignment (exp_assop ('=', buf
,
4790 exp_nameop (LOADADDR
, name
)));
4792 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4793 sprintf (buf
, "__load_stop_%s", clean
);
4794 lang_add_assignment (exp_assop ('=', buf
,
4796 exp_nameop (LOADADDR
, name
),
4797 exp_nameop (SIZEOF
, name
))));
4802 /* Finish an overlay. If there are any overlay wide settings, this
4803 looks through all the sections in the overlay and sets them. */
4806 lang_leave_overlay (fill
, memspec
, phdrs
, lma_memspec
)
4808 const char *memspec
;
4809 struct lang_output_section_phdr_list
*phdrs
;
4810 const char *lma_memspec
;
4812 lang_memory_region_type
*region
;
4813 lang_memory_region_type
* default_region
;
4814 lang_memory_region_type
*lma_region
;
4815 struct overlay_list
*l
;
4816 struct lang_nocrossref
*nocrossref
;
4818 default_region
= lang_memory_region_lookup ("*default*");
4820 if (memspec
== NULL
)
4823 region
= lang_memory_region_lookup (memspec
);
4825 if (lma_memspec
== NULL
)
4828 lma_region
= lang_memory_region_lookup (lma_memspec
);
4835 struct overlay_list
*next
;
4837 if (fill
!= 0 && l
->os
->fill
== 0)
4840 /* Assign a region to the sections, if one has been specified.
4841 Override the assignment of the default section, but not
4843 if (region
!= NULL
&&
4844 (l
->os
->region
== NULL
||
4845 l
->os
->region
== default_region
))
4846 l
->os
->region
= region
;
4848 /* We only set lma_region for the first overlay section, as
4849 subsequent overlay sections will have load_base set relative
4850 to the first section. Also, don't set lma_region if
4851 load_base is specified. FIXME: There should really be a test
4852 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4853 rather than letting LDADDR simply override LMA_REGION. */
4854 if (lma_region
!= NULL
&& l
->os
->lma_region
== NULL
4855 && l
->next
== NULL
&& l
->os
->load_base
== NULL
)
4856 l
->os
->lma_region
= lma_region
;
4858 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4859 l
->os
->phdrs
= phdrs
;
4861 if (overlay_nocrossrefs
)
4863 struct lang_nocrossref
*nc
;
4865 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
4866 nc
->name
= l
->os
->name
;
4867 nc
->next
= nocrossref
;
4876 if (nocrossref
!= NULL
)
4877 lang_add_nocrossref (nocrossref
);
4879 /* Update . for the end of the overlay. */
4880 lang_add_assignment (exp_assop ('=', ".",
4881 exp_binop ('+', overlay_vma
, overlay_max
)));
4885 overlay_nocrossrefs
= 0;
4886 overlay_list
= NULL
;
4890 /* Version handling. This is only useful for ELF. */
4892 /* This global variable holds the version tree that we build. */
4894 struct bfd_elf_version_tree
*lang_elf_version_info
;
4897 lang_vers_match_lang_c (expr
, sym
)
4898 struct bfd_elf_version_expr
*expr
;
4901 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4903 return fnmatch (expr
->pattern
, sym
, 0) == 0;
4907 lang_vers_match_lang_cplusplus (expr
, sym
)
4908 struct bfd_elf_version_expr
*expr
;
4914 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4917 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
4920 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4921 Should we early out false in this case? */
4922 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4926 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4934 lang_vers_match_lang_java (expr
, sym
)
4935 struct bfd_elf_version_expr
*expr
;
4941 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4944 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
4947 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4948 Should we early out false in this case? */
4949 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4953 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4960 /* This is called for each variable name or match expression. */
4962 struct bfd_elf_version_expr
*
4963 lang_new_vers_regex (orig
, new, lang
)
4964 struct bfd_elf_version_expr
*orig
;
4968 struct bfd_elf_version_expr
*ret
;
4970 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
4974 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
4975 ret
->match
= lang_vers_match_lang_c
;
4976 else if (strcasecmp (lang
, "C++") == 0)
4977 ret
->match
= lang_vers_match_lang_cplusplus
;
4978 else if (strcasecmp (lang
, "Java") == 0)
4979 ret
->match
= lang_vers_match_lang_java
;
4982 einfo (_("%X%P: unknown language `%s' in version information\n"),
4984 ret
->match
= lang_vers_match_lang_c
;
4990 /* This is called for each set of variable names and match
4993 struct bfd_elf_version_tree
*
4994 lang_new_vers_node (globals
, locals
)
4995 struct bfd_elf_version_expr
*globals
;
4996 struct bfd_elf_version_expr
*locals
;
4998 struct bfd_elf_version_tree
*ret
;
5000 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
5004 ret
->globals
= globals
;
5005 ret
->locals
= locals
;
5007 ret
->name_indx
= (unsigned int) -1;
5012 /* This static variable keeps track of version indices. */
5014 static int version_index
;
5016 /* This is called when we know the name and dependencies of the
5020 lang_register_vers_node (name
, version
, deps
)
5022 struct bfd_elf_version_tree
*version
;
5023 struct bfd_elf_version_deps
*deps
;
5025 struct bfd_elf_version_tree
*t
, **pp
;
5026 struct bfd_elf_version_expr
*e1
;
5028 /* Make sure this node has a unique name. */
5029 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5030 if (strcmp (t
->name
, name
) == 0)
5031 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5033 /* Check the global and local match names, and make sure there
5034 aren't any duplicates. */
5036 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5038 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5040 struct bfd_elf_version_expr
*e2
;
5042 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5043 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5044 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5049 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
5051 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5053 struct bfd_elf_version_expr
*e2
;
5055 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
5056 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5057 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5062 version
->deps
= deps
;
5063 version
->name
= name
;
5065 version
->vernum
= version_index
;
5067 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5072 /* This is called when we see a version dependency. */
5074 struct bfd_elf_version_deps
*
5075 lang_add_vers_depend (list
, name
)
5076 struct bfd_elf_version_deps
*list
;
5079 struct bfd_elf_version_deps
*ret
;
5080 struct bfd_elf_version_tree
*t
;
5082 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5085 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5087 if (strcmp (t
->name
, name
) == 0)
5089 ret
->version_needed
= t
;
5094 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5100 lang_do_version_exports_section ()
5102 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5104 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5106 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5113 len
= bfd_section_size (is
->the_bfd
, sec
);
5114 contents
= xmalloc (len
);
5115 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5116 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
5119 while (p
< contents
+ len
)
5121 greg
= lang_new_vers_regex (greg
, p
, NULL
);
5122 p
= strchr (p
, '\0') + 1;
5125 /* Do not free the contents, as we used them creating the regex. */
5127 /* Do not include this section in the link. */
5128 bfd_set_section_flags (is
->the_bfd
, sec
,
5129 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5132 lreg
= lang_new_vers_regex (NULL
, "*", NULL
);
5133 lang_register_vers_node (command_line
.version_exports_section
,
5134 lang_new_vers_node (greg
, lreg
), NULL
);
5138 lang_add_unique (name
)
5141 struct unique_sections
*ent
;
5143 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5144 if (strcmp (ent
->name
, name
) == 0)
5147 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
5148 ent
->name
= xstrdup (name
);
5149 ent
->next
= unique_section_list
;
5150 unique_section_list
= ent
;