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 #define offsetof(TYPE,MEMBER) ((size_t)&(((TYPE*)0)->MEMBER))
48 static lang_statement_union_type
*new_statement
49 PARAMS ((enum statement_enum
, size_t, lang_statement_list_type
*));
52 static struct obstack stat_obstack
;
54 #define obstack_chunk_alloc xmalloc
55 #define obstack_chunk_free free
56 static const char *startup_file
;
57 static lang_statement_list_type input_file_chain
;
58 static boolean placed_commons
= false;
59 static lang_output_section_statement_type
*default_common_section
;
60 static boolean map_option_f
;
61 static bfd_vma print_dot
;
62 static lang_input_statement_type
*first_file
;
63 static const char *current_target
;
64 static const char *output_target
;
65 static lang_statement_list_type statement_list
;
66 static struct lang_phdr
*lang_phdr_list
;
68 static void lang_for_each_statement_worker
69 PARAMS ((void (*) (lang_statement_union_type
*),
70 lang_statement_union_type
*));
71 static lang_input_statement_type
*new_afile
72 PARAMS ((const char *, lang_input_file_enum_type
, const char *, boolean
));
73 static lang_memory_region_type
*lang_memory_default
PARAMS ((asection
*));
74 static void lang_map_flags
PARAMS ((flagword
));
75 static void init_os
PARAMS ((lang_output_section_statement_type
*));
76 static void exp_init_os
PARAMS ((etree_type
*));
77 static void section_already_linked
PARAMS ((bfd
*, asection
*, PTR
));
78 static struct bfd_hash_entry
*already_linked_newfunc
79 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
80 static void already_linked_table_init
PARAMS ((void));
81 static void already_linked_table_free
PARAMS ((void));
82 static boolean wildcardp
PARAMS ((const char *));
83 static lang_statement_union_type
*wild_sort
84 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*,
85 lang_input_statement_type
*, asection
*));
86 static void output_section_callback
87 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
88 lang_input_statement_type
*, PTR
));
89 static lang_input_statement_type
*lookup_name
PARAMS ((const char *));
90 static boolean load_symbols
91 PARAMS ((lang_input_statement_type
*, lang_statement_list_type
*));
93 PARAMS ((lang_wild_statement_type
*,
94 const char *, lang_output_section_statement_type
*));
95 static bfd
*open_output
PARAMS ((const char *));
96 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*));
97 static void open_input_bfds
PARAMS ((lang_statement_union_type
*, boolean
));
98 static void lang_reasonable_defaults
PARAMS ((void));
99 static void insert_undefined
PARAMS ((const char *));
100 static void lang_place_undefineds
PARAMS ((void));
101 static void map_input_to_output_sections
102 PARAMS ((lang_statement_union_type
*, const char *,
103 lang_output_section_statement_type
*));
104 static void strip_excluded_output_sections
PARAMS ((void));
105 static void print_output_section_statement
106 PARAMS ((lang_output_section_statement_type
*));
107 static void print_assignment
108 PARAMS ((lang_assignment_statement_type
*,
109 lang_output_section_statement_type
*));
110 static void print_input_statement
PARAMS ((lang_input_statement_type
*));
111 static boolean print_one_symbol
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
112 static void print_input_section
PARAMS ((lang_input_section_type
*));
113 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*));
114 static void print_data_statement
PARAMS ((lang_data_statement_type
*));
115 static void print_address_statement
PARAMS ((lang_address_statement_type
*));
116 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*));
117 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*));
118 static void print_wild_statement
119 PARAMS ((lang_wild_statement_type
*, lang_output_section_statement_type
*));
120 static void print_group
121 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
122 static void print_statement
123 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
124 static void print_statement_list
125 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
126 static void print_statements
PARAMS ((void));
127 static void insert_pad
128 PARAMS ((lang_statement_union_type
**, fill_type
*,
129 unsigned int, asection
*, bfd_vma
));
130 static bfd_vma size_input_section
131 PARAMS ((lang_statement_union_type
**, lang_output_section_statement_type
*,
132 fill_type
*, bfd_vma
));
133 static void lang_finish
PARAMS ((void));
134 static void ignore_bfd_errors
PARAMS ((const char *, ...));
135 static void lang_check
PARAMS ((void));
136 static void lang_common
PARAMS ((void));
137 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
138 static void lang_place_orphans
PARAMS ((void));
139 static int topower
PARAMS ((int));
140 static void lang_set_startof
PARAMS ((void));
141 static void gc_section_callback
142 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
143 lang_input_statement_type
*, PTR
));
144 static void lang_get_regions
PARAMS ((struct memory_region_struct
**,
145 struct memory_region_struct
**,
146 const char *, const char *, int));
147 static void lang_record_phdrs
PARAMS ((void));
148 static void lang_gc_wild
PARAMS ((lang_wild_statement_type
*));
149 static void lang_gc_sections_1
PARAMS ((lang_statement_union_type
*));
150 static void lang_gc_sections
PARAMS ((void));
151 static int lang_vers_match_lang_c
152 PARAMS ((struct bfd_elf_version_expr
*, const char *));
153 static int lang_vers_match_lang_cplusplus
154 PARAMS ((struct bfd_elf_version_expr
*, const char *));
155 static int lang_vers_match_lang_java
156 PARAMS ((struct bfd_elf_version_expr
*, const char *));
157 static void lang_do_version_exports_section
PARAMS ((void));
158 static void lang_check_section_addresses
PARAMS ((void));
159 static void os_region_check
160 PARAMS ((lang_output_section_statement_type
*,
161 struct memory_region_struct
*, etree_type
*, bfd_vma
));
162 static bfd_vma lang_size_sections_1
163 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*,
164 lang_statement_union_type
**, fill_type
*, bfd_vma
, boolean
*));
166 typedef void (*callback_t
) PARAMS ((lang_wild_statement_type
*,
167 struct wildcard_list
*,
169 lang_input_statement_type
*,
171 static void walk_wild
172 PARAMS ((lang_wild_statement_type
*, callback_t
, PTR
));
173 static void walk_wild_section
174 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
176 static void walk_wild_file
177 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
180 static int get_target
PARAMS ((const bfd_target
*, PTR
));
181 static void stricpy
PARAMS ((char *, char *));
182 static void strcut
PARAMS ((char *, char *));
183 static int name_compare
PARAMS ((char *, char *));
184 static int closest_target_match
PARAMS ((const bfd_target
*, PTR
));
185 static char * get_first_input_target
PARAMS ((void));
188 lang_output_section_statement_type
*abs_output_section
;
189 lang_statement_list_type lang_output_section_statement
;
190 lang_statement_list_type
*stat_ptr
= &statement_list
;
191 lang_statement_list_type file_chain
= { NULL
, NULL
};
192 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
193 const char *entry_section
= ".text";
194 boolean entry_from_cmdline
;
195 boolean lang_has_input_file
= false;
196 boolean had_output_filename
= false;
197 boolean lang_float_flag
= false;
198 boolean delete_output_file_on_failure
= false;
199 struct lang_nocrossrefs
*nocrossref_list
;
200 struct unique_sections
*unique_section_list
;
202 etree_type
*base
; /* Relocation base - or null */
204 #if defined (__STDC__) || defined (ALMOST_STDC)
205 #define cat(a,b) a##b
207 #define cat(a,b) a/**/b
210 /* Don't beautify the line below with "innocent" whitespace, it breaks
211 the K&R C preprocessor! */
212 #define new_stat(x, y) \
213 (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
215 #define outside_section_address(q) \
216 ((q)->output_offset + (q)->output_section->vma)
218 #define outside_symbol_address(q) \
219 ((q)->value + outside_section_address (q->section))
221 #define SECTION_NAME_MAP_LENGTH (16)
227 return obstack_alloc (&stat_obstack
, size
);
231 unique_section_p (secnam
)
234 struct unique_sections
*unam
;
236 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
237 if (wildcardp (unam
->name
)
238 ? fnmatch (unam
->name
, secnam
, 0) == 0
239 : strcmp (unam
->name
, secnam
) == 0)
247 /* Generic traversal routines for finding matching sections. */
250 walk_wild_section (ptr
, file
, callback
, data
)
251 lang_wild_statement_type
*ptr
;
252 lang_input_statement_type
*file
;
258 if (file
->just_syms_flag
)
261 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
263 struct wildcard_list
*sec
;
265 sec
= ptr
->section_list
;
267 (*callback
) (ptr
, sec
, s
, file
, data
);
271 boolean skip
= false;
272 struct name_list
*list_tmp
;
274 /* Don't process sections from files which were
276 for (list_tmp
= sec
->spec
.exclude_name_list
;
278 list_tmp
= list_tmp
->next
)
280 if (wildcardp (list_tmp
->name
))
281 skip
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
283 skip
= strcmp (list_tmp
->name
, file
->filename
) == 0;
285 /* If this file is part of an archive, and the archive is
286 excluded, exclude this file. */
287 if (! skip
&& file
->the_bfd
!= NULL
288 && file
->the_bfd
->my_archive
!= NULL
289 && file
->the_bfd
->my_archive
->filename
!= NULL
)
291 if (wildcardp (list_tmp
->name
))
292 skip
= fnmatch (list_tmp
->name
,
293 file
->the_bfd
->my_archive
->filename
,
296 skip
= strcmp (list_tmp
->name
,
297 file
->the_bfd
->my_archive
->filename
) == 0;
304 if (!skip
&& sec
->spec
.name
!= NULL
)
306 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
308 if (wildcardp (sec
->spec
.name
))
309 skip
= fnmatch (sec
->spec
.name
, sname
, 0) != 0;
311 skip
= strcmp (sec
->spec
.name
, sname
) != 0;
315 (*callback
) (ptr
, sec
, s
, file
, data
);
322 /* Handle a wild statement for a single file F. */
325 walk_wild_file (s
, f
, callback
, data
)
326 lang_wild_statement_type
*s
;
327 lang_input_statement_type
*f
;
331 if (f
->the_bfd
== NULL
332 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
333 walk_wild_section (s
, f
, callback
, data
);
338 /* This is an archive file. We must map each member of the
339 archive separately. */
340 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
341 while (member
!= NULL
)
343 /* When lookup_name is called, it will call the add_symbols
344 entry point for the archive. For each element of the
345 archive which is included, BFD will call ldlang_add_file,
346 which will set the usrdata field of the member to the
347 lang_input_statement. */
348 if (member
->usrdata
!= NULL
)
350 walk_wild_section (s
,
351 (lang_input_statement_type
*) member
->usrdata
,
355 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
361 walk_wild (s
, callback
, data
)
362 lang_wild_statement_type
*s
;
366 const char *file_spec
= s
->filename
;
368 if (file_spec
== NULL
)
370 /* Perform the iteration over all files in the list. */
371 LANG_FOR_EACH_INPUT_STATEMENT (f
)
373 walk_wild_file (s
, f
, callback
, data
);
376 else if (wildcardp (file_spec
))
378 LANG_FOR_EACH_INPUT_STATEMENT (f
)
380 if (fnmatch (file_spec
, f
->filename
, FNM_FILE_NAME
) == 0)
381 walk_wild_file (s
, f
, callback
, data
);
386 lang_input_statement_type
*f
;
388 /* Perform the iteration over a single file. */
389 f
= lookup_name (file_spec
);
391 walk_wild_file (s
, f
, callback
, data
);
395 /* lang_for_each_statement walks the parse tree and calls the provided
396 function for each node. */
399 lang_for_each_statement_worker (func
, s
)
400 void (*func
) PARAMS ((lang_statement_union_type
*));
401 lang_statement_union_type
*s
;
403 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
407 switch (s
->header
.type
)
409 case lang_constructors_statement_enum
:
410 lang_for_each_statement_worker (func
, constructor_list
.head
);
412 case lang_output_section_statement_enum
:
413 lang_for_each_statement_worker
415 s
->output_section_statement
.children
.head
);
417 case lang_wild_statement_enum
:
418 lang_for_each_statement_worker
420 s
->wild_statement
.children
.head
);
422 case lang_group_statement_enum
:
423 lang_for_each_statement_worker (func
,
424 s
->group_statement
.children
.head
);
426 case lang_data_statement_enum
:
427 case lang_reloc_statement_enum
:
428 case lang_object_symbols_statement_enum
:
429 case lang_output_statement_enum
:
430 case lang_target_statement_enum
:
431 case lang_input_section_enum
:
432 case lang_input_statement_enum
:
433 case lang_assignment_statement_enum
:
434 case lang_padding_statement_enum
:
435 case lang_address_statement_enum
:
436 case lang_fill_statement_enum
:
446 lang_for_each_statement (func
)
447 void (*func
) PARAMS ((lang_statement_union_type
*));
449 lang_for_each_statement_worker (func
, statement_list
.head
);
452 /*----------------------------------------------------------------------*/
455 lang_list_init (list
)
456 lang_statement_list_type
*list
;
458 list
->head
= (lang_statement_union_type
*) NULL
;
459 list
->tail
= &list
->head
;
462 /* Build a new statement node for the parse tree. */
464 static lang_statement_union_type
*
465 new_statement (type
, size
, list
)
466 enum statement_enum type
;
468 lang_statement_list_type
*list
;
470 lang_statement_union_type
*new = (lang_statement_union_type
*)
473 new->header
.type
= type
;
474 new->header
.next
= (lang_statement_union_type
*) NULL
;
475 lang_statement_append (list
, new, &new->header
.next
);
479 /* Build a new input file node for the language. There are several
480 ways in which we treat an input file, eg, we only look at symbols,
481 or prefix it with a -l etc.
483 We can be supplied with requests for input files more than once;
484 they may, for example be split over serveral lines like foo.o(.text)
485 foo.o(.data) etc, so when asked for a file we check that we haven't
486 got it already so we don't duplicate the bfd. */
488 static lang_input_statement_type
*
489 new_afile (name
, file_type
, target
, add_to_list
)
491 lang_input_file_enum_type file_type
;
495 lang_input_statement_type
*p
;
498 p
= new_stat (lang_input_statement
, stat_ptr
);
501 p
= ((lang_input_statement_type
*)
502 stat_alloc (sizeof (lang_input_statement_type
)));
503 p
->header
.next
= NULL
;
506 lang_has_input_file
= true;
510 case lang_input_file_is_symbols_only_enum
:
512 p
->is_archive
= false;
514 p
->local_sym_name
= name
;
515 p
->just_syms_flag
= true;
516 p
->search_dirs_flag
= false;
518 case lang_input_file_is_fake_enum
:
520 p
->is_archive
= false;
522 p
->local_sym_name
= name
;
523 p
->just_syms_flag
= false;
524 p
->search_dirs_flag
= false;
526 case lang_input_file_is_l_enum
:
527 p
->is_archive
= true;
530 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
531 p
->just_syms_flag
= false;
532 p
->search_dirs_flag
= true;
534 case lang_input_file_is_marker_enum
:
536 p
->is_archive
= false;
538 p
->local_sym_name
= name
;
539 p
->just_syms_flag
= false;
540 p
->search_dirs_flag
= true;
542 case lang_input_file_is_search_file_enum
:
544 p
->is_archive
= false;
546 p
->local_sym_name
= name
;
547 p
->just_syms_flag
= false;
548 p
->search_dirs_flag
= true;
550 case lang_input_file_is_file_enum
:
552 p
->is_archive
= false;
554 p
->local_sym_name
= name
;
555 p
->just_syms_flag
= false;
556 p
->search_dirs_flag
= false;
561 p
->the_bfd
= (bfd
*) NULL
;
562 p
->asymbols
= (asymbol
**) NULL
;
563 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
564 p
->next
= (lang_statement_union_type
*) NULL
;
566 p
->dynamic
= config
.dynamic_link
;
567 p
->whole_archive
= whole_archive
;
569 lang_statement_append (&input_file_chain
,
570 (lang_statement_union_type
*) p
,
575 lang_input_statement_type
*
576 lang_add_input_file (name
, file_type
, target
)
578 lang_input_file_enum_type file_type
;
581 lang_has_input_file
= true;
582 return new_afile (name
, file_type
, target
, true);
585 /* Build enough state so that the parser can build its tree. */
590 obstack_begin (&stat_obstack
, 1000);
592 stat_ptr
= &statement_list
;
594 lang_list_init (stat_ptr
);
596 lang_list_init (&input_file_chain
);
597 lang_list_init (&lang_output_section_statement
);
598 lang_list_init (&file_chain
);
599 first_file
= lang_add_input_file ((char *) NULL
,
600 lang_input_file_is_marker_enum
,
603 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
605 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
609 /*----------------------------------------------------------------------
610 A region is an area of memory declared with the
611 MEMORY { name:org=exp, len=exp ... }
614 We maintain a list of all the regions here.
616 If no regions are specified in the script, then the default is used
617 which is created when looked up to be the entire data space. */
619 static lang_memory_region_type
*lang_memory_region_list
;
620 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
622 lang_memory_region_type
*
623 lang_memory_region_lookup (name
)
624 const char *const name
;
626 lang_memory_region_type
*p
;
628 /* NAME is NULL for LMA memspecs if no region was specified. */
632 for (p
= lang_memory_region_list
;
633 p
!= (lang_memory_region_type
*) NULL
;
636 if (strcmp (p
->name
, name
) == 0)
643 /* This code used to always use the first region in the list as the
644 default region. I changed it to instead use a region
645 encompassing all of memory as the default region. This permits
646 NOLOAD sections to work reasonably without requiring a region.
647 People should specify what region they mean, if they really want
649 if (strcmp (name
, "*default*") == 0)
651 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
653 return lang_memory_region_list
;
659 lang_memory_region_type
*new =
660 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
662 new->name
= xstrdup (name
);
663 new->next
= (lang_memory_region_type
*) NULL
;
665 *lang_memory_region_list_tail
= new;
666 lang_memory_region_list_tail
= &new->next
;
670 new->length
= ~(bfd_size_type
) 0;
672 new->had_full_message
= false;
678 static lang_memory_region_type
*
679 lang_memory_default (section
)
682 lang_memory_region_type
*p
;
684 flagword sec_flags
= section
->flags
;
686 /* Override SEC_DATA to mean a writable section. */
687 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
688 sec_flags
|= SEC_DATA
;
690 for (p
= lang_memory_region_list
;
691 p
!= (lang_memory_region_type
*) NULL
;
694 if ((p
->flags
& sec_flags
) != 0
695 && (p
->not_flags
& sec_flags
) == 0)
700 return lang_memory_region_lookup ("*default*");
703 lang_output_section_statement_type
*
704 lang_output_section_find (name
)
705 const char *const name
;
707 lang_statement_union_type
*u
;
708 lang_output_section_statement_type
*lookup
;
710 for (u
= lang_output_section_statement
.head
;
711 u
!= (lang_statement_union_type
*) NULL
;
714 lookup
= &u
->output_section_statement
;
715 if (strcmp (name
, lookup
->name
) == 0)
720 return (lang_output_section_statement_type
*) NULL
;
723 lang_output_section_statement_type
*
724 lang_output_section_statement_lookup (name
)
725 const char *const name
;
727 lang_output_section_statement_type
*lookup
;
729 lookup
= lang_output_section_find (name
);
730 if (lookup
== (lang_output_section_statement_type
*) NULL
)
733 lookup
= (lang_output_section_statement_type
*)
734 new_stat (lang_output_section_statement
, stat_ptr
);
735 lookup
->region
= (lang_memory_region_type
*) NULL
;
736 lookup
->lma_region
= (lang_memory_region_type
*) NULL
;
737 lookup
->fill
= (fill_type
*) 0;
738 lookup
->block_value
= 1;
741 lookup
->next
= (lang_statement_union_type
*) NULL
;
742 lookup
->bfd_section
= (asection
*) NULL
;
743 lookup
->processed
= false;
744 lookup
->sectype
= normal_section
;
745 lookup
->addr_tree
= (etree_type
*) NULL
;
746 lang_list_init (&lookup
->children
);
748 lookup
->memspec
= (const char *) NULL
;
750 lookup
->subsection_alignment
= -1;
751 lookup
->section_alignment
= -1;
752 lookup
->load_base
= (union etree_union
*) NULL
;
753 lookup
->update_dot_tree
= NULL
;
754 lookup
->phdrs
= NULL
;
756 lang_statement_append (&lang_output_section_statement
,
757 (lang_statement_union_type
*) lookup
,
764 lang_map_flags (flag
)
767 if (flag
& SEC_ALLOC
)
773 if (flag
& SEC_READONLY
)
786 lang_memory_region_type
*m
;
788 minfo (_("\nMemory Configuration\n\n"));
789 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
790 _("Name"), _("Origin"), _("Length"), _("Attributes"));
792 for (m
= lang_memory_region_list
;
793 m
!= (lang_memory_region_type
*) NULL
;
799 fprintf (config
.map_file
, "%-16s ", m
->name
);
801 sprintf_vma (buf
, m
->origin
);
802 minfo ("0x%s ", buf
);
810 minfo ("0x%V", m
->length
);
811 if (m
->flags
|| m
->not_flags
)
819 lang_map_flags (m
->flags
);
825 lang_map_flags (m
->not_flags
);
832 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
837 /* Initialize an output section. */
841 lang_output_section_statement_type
*s
;
843 section_userdata_type
*new;
845 if (s
->bfd_section
!= NULL
)
848 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
849 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
851 new = ((section_userdata_type
*)
852 stat_alloc (sizeof (section_userdata_type
)));
854 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
855 if (s
->bfd_section
== (asection
*) NULL
)
856 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
857 if (s
->bfd_section
== (asection
*) NULL
)
859 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
860 output_bfd
->xvec
->name
, s
->name
);
862 s
->bfd_section
->output_section
= s
->bfd_section
;
864 /* We initialize an output sections output offset to minus its own
865 vma to allow us to output a section through itself. */
866 s
->bfd_section
->output_offset
= 0;
867 get_userdata (s
->bfd_section
) = (PTR
) new;
869 /* If there is a base address, make sure that any sections it might
870 mention are initialized. */
871 if (s
->addr_tree
!= NULL
)
872 exp_init_os (s
->addr_tree
);
875 /* Make sure that all output sections mentioned in an expression are
882 switch (exp
->type
.node_class
)
885 exp_init_os (exp
->assign
.src
);
889 exp_init_os (exp
->binary
.lhs
);
890 exp_init_os (exp
->binary
.rhs
);
894 exp_init_os (exp
->trinary
.cond
);
895 exp_init_os (exp
->trinary
.lhs
);
896 exp_init_os (exp
->trinary
.rhs
);
900 exp_init_os (exp
->unary
.child
);
904 switch (exp
->type
.node_code
)
910 lang_output_section_statement_type
*os
;
912 os
= lang_output_section_find (exp
->name
.name
);
913 if (os
!= NULL
&& os
->bfd_section
== NULL
)
924 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
925 once into the output. This routine checks each section, and
926 arrange to discard it if a section of the same name has already
927 been linked. If the section has COMDAT information, then it uses
928 that to decide whether the section should be included. This code
929 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
930 that is, it does not depend solely upon the section name.
931 section_already_linked is called via bfd_map_over_sections. */
933 /* This is the shape of the elements inside the already_linked hash
934 table. It maps a name onto a list of already_linked elements with
935 the same name. It's possible to get more than one element in a
936 list if the COMDAT sections have different names. */
938 struct already_linked_hash_entry
940 struct bfd_hash_entry root
;
941 struct already_linked
*entry
;
944 struct already_linked
946 struct already_linked
*next
;
950 /* The hash table. */
952 static struct bfd_hash_table already_linked_table
;
955 section_already_linked (abfd
, sec
, data
)
960 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
963 struct already_linked
*l
;
964 struct already_linked_hash_entry
*already_linked_list
;
966 /* If we are only reading symbols from this object, then we want to
967 discard all sections. */
968 if (entry
->just_syms_flag
)
970 bfd_link_just_syms (sec
, &link_info
);
974 flags
= bfd_get_section_flags (abfd
, sec
);
976 if ((flags
& SEC_LINK_ONCE
) == 0)
979 /* FIXME: When doing a relocatable link, we may have trouble
980 copying relocations in other sections that refer to local symbols
981 in the section being discarded. Those relocations will have to
982 be converted somehow; as of this writing I'm not sure that any of
983 the backends handle that correctly.
985 It is tempting to instead not discard link once sections when
986 doing a relocatable link (technically, they should be discarded
987 whenever we are building constructors). However, that fails,
988 because the linker winds up combining all the link once sections
989 into a single large link once section, which defeats the purpose
990 of having link once sections in the first place.
992 Also, not merging link once sections in a relocatable link
993 causes trouble for MIPS ELF, which relies on link once semantics
994 to handle the .reginfo section correctly. */
996 name
= bfd_get_section_name (abfd
, sec
);
998 already_linked_list
=
999 ((struct already_linked_hash_entry
*)
1000 bfd_hash_lookup (&already_linked_table
, name
, true, false));
1002 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
1004 if (sec
->comdat
== NULL
1005 || l
->sec
->comdat
== NULL
1006 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
1008 /* The section has already been linked. See if we should
1010 switch (flags
& SEC_LINK_DUPLICATES
)
1015 case SEC_LINK_DUPLICATES_DISCARD
:
1018 case SEC_LINK_DUPLICATES_ONE_ONLY
:
1019 if (sec
->comdat
== NULL
)
1020 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
1023 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
1024 abfd
, name
, sec
->comdat
->name
);
1027 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
1028 /* FIXME: We should really dig out the contents of both
1029 sections and memcmp them. The COFF/PE spec says that
1030 the Microsoft linker does not implement this
1031 correctly, so I'm not going to bother doing it
1034 case SEC_LINK_DUPLICATES_SAME_SIZE
:
1035 if (bfd_section_size (abfd
, sec
)
1036 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1037 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1042 /* Set the output_section field so that lang_add_section
1043 does not create a lang_input_section structure for this
1045 sec
->output_section
= bfd_abs_section_ptr
;
1047 if (flags
& SEC_GROUP
)
1048 bfd_discard_group (abfd
, sec
);
1054 /* This is the first section with this name. Record it. Allocate
1055 the memory from the same obstack as the hash table is kept in. */
1057 l
= ((struct already_linked
*)
1058 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1061 l
->next
= already_linked_list
->entry
;
1062 already_linked_list
->entry
= l
;
1065 /* Support routines for the hash table used by section_already_linked,
1066 initialize the table, fill in an entry and remove the table. */
1068 static struct bfd_hash_entry
*
1069 already_linked_newfunc (entry
, table
, string
)
1070 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1071 struct bfd_hash_table
*table
;
1072 const char *string ATTRIBUTE_UNUSED
;
1074 struct already_linked_hash_entry
*ret
=
1075 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1079 return (struct bfd_hash_entry
*) ret
;
1083 already_linked_table_init ()
1085 if (! bfd_hash_table_init_n (&already_linked_table
,
1086 already_linked_newfunc
,
1088 einfo (_("%P%F: Failed to create hash table\n"));
1092 already_linked_table_free ()
1094 bfd_hash_table_free (&already_linked_table
);
1097 /* The wild routines.
1099 These expand statements like *(.text) and foo.o to a list of
1100 explicit actions, like foo.o(.text), bar.o(.text) and
1101 foo.o(.text, .data). */
1103 /* Return true if the PATTERN argument is a wildcard pattern.
1104 Although backslashes are treated specially if a pattern contains
1105 wildcards, we do not consider the mere presence of a backslash to
1106 be enough to cause the pattern to be treated as a wildcard.
1107 That lets us handle DOS filenames more naturally. */
1111 const char *pattern
;
1115 for (s
= pattern
; *s
!= '\0'; ++s
)
1123 /* Add SECTION to the output section OUTPUT. Do this by creating a
1124 lang_input_section statement which is placed at PTR. FILE is the
1125 input file which holds SECTION. */
1128 lang_add_section (ptr
, section
, output
, file
)
1129 lang_statement_list_type
*ptr
;
1131 lang_output_section_statement_type
*output
;
1132 lang_input_statement_type
*file
;
1137 flags
= bfd_get_section_flags (section
->owner
, section
);
1141 /* If we are doing a final link, discard sections marked with
1143 if (! link_info
.relocateable
1144 && (flags
& SEC_EXCLUDE
) != 0)
1147 /* Discard input sections which are assigned to a section named
1148 DISCARD_SECTION_NAME. */
1149 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1152 /* Discard debugging sections if we are stripping debugging
1154 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1155 && (flags
& SEC_DEBUGGING
) != 0)
1160 if (section
->output_section
== NULL
)
1162 /* This prevents future calls from assigning this section. */
1163 section
->output_section
= bfd_abs_section_ptr
;
1168 if (section
->output_section
== NULL
)
1171 lang_input_section_type
*new;
1174 if (output
->bfd_section
== NULL
)
1177 first
= ! output
->bfd_section
->linker_has_input
;
1178 output
->bfd_section
->linker_has_input
= 1;
1180 /* Add a section reference to the list. */
1181 new = new_stat (lang_input_section
, ptr
);
1183 new->section
= section
;
1185 section
->output_section
= output
->bfd_section
;
1187 flags
= section
->flags
;
1189 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1190 to an output section, because we want to be able to include a
1191 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1192 section (I don't know why we want to do this, but we do).
1193 build_link_order in ldwrite.c handles this case by turning
1194 the embedded SEC_NEVER_LOAD section into a fill. */
1196 flags
&= ~ SEC_NEVER_LOAD
;
1198 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1199 already been processed. One reason to do this is that on pe
1200 format targets, .text$foo sections go into .text and it's odd
1201 to see .text with SEC_LINK_ONCE set. */
1203 if (! link_info
.relocateable
)
1204 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1206 /* If this is not the first input section, and the SEC_READONLY
1207 flag is not currently set, then don't set it just because the
1208 input section has it set. */
1210 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1211 flags
&= ~ SEC_READONLY
;
1213 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1215 && ((section
->output_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1216 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1217 || ((flags
& SEC_MERGE
)
1218 && section
->output_section
->entsize
!= section
->entsize
)))
1220 section
->output_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1221 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1224 /* For now make .tbss normal section. */
1225 if ((flags
& SEC_THREAD_LOCAL
) && ! link_info
.relocateable
)
1228 section
->output_section
->flags
|= flags
;
1230 if (flags
& SEC_MERGE
)
1231 section
->output_section
->entsize
= section
->entsize
;
1233 /* If SEC_READONLY is not set in the input section, then clear
1234 it from the output section. */
1235 if ((section
->flags
& SEC_READONLY
) == 0)
1236 section
->output_section
->flags
&= ~SEC_READONLY
;
1238 switch (output
->sectype
)
1240 case normal_section
:
1245 case overlay_section
:
1246 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1248 case noload_section
:
1249 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1250 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1254 /* Copy over SEC_SMALL_DATA. */
1255 if (section
->flags
& SEC_SMALL_DATA
)
1256 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1258 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1259 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1261 /* If supplied an aligment, then force it. */
1262 if (output
->section_alignment
!= -1)
1263 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1265 if (section
->flags
& SEC_BLOCK
)
1267 section
->output_section
->flags
|= SEC_BLOCK
;
1268 /* FIXME: This value should really be obtained from the bfd... */
1269 output
->block_value
= 128;
1274 /* Handle wildcard sorting. This returns the lang_input_section which
1275 should follow the one we are going to create for SECTION and FILE,
1276 based on the sorting requirements of WILD. It returns NULL if the
1277 new section should just go at the end of the current list. */
1279 static lang_statement_union_type
*
1280 wild_sort (wild
, sec
, file
, section
)
1281 lang_wild_statement_type
*wild
;
1282 struct wildcard_list
*sec
;
1283 lang_input_statement_type
*file
;
1286 const char *section_name
;
1287 lang_statement_union_type
*l
;
1289 if (!wild
->filenames_sorted
&& (sec
== NULL
|| !sec
->spec
.sorted
))
1292 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1293 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
1295 lang_input_section_type
*ls
;
1297 if (l
->header
.type
!= lang_input_section_enum
)
1299 ls
= &l
->input_section
;
1301 /* Sorting by filename takes precedence over sorting by section
1304 if (wild
->filenames_sorted
)
1306 const char *fn
, *ln
;
1310 /* The PE support for the .idata section as generated by
1311 dlltool assumes that files will be sorted by the name of
1312 the archive and then the name of the file within the
1315 if (file
->the_bfd
!= NULL
1316 && bfd_my_archive (file
->the_bfd
) != NULL
)
1318 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1323 fn
= file
->filename
;
1327 if (ls
->ifile
->the_bfd
!= NULL
1328 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1330 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1335 ln
= ls
->ifile
->filename
;
1339 i
= strcmp (fn
, ln
);
1348 fn
= file
->filename
;
1350 ln
= ls
->ifile
->filename
;
1352 i
= strcmp (fn
, ln
);
1360 /* Here either the files are not sorted by name, or we are
1361 looking at the sections for this file. */
1363 if (sec
!= NULL
&& sec
->spec
.sorted
)
1365 if (strcmp (section_name
,
1366 bfd_get_section_name (ls
->ifile
->the_bfd
,
1376 /* Expand a wild statement for a particular FILE. SECTION may be
1377 NULL, in which case it is a wild card. */
1380 output_section_callback (ptr
, sec
, section
, file
, output
)
1381 lang_wild_statement_type
*ptr
;
1382 struct wildcard_list
*sec
;
1384 lang_input_statement_type
*file
;
1387 lang_statement_union_type
*before
;
1389 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1390 if (unique_section_p (bfd_get_section_name (file
->the_bfd
, section
)))
1393 /* If the wild pattern was marked KEEP, the member sections
1394 should be as well. */
1395 if (ptr
->keep_sections
)
1396 section
->flags
|= SEC_KEEP
;
1398 before
= wild_sort (ptr
, sec
, file
, section
);
1400 /* Here BEFORE points to the lang_input_section which
1401 should follow the one we are about to add. If BEFORE
1402 is NULL, then the section should just go at the end
1403 of the current list. */
1406 lang_add_section (&ptr
->children
, section
,
1407 (lang_output_section_statement_type
*) output
,
1411 lang_statement_list_type list
;
1412 lang_statement_union_type
**pp
;
1414 lang_list_init (&list
);
1415 lang_add_section (&list
, section
,
1416 (lang_output_section_statement_type
*) output
,
1419 /* If we are discarding the section, LIST.HEAD will
1421 if (list
.head
!= NULL
)
1423 ASSERT (list
.head
->header
.next
== NULL
);
1425 for (pp
= &ptr
->children
.head
;
1427 pp
= &(*pp
)->header
.next
)
1428 ASSERT (*pp
!= NULL
);
1430 list
.head
->header
.next
= *pp
;
1436 /* This is passed a file name which must have been seen already and
1437 added to the statement tree. We will see if it has been opened
1438 already and had its symbols read. If not then we'll read it. */
1440 static lang_input_statement_type
*
1444 lang_input_statement_type
*search
;
1446 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1447 search
!= (lang_input_statement_type
*) NULL
;
1448 search
= (lang_input_statement_type
*) search
->next_real_file
)
1450 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1452 if (search
->filename
!= (char *) NULL
1453 && name
!= (char *) NULL
1454 && strcmp (search
->filename
, name
) == 0)
1458 if (search
== (lang_input_statement_type
*) NULL
)
1459 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1462 /* If we have already added this file, or this file is not real
1463 (FIXME: can that ever actually happen?) or the name is NULL
1464 (FIXME: can that ever actually happen?) don't add this file. */
1467 || search
->filename
== (const char *) NULL
)
1470 if (! load_symbols (search
, (lang_statement_list_type
*) NULL
))
1476 /* Get the symbols for an input file. */
1479 load_symbols (entry
, place
)
1480 lang_input_statement_type
*entry
;
1481 lang_statement_list_type
*place
;
1488 ldfile_open_file (entry
);
1490 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1491 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1494 lang_statement_list_type
*hold
;
1495 boolean bad_load
= true;
1497 err
= bfd_get_error ();
1499 /* See if the emulation has some special knowledge. */
1500 if (ldemul_unrecognized_file (entry
))
1503 if (err
== bfd_error_file_ambiguously_recognized
)
1507 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1508 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1509 for (p
= matching
; *p
!= NULL
; p
++)
1513 else if (err
!= bfd_error_file_not_recognized
1515 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1519 bfd_close (entry
->the_bfd
);
1520 entry
->the_bfd
= NULL
;
1522 /* Try to interpret the file as a linker script. */
1523 ldfile_open_command_file (entry
->filename
);
1528 ldfile_assumed_script
= true;
1529 parser_input
= input_script
;
1531 ldfile_assumed_script
= false;
1538 if (ldemul_recognized_file (entry
))
1541 /* We don't call ldlang_add_file for an archive. Instead, the
1542 add_symbols entry point will call ldlang_add_file, via the
1543 add_archive_element callback, for each element of the archive
1545 switch (bfd_get_format (entry
->the_bfd
))
1551 ldlang_add_file (entry
);
1552 if (trace_files
|| trace_file_tries
)
1553 info_msg ("%I\n", entry
);
1557 if (entry
->whole_archive
)
1560 boolean loaded
= true;
1564 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
1569 if (! bfd_check_format (member
, bfd_object
))
1571 einfo (_("%F%B: member %B in archive is not an object\n"),
1572 entry
->the_bfd
, member
);
1576 if (! ((*link_info
.callbacks
->add_archive_element
)
1577 (&link_info
, member
, "--whole-archive")))
1580 if (! bfd_link_add_symbols (member
, &link_info
))
1582 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1587 entry
->loaded
= loaded
;
1593 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1594 entry
->loaded
= true;
1596 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1598 return entry
->loaded
;
1601 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1602 may be NULL, indicating that it is a wildcard. Separate
1603 lang_input_section statements are created for each part of the
1604 expansion; they are added after the wild statement S. OUTPUT is
1605 the output section. */
1608 wild (s
, target
, output
)
1609 lang_wild_statement_type
*s
;
1610 const char *target ATTRIBUTE_UNUSED
;
1611 lang_output_section_statement_type
*output
;
1613 struct wildcard_list
*sec
;
1615 walk_wild (s
, output_section_callback
, (PTR
) output
);
1617 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
1619 if (default_common_section
!= NULL
)
1621 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
1623 /* Remember the section that common is going to in case we
1624 later get something which doesn't know where to put it. */
1625 default_common_section
= output
;
1630 /* Return true iff target is the sought target. */
1633 get_target (target
, data
)
1634 const bfd_target
*target
;
1637 const char *sought
= (const char *) data
;
1639 return strcmp (target
->name
, sought
) == 0;
1642 /* Like strcpy() but convert to lower case as well. */
1651 while ((c
= *src
++) != 0)
1652 *dest
++ = TOLOWER (c
);
1657 /* Remove the first occurance of needle (if any) in haystack
1661 strcut (haystack
, needle
)
1665 haystack
= strstr (haystack
, needle
);
1671 for (src
= haystack
+ strlen (needle
); *src
;)
1672 *haystack
++ = *src
++;
1678 /* Compare two target format name strings.
1679 Return a value indicating how "similar" they are. */
1682 name_compare (first
, second
)
1690 copy1
= xmalloc (strlen (first
) + 1);
1691 copy2
= xmalloc (strlen (second
) + 1);
1693 /* Convert the names to lower case. */
1694 stricpy (copy1
, first
);
1695 stricpy (copy2
, second
);
1697 /* Remove and endian strings from the name. */
1698 strcut (copy1
, "big");
1699 strcut (copy1
, "little");
1700 strcut (copy2
, "big");
1701 strcut (copy2
, "little");
1703 /* Return a value based on how many characters match,
1704 starting from the beginning. If both strings are
1705 the same then return 10 * their length. */
1706 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1707 if (copy1
[result
] == 0)
1719 /* Set by closest_target_match() below. */
1720 static const bfd_target
*winner
;
1722 /* Scan all the valid bfd targets looking for one that has the endianness
1723 requirement that was specified on the command line, and is the nearest
1724 match to the original output target. */
1727 closest_target_match (target
, data
)
1728 const bfd_target
*target
;
1731 const bfd_target
*original
= (const bfd_target
*) data
;
1733 if (command_line
.endian
== ENDIAN_BIG
1734 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1737 if (command_line
.endian
== ENDIAN_LITTLE
1738 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1741 /* Must be the same flavour. */
1742 if (target
->flavour
!= original
->flavour
)
1745 /* If we have not found a potential winner yet, then record this one. */
1752 /* Oh dear, we now have two potential candidates for a successful match.
1753 Compare their names and choose the better one. */
1754 if (name_compare (target
->name
, original
->name
)
1755 > name_compare (winner
->name
, original
->name
))
1758 /* Keep on searching until wqe have checked them all. */
1762 /* Return the BFD target format of the first input file. */
1765 get_first_input_target ()
1767 char *target
= NULL
;
1769 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1771 if (s
->header
.type
== lang_input_statement_enum
1774 ldfile_open_file (s
);
1776 if (s
->the_bfd
!= NULL
1777 && bfd_check_format (s
->the_bfd
, bfd_object
))
1779 target
= bfd_get_target (s
->the_bfd
);
1791 lang_get_output_target ()
1795 /* Has the user told us which output format to use? */
1796 if (output_target
!= (char *) NULL
)
1797 return output_target
;
1799 /* No - has the current target been set to something other than
1801 if (current_target
!= default_target
)
1802 return current_target
;
1804 /* No - can we determine the format of the first input file? */
1805 target
= get_first_input_target ();
1809 /* Failed - use the default output target. */
1810 return default_target
;
1813 /* Open the output file. */
1821 output_target
= lang_get_output_target ();
1823 /* Has the user requested a particular endianness on the command
1825 if (command_line
.endian
!= ENDIAN_UNSET
)
1827 const bfd_target
*target
;
1828 enum bfd_endian desired_endian
;
1830 /* Get the chosen target. */
1831 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1833 /* If the target is not supported, we cannot do anything. */
1836 if (command_line
.endian
== ENDIAN_BIG
)
1837 desired_endian
= BFD_ENDIAN_BIG
;
1839 desired_endian
= BFD_ENDIAN_LITTLE
;
1841 /* See if the target has the wrong endianness. This should
1842 not happen if the linker script has provided big and
1843 little endian alternatives, but some scrips don't do
1845 if (target
->byteorder
!= desired_endian
)
1847 /* If it does, then see if the target provides
1848 an alternative with the correct endianness. */
1849 if (target
->alternative_target
!= NULL
1850 && (target
->alternative_target
->byteorder
== desired_endian
))
1851 output_target
= target
->alternative_target
->name
;
1854 /* Try to find a target as similar as possible to
1855 the default target, but which has the desired
1856 endian characteristic. */
1857 (void) bfd_search_for_target (closest_target_match
,
1860 /* Oh dear - we could not find any targets that
1861 satisfy our requirements. */
1863 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1865 output_target
= winner
->name
;
1871 output
= bfd_openw (name
, output_target
);
1873 if (output
== (bfd
*) NULL
)
1875 if (bfd_get_error () == bfd_error_invalid_target
)
1876 einfo (_("%P%F: target %s not found\n"), output_target
);
1878 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1881 delete_output_file_on_failure
= true;
1884 output
->flags
|= D_PAGED
;
1887 if (! bfd_set_format (output
, bfd_object
))
1888 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1889 if (! bfd_set_arch_mach (output
,
1890 ldfile_output_architecture
,
1891 ldfile_output_machine
))
1892 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1894 link_info
.hash
= bfd_link_hash_table_create (output
);
1895 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1896 einfo (_("%P%F: can not create link hash table: %E\n"));
1898 bfd_set_gp_size (output
, g_switch_value
);
1903 ldlang_open_output (statement
)
1904 lang_statement_union_type
*statement
;
1906 switch (statement
->header
.type
)
1908 case lang_output_statement_enum
:
1909 ASSERT (output_bfd
== (bfd
*) NULL
);
1910 output_bfd
= open_output (statement
->output_statement
.name
);
1911 ldemul_set_output_arch ();
1912 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1913 output_bfd
->flags
|= D_PAGED
;
1915 output_bfd
->flags
&= ~D_PAGED
;
1916 if (config
.text_read_only
)
1917 output_bfd
->flags
|= WP_TEXT
;
1919 output_bfd
->flags
&= ~WP_TEXT
;
1920 if (link_info
.traditional_format
)
1921 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1923 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1926 case lang_target_statement_enum
:
1927 current_target
= statement
->target_statement
.target
;
1934 /* Open all the input files. */
1937 open_input_bfds (s
, force
)
1938 lang_statement_union_type
*s
;
1941 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
1943 switch (s
->header
.type
)
1945 case lang_constructors_statement_enum
:
1946 open_input_bfds (constructor_list
.head
, force
);
1948 case lang_output_section_statement_enum
:
1949 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1951 case lang_wild_statement_enum
:
1952 /* Maybe we should load the file's symbols. */
1953 if (s
->wild_statement
.filename
1954 && ! wildcardp (s
->wild_statement
.filename
))
1955 (void) lookup_name (s
->wild_statement
.filename
);
1956 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1958 case lang_group_statement_enum
:
1960 struct bfd_link_hash_entry
*undefs
;
1962 /* We must continually search the entries in the group
1963 until no new symbols are added to the list of undefined
1968 undefs
= link_info
.hash
->undefs_tail
;
1969 open_input_bfds (s
->group_statement
.children
.head
, true);
1971 while (undefs
!= link_info
.hash
->undefs_tail
);
1974 case lang_target_statement_enum
:
1975 current_target
= s
->target_statement
.target
;
1977 case lang_input_statement_enum
:
1978 if (s
->input_statement
.real
)
1980 lang_statement_list_type add
;
1982 s
->input_statement
.target
= current_target
;
1984 /* If we are being called from within a group, and this
1985 is an archive which has already been searched, then
1986 force it to be researched unless the whole archive
1987 has been loaded already. */
1989 && !s
->input_statement
.whole_archive
1990 && s
->input_statement
.loaded
1991 && bfd_check_format (s
->input_statement
.the_bfd
,
1993 s
->input_statement
.loaded
= false;
1995 lang_list_init (&add
);
1997 if (! load_symbols (&s
->input_statement
, &add
))
1998 config
.make_executable
= false;
2000 if (add
.head
!= NULL
)
2002 *add
.tail
= s
->header
.next
;
2003 s
->header
.next
= add
.head
;
2013 /* If there are [COMMONS] statements, put a wild one into the bss
2017 lang_reasonable_defaults ()
2020 lang_output_section_statement_lookup (".text");
2021 lang_output_section_statement_lookup (".data");
2023 default_common_section
= lang_output_section_statement_lookup (".bss");
2025 if (!placed_commons
)
2027 lang_wild_statement_type
*new =
2028 new_stat (lang_wild_statement
,
2029 &default_common_section
->children
);
2031 new->section_name
= "COMMON";
2032 new->filename
= (char *) NULL
;
2033 lang_list_init (&new->children
);
2038 /* Add the supplied name to the symbol table as an undefined reference.
2039 This is a two step process as the symbol table doesn't even exist at
2040 the time the ld command line is processed. First we put the name
2041 on a list, then, once the output file has been opened, transfer the
2042 name to the symbol table. */
2044 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
2046 #define ldlang_undef_chain_list_head entry_symbol.next
2049 ldlang_add_undef (name
)
2050 const char *const name
;
2052 ldlang_undef_chain_list_type
*new =
2053 ((ldlang_undef_chain_list_type
*)
2054 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
2056 new->next
= ldlang_undef_chain_list_head
;
2057 ldlang_undef_chain_list_head
= new;
2059 new->name
= xstrdup (name
);
2061 if (output_bfd
!= NULL
)
2062 insert_undefined (new->name
);
2065 /* Insert NAME as undefined in the symbol table. */
2068 insert_undefined (name
)
2071 struct bfd_link_hash_entry
*h
;
2073 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, false, true);
2074 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2075 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2076 if (h
->type
== bfd_link_hash_new
)
2078 h
->type
= bfd_link_hash_undefined
;
2079 h
->u
.undef
.abfd
= NULL
;
2080 bfd_link_add_undef (link_info
.hash
, h
);
2084 /* Run through the list of undefineds created above and place them
2085 into the linker hash table as undefined symbols belonging to the
2089 lang_place_undefineds ()
2091 ldlang_undef_chain_list_type
*ptr
;
2093 for (ptr
= ldlang_undef_chain_list_head
;
2094 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
2097 insert_undefined (ptr
->name
);
2101 /* Open input files and attatch to output sections. */
2104 map_input_to_output_sections (s
, target
, output_section_statement
)
2105 lang_statement_union_type
*s
;
2107 lang_output_section_statement_type
*output_section_statement
;
2109 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2111 switch (s
->header
.type
)
2113 case lang_wild_statement_enum
:
2114 wild (&s
->wild_statement
, target
, output_section_statement
);
2116 case lang_constructors_statement_enum
:
2117 map_input_to_output_sections (constructor_list
.head
,
2119 output_section_statement
);
2121 case lang_output_section_statement_enum
:
2122 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2124 &s
->output_section_statement
);
2126 case lang_output_statement_enum
:
2128 case lang_target_statement_enum
:
2129 target
= s
->target_statement
.target
;
2131 case lang_group_statement_enum
:
2132 map_input_to_output_sections (s
->group_statement
.children
.head
,
2134 output_section_statement
);
2136 case lang_fill_statement_enum
:
2137 case lang_input_section_enum
:
2138 case lang_object_symbols_statement_enum
:
2139 case lang_data_statement_enum
:
2140 case lang_reloc_statement_enum
:
2141 case lang_padding_statement_enum
:
2142 case lang_input_statement_enum
:
2143 if (output_section_statement
!= NULL
2144 && output_section_statement
->bfd_section
== NULL
)
2145 init_os (output_section_statement
);
2147 case lang_assignment_statement_enum
:
2148 if (output_section_statement
!= NULL
2149 && output_section_statement
->bfd_section
== NULL
)
2150 init_os (output_section_statement
);
2152 /* Make sure that any sections mentioned in the assignment
2154 exp_init_os (s
->assignment_statement
.exp
);
2156 case lang_afile_asection_pair_statement_enum
:
2159 case lang_address_statement_enum
:
2160 /* Mark the specified section with the supplied address. */
2162 lang_output_section_statement_type
*os
=
2163 lang_output_section_statement_lookup
2164 (s
->address_statement
.section_name
);
2166 if (os
->bfd_section
== NULL
)
2168 os
->addr_tree
= s
->address_statement
.address
;
2175 /* An output section might have been removed after its statement was
2176 added. For example, ldemul_before_allocation can remove dynamic
2177 sections if they turn out to be not needed. Clean them up here. */
2180 strip_excluded_output_sections ()
2182 lang_statement_union_type
*u
;
2184 for (u
= lang_output_section_statement
.head
;
2186 u
= u
->output_section_statement
.next
)
2188 lang_output_section_statement_type
*os
;
2191 os
= &u
->output_section_statement
;
2192 s
= os
->bfd_section
;
2193 if (s
!= NULL
&& (s
->flags
& SEC_EXCLUDE
) != 0)
2197 os
->bfd_section
= NULL
;
2199 for (p
= &output_bfd
->sections
; *p
; p
= &(*p
)->next
)
2202 bfd_section_list_remove (output_bfd
, p
);
2203 output_bfd
->section_count
--;
2211 print_output_section_statement (output_section_statement
)
2212 lang_output_section_statement_type
*output_section_statement
;
2214 asection
*section
= output_section_statement
->bfd_section
;
2217 if (output_section_statement
!= abs_output_section
)
2219 minfo ("\n%s", output_section_statement
->name
);
2221 if (section
!= NULL
)
2223 print_dot
= section
->vma
;
2225 len
= strlen (output_section_statement
->name
);
2226 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2231 while (len
< SECTION_NAME_MAP_LENGTH
)
2237 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2239 if (output_section_statement
->load_base
!= NULL
)
2243 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2244 "load base", lang_final_phase_enum
);
2245 minfo (_(" load address 0x%V"), addr
);
2252 print_statement_list (output_section_statement
->children
.head
,
2253 output_section_statement
);
2257 print_assignment (assignment
, output_section
)
2258 lang_assignment_statement_type
*assignment
;
2259 lang_output_section_statement_type
*output_section
;
2262 etree_value_type result
;
2264 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2267 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2268 lang_final_phase_enum
, print_dot
, &print_dot
);
2274 value
= result
.value
+ result
.section
->bfd_section
->vma
;
2275 dst
= assignment
->exp
->assign
.dst
;
2277 minfo ("0x%V", value
);
2278 if (dst
[0] == '.' && dst
[1] == 0)
2291 exp_print_tree (assignment
->exp
);
2297 print_input_statement (statm
)
2298 lang_input_statement_type
*statm
;
2300 if (statm
->filename
!= (char *) NULL
)
2302 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2306 /* Print all symbols defined in a particular section. This is called
2307 via bfd_link_hash_traverse. */
2310 print_one_symbol (hash_entry
, ptr
)
2311 struct bfd_link_hash_entry
*hash_entry
;
2314 asection
*sec
= (asection
*) ptr
;
2316 if ((hash_entry
->type
== bfd_link_hash_defined
2317 || hash_entry
->type
== bfd_link_hash_defweak
)
2318 && sec
== hash_entry
->u
.def
.section
)
2322 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2325 (hash_entry
->u
.def
.value
2326 + hash_entry
->u
.def
.section
->output_offset
2327 + hash_entry
->u
.def
.section
->output_section
->vma
));
2329 minfo (" %T\n", hash_entry
->root
.string
);
2335 /* Print information about an input section to the map file. */
2338 print_input_section (in
)
2339 lang_input_section_type
*in
;
2341 asection
*i
= in
->section
;
2342 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2343 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2344 ldfile_output_machine
);
2349 minfo ("%s", i
->name
);
2351 if (i
->output_section
!= NULL
)
2355 len
= 1 + strlen (i
->name
);
2356 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2361 while (len
< SECTION_NAME_MAP_LENGTH
)
2367 minfo ("0x%V %W %B\n",
2368 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2371 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2373 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2385 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2388 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2390 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2396 print_fill_statement (fill
)
2397 lang_fill_statement_type
*fill
;
2401 fputs (" FILL mask 0x", config
.map_file
);
2402 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
2403 fprintf (config
.map_file
, "%02x", *p
);
2404 fputs ("\n", config
.map_file
);
2408 print_data_statement (data
)
2409 lang_data_statement_type
*data
;
2415 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2416 ldfile_output_machine
);
2418 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2421 addr
= data
->output_vma
;
2422 if (data
->output_section
!= NULL
)
2423 addr
+= data
->output_section
->vma
;
2451 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2453 if (data
->exp
->type
.node_class
!= etree_value
)
2456 exp_print_tree (data
->exp
);
2461 print_dot
= addr
+ size
/ opb
;
2465 /* Print an address statement. These are generated by options like
2469 print_address_statement (address
)
2470 lang_address_statement_type
*address
;
2472 minfo (_("Address of section %s set to "), address
->section_name
);
2473 exp_print_tree (address
->address
);
2477 /* Print a reloc statement. */
2480 print_reloc_statement (reloc
)
2481 lang_reloc_statement_type
*reloc
;
2486 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2487 ldfile_output_machine
);
2489 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2492 addr
= reloc
->output_vma
;
2493 if (reloc
->output_section
!= NULL
)
2494 addr
+= reloc
->output_section
->vma
;
2496 size
= bfd_get_reloc_size (reloc
->howto
);
2498 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2500 if (reloc
->name
!= NULL
)
2501 minfo ("%s+", reloc
->name
);
2503 minfo ("%s+", reloc
->section
->name
);
2505 exp_print_tree (reloc
->addend_exp
);
2509 print_dot
= addr
+ size
/ opb
;
2513 print_padding_statement (s
)
2514 lang_padding_statement_type
*s
;
2518 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2519 ldfile_output_machine
);
2523 len
= sizeof " *fill*" - 1;
2524 while (len
< SECTION_NAME_MAP_LENGTH
)
2530 addr
= s
->output_offset
;
2531 if (s
->output_section
!= NULL
)
2532 addr
+= s
->output_section
->vma
;
2533 minfo ("0x%V %W ", addr
, s
->size
);
2535 if (s
->fill
->size
!= 0)
2539 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
2540 fprintf (config
.map_file
, "%02x", *p
);
2545 print_dot
= addr
+ s
->size
/ opb
;
2549 print_wild_statement (w
, os
)
2550 lang_wild_statement_type
*w
;
2551 lang_output_section_statement_type
*os
;
2553 struct wildcard_list
*sec
;
2557 if (w
->filenames_sorted
)
2559 if (w
->filename
!= NULL
)
2560 minfo ("%s", w
->filename
);
2563 if (w
->filenames_sorted
)
2567 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
2569 if (sec
->spec
.sorted
)
2571 if (sec
->spec
.exclude_name_list
!= NULL
)
2574 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
2575 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
2576 minfo (" %s", tmp
->name
);
2579 if (sec
->spec
.name
!= NULL
)
2580 minfo ("%s", sec
->spec
.name
);
2583 if (sec
->spec
.sorted
)
2592 print_statement_list (w
->children
.head
, os
);
2595 /* Print a group statement. */
2599 lang_group_statement_type
*s
;
2600 lang_output_section_statement_type
*os
;
2602 fprintf (config
.map_file
, "START GROUP\n");
2603 print_statement_list (s
->children
.head
, os
);
2604 fprintf (config
.map_file
, "END GROUP\n");
2607 /* Print the list of statements in S.
2608 This can be called for any statement type. */
2611 print_statement_list (s
, os
)
2612 lang_statement_union_type
*s
;
2613 lang_output_section_statement_type
*os
;
2617 print_statement (s
, os
);
2622 /* Print the first statement in statement list S.
2623 This can be called for any statement type. */
2626 print_statement (s
, os
)
2627 lang_statement_union_type
*s
;
2628 lang_output_section_statement_type
*os
;
2630 switch (s
->header
.type
)
2633 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2636 case lang_constructors_statement_enum
:
2637 if (constructor_list
.head
!= NULL
)
2639 if (constructors_sorted
)
2640 minfo (" SORT (CONSTRUCTORS)\n");
2642 minfo (" CONSTRUCTORS\n");
2643 print_statement_list (constructor_list
.head
, os
);
2646 case lang_wild_statement_enum
:
2647 print_wild_statement (&s
->wild_statement
, os
);
2649 case lang_address_statement_enum
:
2650 print_address_statement (&s
->address_statement
);
2652 case lang_object_symbols_statement_enum
:
2653 minfo (" CREATE_OBJECT_SYMBOLS\n");
2655 case lang_fill_statement_enum
:
2656 print_fill_statement (&s
->fill_statement
);
2658 case lang_data_statement_enum
:
2659 print_data_statement (&s
->data_statement
);
2661 case lang_reloc_statement_enum
:
2662 print_reloc_statement (&s
->reloc_statement
);
2664 case lang_input_section_enum
:
2665 print_input_section (&s
->input_section
);
2667 case lang_padding_statement_enum
:
2668 print_padding_statement (&s
->padding_statement
);
2670 case lang_output_section_statement_enum
:
2671 print_output_section_statement (&s
->output_section_statement
);
2673 case lang_assignment_statement_enum
:
2674 print_assignment (&s
->assignment_statement
, os
);
2676 case lang_target_statement_enum
:
2677 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2679 case lang_output_statement_enum
:
2680 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2681 if (output_target
!= NULL
)
2682 minfo (" %s", output_target
);
2685 case lang_input_statement_enum
:
2686 print_input_statement (&s
->input_statement
);
2688 case lang_group_statement_enum
:
2689 print_group (&s
->group_statement
, os
);
2691 case lang_afile_asection_pair_statement_enum
:
2700 print_statement_list (statement_list
.head
, abs_output_section
);
2703 /* Print the first N statements in statement list S to STDERR.
2704 If N == 0, nothing is printed.
2705 If N < 0, the entire list is printed.
2706 Intended to be called from GDB. */
2709 dprint_statement (s
, n
)
2710 lang_statement_union_type
*s
;
2713 FILE *map_save
= config
.map_file
;
2715 config
.map_file
= stderr
;
2718 print_statement_list (s
, abs_output_section
);
2721 while (s
&& --n
>= 0)
2723 print_statement (s
, abs_output_section
);
2728 config
.map_file
= map_save
;
2732 insert_pad (ptr
, fill
, alignment_needed
, output_section
, dot
)
2733 lang_statement_union_type
**ptr
;
2735 unsigned int alignment_needed
;
2736 asection
*output_section
;
2739 static fill_type zero_fill
= { 1, { 0 } };
2740 lang_statement_union_type
*pad
;
2742 pad
= ((lang_statement_union_type
*)
2743 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
2744 if (ptr
!= &statement_list
.head
2745 && pad
->header
.type
== lang_padding_statement_enum
2746 && pad
->padding_statement
.output_section
== output_section
)
2748 /* Use the existing pad statement. The above test on output
2749 section is probably redundant, but it doesn't hurt to check. */
2753 /* Make a new padding statement, linked into existing chain. */
2754 pad
= ((lang_statement_union_type
*)
2755 stat_alloc (sizeof (lang_padding_statement_type
)));
2756 pad
->header
.next
= *ptr
;
2758 pad
->header
.type
= lang_padding_statement_enum
;
2759 pad
->padding_statement
.output_section
= output_section
;
2760 if (fill
== (fill_type
*) 0)
2762 pad
->padding_statement
.fill
= fill
;
2764 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
2765 pad
->padding_statement
.size
= alignment_needed
;
2766 output_section
->_raw_size
+= alignment_needed
;
2769 /* Work out how much this section will move the dot point. */
2772 size_input_section (this_ptr
, output_section_statement
, fill
, dot
)
2773 lang_statement_union_type
**this_ptr
;
2774 lang_output_section_statement_type
*output_section_statement
;
2778 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2779 asection
*i
= is
->section
;
2781 if (!is
->ifile
->just_syms_flag
)
2783 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2784 ldfile_output_machine
);
2785 unsigned int alignment_needed
;
2788 /* Align this section first to the input sections requirement,
2789 then to the output section's requirement. If this alignment
2790 is greater than any seen before, then record it too. Perform
2791 the alignment by inserting a magic 'padding' statement. */
2793 if (output_section_statement
->subsection_alignment
!= -1)
2794 i
->alignment_power
= output_section_statement
->subsection_alignment
;
2796 o
= output_section_statement
->bfd_section
;
2797 if (o
->alignment_power
< i
->alignment_power
)
2798 o
->alignment_power
= i
->alignment_power
;
2800 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
2802 if (alignment_needed
!= 0)
2804 insert_pad (this_ptr
, fill
, alignment_needed
* opb
, o
, dot
);
2805 dot
+= alignment_needed
;
2808 /* Remember where in the output section this input section goes. */
2810 i
->output_offset
= dot
- o
->vma
;
2812 /* Mark how big the output section must be to contain this now. */
2813 if (i
->_cooked_size
!= 0)
2814 dot
+= i
->_cooked_size
/ opb
;
2816 dot
+= i
->_raw_size
/ opb
;
2817 o
->_raw_size
= (dot
- o
->vma
) * opb
;
2821 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2827 #define IGNORE_SECTION(bfd, s) \
2828 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2829 != (SEC_ALLOC | SEC_LOAD)) \
2830 || bfd_section_size (bfd, s) == 0)
2832 /* Check to see if any allocated sections overlap with other allocated
2833 sections. This can happen when the linker script specifically specifies
2834 the output section addresses of the two sections. */
2837 lang_check_section_addresses ()
2840 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2842 /* Scan all sections in the output list. */
2843 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2847 /* Ignore sections which are not loaded or which have no contents. */
2848 if (IGNORE_SECTION (output_bfd
, s
))
2851 /* Once we reach section 's' stop our seach. This prevents two
2852 warning messages from being produced, one for 'section A overlaps
2853 section B' and one for 'section B overlaps section A'. */
2854 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2861 /* Only consider loadable sections with real contents. */
2862 if (IGNORE_SECTION (output_bfd
, os
))
2865 /* We must check the sections' LMA addresses not their
2866 VMA addresses because overlay sections can have
2867 overlapping VMAs but they must have distinct LMAs. */
2868 s_start
= bfd_section_lma (output_bfd
, s
);
2869 os_start
= bfd_section_lma (output_bfd
, os
);
2870 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2871 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2873 /* Look for an overlap. */
2874 if ((s_end
< os_start
) || (s_start
> os_end
))
2878 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2879 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2881 /* Once we have found one overlap for this section,
2882 stop looking for others. */
2888 /* Make sure the new address is within the region. We explicitly permit the
2889 current address to be at the exact end of the region when the address is
2890 non-zero, in case the region is at the end of addressable memory and the
2891 calculation wraps around. */
2894 os_region_check (os
, region
, tree
, base
)
2895 lang_output_section_statement_type
*os
;
2896 struct memory_region_struct
*region
;
2900 if ((region
->current
< region
->origin
2901 || (region
->current
- region
->origin
> region
->length
))
2902 && ((region
->current
!= region
->origin
+ region
->length
)
2905 if (tree
!= (etree_type
*) NULL
)
2907 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2909 os
->bfd_section
->owner
,
2910 os
->bfd_section
->name
,
2915 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2917 os
->bfd_section
->owner
,
2918 os
->bfd_section
->name
);
2920 /* Reset the region pointer. */
2921 region
->current
= region
->origin
;
2925 /* Set the sizes for all the output sections. */
2928 lang_size_sections_1 (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2929 lang_statement_union_type
*s
;
2930 lang_output_section_statement_type
*output_section_statement
;
2931 lang_statement_union_type
**prev
;
2936 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2937 ldfile_output_machine
);
2939 /* Size up the sections from their constituent parts. */
2940 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2942 switch (s
->header
.type
)
2944 case lang_output_section_statement_enum
:
2947 lang_output_section_statement_type
*os
;
2949 os
= &s
->output_section_statement
;
2950 if (os
->bfd_section
== NULL
)
2951 /* This section was never actually created. */
2954 /* If this is a COFF shared library section, use the size and
2955 address from the input section. FIXME: This is COFF
2956 specific; it would be cleaner if there were some other way
2957 to do this, but nothing simple comes to mind. */
2958 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2962 if (os
->children
.head
== NULL
2963 || os
->children
.head
->header
.next
!= NULL
2964 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2965 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2968 input
= os
->children
.head
->input_section
.section
;
2969 bfd_set_section_vma (os
->bfd_section
->owner
,
2971 bfd_section_vma (input
->owner
, input
));
2972 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2976 if (bfd_is_abs_section (os
->bfd_section
))
2978 /* No matter what happens, an abs section starts at zero. */
2979 ASSERT (os
->bfd_section
->vma
== 0);
2983 if (os
->addr_tree
== (etree_type
*) NULL
)
2985 /* No address specified for this section, get one
2986 from the region specification. */
2987 if (os
->region
== (lang_memory_region_type
*) NULL
2988 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2989 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2990 && os
->region
->name
[0] == '*'
2991 && strcmp (os
->region
->name
, "*default*") == 0))
2993 os
->region
= lang_memory_default (os
->bfd_section
);
2996 /* If a loadable section is using the default memory
2997 region, and some non default memory regions were
2998 defined, issue a warning. */
2999 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3000 & (SEC_ALLOC
| SEC_LOAD
)) != 0
3001 && (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3002 & SEC_NEVER_LOAD
) == 0
3003 && ! link_info
.relocateable
3004 && strcmp (os
->region
->name
, "*default*") == 0
3005 && lang_memory_region_list
!= NULL
3006 && (strcmp (lang_memory_region_list
->name
,
3008 || lang_memory_region_list
->next
!= NULL
))
3009 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
3010 bfd_get_section_name (output_bfd
,
3013 dot
= os
->region
->current
;
3015 if (os
->section_alignment
== -1)
3020 dot
= align_power (dot
,
3021 os
->bfd_section
->alignment_power
);
3023 if (dot
!= olddot
&& config
.warn_section_align
)
3024 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
3025 os
->name
, (unsigned int) (dot
- olddot
));
3032 r
= exp_fold_tree (os
->addr_tree
,
3034 lang_allocating_phase_enum
,
3037 einfo (_("%F%S: non constant address expression for section %s\n"),
3040 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
3043 /* The section starts here.
3044 First, align to what the section needs. */
3046 if (os
->section_alignment
!= -1)
3047 dot
= align_power (dot
, os
->section_alignment
);
3049 bfd_set_section_vma (0, os
->bfd_section
, dot
);
3051 os
->bfd_section
->output_offset
= 0;
3054 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
3055 os
->fill
, dot
, relax
);
3057 /* Put the section within the requested block size, or
3058 align at the block boundary. */
3059 after
= align_n (os
->bfd_section
->vma
3060 + os
->bfd_section
->_raw_size
/ opb
,
3061 (bfd_vma
) os
->block_value
);
3063 if (bfd_is_abs_section (os
->bfd_section
))
3064 ASSERT (after
== os
->bfd_section
->vma
);
3065 else if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) == 0
3066 && (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
)
3067 && ! link_info
.relocateable
)
3068 os
->bfd_section
->_raw_size
= 0;
3070 os
->bfd_section
->_raw_size
=
3071 (after
- os
->bfd_section
->vma
) * opb
;
3073 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3074 os
->processed
= true;
3076 if (os
->update_dot_tree
!= 0)
3077 exp_fold_tree (os
->update_dot_tree
, abs_output_section
,
3078 lang_allocating_phase_enum
, dot
, &dot
);
3080 /* Update dot in the region ?
3081 We only do this if the section is going to be allocated,
3082 since unallocated sections do not contribute to the region's
3083 overall size in memory.
3085 If the SEC_NEVER_LOAD bit is not set, it will affect the
3086 addresses of sections after it. We have to update
3088 if (os
->region
!= (lang_memory_region_type
*) NULL
3089 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3090 & SEC_NEVER_LOAD
) == 0
3091 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3092 & (SEC_ALLOC
| SEC_LOAD
))))
3094 os
->region
->current
= dot
;
3096 /* Make sure the new address is within the region. */
3097 os_region_check (os
, os
->region
, os
->addr_tree
,
3098 os
->bfd_section
->vma
);
3100 /* If there's no load address specified, use the run
3101 region as the load region. */
3102 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
3103 os
->lma_region
= os
->region
;
3105 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
)
3107 /* Set load_base, which will be handled later. */
3108 os
->load_base
= exp_intop (os
->lma_region
->current
);
3109 os
->lma_region
->current
+=
3110 os
->bfd_section
->_raw_size
/ opb
;
3111 os_region_check (os
, os
->lma_region
, NULL
,
3112 os
->bfd_section
->lma
);
3118 case lang_constructors_statement_enum
:
3119 dot
= lang_size_sections_1 (constructor_list
.head
,
3120 output_section_statement
,
3121 &s
->wild_statement
.children
.head
,
3125 case lang_data_statement_enum
:
3127 unsigned int size
= 0;
3129 s
->data_statement
.output_vma
=
3130 dot
- output_section_statement
->bfd_section
->vma
;
3131 s
->data_statement
.output_section
=
3132 output_section_statement
->bfd_section
;
3134 switch (s
->data_statement
.type
)
3155 output_section_statement
->bfd_section
->_raw_size
+= size
;
3156 /* The output section gets contents, and then we inspect for
3157 any flags set in the input script which override any ALLOC. */
3158 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3159 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3161 output_section_statement
->bfd_section
->flags
|=
3162 SEC_ALLOC
| SEC_LOAD
;
3167 case lang_reloc_statement_enum
:
3171 s
->reloc_statement
.output_vma
=
3172 dot
- output_section_statement
->bfd_section
->vma
;
3173 s
->reloc_statement
.output_section
=
3174 output_section_statement
->bfd_section
;
3175 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3177 output_section_statement
->bfd_section
->_raw_size
+= size
;
3181 case lang_wild_statement_enum
:
3183 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
3184 output_section_statement
,
3185 &s
->wild_statement
.children
.head
,
3190 case lang_object_symbols_statement_enum
:
3191 link_info
.create_object_symbols_section
=
3192 output_section_statement
->bfd_section
;
3194 case lang_output_statement_enum
:
3195 case lang_target_statement_enum
:
3197 case lang_input_section_enum
:
3201 i
= (*prev
)->input_section
.section
;
3204 if (i
->_cooked_size
== 0)
3205 i
->_cooked_size
= i
->_raw_size
;
3211 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3212 einfo (_("%P%F: can't relax section: %E\n"));
3216 dot
= size_input_section (prev
, output_section_statement
,
3217 output_section_statement
->fill
, dot
);
3220 case lang_input_statement_enum
:
3222 case lang_fill_statement_enum
:
3223 s
->fill_statement
.output_section
=
3224 output_section_statement
->bfd_section
;
3226 fill
= s
->fill_statement
.fill
;
3228 case lang_assignment_statement_enum
:
3230 bfd_vma newdot
= dot
;
3232 exp_fold_tree (s
->assignment_statement
.exp
,
3233 output_section_statement
,
3234 lang_allocating_phase_enum
,
3240 if (output_section_statement
== abs_output_section
)
3242 /* If we don't have an output section, then just adjust
3243 the default memory address. */
3244 lang_memory_region_lookup ("*default*")->current
= newdot
;
3248 /* Insert a pad after this statement. We can't
3249 put the pad before when relaxing, in case the
3250 assignment references dot. */
3251 insert_pad (&s
->header
.next
, fill
, (newdot
- dot
) * opb
,
3252 output_section_statement
->bfd_section
, dot
);
3254 /* Don't neuter the pad below when relaxing. */
3263 case lang_padding_statement_enum
:
3264 /* If this is the first time lang_size_sections is called,
3265 we won't have any padding statements. If this is the
3266 second or later passes when relaxing, we should allow
3267 padding to shrink. If padding is needed on this pass, it
3268 will be added back in. */
3269 s
->padding_statement
.size
= 0;
3271 /* Make sure output_offset is valid. If relaxation shrinks
3272 the section and this pad isn't needed, it's possible to
3273 have output_offset larger than the final size of the
3274 section. bfd_set_section_contents will complain even for
3275 a pad size of zero. */
3276 s
->padding_statement
.output_offset
3277 = dot
- output_section_statement
->bfd_section
->vma
;
3280 case lang_group_statement_enum
:
3281 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
3282 output_section_statement
,
3283 &s
->group_statement
.children
.head
,
3291 /* We can only get here when relaxing is turned on. */
3292 case lang_address_statement_enum
:
3295 prev
= &s
->header
.next
;
3301 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
3302 lang_statement_union_type
*s
;
3303 lang_output_section_statement_type
*output_section_statement
;
3304 lang_statement_union_type
**prev
;
3311 exp_data_seg
.phase
= exp_dataseg_none
;
3312 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
3314 if (exp_data_seg
.phase
== exp_dataseg_end_seen
)
3316 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3317 a page could be saved in the data segment. */
3318 bfd_vma first
, last
;
3320 first
= -exp_data_seg
.base
& (exp_data_seg
.pagesize
- 1);
3321 last
= exp_data_seg
.end
& (exp_data_seg
.pagesize
- 1);
3323 && ((exp_data_seg
.base
& ~(exp_data_seg
.pagesize
- 1))
3324 != (exp_data_seg
.end
& ~(exp_data_seg
.pagesize
- 1)))
3325 && first
+ last
<= exp_data_seg
.pagesize
)
3327 exp_data_seg
.phase
= exp_dataseg_adjust
;
3328 result
= lang_size_sections_1 (s
, output_section_statement
, prev
,
3337 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3338 lang_statement_union_type
*s
;
3339 lang_output_section_statement_type
*output_section_statement
;
3343 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3344 ldfile_output_machine
);
3346 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3348 switch (s
->header
.type
)
3350 case lang_constructors_statement_enum
:
3351 dot
= lang_do_assignments (constructor_list
.head
,
3352 output_section_statement
,
3357 case lang_output_section_statement_enum
:
3359 lang_output_section_statement_type
*os
;
3361 os
= &(s
->output_section_statement
);
3362 if (os
->bfd_section
!= NULL
)
3364 dot
= os
->bfd_section
->vma
;
3365 (void) lang_do_assignments (os
->children
.head
, os
,
3367 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3372 /* If nothing has been placed into the output section then
3373 it won't have a bfd_section. */
3374 if (os
->bfd_section
)
3376 os
->bfd_section
->lma
3377 = exp_get_abs_int (os
->load_base
, 0, "load base",
3378 lang_final_phase_enum
);
3383 case lang_wild_statement_enum
:
3385 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3386 output_section_statement
,
3391 case lang_object_symbols_statement_enum
:
3392 case lang_output_statement_enum
:
3393 case lang_target_statement_enum
:
3395 case lang_common_statement_enum
:
3398 case lang_data_statement_enum
:
3400 etree_value_type value
;
3402 value
= exp_fold_tree (s
->data_statement
.exp
,
3404 lang_final_phase_enum
, dot
, &dot
);
3405 s
->data_statement
.value
= value
.value
;
3407 einfo (_("%F%P: invalid data statement\n"));
3411 switch (s
->data_statement
.type
)
3435 case lang_reloc_statement_enum
:
3437 etree_value_type value
;
3439 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3441 lang_final_phase_enum
, dot
, &dot
);
3442 s
->reloc_statement
.addend_value
= value
.value
;
3444 einfo (_("%F%P: invalid reloc statement\n"));
3446 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3449 case lang_input_section_enum
:
3451 asection
*in
= s
->input_section
.section
;
3453 if (in
->_cooked_size
!= 0)
3454 dot
+= in
->_cooked_size
/ opb
;
3456 dot
+= in
->_raw_size
/ opb
;
3460 case lang_input_statement_enum
:
3462 case lang_fill_statement_enum
:
3463 fill
= s
->fill_statement
.fill
;
3465 case lang_assignment_statement_enum
:
3467 exp_fold_tree (s
->assignment_statement
.exp
,
3468 output_section_statement
,
3469 lang_final_phase_enum
,
3475 case lang_padding_statement_enum
:
3476 dot
+= s
->padding_statement
.size
/ opb
;
3479 case lang_group_statement_enum
:
3480 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3481 output_section_statement
,
3489 case lang_address_statement_enum
:
3497 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3498 operator .startof. (section_name), it produces an undefined symbol
3499 .startof.section_name. Similarly, when it sees
3500 .sizeof. (section_name), it produces an undefined symbol
3501 .sizeof.section_name. For all the output sections, we look for
3502 such symbols, and set them to the correct value. */
3509 if (link_info
.relocateable
)
3512 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3514 const char *secname
;
3516 struct bfd_link_hash_entry
*h
;
3518 secname
= bfd_get_section_name (output_bfd
, s
);
3519 buf
= xmalloc (10 + strlen (secname
));
3521 sprintf (buf
, ".startof.%s", secname
);
3522 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3523 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3525 h
->type
= bfd_link_hash_defined
;
3526 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3527 h
->u
.def
.section
= bfd_abs_section_ptr
;
3530 sprintf (buf
, ".sizeof.%s", secname
);
3531 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3532 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3536 opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3537 ldfile_output_machine
);
3538 h
->type
= bfd_link_hash_defined
;
3539 if (s
->_cooked_size
!= 0)
3540 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3542 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3543 h
->u
.def
.section
= bfd_abs_section_ptr
;
3553 struct bfd_link_hash_entry
*h
;
3556 if (link_info
.relocateable
|| link_info
.shared
)
3561 if (entry_symbol
.name
== (const char *) NULL
)
3563 /* No entry has been specified. Look for start, but don't warn
3564 if we don't find it. */
3565 entry_symbol
.name
= "start";
3569 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
3570 false, false, true);
3571 if (h
!= (struct bfd_link_hash_entry
*) NULL
3572 && (h
->type
== bfd_link_hash_defined
3573 || h
->type
== bfd_link_hash_defweak
)
3574 && h
->u
.def
.section
->output_section
!= NULL
)
3578 val
= (h
->u
.def
.value
3579 + bfd_get_section_vma (output_bfd
,
3580 h
->u
.def
.section
->output_section
)
3581 + h
->u
.def
.section
->output_offset
);
3582 if (! bfd_set_start_address (output_bfd
, val
))
3583 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
3590 /* We couldn't find the entry symbol. Try parsing it as a
3592 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
3595 if (! bfd_set_start_address (output_bfd
, val
))
3596 einfo (_("%P%F: can't set start address\n"));
3602 /* Can't find the entry symbol, and it's not a number. Use
3603 the first address in the text section. */
3604 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
3605 if (ts
!= (asection
*) NULL
)
3608 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3610 bfd_get_section_vma (output_bfd
, ts
));
3611 if (! bfd_set_start_address (output_bfd
,
3612 bfd_get_section_vma (output_bfd
,
3614 einfo (_("%P%F: can't set start address\n"));
3619 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3626 /* This is a small function used when we want to ignore errors from
3630 #ifdef ANSI_PROTOTYPES
3631 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3633 ignore_bfd_errors (s
)
3634 const char *s ATTRIBUTE_UNUSED
;
3637 /* Don't do anything. */
3640 /* Check that the architecture of all the input files is compatible
3641 with the output file. Also call the backend to let it do any
3642 other checking that is needed. */
3647 lang_statement_union_type
*file
;
3649 const bfd_arch_info_type
*compatible
;
3651 for (file
= file_chain
.head
;
3652 file
!= (lang_statement_union_type
*) NULL
;
3653 file
= file
->input_statement
.next
)
3655 input_bfd
= file
->input_statement
.the_bfd
;
3656 compatible
= bfd_arch_get_compatible (input_bfd
, output_bfd
);
3658 /* In general it is not possible to perform a relocatable
3659 link between differing object formats when the input
3660 file has relocations, because the relocations in the
3661 input format may not have equivalent representations in
3662 the output format (and besides BFD does not translate
3663 relocs for other link purposes than a final link). */
3664 if ((link_info
.relocateable
|| link_info
.emitrelocations
)
3665 && (compatible
== NULL
3666 || bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
3667 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
3669 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3670 bfd_get_target (input_bfd
), input_bfd
,
3671 bfd_get_target (output_bfd
), output_bfd
);
3672 /* einfo with %F exits. */
3675 if (compatible
== NULL
)
3677 if (command_line
.warn_mismatch
)
3678 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3679 bfd_printable_name (input_bfd
), input_bfd
,
3680 bfd_printable_name (output_bfd
));
3682 else if (bfd_count_sections (input_bfd
))
3684 /* If the input bfd has no contents, it shouldn't set the
3685 private data of the output bfd. */
3687 bfd_error_handler_type pfn
= NULL
;
3689 /* If we aren't supposed to warn about mismatched input
3690 files, temporarily set the BFD error handler to a
3691 function which will do nothing. We still want to call
3692 bfd_merge_private_bfd_data, since it may set up
3693 information which is needed in the output file. */
3694 if (! command_line
.warn_mismatch
)
3695 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3696 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3698 if (command_line
.warn_mismatch
)
3699 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3702 if (! command_line
.warn_mismatch
)
3703 bfd_set_error_handler (pfn
);
3708 /* Look through all the global common symbols and attach them to the
3709 correct section. The -sort-common command line switch may be used
3710 to roughly sort the entries by size. */
3715 if (command_line
.inhibit_common_definition
)
3717 if (link_info
.relocateable
3718 && ! command_line
.force_common_definition
)
3721 if (! config
.sort_common
)
3722 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3727 for (power
= 4; power
>= 0; power
--)
3728 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3733 /* Place one common symbol in the correct section. */
3736 lang_one_common (h
, info
)
3737 struct bfd_link_hash_entry
*h
;
3740 unsigned int power_of_two
;
3743 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3744 ldfile_output_machine
);
3746 if (h
->type
!= bfd_link_hash_common
)
3750 power_of_two
= h
->u
.c
.p
->alignment_power
;
3752 if (config
.sort_common
3753 && power_of_two
< (unsigned int) *(int *) info
)
3756 section
= h
->u
.c
.p
->section
;
3758 /* Increase the size of the section. */
3759 section
->_cooked_size
= align_n ((section
->_cooked_size
+ opb
- 1) / opb
,
3760 (bfd_vma
) 1 << power_of_two
) * opb
;
3762 /* Adjust the alignment if necessary. */
3763 if (power_of_two
> section
->alignment_power
)
3764 section
->alignment_power
= power_of_two
;
3766 /* Change the symbol from common to defined. */
3767 h
->type
= bfd_link_hash_defined
;
3768 h
->u
.def
.section
= section
;
3769 h
->u
.def
.value
= section
->_cooked_size
;
3771 /* Increase the size of the section. */
3772 section
->_cooked_size
+= size
;
3774 /* Make sure the section is allocated in memory, and make sure that
3775 it is no longer a common section. */
3776 section
->flags
|= SEC_ALLOC
;
3777 section
->flags
&= ~SEC_IS_COMMON
;
3779 if (config
.map_file
!= NULL
)
3781 static boolean header_printed
;
3786 if (! header_printed
)
3788 minfo (_("\nAllocating common symbols\n"));
3789 minfo (_("Common symbol size file\n\n"));
3790 header_printed
= true;
3793 name
= demangle (h
->root
.string
);
3795 len
= strlen (name
);
3810 if (size
<= 0xffffffff)
3811 sprintf (buf
, "%lx", (unsigned long) size
);
3813 sprintf_vma (buf
, size
);
3823 minfo ("%B\n", section
->owner
);
3829 /* Run through the input files and ensure that every input section has
3830 somewhere to go. If one is found without a destination then create
3831 an input request and place it into the statement tree. */
3834 lang_place_orphans ()
3836 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3840 for (s
= file
->the_bfd
->sections
;
3841 s
!= (asection
*) NULL
;
3844 if (s
->output_section
== (asection
*) NULL
)
3846 /* This section of the file is not attatched, root
3847 around for a sensible place for it to go. */
3849 if (file
->just_syms_flag
)
3853 else if (strcmp (s
->name
, "COMMON") == 0)
3855 /* This is a lonely common section which must have
3856 come from an archive. We attach to the section
3857 with the wildcard. */
3858 if (! link_info
.relocateable
3859 || command_line
.force_common_definition
)
3861 if (default_common_section
== NULL
)
3864 /* This message happens when using the
3865 svr3.ifile linker script, so I have
3867 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3869 default_common_section
=
3870 lang_output_section_statement_lookup (".bss");
3873 lang_add_section (&default_common_section
->children
, s
,
3874 default_common_section
, file
);
3877 else if (ldemul_place_orphan (file
, s
))
3881 lang_output_section_statement_type
*os
;
3883 os
= lang_output_section_statement_lookup (s
->name
);
3884 lang_add_section (&os
->children
, s
, os
, file
);
3892 lang_set_flags (ptr
, flags
, invert
)
3893 lang_memory_region_type
*ptr
;
3897 flagword
*ptr_flags
;
3899 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3905 *ptr_flags
|= SEC_ALLOC
;
3909 *ptr_flags
|= SEC_READONLY
;
3913 *ptr_flags
|= SEC_DATA
;
3917 *ptr_flags
|= SEC_CODE
;
3922 *ptr_flags
|= SEC_LOAD
;
3926 einfo (_("%P%F: invalid syntax in flags\n"));
3933 /* Call a function on each input file. This function will be called
3934 on an archive, but not on the elements. */
3937 lang_for_each_input_file (func
)
3938 void (*func
) PARAMS ((lang_input_statement_type
*));
3940 lang_input_statement_type
*f
;
3942 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3944 f
= (lang_input_statement_type
*) f
->next_real_file
)
3948 /* Call a function on each file. The function will be called on all
3949 the elements of an archive which are included in the link, but will
3950 not be called on the archive file itself. */
3953 lang_for_each_file (func
)
3954 void (*func
) PARAMS ((lang_input_statement_type
*));
3956 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3967 lang_for_each_input_section (func
)
3968 void (*func
) PARAMS ((bfd
*ab
, asection
*as
));
3970 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3974 for (s
= f
->the_bfd
->sections
;
3975 s
!= (asection
*) NULL
;
3978 func (f
->the_bfd
, s
);
3986 ldlang_add_file (entry
)
3987 lang_input_statement_type
*entry
;
3991 lang_statement_append (&file_chain
,
3992 (lang_statement_union_type
*) entry
,
3995 /* The BFD linker needs to have a list of all input BFDs involved in
3997 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3998 ASSERT (entry
->the_bfd
!= output_bfd
);
3999 for (pp
= &link_info
.input_bfds
;
4000 *pp
!= (bfd
*) NULL
;
4001 pp
= &(*pp
)->link_next
)
4003 *pp
= entry
->the_bfd
;
4004 entry
->the_bfd
->usrdata
= (PTR
) entry
;
4005 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
4007 /* Look through the sections and check for any which should not be
4008 included in the link. We need to do this now, so that we can
4009 notice when the backend linker tries to report multiple
4010 definition errors for symbols which are in sections we aren't
4011 going to link. FIXME: It might be better to entirely ignore
4012 symbols which are defined in sections which are going to be
4013 discarded. This would require modifying the backend linker for
4014 each backend which might set the SEC_LINK_ONCE flag. If we do
4015 this, we should probably handle SEC_EXCLUDE in the same way. */
4017 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
4021 lang_add_output (name
, from_script
)
4025 /* Make -o on command line override OUTPUT in script. */
4026 if (!had_output_filename
|| !from_script
)
4028 output_filename
= name
;
4029 had_output_filename
= true;
4033 static lang_output_section_statement_type
*current_section
;
4045 for (l
= 0; l
< 32; l
++)
4047 if (i
>= (unsigned int) x
)
4055 lang_output_section_statement_type
*
4056 lang_enter_output_section_statement (output_section_statement_name
,
4057 address_exp
, sectype
, block_value
,
4058 align
, subalign
, ebase
)
4059 const char *output_section_statement_name
;
4060 etree_type
*address_exp
;
4061 enum section_type sectype
;
4062 bfd_vma block_value
;
4064 etree_type
*subalign
;
4067 lang_output_section_statement_type
*os
;
4071 lang_output_section_statement_lookup (output_section_statement_name
);
4073 /* Add this statement to tree. */
4075 add_statement (lang_output_section_statement_enum
,
4076 output_section_statement
);
4078 /* Make next things chain into subchain of this. */
4080 if (os
->addr_tree
== (etree_type
*) NULL
)
4082 os
->addr_tree
= address_exp
;
4084 os
->sectype
= sectype
;
4085 if (sectype
!= noload_section
)
4086 os
->flags
= SEC_NO_FLAGS
;
4088 os
->flags
= SEC_NEVER_LOAD
;
4089 os
->block_value
= block_value
? block_value
: 1;
4090 stat_ptr
= &os
->children
;
4092 os
->subsection_alignment
=
4093 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
4094 os
->section_alignment
=
4095 topower (exp_get_value_int (align
, -1, "section alignment", 0));
4097 os
->load_base
= ebase
;
4104 lang_output_statement_type
*new =
4105 new_stat (lang_output_statement
, stat_ptr
);
4107 new->name
= output_filename
;
4110 /* Reset the current counters in the regions. */
4113 lang_reset_memory_regions ()
4115 lang_memory_region_type
*p
= lang_memory_region_list
;
4118 for (p
= lang_memory_region_list
;
4119 p
!= (lang_memory_region_type
*) NULL
;
4122 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
4123 p
->current
= p
->origin
;
4126 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4130 /* If the wild pattern was marked KEEP, the member sections
4131 should be as well. */
4134 gc_section_callback (ptr
, sec
, section
, file
, data
)
4135 lang_wild_statement_type
*ptr
;
4136 struct wildcard_list
*sec ATTRIBUTE_UNUSED
;
4138 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
4139 PTR data ATTRIBUTE_UNUSED
;
4141 if (ptr
->keep_sections
)
4142 section
->flags
|= SEC_KEEP
;
4145 /* Handle a wild statement, marking it against GC. */
4149 lang_wild_statement_type
*s
;
4151 walk_wild (s
, gc_section_callback
, NULL
);
4154 /* Iterate over sections marking them against GC. */
4157 lang_gc_sections_1 (s
)
4158 lang_statement_union_type
*s
;
4160 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
4162 switch (s
->header
.type
)
4164 case lang_wild_statement_enum
:
4165 lang_gc_wild (&s
->wild_statement
);
4167 case lang_constructors_statement_enum
:
4168 lang_gc_sections_1 (constructor_list
.head
);
4170 case lang_output_section_statement_enum
:
4171 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4173 case lang_group_statement_enum
:
4174 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4185 struct bfd_link_hash_entry
*h
;
4186 ldlang_undef_chain_list_type
*ulist
;
4188 /* Keep all sections so marked in the link script. */
4190 lang_gc_sections_1 (statement_list
.head
);
4192 /* Keep all sections containing symbols undefined on the command-line,
4193 and the section containing the entry symbol. */
4195 for (ulist
= link_info
.gc_sym_list
; ulist
; ulist
= ulist
->next
)
4197 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4198 false, false, false);
4200 if (h
!= (struct bfd_link_hash_entry
*) NULL
4201 && (h
->type
== bfd_link_hash_defined
4202 || h
->type
== bfd_link_hash_defweak
)
4203 && ! bfd_is_abs_section (h
->u
.def
.section
))
4205 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4209 bfd_gc_sections (output_bfd
, &link_info
);
4215 lang_reasonable_defaults ();
4216 current_target
= default_target
;
4218 /* Open the output file. */
4219 lang_for_each_statement (ldlang_open_output
);
4221 ldemul_create_output_section_statements ();
4223 /* Add to the hash table all undefineds on the command line. */
4224 lang_place_undefineds ();
4226 already_linked_table_init ();
4228 /* Create a bfd for each input file. */
4229 current_target
= default_target
;
4230 open_input_bfds (statement_list
.head
, false);
4232 link_info
.gc_sym_list
= &entry_symbol
;
4233 if (entry_symbol
.name
== NULL
)
4234 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
4236 ldemul_after_open ();
4238 already_linked_table_free ();
4240 /* Make sure that we're not mixing architectures. We call this
4241 after all the input files have been opened, but before we do any
4242 other processing, so that any operations merge_private_bfd_data
4243 does on the output file will be known during the rest of the
4247 /* Handle .exports instead of a version script if we're told to do so. */
4248 if (command_line
.version_exports_section
)
4249 lang_do_version_exports_section ();
4251 /* Build all sets based on the information gathered from the input
4253 ldctor_build_sets ();
4255 /* Remove unreferenced sections if asked to. */
4256 if (command_line
.gc_sections
)
4257 lang_gc_sections ();
4259 /* If there were any SEC_MERGE sections, finish their merging, so that
4260 section sizes can be computed. This has to be done after GC of sections,
4261 so that GCed sections are not merged, but before assigning output
4262 sections, since removing whole input sections is hard then. */
4263 bfd_merge_sections (output_bfd
, &link_info
);
4265 /* Size up the common data. */
4268 /* Run through the contours of the script and attach input sections
4269 to the correct output sections. */
4270 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4271 (lang_output_section_statement_type
*) NULL
);
4273 /* Find any sections not attached explicitly and handle them. */
4274 lang_place_orphans ();
4276 if (! link_info
.relocateable
)
4278 /* Look for a text section and set the readonly attribute in it. */
4279 asection
*found
= bfd_get_section_by_name (output_bfd
, ".text");
4281 if (found
!= (asection
*) NULL
)
4283 if (config
.text_read_only
)
4284 found
->flags
|= SEC_READONLY
;
4286 found
->flags
&= ~SEC_READONLY
;
4290 /* Do anything special before sizing sections. This is where ELF
4291 and other back-ends size dynamic sections. */
4292 ldemul_before_allocation ();
4294 if (!link_info
.relocateable
)
4295 strip_excluded_output_sections ();
4297 /* We must record the program headers before we try to fix the
4298 section positions, since they will affect SIZEOF_HEADERS. */
4299 lang_record_phdrs ();
4301 /* Size up the sections. */
4302 lang_size_sections (statement_list
.head
,
4304 &statement_list
.head
, 0, (bfd_vma
) 0, NULL
);
4306 /* Now run around and relax if we can. */
4307 if (command_line
.relax
)
4309 /* Keep relaxing until bfd_relax_section gives up. */
4310 boolean relax_again
;
4314 lang_reset_memory_regions ();
4316 relax_again
= false;
4318 /* Note: pe-dll.c does something like this also. If you find
4319 you need to change this code, you probably need to change
4320 pe-dll.c also. DJ */
4322 /* Do all the assignments with our current guesses as to
4324 lang_do_assignments (statement_list
.head
,
4326 (fill_type
*) 0, (bfd_vma
) 0);
4328 /* Perform another relax pass - this time we know where the
4329 globals are, so can make a better guess. */
4330 lang_size_sections (statement_list
.head
,
4332 &statement_list
.head
, 0, (bfd_vma
) 0,
4335 while (relax_again
);
4338 /* See if anything special should be done now we know how big
4340 ldemul_after_allocation ();
4342 /* Fix any .startof. or .sizeof. symbols. */
4343 lang_set_startof ();
4345 /* Do all the assignments, now that we know the final resting places
4346 of all the symbols. */
4348 lang_do_assignments (statement_list
.head
,
4350 (fill_type
*) 0, (bfd_vma
) 0);
4352 /* Make sure that the section addresses make sense. */
4353 if (! link_info
.relocateable
4354 && command_line
.check_section_addresses
)
4355 lang_check_section_addresses ();
4363 /* EXPORTED TO YACC */
4366 lang_add_wild (filespec
, section_list
, keep_sections
)
4367 struct wildcard_spec
*filespec
;
4368 struct wildcard_list
*section_list
;
4369 boolean keep_sections
;
4371 struct wildcard_list
*curr
, *next
;
4372 lang_wild_statement_type
*new;
4374 /* Reverse the list as the parser puts it back to front. */
4375 for (curr
= section_list
, section_list
= NULL
;
4377 section_list
= curr
, curr
= next
)
4379 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
4380 placed_commons
= true;
4383 curr
->next
= section_list
;
4386 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
4388 if (strcmp (filespec
->name
, "*") == 0)
4389 filespec
->name
= NULL
;
4390 else if (! wildcardp (filespec
->name
))
4391 lang_has_input_file
= true;
4394 new = new_stat (lang_wild_statement
, stat_ptr
);
4395 new->filename
= NULL
;
4396 new->filenames_sorted
= false;
4397 if (filespec
!= NULL
)
4399 new->filename
= filespec
->name
;
4400 new->filenames_sorted
= filespec
->sorted
;
4402 new->section_list
= section_list
;
4403 new->keep_sections
= keep_sections
;
4404 lang_list_init (&new->children
);
4408 lang_section_start (name
, address
)
4410 etree_type
*address
;
4412 lang_address_statement_type
*ad
;
4414 ad
= new_stat (lang_address_statement
, stat_ptr
);
4415 ad
->section_name
= name
;
4416 ad
->address
= address
;
4419 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4420 because of a -e argument on the command line, or zero if this is
4421 called by ENTRY in a linker script. Command line arguments take
4425 lang_add_entry (name
, cmdline
)
4429 if (entry_symbol
.name
== NULL
4431 || ! entry_from_cmdline
)
4433 entry_symbol
.name
= name
;
4434 entry_from_cmdline
= cmdline
;
4439 lang_add_target (name
)
4442 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4458 map_option_f
= true;
4466 lang_add_fill (fill
)
4469 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4476 lang_add_data (type
, exp
)
4478 union etree_union
*exp
;
4481 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4489 /* Create a new reloc statement. RELOC is the BFD relocation type to
4490 generate. HOWTO is the corresponding howto structure (we could
4491 look this up, but the caller has already done so). SECTION is the
4492 section to generate a reloc against, or NAME is the name of the
4493 symbol to generate a reloc against. Exactly one of SECTION and
4494 NAME must be NULL. ADDEND is an expression for the addend. */
4497 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4498 bfd_reloc_code_real_type reloc
;
4499 reloc_howto_type
*howto
;
4502 union etree_union
*addend
;
4504 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4508 p
->section
= section
;
4510 p
->addend_exp
= addend
;
4512 p
->addend_value
= 0;
4513 p
->output_section
= NULL
;
4517 lang_assignment_statement_type
*
4518 lang_add_assignment (exp
)
4521 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4529 lang_add_attribute (attribute
)
4530 enum statement_enum attribute
;
4532 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4539 if (startup_file
!= (char *) NULL
)
4541 einfo (_("%P%Fmultiple STARTUP files\n"));
4543 first_file
->filename
= name
;
4544 first_file
->local_sym_name
= name
;
4545 first_file
->real
= true;
4547 startup_file
= name
;
4554 lang_float_flag
= maybe
;
4558 /* Work out the load- and run-time regions from a script statement, and
4559 store them in *LMA_REGION and *REGION respectively.
4561 MEMSPEC is the name of the run-time region, or "*default*" if the
4562 statement didn't specify one. LMA_MEMSPEC is the name of the
4563 load-time region, or null if the statement didn't specify one.
4564 HAVE_LMA_P is true if the statement had an explicit load address.
4566 It is an error to specify both a load region and a load address. */
4569 lang_get_regions (region
, lma_region
, memspec
, lma_memspec
, have_lma_p
)
4570 struct memory_region_struct
**region
, **lma_region
;
4571 const char *memspec
, *lma_memspec
;
4574 *lma_region
= lang_memory_region_lookup (lma_memspec
);
4576 /* If no runtime region has been given, but the load region has
4577 been, use the load region. */
4578 if (lma_memspec
!= 0 && strcmp (memspec
, "*default*") == 0)
4579 *region
= *lma_region
;
4581 *region
= lang_memory_region_lookup (memspec
);
4583 if (have_lma_p
&& lma_memspec
!= 0)
4584 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4588 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4590 const char *memspec
;
4591 struct lang_output_section_phdr_list
*phdrs
;
4592 const char *lma_memspec
;
4594 lang_get_regions (¤t_section
->region
,
4595 ¤t_section
->lma_region
,
4596 memspec
, lma_memspec
,
4597 current_section
->load_base
!= 0);
4598 current_section
->fill
= fill
;
4599 current_section
->phdrs
= phdrs
;
4600 stat_ptr
= &statement_list
;
4603 /* Create an absolute symbol with the given name with the value of the
4604 address of first byte of the section named.
4606 If the symbol already exists, then do nothing. */
4609 lang_abs_symbol_at_beginning_of (secname
, name
)
4610 const char *secname
;
4613 struct bfd_link_hash_entry
*h
;
4615 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4616 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4617 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4619 if (h
->type
== bfd_link_hash_new
4620 || h
->type
== bfd_link_hash_undefined
)
4624 h
->type
= bfd_link_hash_defined
;
4626 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4627 if (sec
== (asection
*) NULL
)
4630 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4632 h
->u
.def
.section
= bfd_abs_section_ptr
;
4636 /* Create an absolute symbol with the given name with the value of the
4637 address of the first byte after the end of the section named.
4639 If the symbol already exists, then do nothing. */
4642 lang_abs_symbol_at_end_of (secname
, name
)
4643 const char *secname
;
4646 struct bfd_link_hash_entry
*h
;
4648 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4649 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4650 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4652 if (h
->type
== bfd_link_hash_new
4653 || h
->type
== bfd_link_hash_undefined
)
4657 h
->type
= bfd_link_hash_defined
;
4659 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4660 if (sec
== (asection
*) NULL
)
4663 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4664 + bfd_section_size (output_bfd
, sec
) /
4665 bfd_octets_per_byte (output_bfd
));
4667 h
->u
.def
.section
= bfd_abs_section_ptr
;
4672 lang_statement_append (list
, element
, field
)
4673 lang_statement_list_type
*list
;
4674 lang_statement_union_type
*element
;
4675 lang_statement_union_type
**field
;
4677 *(list
->tail
) = element
;
4681 /* Set the output format type. -oformat overrides scripts. */
4684 lang_add_output_format (format
, big
, little
, from_script
)
4690 if (output_target
== NULL
|| !from_script
)
4692 if (command_line
.endian
== ENDIAN_BIG
4695 else if (command_line
.endian
== ENDIAN_LITTLE
4699 output_target
= format
;
4703 /* Enter a group. This creates a new lang_group_statement, and sets
4704 stat_ptr to build new statements within the group. */
4709 lang_group_statement_type
*g
;
4711 g
= new_stat (lang_group_statement
, stat_ptr
);
4712 lang_list_init (&g
->children
);
4713 stat_ptr
= &g
->children
;
4716 /* Leave a group. This just resets stat_ptr to start writing to the
4717 regular list of statements again. Note that this will not work if
4718 groups can occur inside anything else which can adjust stat_ptr,
4719 but currently they can't. */
4724 stat_ptr
= &statement_list
;
4727 /* Add a new program header. This is called for each entry in a PHDRS
4728 command in a linker script. */
4731 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4739 struct lang_phdr
*n
, **pp
;
4741 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4744 n
->type
= exp_get_value_int (type
, 0, "program header type",
4745 lang_final_phase_enum
);
4746 n
->filehdr
= filehdr
;
4751 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4756 /* Record the program header information in the output BFD. FIXME: We
4757 should not be calling an ELF specific function here. */
4760 lang_record_phdrs ()
4764 struct lang_output_section_phdr_list
*last
;
4765 struct lang_phdr
*l
;
4766 lang_statement_union_type
*u
;
4769 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4771 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4778 for (u
= lang_output_section_statement
.head
;
4780 u
= u
->output_section_statement
.next
)
4782 lang_output_section_statement_type
*os
;
4783 struct lang_output_section_phdr_list
*pl
;
4785 os
= &u
->output_section_statement
;
4792 if (os
->sectype
== noload_section
4793 || os
->bfd_section
== NULL
4794 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4799 if (os
->bfd_section
== NULL
)
4802 for (; pl
!= NULL
; pl
= pl
->next
)
4804 if (strcmp (pl
->name
, l
->name
) == 0)
4809 secs
= ((asection
**)
4810 xrealloc (secs
, alc
* sizeof (asection
*)));
4812 secs
[c
] = os
->bfd_section
;
4819 if (l
->flags
== NULL
)
4822 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4823 lang_final_phase_enum
);
4828 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4829 lang_final_phase_enum
);
4831 if (! bfd_record_phdr (output_bfd
, l
->type
,
4832 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
4833 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4834 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4839 /* Make sure all the phdr assignments succeeded. */
4840 for (u
= lang_output_section_statement
.head
;
4842 u
= u
->output_section_statement
.next
)
4844 struct lang_output_section_phdr_list
*pl
;
4846 if (u
->output_section_statement
.bfd_section
== NULL
)
4849 for (pl
= u
->output_section_statement
.phdrs
;
4852 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4853 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4854 u
->output_section_statement
.name
, pl
->name
);
4858 /* Record a list of sections which may not be cross referenced. */
4861 lang_add_nocrossref (l
)
4862 struct lang_nocrossref
*l
;
4864 struct lang_nocrossrefs
*n
;
4866 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4867 n
->next
= nocrossref_list
;
4869 nocrossref_list
= n
;
4871 /* Set notice_all so that we get informed about all symbols. */
4872 link_info
.notice_all
= true;
4875 /* Overlay handling. We handle overlays with some static variables. */
4877 /* The overlay virtual address. */
4878 static etree_type
*overlay_vma
;
4880 /* An expression for the maximum section size seen so far. */
4881 static etree_type
*overlay_max
;
4883 /* A list of all the sections in this overlay. */
4885 struct overlay_list
{
4886 struct overlay_list
*next
;
4887 lang_output_section_statement_type
*os
;
4890 static struct overlay_list
*overlay_list
;
4892 /* Start handling an overlay. */
4895 lang_enter_overlay (vma_expr
)
4896 etree_type
*vma_expr
;
4898 /* The grammar should prevent nested overlays from occurring. */
4899 ASSERT (overlay_vma
== NULL
&& overlay_max
== NULL
);
4901 overlay_vma
= vma_expr
;
4904 /* Start a section in an overlay. We handle this by calling
4905 lang_enter_output_section_statement with the correct VMA.
4906 lang_leave_overlay sets up the LMA and memory regions. */
4909 lang_enter_overlay_section (name
)
4912 struct overlay_list
*n
;
4915 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4918 /* If this is the first section, then base the VMA of future
4919 sections on this one. This will work correctly even if `.' is
4920 used in the addresses. */
4921 if (overlay_list
== NULL
)
4922 overlay_vma
= exp_nameop (ADDR
, name
);
4924 /* Remember the section. */
4925 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4926 n
->os
= current_section
;
4927 n
->next
= overlay_list
;
4930 size
= exp_nameop (SIZEOF
, name
);
4932 /* Arrange to work out the maximum section end address. */
4933 if (overlay_max
== NULL
)
4936 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4939 /* Finish a section in an overlay. There isn't any special to do
4943 lang_leave_overlay_section (fill
, phdrs
)
4945 struct lang_output_section_phdr_list
*phdrs
;
4952 name
= current_section
->name
;
4954 /* For now, assume that "*default*" is the run-time memory region and
4955 that no load-time region has been specified. It doesn't really
4956 matter what we say here, since lang_leave_overlay will override it. */
4957 lang_leave_output_section_statement (fill
, "*default*", phdrs
, 0);
4959 /* Define the magic symbols. */
4961 clean
= xmalloc (strlen (name
) + 1);
4963 for (s1
= name
; *s1
!= '\0'; s1
++)
4964 if (ISALNUM (*s1
) || *s1
== '_')
4968 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4969 sprintf (buf
, "__load_start_%s", clean
);
4970 lang_add_assignment (exp_assop ('=', buf
,
4971 exp_nameop (LOADADDR
, name
)));
4973 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4974 sprintf (buf
, "__load_stop_%s", clean
);
4975 lang_add_assignment (exp_assop ('=', buf
,
4977 exp_nameop (LOADADDR
, name
),
4978 exp_nameop (SIZEOF
, name
))));
4983 /* Finish an overlay. If there are any overlay wide settings, this
4984 looks through all the sections in the overlay and sets them. */
4987 lang_leave_overlay (lma_expr
, nocrossrefs
, fill
, memspec
, phdrs
, lma_memspec
)
4988 etree_type
*lma_expr
;
4991 const char *memspec
;
4992 struct lang_output_section_phdr_list
*phdrs
;
4993 const char *lma_memspec
;
4995 lang_memory_region_type
*region
;
4996 lang_memory_region_type
*lma_region
;
4997 struct overlay_list
*l
;
4998 struct lang_nocrossref
*nocrossref
;
5000 lang_get_regions (®ion
, &lma_region
,
5001 memspec
, lma_memspec
,
5006 /* After setting the size of the last section, set '.' to end of the
5008 if (overlay_list
!= NULL
)
5009 overlay_list
->os
->update_dot_tree
5010 = exp_assop ('=', ".", exp_binop ('+', overlay_vma
, overlay_max
));
5015 struct overlay_list
*next
;
5017 if (fill
!= (fill_type
*) 0 && l
->os
->fill
== (fill_type
*) 0)
5020 l
->os
->region
= region
;
5021 l
->os
->lma_region
= lma_region
;
5023 /* The first section has the load address specified in the
5024 OVERLAY statement. The rest are worked out from that.
5025 The base address is not needed (and should be null) if
5026 an LMA region was specified. */
5028 l
->os
->load_base
= lma_expr
;
5029 else if (lma_region
== 0)
5030 l
->os
->load_base
= exp_binop ('+',
5031 exp_nameop (LOADADDR
, l
->next
->os
->name
),
5032 exp_nameop (SIZEOF
, l
->next
->os
->name
));
5034 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
5035 l
->os
->phdrs
= phdrs
;
5039 struct lang_nocrossref
*nc
;
5041 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
5042 nc
->name
= l
->os
->name
;
5043 nc
->next
= nocrossref
;
5052 if (nocrossref
!= NULL
)
5053 lang_add_nocrossref (nocrossref
);
5056 overlay_list
= NULL
;
5060 /* Version handling. This is only useful for ELF. */
5062 /* This global variable holds the version tree that we build. */
5064 struct bfd_elf_version_tree
*lang_elf_version_info
;
5067 lang_vers_match_lang_c (expr
, sym
)
5068 struct bfd_elf_version_expr
*expr
;
5071 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5073 return fnmatch (expr
->pattern
, sym
, 0) == 0;
5077 lang_vers_match_lang_cplusplus (expr
, sym
)
5078 struct bfd_elf_version_expr
*expr
;
5084 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5087 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
5090 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5091 Should we early out false in this case? */
5092 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5096 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5104 lang_vers_match_lang_java (expr
, sym
)
5105 struct bfd_elf_version_expr
*expr
;
5111 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5114 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
5117 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5118 Should we early out false in this case? */
5119 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5123 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5130 /* This is called for each variable name or match expression. */
5132 struct bfd_elf_version_expr
*
5133 lang_new_vers_pattern (orig
, new, lang
)
5134 struct bfd_elf_version_expr
*orig
;
5138 struct bfd_elf_version_expr
*ret
;
5140 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
5146 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
5147 ret
->match
= lang_vers_match_lang_c
;
5148 else if (strcasecmp (lang
, "C++") == 0)
5149 ret
->match
= lang_vers_match_lang_cplusplus
;
5150 else if (strcasecmp (lang
, "Java") == 0)
5151 ret
->match
= lang_vers_match_lang_java
;
5154 einfo (_("%X%P: unknown language `%s' in version information\n"),
5156 ret
->match
= lang_vers_match_lang_c
;
5159 return ldemul_new_vers_pattern (ret
);
5162 /* This is called for each set of variable names and match
5165 struct bfd_elf_version_tree
*
5166 lang_new_vers_node (globals
, locals
)
5167 struct bfd_elf_version_expr
*globals
;
5168 struct bfd_elf_version_expr
*locals
;
5170 struct bfd_elf_version_tree
*ret
;
5172 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
5176 ret
->globals
= globals
;
5177 ret
->locals
= locals
;
5179 ret
->name_indx
= (unsigned int) -1;
5184 /* This static variable keeps track of version indices. */
5186 static int version_index
;
5188 /* This is called when we know the name and dependencies of the
5192 lang_register_vers_node (name
, version
, deps
)
5194 struct bfd_elf_version_tree
*version
;
5195 struct bfd_elf_version_deps
*deps
;
5197 struct bfd_elf_version_tree
*t
, **pp
;
5198 struct bfd_elf_version_expr
*e1
;
5203 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
5204 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
5206 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5210 /* Make sure this node has a unique name. */
5211 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5212 if (strcmp (t
->name
, name
) == 0)
5213 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5215 /* Check the global and local match names, and make sure there
5216 aren't any duplicates. */
5218 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5220 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5222 struct bfd_elf_version_expr
*e2
;
5224 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5225 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5226 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5231 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
5233 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5235 struct bfd_elf_version_expr
*e2
;
5237 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
5238 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5239 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5244 version
->deps
= deps
;
5245 version
->name
= name
;
5246 if (name
[0] != '\0')
5249 version
->vernum
= version_index
;
5252 version
->vernum
= 0;
5254 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5259 /* This is called when we see a version dependency. */
5261 struct bfd_elf_version_deps
*
5262 lang_add_vers_depend (list
, name
)
5263 struct bfd_elf_version_deps
*list
;
5266 struct bfd_elf_version_deps
*ret
;
5267 struct bfd_elf_version_tree
*t
;
5269 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5272 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5274 if (strcmp (t
->name
, name
) == 0)
5276 ret
->version_needed
= t
;
5281 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5287 lang_do_version_exports_section ()
5289 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5291 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5293 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5300 len
= bfd_section_size (is
->the_bfd
, sec
);
5301 contents
= xmalloc (len
);
5302 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5303 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
5306 while (p
< contents
+ len
)
5308 greg
= lang_new_vers_pattern (greg
, p
, NULL
);
5309 p
= strchr (p
, '\0') + 1;
5312 /* Do not free the contents, as we used them creating the regex. */
5314 /* Do not include this section in the link. */
5315 bfd_set_section_flags (is
->the_bfd
, sec
,
5316 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5319 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
);
5320 lang_register_vers_node (command_line
.version_exports_section
,
5321 lang_new_vers_node (greg
, lreg
), NULL
);
5325 lang_add_unique (name
)
5328 struct unique_sections
*ent
;
5330 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5331 if (strcmp (ent
->name
, name
) == 0)
5334 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
5335 ent
->name
= xstrdup (name
);
5336 ent
->next
= unique_section_list
;
5337 unique_section_list
= ent
;