1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
6 This file is part of GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
26 #include "safe-ctype.h"
44 static lang_statement_union_type
*new_statement
45 PARAMS ((enum statement_enum
, size_t, lang_statement_list_type
*));
48 static struct obstack stat_obstack
;
50 #define obstack_chunk_alloc xmalloc
51 #define obstack_chunk_free free
52 static const char *startup_file
;
53 static lang_statement_list_type input_file_chain
;
54 static boolean placed_commons
= false;
55 static lang_output_section_statement_type
*default_common_section
;
56 static boolean map_option_f
;
57 static bfd_vma print_dot
;
58 static lang_input_statement_type
*first_file
;
59 static const char *current_target
;
60 static const char *output_target
;
61 static lang_statement_list_type statement_list
;
62 static struct lang_phdr
*lang_phdr_list
;
64 static void lang_for_each_statement_worker
65 PARAMS ((void (*) (lang_statement_union_type
*),
66 lang_statement_union_type
*));
67 static lang_input_statement_type
*new_afile
68 PARAMS ((const char *, lang_input_file_enum_type
, const char *, boolean
));
69 static lang_memory_region_type
*lang_memory_default
PARAMS ((asection
*));
70 static void lang_map_flags
PARAMS ((flagword
));
71 static void init_os
PARAMS ((lang_output_section_statement_type
*));
72 static void exp_init_os
PARAMS ((etree_type
*));
73 static void section_already_linked
PARAMS ((bfd
*, asection
*, PTR
));
74 static struct bfd_hash_entry
*already_linked_newfunc
75 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
76 static void already_linked_table_init
PARAMS ((void));
77 static void already_linked_table_free
PARAMS ((void));
78 static boolean wildcardp
PARAMS ((const char *));
79 static lang_statement_union_type
*wild_sort
80 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*,
81 lang_input_statement_type
*, asection
*));
82 static void output_section_callback
83 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
84 lang_input_statement_type
*, PTR
));
85 static lang_input_statement_type
*lookup_name
PARAMS ((const char *));
86 static boolean load_symbols
87 PARAMS ((lang_input_statement_type
*, lang_statement_list_type
*));
89 PARAMS ((lang_wild_statement_type
*,
90 const char *, lang_output_section_statement_type
*));
91 static bfd
*open_output
PARAMS ((const char *));
92 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*));
93 static void open_input_bfds
PARAMS ((lang_statement_union_type
*, boolean
));
94 static void lang_reasonable_defaults
PARAMS ((void));
95 static void insert_undefined
PARAMS ((const char *));
96 static void lang_place_undefineds
PARAMS ((void));
97 static void map_input_to_output_sections
98 PARAMS ((lang_statement_union_type
*, const char *,
99 lang_output_section_statement_type
*));
100 static void strip_excluded_output_sections
PARAMS ((void));
101 static void print_output_section_statement
102 PARAMS ((lang_output_section_statement_type
*));
103 static void print_assignment
104 PARAMS ((lang_assignment_statement_type
*,
105 lang_output_section_statement_type
*));
106 static void print_input_statement
PARAMS ((lang_input_statement_type
*));
107 static boolean print_one_symbol
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
108 static void print_input_section
PARAMS ((lang_input_section_type
*));
109 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*));
110 static void print_data_statement
PARAMS ((lang_data_statement_type
*));
111 static void print_address_statement
PARAMS ((lang_address_statement_type
*));
112 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*));
113 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*));
114 static void print_wild_statement
115 PARAMS ((lang_wild_statement_type
*, lang_output_section_statement_type
*));
116 static void print_group
117 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
118 static void print_statement
119 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
120 static void print_statement_list
121 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
122 static void print_statements
PARAMS ((void));
123 static void insert_pad
124 PARAMS ((lang_statement_union_type
**, fill_type
*,
125 unsigned int, asection
*, bfd_vma
));
126 static bfd_vma size_input_section
127 PARAMS ((lang_statement_union_type
**, lang_output_section_statement_type
*,
128 fill_type
*, bfd_vma
));
129 static void lang_finish
PARAMS ((void));
130 static void ignore_bfd_errors
PARAMS ((const char *, ...));
131 static void lang_check
PARAMS ((void));
132 static void lang_common
PARAMS ((void));
133 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
134 static void lang_place_orphans
PARAMS ((void));
135 static int topower
PARAMS ((int));
136 static void lang_set_startof
PARAMS ((void));
137 static void gc_section_callback
138 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
139 lang_input_statement_type
*, PTR
));
140 static void lang_get_regions
PARAMS ((struct memory_region_struct
**,
141 struct memory_region_struct
**,
142 const char *, const char *, int));
143 static void lang_record_phdrs
PARAMS ((void));
144 static void lang_gc_wild
PARAMS ((lang_wild_statement_type
*));
145 static void lang_gc_sections_1
PARAMS ((lang_statement_union_type
*));
146 static void lang_gc_sections
PARAMS ((void));
147 static int lang_vers_match_lang_c
148 PARAMS ((struct bfd_elf_version_expr
*, const char *));
149 static int lang_vers_match_lang_cplusplus
150 PARAMS ((struct bfd_elf_version_expr
*, const char *));
151 static int lang_vers_match_lang_java
152 PARAMS ((struct bfd_elf_version_expr
*, const char *));
153 static void lang_do_version_exports_section
PARAMS ((void));
154 static void lang_check_section_addresses
PARAMS ((void));
155 static void os_region_check
156 PARAMS ((lang_output_section_statement_type
*,
157 struct memory_region_struct
*, etree_type
*, bfd_vma
));
158 static bfd_vma lang_size_sections_1
159 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*,
160 lang_statement_union_type
**, fill_type
*, bfd_vma
, boolean
*));
162 typedef void (*callback_t
) PARAMS ((lang_wild_statement_type
*,
163 struct wildcard_list
*,
165 lang_input_statement_type
*,
167 static void walk_wild
168 PARAMS ((lang_wild_statement_type
*, callback_t
, PTR
));
169 static void walk_wild_section
170 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
172 static void walk_wild_file
173 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
176 static int get_target
PARAMS ((const bfd_target
*, PTR
));
177 static void stricpy
PARAMS ((char *, char *));
178 static void strcut
PARAMS ((char *, char *));
179 static int name_compare
PARAMS ((char *, char *));
180 static int closest_target_match
PARAMS ((const bfd_target
*, PTR
));
181 static char * get_first_input_target
PARAMS ((void));
184 lang_output_section_statement_type
*abs_output_section
;
185 lang_statement_list_type lang_output_section_statement
;
186 lang_statement_list_type
*stat_ptr
= &statement_list
;
187 lang_statement_list_type file_chain
= { NULL
, NULL
};
188 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
189 const char *entry_section
= ".text";
190 boolean entry_from_cmdline
;
191 boolean lang_has_input_file
= false;
192 boolean had_output_filename
= false;
193 boolean lang_float_flag
= false;
194 boolean delete_output_file_on_failure
= false;
195 struct lang_nocrossrefs
*nocrossref_list
;
196 struct unique_sections
*unique_section_list
;
198 etree_type
*base
; /* Relocation base - or null */
200 #if defined (__STDC__) || defined (ALMOST_STDC)
201 #define cat(a,b) a##b
203 #define cat(a,b) a/**/b
206 /* Don't beautify the line below with "innocent" whitespace, it breaks
207 the K&R C preprocessor! */
208 #define new_stat(x, y) \
209 (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
211 #define outside_section_address(q) \
212 ((q)->output_offset + (q)->output_section->vma)
214 #define outside_symbol_address(q) \
215 ((q)->value + outside_section_address (q->section))
217 #define SECTION_NAME_MAP_LENGTH (16)
223 return obstack_alloc (&stat_obstack
, size
);
227 unique_section_p (secnam
)
230 struct unique_sections
*unam
;
232 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
233 if (wildcardp (unam
->name
)
234 ? fnmatch (unam
->name
, secnam
, 0) == 0
235 : strcmp (unam
->name
, secnam
) == 0)
243 /* Generic traversal routines for finding matching sections. */
246 walk_wild_section (ptr
, file
, callback
, data
)
247 lang_wild_statement_type
*ptr
;
248 lang_input_statement_type
*file
;
254 if (file
->just_syms_flag
)
257 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
259 struct wildcard_list
*sec
;
261 sec
= ptr
->section_list
;
263 (*callback
) (ptr
, sec
, s
, file
, data
);
267 boolean skip
= false;
268 struct name_list
*list_tmp
;
270 /* Don't process sections from files which were
272 for (list_tmp
= sec
->spec
.exclude_name_list
;
274 list_tmp
= list_tmp
->next
)
276 if (wildcardp (list_tmp
->name
))
277 skip
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
279 skip
= strcmp (list_tmp
->name
, file
->filename
) == 0;
281 /* If this file is part of an archive, and the archive is
282 excluded, exclude this file. */
283 if (! skip
&& file
->the_bfd
!= NULL
284 && file
->the_bfd
->my_archive
!= NULL
285 && file
->the_bfd
->my_archive
->filename
!= NULL
)
287 if (wildcardp (list_tmp
->name
))
288 skip
= fnmatch (list_tmp
->name
,
289 file
->the_bfd
->my_archive
->filename
,
292 skip
= strcmp (list_tmp
->name
,
293 file
->the_bfd
->my_archive
->filename
) == 0;
300 if (!skip
&& sec
->spec
.name
!= NULL
)
302 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
304 if (wildcardp (sec
->spec
.name
))
305 skip
= fnmatch (sec
->spec
.name
, sname
, 0) != 0;
307 skip
= strcmp (sec
->spec
.name
, sname
) != 0;
311 (*callback
) (ptr
, sec
, s
, file
, data
);
318 /* Handle a wild statement for a single file F. */
321 walk_wild_file (s
, f
, callback
, data
)
322 lang_wild_statement_type
*s
;
323 lang_input_statement_type
*f
;
327 if (f
->the_bfd
== NULL
328 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
329 walk_wild_section (s
, f
, callback
, data
);
334 /* This is an archive file. We must map each member of the
335 archive separately. */
336 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
337 while (member
!= NULL
)
339 /* When lookup_name is called, it will call the add_symbols
340 entry point for the archive. For each element of the
341 archive which is included, BFD will call ldlang_add_file,
342 which will set the usrdata field of the member to the
343 lang_input_statement. */
344 if (member
->usrdata
!= NULL
)
346 walk_wild_section (s
,
347 (lang_input_statement_type
*) member
->usrdata
,
351 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
357 walk_wild (s
, callback
, data
)
358 lang_wild_statement_type
*s
;
362 const char *file_spec
= s
->filename
;
364 if (file_spec
== NULL
)
366 /* Perform the iteration over all files in the list. */
367 LANG_FOR_EACH_INPUT_STATEMENT (f
)
369 walk_wild_file (s
, f
, callback
, data
);
372 else if (wildcardp (file_spec
))
374 LANG_FOR_EACH_INPUT_STATEMENT (f
)
376 if (fnmatch (file_spec
, f
->filename
, FNM_FILE_NAME
) == 0)
377 walk_wild_file (s
, f
, callback
, data
);
382 lang_input_statement_type
*f
;
384 /* Perform the iteration over a single file. */
385 f
= lookup_name (file_spec
);
387 walk_wild_file (s
, f
, callback
, data
);
391 /* lang_for_each_statement walks the parse tree and calls the provided
392 function for each node. */
395 lang_for_each_statement_worker (func
, s
)
396 void (*func
) PARAMS ((lang_statement_union_type
*));
397 lang_statement_union_type
*s
;
399 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
403 switch (s
->header
.type
)
405 case lang_constructors_statement_enum
:
406 lang_for_each_statement_worker (func
, constructor_list
.head
);
408 case lang_output_section_statement_enum
:
409 lang_for_each_statement_worker
411 s
->output_section_statement
.children
.head
);
413 case lang_wild_statement_enum
:
414 lang_for_each_statement_worker
416 s
->wild_statement
.children
.head
);
418 case lang_group_statement_enum
:
419 lang_for_each_statement_worker (func
,
420 s
->group_statement
.children
.head
);
422 case lang_data_statement_enum
:
423 case lang_reloc_statement_enum
:
424 case lang_object_symbols_statement_enum
:
425 case lang_output_statement_enum
:
426 case lang_target_statement_enum
:
427 case lang_input_section_enum
:
428 case lang_input_statement_enum
:
429 case lang_assignment_statement_enum
:
430 case lang_padding_statement_enum
:
431 case lang_address_statement_enum
:
432 case lang_fill_statement_enum
:
442 lang_for_each_statement (func
)
443 void (*func
) PARAMS ((lang_statement_union_type
*));
445 lang_for_each_statement_worker (func
, statement_list
.head
);
448 /*----------------------------------------------------------------------*/
451 lang_list_init (list
)
452 lang_statement_list_type
*list
;
454 list
->head
= (lang_statement_union_type
*) NULL
;
455 list
->tail
= &list
->head
;
458 /* Build a new statement node for the parse tree. */
460 static lang_statement_union_type
*
461 new_statement (type
, size
, list
)
462 enum statement_enum type
;
464 lang_statement_list_type
*list
;
466 lang_statement_union_type
*new = (lang_statement_union_type
*)
469 new->header
.type
= type
;
470 new->header
.next
= (lang_statement_union_type
*) NULL
;
471 lang_statement_append (list
, new, &new->header
.next
);
475 /* Build a new input file node for the language. There are several
476 ways in which we treat an input file, eg, we only look at symbols,
477 or prefix it with a -l etc.
479 We can be supplied with requests for input files more than once;
480 they may, for example be split over serveral lines like foo.o(.text)
481 foo.o(.data) etc, so when asked for a file we check that we haven't
482 got it already so we don't duplicate the bfd. */
484 static lang_input_statement_type
*
485 new_afile (name
, file_type
, target
, add_to_list
)
487 lang_input_file_enum_type file_type
;
491 lang_input_statement_type
*p
;
494 p
= new_stat (lang_input_statement
, stat_ptr
);
497 p
= ((lang_input_statement_type
*)
498 stat_alloc (sizeof (lang_input_statement_type
)));
499 p
->header
.next
= NULL
;
502 lang_has_input_file
= true;
506 case lang_input_file_is_symbols_only_enum
:
508 p
->is_archive
= false;
510 p
->local_sym_name
= name
;
511 p
->just_syms_flag
= true;
512 p
->search_dirs_flag
= false;
514 case lang_input_file_is_fake_enum
:
516 p
->is_archive
= false;
518 p
->local_sym_name
= name
;
519 p
->just_syms_flag
= false;
520 p
->search_dirs_flag
= false;
522 case lang_input_file_is_l_enum
:
523 p
->is_archive
= true;
526 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
527 p
->just_syms_flag
= false;
528 p
->search_dirs_flag
= true;
530 case lang_input_file_is_marker_enum
:
532 p
->is_archive
= false;
534 p
->local_sym_name
= name
;
535 p
->just_syms_flag
= false;
536 p
->search_dirs_flag
= true;
538 case lang_input_file_is_search_file_enum
:
540 p
->is_archive
= false;
542 p
->local_sym_name
= name
;
543 p
->just_syms_flag
= false;
544 p
->search_dirs_flag
= true;
546 case lang_input_file_is_file_enum
:
548 p
->is_archive
= false;
550 p
->local_sym_name
= name
;
551 p
->just_syms_flag
= false;
552 p
->search_dirs_flag
= false;
557 p
->the_bfd
= (bfd
*) NULL
;
558 p
->asymbols
= (asymbol
**) NULL
;
559 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
560 p
->next
= (lang_statement_union_type
*) NULL
;
562 p
->dynamic
= config
.dynamic_link
;
563 p
->whole_archive
= whole_archive
;
565 lang_statement_append (&input_file_chain
,
566 (lang_statement_union_type
*) p
,
571 lang_input_statement_type
*
572 lang_add_input_file (name
, file_type
, target
)
574 lang_input_file_enum_type file_type
;
577 lang_has_input_file
= true;
578 return new_afile (name
, file_type
, target
, true);
581 /* Build enough state so that the parser can build its tree. */
586 obstack_begin (&stat_obstack
, 1000);
588 stat_ptr
= &statement_list
;
590 lang_list_init (stat_ptr
);
592 lang_list_init (&input_file_chain
);
593 lang_list_init (&lang_output_section_statement
);
594 lang_list_init (&file_chain
);
595 first_file
= lang_add_input_file ((char *) NULL
,
596 lang_input_file_is_marker_enum
,
599 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
601 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
605 /*----------------------------------------------------------------------
606 A region is an area of memory declared with the
607 MEMORY { name:org=exp, len=exp ... }
610 We maintain a list of all the regions here.
612 If no regions are specified in the script, then the default is used
613 which is created when looked up to be the entire data space. */
615 static lang_memory_region_type
*lang_memory_region_list
;
616 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
618 lang_memory_region_type
*
619 lang_memory_region_lookup (name
)
620 const char *const name
;
622 lang_memory_region_type
*p
;
624 /* NAME is NULL for LMA memspecs if no region was specified. */
628 for (p
= lang_memory_region_list
;
629 p
!= (lang_memory_region_type
*) NULL
;
632 if (strcmp (p
->name
, name
) == 0)
639 /* This code used to always use the first region in the list as the
640 default region. I changed it to instead use a region
641 encompassing all of memory as the default region. This permits
642 NOLOAD sections to work reasonably without requiring a region.
643 People should specify what region they mean, if they really want
645 if (strcmp (name
, "*default*") == 0)
647 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
649 return lang_memory_region_list
;
655 lang_memory_region_type
*new =
656 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
658 new->name
= xstrdup (name
);
659 new->next
= (lang_memory_region_type
*) NULL
;
661 *lang_memory_region_list_tail
= new;
662 lang_memory_region_list_tail
= &new->next
;
666 new->length
= ~(bfd_size_type
) 0;
668 new->had_full_message
= false;
674 static lang_memory_region_type
*
675 lang_memory_default (section
)
678 lang_memory_region_type
*p
;
680 flagword sec_flags
= section
->flags
;
682 /* Override SEC_DATA to mean a writable section. */
683 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
684 sec_flags
|= SEC_DATA
;
686 for (p
= lang_memory_region_list
;
687 p
!= (lang_memory_region_type
*) NULL
;
690 if ((p
->flags
& sec_flags
) != 0
691 && (p
->not_flags
& sec_flags
) == 0)
696 return lang_memory_region_lookup ("*default*");
699 lang_output_section_statement_type
*
700 lang_output_section_find (name
)
701 const char *const name
;
703 lang_statement_union_type
*u
;
704 lang_output_section_statement_type
*lookup
;
706 for (u
= lang_output_section_statement
.head
;
707 u
!= (lang_statement_union_type
*) NULL
;
710 lookup
= &u
->output_section_statement
;
711 if (strcmp (name
, lookup
->name
) == 0)
716 return (lang_output_section_statement_type
*) NULL
;
719 lang_output_section_statement_type
*
720 lang_output_section_statement_lookup (name
)
721 const char *const name
;
723 lang_output_section_statement_type
*lookup
;
725 lookup
= lang_output_section_find (name
);
726 if (lookup
== (lang_output_section_statement_type
*) NULL
)
729 lookup
= (lang_output_section_statement_type
*)
730 new_stat (lang_output_section_statement
, stat_ptr
);
731 lookup
->region
= (lang_memory_region_type
*) NULL
;
732 lookup
->lma_region
= (lang_memory_region_type
*) NULL
;
733 lookup
->fill
= (fill_type
*) 0;
734 lookup
->block_value
= 1;
737 lookup
->next
= (lang_statement_union_type
*) NULL
;
738 lookup
->bfd_section
= (asection
*) NULL
;
739 lookup
->processed
= false;
740 lookup
->sectype
= normal_section
;
741 lookup
->addr_tree
= (etree_type
*) NULL
;
742 lang_list_init (&lookup
->children
);
744 lookup
->memspec
= (const char *) NULL
;
746 lookup
->subsection_alignment
= -1;
747 lookup
->section_alignment
= -1;
748 lookup
->load_base
= (union etree_union
*) NULL
;
749 lookup
->update_dot_tree
= NULL
;
750 lookup
->phdrs
= NULL
;
752 lang_statement_append (&lang_output_section_statement
,
753 (lang_statement_union_type
*) lookup
,
760 lang_map_flags (flag
)
763 if (flag
& SEC_ALLOC
)
769 if (flag
& SEC_READONLY
)
782 lang_memory_region_type
*m
;
784 minfo (_("\nMemory Configuration\n\n"));
785 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
786 _("Name"), _("Origin"), _("Length"), _("Attributes"));
788 for (m
= lang_memory_region_list
;
789 m
!= (lang_memory_region_type
*) NULL
;
795 fprintf (config
.map_file
, "%-16s ", m
->name
);
797 sprintf_vma (buf
, m
->origin
);
798 minfo ("0x%s ", buf
);
806 minfo ("0x%V", m
->length
);
807 if (m
->flags
|| m
->not_flags
)
815 lang_map_flags (m
->flags
);
821 lang_map_flags (m
->not_flags
);
828 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
833 /* Initialize an output section. */
837 lang_output_section_statement_type
*s
;
839 section_userdata_type
*new;
841 if (s
->bfd_section
!= NULL
)
844 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
845 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
847 new = ((section_userdata_type
*)
848 stat_alloc (sizeof (section_userdata_type
)));
850 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
851 if (s
->bfd_section
== (asection
*) NULL
)
852 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
853 if (s
->bfd_section
== (asection
*) NULL
)
855 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
856 output_bfd
->xvec
->name
, s
->name
);
858 s
->bfd_section
->output_section
= s
->bfd_section
;
860 /* We initialize an output sections output offset to minus its own
861 vma to allow us to output a section through itself. */
862 s
->bfd_section
->output_offset
= 0;
863 get_userdata (s
->bfd_section
) = (PTR
) new;
865 /* If there is a base address, make sure that any sections it might
866 mention are initialized. */
867 if (s
->addr_tree
!= NULL
)
868 exp_init_os (s
->addr_tree
);
871 /* Make sure that all output sections mentioned in an expression are
878 switch (exp
->type
.node_class
)
881 exp_init_os (exp
->assign
.src
);
885 exp_init_os (exp
->binary
.lhs
);
886 exp_init_os (exp
->binary
.rhs
);
890 exp_init_os (exp
->trinary
.cond
);
891 exp_init_os (exp
->trinary
.lhs
);
892 exp_init_os (exp
->trinary
.rhs
);
896 exp_init_os (exp
->unary
.child
);
900 switch (exp
->type
.node_code
)
906 lang_output_section_statement_type
*os
;
908 os
= lang_output_section_find (exp
->name
.name
);
909 if (os
!= NULL
&& os
->bfd_section
== NULL
)
920 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
921 once into the output. This routine checks each section, and
922 arrange to discard it if a section of the same name has already
923 been linked. If the section has COMDAT information, then it uses
924 that to decide whether the section should be included. This code
925 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
926 that is, it does not depend solely upon the section name.
927 section_already_linked is called via bfd_map_over_sections. */
929 /* This is the shape of the elements inside the already_linked hash
930 table. It maps a name onto a list of already_linked elements with
931 the same name. It's possible to get more than one element in a
932 list if the COMDAT sections have different names. */
934 struct already_linked_hash_entry
936 struct bfd_hash_entry root
;
937 struct already_linked
*entry
;
940 struct already_linked
942 struct already_linked
*next
;
946 /* The hash table. */
948 static struct bfd_hash_table already_linked_table
;
951 section_already_linked (abfd
, sec
, data
)
956 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
959 struct already_linked
*l
;
960 struct already_linked_hash_entry
*already_linked_list
;
962 /* If we are only reading symbols from this object, then we want to
963 discard all sections. */
964 if (entry
->just_syms_flag
)
966 bfd_link_just_syms (sec
, &link_info
);
970 flags
= bfd_get_section_flags (abfd
, sec
);
972 if ((flags
& SEC_LINK_ONCE
) == 0)
975 /* FIXME: When doing a relocatable link, we may have trouble
976 copying relocations in other sections that refer to local symbols
977 in the section being discarded. Those relocations will have to
978 be converted somehow; as of this writing I'm not sure that any of
979 the backends handle that correctly.
981 It is tempting to instead not discard link once sections when
982 doing a relocatable link (technically, they should be discarded
983 whenever we are building constructors). However, that fails,
984 because the linker winds up combining all the link once sections
985 into a single large link once section, which defeats the purpose
986 of having link once sections in the first place.
988 Also, not merging link once sections in a relocatable link
989 causes trouble for MIPS ELF, which relies on link once semantics
990 to handle the .reginfo section correctly. */
992 name
= bfd_get_section_name (abfd
, sec
);
994 already_linked_list
=
995 ((struct already_linked_hash_entry
*)
996 bfd_hash_lookup (&already_linked_table
, name
, true, false));
998 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
1000 if (sec
->comdat
== NULL
1001 || l
->sec
->comdat
== NULL
1002 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
1004 /* The section has already been linked. See if we should
1006 switch (flags
& SEC_LINK_DUPLICATES
)
1011 case SEC_LINK_DUPLICATES_DISCARD
:
1014 case SEC_LINK_DUPLICATES_ONE_ONLY
:
1015 if (sec
->comdat
== NULL
)
1016 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
1019 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
1020 abfd
, name
, sec
->comdat
->name
);
1023 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
1024 /* FIXME: We should really dig out the contents of both
1025 sections and memcmp them. The COFF/PE spec says that
1026 the Microsoft linker does not implement this
1027 correctly, so I'm not going to bother doing it
1030 case SEC_LINK_DUPLICATES_SAME_SIZE
:
1031 if (bfd_section_size (abfd
, sec
)
1032 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1033 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1038 /* Set the output_section field so that lang_add_section
1039 does not create a lang_input_section structure for this
1041 sec
->output_section
= bfd_abs_section_ptr
;
1043 if (flags
& SEC_GROUP
)
1044 bfd_discard_group (abfd
, sec
);
1050 /* This is the first section with this name. Record it. Allocate
1051 the memory from the same obstack as the hash table is kept in. */
1053 l
= ((struct already_linked
*)
1054 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1057 l
->next
= already_linked_list
->entry
;
1058 already_linked_list
->entry
= l
;
1061 /* Support routines for the hash table used by section_already_linked,
1062 initialize the table, fill in an entry and remove the table. */
1064 static struct bfd_hash_entry
*
1065 already_linked_newfunc (entry
, table
, string
)
1066 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1067 struct bfd_hash_table
*table
;
1068 const char *string ATTRIBUTE_UNUSED
;
1070 struct already_linked_hash_entry
*ret
=
1071 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1075 return (struct bfd_hash_entry
*) ret
;
1079 already_linked_table_init ()
1081 if (! bfd_hash_table_init_n (&already_linked_table
,
1082 already_linked_newfunc
,
1084 einfo (_("%P%F: Failed to create hash table\n"));
1088 already_linked_table_free ()
1090 bfd_hash_table_free (&already_linked_table
);
1093 /* The wild routines.
1095 These expand statements like *(.text) and foo.o to a list of
1096 explicit actions, like foo.o(.text), bar.o(.text) and
1097 foo.o(.text, .data). */
1099 /* Return true if the PATTERN argument is a wildcard pattern.
1100 Although backslashes are treated specially if a pattern contains
1101 wildcards, we do not consider the mere presence of a backslash to
1102 be enough to cause the pattern to be treated as a wildcard.
1103 That lets us handle DOS filenames more naturally. */
1107 const char *pattern
;
1111 for (s
= pattern
; *s
!= '\0'; ++s
)
1119 /* Add SECTION to the output section OUTPUT. Do this by creating a
1120 lang_input_section statement which is placed at PTR. FILE is the
1121 input file which holds SECTION. */
1124 lang_add_section (ptr
, section
, output
, file
)
1125 lang_statement_list_type
*ptr
;
1127 lang_output_section_statement_type
*output
;
1128 lang_input_statement_type
*file
;
1133 flags
= bfd_get_section_flags (section
->owner
, section
);
1137 /* If we are doing a final link, discard sections marked with
1139 if (! link_info
.relocateable
1140 && (flags
& SEC_EXCLUDE
) != 0)
1143 /* Discard input sections which are assigned to a section named
1144 DISCARD_SECTION_NAME. */
1145 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1148 /* Discard debugging sections if we are stripping debugging
1150 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1151 && (flags
& SEC_DEBUGGING
) != 0)
1156 if (section
->output_section
== NULL
)
1158 /* This prevents future calls from assigning this section. */
1159 section
->output_section
= bfd_abs_section_ptr
;
1164 if (section
->output_section
== NULL
)
1167 lang_input_section_type
*new;
1170 if (output
->bfd_section
== NULL
)
1173 first
= ! output
->bfd_section
->linker_has_input
;
1174 output
->bfd_section
->linker_has_input
= 1;
1176 /* Add a section reference to the list. */
1177 new = new_stat (lang_input_section
, ptr
);
1179 new->section
= section
;
1181 section
->output_section
= output
->bfd_section
;
1183 flags
= section
->flags
;
1185 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1186 to an output section, because we want to be able to include a
1187 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1188 section (I don't know why we want to do this, but we do).
1189 build_link_order in ldwrite.c handles this case by turning
1190 the embedded SEC_NEVER_LOAD section into a fill. */
1192 flags
&= ~ SEC_NEVER_LOAD
;
1194 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1195 already been processed. One reason to do this is that on pe
1196 format targets, .text$foo sections go into .text and it's odd
1197 to see .text with SEC_LINK_ONCE set. */
1199 if (! link_info
.relocateable
)
1200 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1202 /* If this is not the first input section, and the SEC_READONLY
1203 flag is not currently set, then don't set it just because the
1204 input section has it set. */
1206 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1207 flags
&= ~ SEC_READONLY
;
1209 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1211 && ((section
->output_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1212 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1213 || ((flags
& SEC_MERGE
)
1214 && section
->output_section
->entsize
!= section
->entsize
)))
1216 section
->output_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1217 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1220 /* For now make .tbss normal section. */
1221 if (flags
& SEC_THREAD_LOCAL
)
1224 section
->output_section
->flags
|= flags
;
1226 if (flags
& SEC_MERGE
)
1227 section
->output_section
->entsize
= section
->entsize
;
1229 /* If SEC_READONLY is not set in the input section, then clear
1230 it from the output section. */
1231 if ((section
->flags
& SEC_READONLY
) == 0)
1232 section
->output_section
->flags
&= ~SEC_READONLY
;
1234 switch (output
->sectype
)
1236 case normal_section
:
1241 case overlay_section
:
1242 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1244 case noload_section
:
1245 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1246 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1250 /* Copy over SEC_SMALL_DATA. */
1251 if (section
->flags
& SEC_SMALL_DATA
)
1252 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1254 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1255 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1257 /* If supplied an aligment, then force it. */
1258 if (output
->section_alignment
!= -1)
1259 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1261 if (section
->flags
& SEC_BLOCK
)
1263 section
->output_section
->flags
|= SEC_BLOCK
;
1264 /* FIXME: This value should really be obtained from the bfd... */
1265 output
->block_value
= 128;
1270 /* Handle wildcard sorting. This returns the lang_input_section which
1271 should follow the one we are going to create for SECTION and FILE,
1272 based on the sorting requirements of WILD. It returns NULL if the
1273 new section should just go at the end of the current list. */
1275 static lang_statement_union_type
*
1276 wild_sort (wild
, sec
, file
, section
)
1277 lang_wild_statement_type
*wild
;
1278 struct wildcard_list
*sec
;
1279 lang_input_statement_type
*file
;
1282 const char *section_name
;
1283 lang_statement_union_type
*l
;
1285 if (!wild
->filenames_sorted
&& (sec
== NULL
|| !sec
->spec
.sorted
))
1288 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1289 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
1291 lang_input_section_type
*ls
;
1293 if (l
->header
.type
!= lang_input_section_enum
)
1295 ls
= &l
->input_section
;
1297 /* Sorting by filename takes precedence over sorting by section
1300 if (wild
->filenames_sorted
)
1302 const char *fn
, *ln
;
1306 /* The PE support for the .idata section as generated by
1307 dlltool assumes that files will be sorted by the name of
1308 the archive and then the name of the file within the
1311 if (file
->the_bfd
!= NULL
1312 && bfd_my_archive (file
->the_bfd
) != NULL
)
1314 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1319 fn
= file
->filename
;
1323 if (ls
->ifile
->the_bfd
!= NULL
1324 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1326 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1331 ln
= ls
->ifile
->filename
;
1335 i
= strcmp (fn
, ln
);
1344 fn
= file
->filename
;
1346 ln
= ls
->ifile
->filename
;
1348 i
= strcmp (fn
, ln
);
1356 /* Here either the files are not sorted by name, or we are
1357 looking at the sections for this file. */
1359 if (sec
!= NULL
&& sec
->spec
.sorted
)
1361 if (strcmp (section_name
,
1362 bfd_get_section_name (ls
->ifile
->the_bfd
,
1372 /* Expand a wild statement for a particular FILE. SECTION may be
1373 NULL, in which case it is a wild card. */
1376 output_section_callback (ptr
, sec
, section
, file
, output
)
1377 lang_wild_statement_type
*ptr
;
1378 struct wildcard_list
*sec
;
1380 lang_input_statement_type
*file
;
1383 lang_statement_union_type
*before
;
1385 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1386 if (unique_section_p (bfd_get_section_name (file
->the_bfd
, section
)))
1389 /* If the wild pattern was marked KEEP, the member sections
1390 should be as well. */
1391 if (ptr
->keep_sections
)
1392 section
->flags
|= SEC_KEEP
;
1394 before
= wild_sort (ptr
, sec
, file
, section
);
1396 /* Here BEFORE points to the lang_input_section which
1397 should follow the one we are about to add. If BEFORE
1398 is NULL, then the section should just go at the end
1399 of the current list. */
1402 lang_add_section (&ptr
->children
, section
,
1403 (lang_output_section_statement_type
*) output
,
1407 lang_statement_list_type list
;
1408 lang_statement_union_type
**pp
;
1410 lang_list_init (&list
);
1411 lang_add_section (&list
, section
,
1412 (lang_output_section_statement_type
*) output
,
1415 /* If we are discarding the section, LIST.HEAD will
1417 if (list
.head
!= NULL
)
1419 ASSERT (list
.head
->header
.next
== NULL
);
1421 for (pp
= &ptr
->children
.head
;
1423 pp
= &(*pp
)->header
.next
)
1424 ASSERT (*pp
!= NULL
);
1426 list
.head
->header
.next
= *pp
;
1432 /* This is passed a file name which must have been seen already and
1433 added to the statement tree. We will see if it has been opened
1434 already and had its symbols read. If not then we'll read it. */
1436 static lang_input_statement_type
*
1440 lang_input_statement_type
*search
;
1442 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1443 search
!= (lang_input_statement_type
*) NULL
;
1444 search
= (lang_input_statement_type
*) search
->next_real_file
)
1446 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1448 if (search
->filename
!= (char *) NULL
1449 && name
!= (char *) NULL
1450 && strcmp (search
->filename
, name
) == 0)
1454 if (search
== (lang_input_statement_type
*) NULL
)
1455 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1458 /* If we have already added this file, or this file is not real
1459 (FIXME: can that ever actually happen?) or the name is NULL
1460 (FIXME: can that ever actually happen?) don't add this file. */
1463 || search
->filename
== (const char *) NULL
)
1466 if (! load_symbols (search
, (lang_statement_list_type
*) NULL
))
1472 /* Get the symbols for an input file. */
1475 load_symbols (entry
, place
)
1476 lang_input_statement_type
*entry
;
1477 lang_statement_list_type
*place
;
1484 ldfile_open_file (entry
);
1486 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1487 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1490 lang_statement_list_type
*hold
;
1491 boolean bad_load
= true;
1493 err
= bfd_get_error ();
1495 /* See if the emulation has some special knowledge. */
1496 if (ldemul_unrecognized_file (entry
))
1499 if (err
== bfd_error_file_ambiguously_recognized
)
1503 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1504 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1505 for (p
= matching
; *p
!= NULL
; p
++)
1509 else if (err
!= bfd_error_file_not_recognized
1511 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1515 bfd_close (entry
->the_bfd
);
1516 entry
->the_bfd
= NULL
;
1518 /* Try to interpret the file as a linker script. */
1519 ldfile_open_command_file (entry
->filename
);
1524 ldfile_assumed_script
= true;
1525 parser_input
= input_script
;
1527 ldfile_assumed_script
= false;
1534 if (ldemul_recognized_file (entry
))
1537 /* We don't call ldlang_add_file for an archive. Instead, the
1538 add_symbols entry point will call ldlang_add_file, via the
1539 add_archive_element callback, for each element of the archive
1541 switch (bfd_get_format (entry
->the_bfd
))
1547 ldlang_add_file (entry
);
1548 if (trace_files
|| trace_file_tries
)
1549 info_msg ("%I\n", entry
);
1553 if (entry
->whole_archive
)
1556 boolean loaded
= true;
1560 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
1565 if (! bfd_check_format (member
, bfd_object
))
1567 einfo (_("%F%B: member %B in archive is not an object\n"),
1568 entry
->the_bfd
, member
);
1572 if (! ((*link_info
.callbacks
->add_archive_element
)
1573 (&link_info
, member
, "--whole-archive")))
1576 if (! bfd_link_add_symbols (member
, &link_info
))
1578 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1583 entry
->loaded
= loaded
;
1589 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1590 entry
->loaded
= true;
1592 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1594 return entry
->loaded
;
1597 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1598 may be NULL, indicating that it is a wildcard. Separate
1599 lang_input_section statements are created for each part of the
1600 expansion; they are added after the wild statement S. OUTPUT is
1601 the output section. */
1604 wild (s
, target
, output
)
1605 lang_wild_statement_type
*s
;
1606 const char *target ATTRIBUTE_UNUSED
;
1607 lang_output_section_statement_type
*output
;
1609 struct wildcard_list
*sec
;
1611 walk_wild (s
, output_section_callback
, (PTR
) output
);
1613 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
1615 if (default_common_section
!= NULL
)
1617 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
1619 /* Remember the section that common is going to in case we
1620 later get something which doesn't know where to put it. */
1621 default_common_section
= output
;
1626 /* Return true iff target is the sought target. */
1629 get_target (target
, data
)
1630 const bfd_target
*target
;
1633 const char *sought
= (const char *) data
;
1635 return strcmp (target
->name
, sought
) == 0;
1638 /* Like strcpy() but convert to lower case as well. */
1647 while ((c
= *src
++) != 0)
1648 *dest
++ = TOLOWER (c
);
1653 /* Remove the first occurance of needle (if any) in haystack
1657 strcut (haystack
, needle
)
1661 haystack
= strstr (haystack
, needle
);
1667 for (src
= haystack
+ strlen (needle
); *src
;)
1668 *haystack
++ = *src
++;
1674 /* Compare two target format name strings.
1675 Return a value indicating how "similar" they are. */
1678 name_compare (first
, second
)
1686 copy1
= xmalloc (strlen (first
) + 1);
1687 copy2
= xmalloc (strlen (second
) + 1);
1689 /* Convert the names to lower case. */
1690 stricpy (copy1
, first
);
1691 stricpy (copy2
, second
);
1693 /* Remove and endian strings from the name. */
1694 strcut (copy1
, "big");
1695 strcut (copy1
, "little");
1696 strcut (copy2
, "big");
1697 strcut (copy2
, "little");
1699 /* Return a value based on how many characters match,
1700 starting from the beginning. If both strings are
1701 the same then return 10 * their length. */
1702 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1703 if (copy1
[result
] == 0)
1715 /* Set by closest_target_match() below. */
1716 static const bfd_target
*winner
;
1718 /* Scan all the valid bfd targets looking for one that has the endianness
1719 requirement that was specified on the command line, and is the nearest
1720 match to the original output target. */
1723 closest_target_match (target
, data
)
1724 const bfd_target
*target
;
1727 const bfd_target
*original
= (const bfd_target
*) data
;
1729 if (command_line
.endian
== ENDIAN_BIG
1730 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1733 if (command_line
.endian
== ENDIAN_LITTLE
1734 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1737 /* Must be the same flavour. */
1738 if (target
->flavour
!= original
->flavour
)
1741 /* If we have not found a potential winner yet, then record this one. */
1748 /* Oh dear, we now have two potential candidates for a successful match.
1749 Compare their names and choose the better one. */
1750 if (name_compare (target
->name
, original
->name
)
1751 > name_compare (winner
->name
, original
->name
))
1754 /* Keep on searching until wqe have checked them all. */
1758 /* Return the BFD target format of the first input file. */
1761 get_first_input_target ()
1763 char *target
= NULL
;
1765 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1767 if (s
->header
.type
== lang_input_statement_enum
1770 ldfile_open_file (s
);
1772 if (s
->the_bfd
!= NULL
1773 && bfd_check_format (s
->the_bfd
, bfd_object
))
1775 target
= bfd_get_target (s
->the_bfd
);
1786 /* Open the output file. */
1794 /* Has the user told us which output format to use? */
1795 if (output_target
== (char *) NULL
)
1797 /* No - has the current target been set to something other than
1799 if (current_target
!= default_target
)
1800 output_target
= current_target
;
1802 /* No - can we determine the format of the first input file? */
1805 output_target
= get_first_input_target ();
1807 /* Failed - use the default output target. */
1808 if (output_target
== NULL
)
1809 output_target
= default_target
;
1813 /* Has the user requested a particular endianness on the command
1815 if (command_line
.endian
!= ENDIAN_UNSET
)
1817 const bfd_target
*target
;
1818 enum bfd_endian desired_endian
;
1820 /* Get the chosen target. */
1821 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1823 /* If the target is not supported, we cannot do anything. */
1826 if (command_line
.endian
== ENDIAN_BIG
)
1827 desired_endian
= BFD_ENDIAN_BIG
;
1829 desired_endian
= BFD_ENDIAN_LITTLE
;
1831 /* See if the target has the wrong endianness. This should
1832 not happen if the linker script has provided big and
1833 little endian alternatives, but some scrips don't do
1835 if (target
->byteorder
!= desired_endian
)
1837 /* If it does, then see if the target provides
1838 an alternative with the correct endianness. */
1839 if (target
->alternative_target
!= NULL
1840 && (target
->alternative_target
->byteorder
== desired_endian
))
1841 output_target
= target
->alternative_target
->name
;
1844 /* Try to find a target as similar as possible to
1845 the default target, but which has the desired
1846 endian characteristic. */
1847 (void) bfd_search_for_target (closest_target_match
,
1850 /* Oh dear - we could not find any targets that
1851 satisfy our requirements. */
1853 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1855 output_target
= winner
->name
;
1861 output
= bfd_openw (name
, output_target
);
1863 if (output
== (bfd
*) NULL
)
1865 if (bfd_get_error () == bfd_error_invalid_target
)
1866 einfo (_("%P%F: target %s not found\n"), output_target
);
1868 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1871 delete_output_file_on_failure
= true;
1874 output
->flags
|= D_PAGED
;
1877 if (! bfd_set_format (output
, bfd_object
))
1878 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1879 if (! bfd_set_arch_mach (output
,
1880 ldfile_output_architecture
,
1881 ldfile_output_machine
))
1882 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1884 link_info
.hash
= bfd_link_hash_table_create (output
);
1885 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1886 einfo (_("%P%F: can not create link hash table: %E\n"));
1888 bfd_set_gp_size (output
, g_switch_value
);
1893 ldlang_open_output (statement
)
1894 lang_statement_union_type
*statement
;
1896 switch (statement
->header
.type
)
1898 case lang_output_statement_enum
:
1899 ASSERT (output_bfd
== (bfd
*) NULL
);
1900 output_bfd
= open_output (statement
->output_statement
.name
);
1901 ldemul_set_output_arch ();
1902 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1903 output_bfd
->flags
|= D_PAGED
;
1905 output_bfd
->flags
&= ~D_PAGED
;
1906 if (config
.text_read_only
)
1907 output_bfd
->flags
|= WP_TEXT
;
1909 output_bfd
->flags
&= ~WP_TEXT
;
1910 if (link_info
.traditional_format
)
1911 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1913 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1916 case lang_target_statement_enum
:
1917 current_target
= statement
->target_statement
.target
;
1924 /* Open all the input files. */
1927 open_input_bfds (s
, force
)
1928 lang_statement_union_type
*s
;
1931 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
1933 switch (s
->header
.type
)
1935 case lang_constructors_statement_enum
:
1936 open_input_bfds (constructor_list
.head
, force
);
1938 case lang_output_section_statement_enum
:
1939 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1941 case lang_wild_statement_enum
:
1942 /* Maybe we should load the file's symbols. */
1943 if (s
->wild_statement
.filename
1944 && ! wildcardp (s
->wild_statement
.filename
))
1945 (void) lookup_name (s
->wild_statement
.filename
);
1946 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1948 case lang_group_statement_enum
:
1950 struct bfd_link_hash_entry
*undefs
;
1952 /* We must continually search the entries in the group
1953 until no new symbols are added to the list of undefined
1958 undefs
= link_info
.hash
->undefs_tail
;
1959 open_input_bfds (s
->group_statement
.children
.head
, true);
1961 while (undefs
!= link_info
.hash
->undefs_tail
);
1964 case lang_target_statement_enum
:
1965 current_target
= s
->target_statement
.target
;
1967 case lang_input_statement_enum
:
1968 if (s
->input_statement
.real
)
1970 lang_statement_list_type add
;
1972 s
->input_statement
.target
= current_target
;
1974 /* If we are being called from within a group, and this
1975 is an archive which has already been searched, then
1976 force it to be researched unless the whole archive
1977 has been loaded already. */
1979 && !s
->input_statement
.whole_archive
1980 && s
->input_statement
.loaded
1981 && bfd_check_format (s
->input_statement
.the_bfd
,
1983 s
->input_statement
.loaded
= false;
1985 lang_list_init (&add
);
1987 if (! load_symbols (&s
->input_statement
, &add
))
1988 config
.make_executable
= false;
1990 if (add
.head
!= NULL
)
1992 *add
.tail
= s
->header
.next
;
1993 s
->header
.next
= add
.head
;
2003 /* If there are [COMMONS] statements, put a wild one into the bss
2007 lang_reasonable_defaults ()
2010 lang_output_section_statement_lookup (".text");
2011 lang_output_section_statement_lookup (".data");
2013 default_common_section
= lang_output_section_statement_lookup (".bss");
2015 if (placed_commons
== false)
2017 lang_wild_statement_type
*new =
2018 new_stat (lang_wild_statement
,
2019 &default_common_section
->children
);
2021 new->section_name
= "COMMON";
2022 new->filename
= (char *) NULL
;
2023 lang_list_init (&new->children
);
2028 /* Add the supplied name to the symbol table as an undefined reference.
2029 This is a two step process as the symbol table doesn't even exist at
2030 the time the ld command line is processed. First we put the name
2031 on a list, then, once the output file has been opened, transfer the
2032 name to the symbol table. */
2034 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
2036 #define ldlang_undef_chain_list_head entry_symbol.next
2039 ldlang_add_undef (name
)
2040 const char *const name
;
2042 ldlang_undef_chain_list_type
*new =
2043 ((ldlang_undef_chain_list_type
*)
2044 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
2046 new->next
= ldlang_undef_chain_list_head
;
2047 ldlang_undef_chain_list_head
= new;
2049 new->name
= xstrdup (name
);
2051 if (output_bfd
!= NULL
)
2052 insert_undefined (new->name
);
2055 /* Insert NAME as undefined in the symbol table. */
2058 insert_undefined (name
)
2061 struct bfd_link_hash_entry
*h
;
2063 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, false, true);
2064 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2065 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2066 if (h
->type
== bfd_link_hash_new
)
2068 h
->type
= bfd_link_hash_undefined
;
2069 h
->u
.undef
.abfd
= NULL
;
2070 bfd_link_add_undef (link_info
.hash
, h
);
2074 /* Run through the list of undefineds created above and place them
2075 into the linker hash table as undefined symbols belonging to the
2079 lang_place_undefineds ()
2081 ldlang_undef_chain_list_type
*ptr
;
2083 for (ptr
= ldlang_undef_chain_list_head
;
2084 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
2087 insert_undefined (ptr
->name
);
2091 /* Open input files and attatch to output sections. */
2094 map_input_to_output_sections (s
, target
, output_section_statement
)
2095 lang_statement_union_type
*s
;
2097 lang_output_section_statement_type
*output_section_statement
;
2099 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2101 switch (s
->header
.type
)
2103 case lang_wild_statement_enum
:
2104 wild (&s
->wild_statement
, target
, output_section_statement
);
2106 case lang_constructors_statement_enum
:
2107 map_input_to_output_sections (constructor_list
.head
,
2109 output_section_statement
);
2111 case lang_output_section_statement_enum
:
2112 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2114 &s
->output_section_statement
);
2116 case lang_output_statement_enum
:
2118 case lang_target_statement_enum
:
2119 target
= s
->target_statement
.target
;
2121 case lang_group_statement_enum
:
2122 map_input_to_output_sections (s
->group_statement
.children
.head
,
2124 output_section_statement
);
2126 case lang_fill_statement_enum
:
2127 case lang_input_section_enum
:
2128 case lang_object_symbols_statement_enum
:
2129 case lang_data_statement_enum
:
2130 case lang_reloc_statement_enum
:
2131 case lang_padding_statement_enum
:
2132 case lang_input_statement_enum
:
2133 if (output_section_statement
!= NULL
2134 && output_section_statement
->bfd_section
== NULL
)
2135 init_os (output_section_statement
);
2137 case lang_assignment_statement_enum
:
2138 if (output_section_statement
!= NULL
2139 && output_section_statement
->bfd_section
== NULL
)
2140 init_os (output_section_statement
);
2142 /* Make sure that any sections mentioned in the assignment
2144 exp_init_os (s
->assignment_statement
.exp
);
2146 case lang_afile_asection_pair_statement_enum
:
2149 case lang_address_statement_enum
:
2150 /* Mark the specified section with the supplied address. */
2152 lang_output_section_statement_type
*os
=
2153 lang_output_section_statement_lookup
2154 (s
->address_statement
.section_name
);
2156 if (os
->bfd_section
== NULL
)
2158 os
->addr_tree
= s
->address_statement
.address
;
2165 /* An output section might have been removed after its statement was
2166 added. For example, ldemul_before_allocation can remove dynamic
2167 sections if they turn out to be not needed. Clean them up here. */
2170 strip_excluded_output_sections ()
2172 lang_statement_union_type
*u
;
2174 for (u
= lang_output_section_statement
.head
;
2176 u
= u
->output_section_statement
.next
)
2178 lang_output_section_statement_type
*os
;
2181 os
= &u
->output_section_statement
;
2182 s
= os
->bfd_section
;
2183 if (s
!= NULL
&& (s
->flags
& SEC_EXCLUDE
) != 0)
2187 os
->bfd_section
= NULL
;
2189 for (p
= &output_bfd
->sections
; *p
; p
= &(*p
)->next
)
2192 bfd_section_list_remove (output_bfd
, p
);
2193 output_bfd
->section_count
--;
2201 print_output_section_statement (output_section_statement
)
2202 lang_output_section_statement_type
*output_section_statement
;
2204 asection
*section
= output_section_statement
->bfd_section
;
2207 if (output_section_statement
!= abs_output_section
)
2209 minfo ("\n%s", output_section_statement
->name
);
2211 if (section
!= NULL
)
2213 print_dot
= section
->vma
;
2215 len
= strlen (output_section_statement
->name
);
2216 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2221 while (len
< SECTION_NAME_MAP_LENGTH
)
2227 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2229 if (output_section_statement
->load_base
!= NULL
)
2233 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2234 "load base", lang_final_phase_enum
);
2235 minfo (_(" load address 0x%V"), addr
);
2242 print_statement_list (output_section_statement
->children
.head
,
2243 output_section_statement
);
2247 print_assignment (assignment
, output_section
)
2248 lang_assignment_statement_type
*assignment
;
2249 lang_output_section_statement_type
*output_section
;
2252 etree_value_type result
;
2254 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2257 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2258 lang_final_phase_enum
, print_dot
, &print_dot
);
2264 value
= result
.value
+ result
.section
->bfd_section
->vma
;
2265 dst
= assignment
->exp
->assign
.dst
;
2267 minfo ("0x%V", value
);
2268 if (dst
[0] == '.' && dst
[1] == 0)
2281 exp_print_tree (assignment
->exp
);
2287 print_input_statement (statm
)
2288 lang_input_statement_type
*statm
;
2290 if (statm
->filename
!= (char *) NULL
)
2292 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2296 /* Print all symbols defined in a particular section. This is called
2297 via bfd_link_hash_traverse. */
2300 print_one_symbol (hash_entry
, ptr
)
2301 struct bfd_link_hash_entry
*hash_entry
;
2304 asection
*sec
= (asection
*) ptr
;
2306 if ((hash_entry
->type
== bfd_link_hash_defined
2307 || hash_entry
->type
== bfd_link_hash_defweak
)
2308 && sec
== hash_entry
->u
.def
.section
)
2312 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2315 (hash_entry
->u
.def
.value
2316 + hash_entry
->u
.def
.section
->output_offset
2317 + hash_entry
->u
.def
.section
->output_section
->vma
));
2319 minfo (" %T\n", hash_entry
->root
.string
);
2325 /* Print information about an input section to the map file. */
2328 print_input_section (in
)
2329 lang_input_section_type
*in
;
2331 asection
*i
= in
->section
;
2332 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2333 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2334 ldfile_output_machine
);
2339 minfo ("%s", i
->name
);
2341 if (i
->output_section
!= NULL
)
2345 len
= 1 + strlen (i
->name
);
2346 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2351 while (len
< SECTION_NAME_MAP_LENGTH
)
2357 minfo ("0x%V %W %B\n",
2358 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2361 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2363 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2375 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2378 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2380 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2386 print_fill_statement (fill
)
2387 lang_fill_statement_type
*fill
;
2391 fputs (" FILL mask 0x", config
.map_file
);
2392 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
2393 fprintf (config
.map_file
, "%02x", *p
);
2394 fputs ("\n", config
.map_file
);
2398 print_data_statement (data
)
2399 lang_data_statement_type
*data
;
2405 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2406 ldfile_output_machine
);
2408 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2411 addr
= data
->output_vma
;
2412 if (data
->output_section
!= NULL
)
2413 addr
+= data
->output_section
->vma
;
2441 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2443 if (data
->exp
->type
.node_class
!= etree_value
)
2446 exp_print_tree (data
->exp
);
2451 print_dot
= addr
+ size
/ opb
;
2455 /* Print an address statement. These are generated by options like
2459 print_address_statement (address
)
2460 lang_address_statement_type
*address
;
2462 minfo (_("Address of section %s set to "), address
->section_name
);
2463 exp_print_tree (address
->address
);
2467 /* Print a reloc statement. */
2470 print_reloc_statement (reloc
)
2471 lang_reloc_statement_type
*reloc
;
2476 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2477 ldfile_output_machine
);
2479 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2482 addr
= reloc
->output_vma
;
2483 if (reloc
->output_section
!= NULL
)
2484 addr
+= reloc
->output_section
->vma
;
2486 size
= bfd_get_reloc_size (reloc
->howto
);
2488 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2490 if (reloc
->name
!= NULL
)
2491 minfo ("%s+", reloc
->name
);
2493 minfo ("%s+", reloc
->section
->name
);
2495 exp_print_tree (reloc
->addend_exp
);
2499 print_dot
= addr
+ size
/ opb
;
2503 print_padding_statement (s
)
2504 lang_padding_statement_type
*s
;
2508 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2509 ldfile_output_machine
);
2513 len
= sizeof " *fill*" - 1;
2514 while (len
< SECTION_NAME_MAP_LENGTH
)
2520 addr
= s
->output_offset
;
2521 if (s
->output_section
!= NULL
)
2522 addr
+= s
->output_section
->vma
;
2523 minfo ("0x%V %W ", addr
, s
->size
);
2525 if (s
->fill
->size
!= 0)
2529 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
2530 fprintf (config
.map_file
, "%02x", *p
);
2535 print_dot
= addr
+ s
->size
/ opb
;
2539 print_wild_statement (w
, os
)
2540 lang_wild_statement_type
*w
;
2541 lang_output_section_statement_type
*os
;
2543 struct wildcard_list
*sec
;
2547 if (w
->filenames_sorted
)
2549 if (w
->filename
!= NULL
)
2550 minfo ("%s", w
->filename
);
2553 if (w
->filenames_sorted
)
2557 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
2559 if (sec
->spec
.sorted
)
2561 if (sec
->spec
.exclude_name_list
!= NULL
)
2564 minfo ("EXCLUDE_FILE ( %s", sec
->spec
.exclude_name_list
->name
);
2565 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
2566 minfo (", %s", tmp
->name
);
2569 if (sec
->spec
.name
!= NULL
)
2570 minfo ("%s", sec
->spec
.name
);
2573 if (sec
->spec
.sorted
)
2580 print_statement_list (w
->children
.head
, os
);
2583 /* Print a group statement. */
2587 lang_group_statement_type
*s
;
2588 lang_output_section_statement_type
*os
;
2590 fprintf (config
.map_file
, "START GROUP\n");
2591 print_statement_list (s
->children
.head
, os
);
2592 fprintf (config
.map_file
, "END GROUP\n");
2595 /* Print the list of statements in S.
2596 This can be called for any statement type. */
2599 print_statement_list (s
, os
)
2600 lang_statement_union_type
*s
;
2601 lang_output_section_statement_type
*os
;
2605 print_statement (s
, os
);
2610 /* Print the first statement in statement list S.
2611 This can be called for any statement type. */
2614 print_statement (s
, os
)
2615 lang_statement_union_type
*s
;
2616 lang_output_section_statement_type
*os
;
2618 switch (s
->header
.type
)
2621 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2624 case lang_constructors_statement_enum
:
2625 if (constructor_list
.head
!= NULL
)
2627 if (constructors_sorted
)
2628 minfo (" SORT (CONSTRUCTORS)\n");
2630 minfo (" CONSTRUCTORS\n");
2631 print_statement_list (constructor_list
.head
, os
);
2634 case lang_wild_statement_enum
:
2635 print_wild_statement (&s
->wild_statement
, os
);
2637 case lang_address_statement_enum
:
2638 print_address_statement (&s
->address_statement
);
2640 case lang_object_symbols_statement_enum
:
2641 minfo (" CREATE_OBJECT_SYMBOLS\n");
2643 case lang_fill_statement_enum
:
2644 print_fill_statement (&s
->fill_statement
);
2646 case lang_data_statement_enum
:
2647 print_data_statement (&s
->data_statement
);
2649 case lang_reloc_statement_enum
:
2650 print_reloc_statement (&s
->reloc_statement
);
2652 case lang_input_section_enum
:
2653 print_input_section (&s
->input_section
);
2655 case lang_padding_statement_enum
:
2656 print_padding_statement (&s
->padding_statement
);
2658 case lang_output_section_statement_enum
:
2659 print_output_section_statement (&s
->output_section_statement
);
2661 case lang_assignment_statement_enum
:
2662 print_assignment (&s
->assignment_statement
, os
);
2664 case lang_target_statement_enum
:
2665 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2667 case lang_output_statement_enum
:
2668 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2669 if (output_target
!= NULL
)
2670 minfo (" %s", output_target
);
2673 case lang_input_statement_enum
:
2674 print_input_statement (&s
->input_statement
);
2676 case lang_group_statement_enum
:
2677 print_group (&s
->group_statement
, os
);
2679 case lang_afile_asection_pair_statement_enum
:
2688 print_statement_list (statement_list
.head
, abs_output_section
);
2691 /* Print the first N statements in statement list S to STDERR.
2692 If N == 0, nothing is printed.
2693 If N < 0, the entire list is printed.
2694 Intended to be called from GDB. */
2697 dprint_statement (s
, n
)
2698 lang_statement_union_type
*s
;
2701 FILE *map_save
= config
.map_file
;
2703 config
.map_file
= stderr
;
2706 print_statement_list (s
, abs_output_section
);
2709 while (s
&& --n
>= 0)
2711 print_statement (s
, abs_output_section
);
2716 config
.map_file
= map_save
;
2720 insert_pad (ptr
, fill
, alignment_needed
, output_section
, dot
)
2721 lang_statement_union_type
**ptr
;
2723 unsigned int alignment_needed
;
2724 asection
*output_section
;
2727 static fill_type zero_fill
= { 1, { 0 } };
2728 lang_statement_union_type
*pad
;
2730 pad
= ((lang_statement_union_type
*)
2731 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
2732 if (ptr
!= &statement_list
.head
2733 && pad
->header
.type
== lang_padding_statement_enum
2734 && pad
->padding_statement
.output_section
== output_section
)
2736 /* Use the existing pad statement. The above test on output
2737 section is probably redundant, but it doesn't hurt to check. */
2741 /* Make a new padding statement, linked into existing chain. */
2742 pad
= ((lang_statement_union_type
*)
2743 stat_alloc (sizeof (lang_padding_statement_type
)));
2744 pad
->header
.next
= *ptr
;
2746 pad
->header
.type
= lang_padding_statement_enum
;
2747 pad
->padding_statement
.output_section
= output_section
;
2748 if (fill
== (fill_type
*) 0)
2750 pad
->padding_statement
.fill
= fill
;
2752 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
2753 pad
->padding_statement
.size
= alignment_needed
;
2754 output_section
->_raw_size
+= alignment_needed
;
2757 /* Work out how much this section will move the dot point. */
2760 size_input_section (this_ptr
, output_section_statement
, fill
, dot
)
2761 lang_statement_union_type
**this_ptr
;
2762 lang_output_section_statement_type
*output_section_statement
;
2766 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2767 asection
*i
= is
->section
;
2769 if (is
->ifile
->just_syms_flag
== false)
2771 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2772 ldfile_output_machine
);
2773 unsigned int alignment_needed
;
2776 /* Align this section first to the input sections requirement,
2777 then to the output section's requirement. If this alignment
2778 is greater than any seen before, then record it too. Perform
2779 the alignment by inserting a magic 'padding' statement. */
2781 if (output_section_statement
->subsection_alignment
!= -1)
2782 i
->alignment_power
= output_section_statement
->subsection_alignment
;
2784 o
= output_section_statement
->bfd_section
;
2785 if (o
->alignment_power
< i
->alignment_power
)
2786 o
->alignment_power
= i
->alignment_power
;
2788 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
2790 if (alignment_needed
!= 0)
2792 insert_pad (this_ptr
, fill
, alignment_needed
* opb
, o
, dot
);
2793 dot
+= alignment_needed
;
2796 /* Remember where in the output section this input section goes. */
2798 i
->output_offset
= dot
- o
->vma
;
2800 /* Mark how big the output section must be to contain this now. */
2801 if (i
->_cooked_size
!= 0)
2802 dot
+= i
->_cooked_size
/ opb
;
2804 dot
+= i
->_raw_size
/ opb
;
2805 o
->_raw_size
= (dot
- o
->vma
) * opb
;
2809 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2815 #define IGNORE_SECTION(bfd, s) \
2816 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2817 != (SEC_ALLOC | SEC_LOAD)) \
2818 || bfd_section_size (bfd, s) == 0)
2820 /* Check to see if any allocated sections overlap with other allocated
2821 sections. This can happen when the linker script specifically specifies
2822 the output section addresses of the two sections. */
2825 lang_check_section_addresses ()
2828 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2830 /* Scan all sections in the output list. */
2831 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2835 /* Ignore sections which are not loaded or which have no contents. */
2836 if (IGNORE_SECTION (output_bfd
, s
))
2839 /* Once we reach section 's' stop our seach. This prevents two
2840 warning messages from being produced, one for 'section A overlaps
2841 section B' and one for 'section B overlaps section A'. */
2842 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2849 /* Only consider loadable sections with real contents. */
2850 if (IGNORE_SECTION (output_bfd
, os
))
2853 /* We must check the sections' LMA addresses not their
2854 VMA addresses because overlay sections can have
2855 overlapping VMAs but they must have distinct LMAs. */
2856 s_start
= bfd_section_lma (output_bfd
, s
);
2857 os_start
= bfd_section_lma (output_bfd
, os
);
2858 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2859 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2861 /* Look for an overlap. */
2862 if ((s_end
< os_start
) || (s_start
> os_end
))
2866 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2867 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2869 /* Once we have found one overlap for this section,
2870 stop looking for others. */
2876 /* Make sure the new address is within the region. We explicitly permit the
2877 current address to be at the exact end of the region when the address is
2878 non-zero, in case the region is at the end of addressable memory and the
2879 calculation wraps around. */
2882 os_region_check (os
, region
, tree
, base
)
2883 lang_output_section_statement_type
*os
;
2884 struct memory_region_struct
*region
;
2888 if ((region
->current
< region
->origin
2889 || (region
->current
- region
->origin
> region
->length
))
2890 && ((region
->current
!= region
->origin
+ region
->length
)
2893 if (tree
!= (etree_type
*) NULL
)
2895 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2897 os
->bfd_section
->owner
,
2898 os
->bfd_section
->name
,
2903 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2905 os
->bfd_section
->owner
,
2906 os
->bfd_section
->name
);
2908 /* Reset the region pointer. */
2909 region
->current
= region
->origin
;
2913 /* Set the sizes for all the output sections. */
2916 lang_size_sections_1 (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2917 lang_statement_union_type
*s
;
2918 lang_output_section_statement_type
*output_section_statement
;
2919 lang_statement_union_type
**prev
;
2924 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2925 ldfile_output_machine
);
2927 /* Size up the sections from their constituent parts. */
2928 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2930 switch (s
->header
.type
)
2932 case lang_output_section_statement_enum
:
2935 lang_output_section_statement_type
*os
;
2937 os
= &s
->output_section_statement
;
2938 if (os
->bfd_section
== NULL
)
2939 /* This section was never actually created. */
2942 /* If this is a COFF shared library section, use the size and
2943 address from the input section. FIXME: This is COFF
2944 specific; it would be cleaner if there were some other way
2945 to do this, but nothing simple comes to mind. */
2946 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2950 if (os
->children
.head
== NULL
2951 || os
->children
.head
->header
.next
!= NULL
2952 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2953 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2956 input
= os
->children
.head
->input_section
.section
;
2957 bfd_set_section_vma (os
->bfd_section
->owner
,
2959 bfd_section_vma (input
->owner
, input
));
2960 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2964 if (bfd_is_abs_section (os
->bfd_section
))
2966 /* No matter what happens, an abs section starts at zero. */
2967 ASSERT (os
->bfd_section
->vma
== 0);
2971 if (os
->addr_tree
== (etree_type
*) NULL
)
2973 /* No address specified for this section, get one
2974 from the region specification. */
2975 if (os
->region
== (lang_memory_region_type
*) NULL
2976 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2977 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2978 && os
->region
->name
[0] == '*'
2979 && strcmp (os
->region
->name
, "*default*") == 0))
2981 os
->region
= lang_memory_default (os
->bfd_section
);
2984 /* If a loadable section is using the default memory
2985 region, and some non default memory regions were
2986 defined, issue a warning. */
2987 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2988 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2989 && (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2990 & SEC_NEVER_LOAD
) == 0
2991 && ! link_info
.relocateable
2992 && strcmp (os
->region
->name
, "*default*") == 0
2993 && lang_memory_region_list
!= NULL
2994 && (strcmp (lang_memory_region_list
->name
,
2996 || lang_memory_region_list
->next
!= NULL
))
2997 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2998 bfd_get_section_name (output_bfd
,
3001 dot
= os
->region
->current
;
3003 if (os
->section_alignment
== -1)
3008 dot
= align_power (dot
,
3009 os
->bfd_section
->alignment_power
);
3011 if (dot
!= olddot
&& config
.warn_section_align
)
3012 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
3013 os
->name
, (unsigned int) (dot
- olddot
));
3020 r
= exp_fold_tree (os
->addr_tree
,
3022 lang_allocating_phase_enum
,
3024 if (r
.valid_p
== false)
3026 einfo (_("%F%S: non constant address expression for section %s\n"),
3029 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
3032 /* The section starts here.
3033 First, align to what the section needs. */
3035 if (os
->section_alignment
!= -1)
3036 dot
= align_power (dot
, os
->section_alignment
);
3038 bfd_set_section_vma (0, os
->bfd_section
, dot
);
3040 os
->bfd_section
->output_offset
= 0;
3043 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
3044 os
->fill
, dot
, relax
);
3046 /* Put the section within the requested block size, or
3047 align at the block boundary. */
3048 after
= ALIGN_N (os
->bfd_section
->vma
3049 + os
->bfd_section
->_raw_size
/ opb
,
3050 /* The coercion here is important, see ld.h. */
3051 (bfd_vma
) os
->block_value
);
3053 if (bfd_is_abs_section (os
->bfd_section
))
3054 ASSERT (after
== os
->bfd_section
->vma
);
3055 else if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) == 0
3056 && (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
))
3057 os
->bfd_section
->_raw_size
= 0;
3059 os
->bfd_section
->_raw_size
=
3060 (after
- os
->bfd_section
->vma
) * opb
;
3062 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3063 os
->processed
= true;
3065 if (os
->update_dot_tree
!= 0)
3066 exp_fold_tree (os
->update_dot_tree
, abs_output_section
,
3067 lang_allocating_phase_enum
, dot
, &dot
);
3069 /* Update dot in the region ?
3070 We only do this if the section is going to be allocated,
3071 since unallocated sections do not contribute to the region's
3072 overall size in memory.
3074 If the SEC_NEVER_LOAD bit is not set, it will affect the
3075 addresses of sections after it. We have to update
3077 if (os
->region
!= (lang_memory_region_type
*) NULL
3078 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3079 & SEC_NEVER_LOAD
) == 0
3080 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3081 & (SEC_ALLOC
| SEC_LOAD
))))
3083 os
->region
->current
= dot
;
3085 /* Make sure the new address is within the region. */
3086 os_region_check (os
, os
->region
, os
->addr_tree
,
3087 os
->bfd_section
->vma
);
3089 /* If there's no load address specified, use the run
3090 region as the load region. */
3091 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
3092 os
->lma_region
= os
->region
;
3094 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
)
3096 /* Set load_base, which will be handled later. */
3097 os
->load_base
= exp_intop (os
->lma_region
->current
);
3098 os
->lma_region
->current
+=
3099 os
->bfd_section
->_raw_size
/ opb
;
3100 os_region_check (os
, os
->lma_region
, NULL
,
3101 os
->bfd_section
->lma
);
3107 case lang_constructors_statement_enum
:
3108 dot
= lang_size_sections_1 (constructor_list
.head
,
3109 output_section_statement
,
3110 &s
->wild_statement
.children
.head
,
3114 case lang_data_statement_enum
:
3116 unsigned int size
= 0;
3118 s
->data_statement
.output_vma
=
3119 dot
- output_section_statement
->bfd_section
->vma
;
3120 s
->data_statement
.output_section
=
3121 output_section_statement
->bfd_section
;
3123 switch (s
->data_statement
.type
)
3144 output_section_statement
->bfd_section
->_raw_size
+= size
;
3145 /* The output section gets contents, and then we inspect for
3146 any flags set in the input script which override any ALLOC. */
3147 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3148 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3150 output_section_statement
->bfd_section
->flags
|=
3151 SEC_ALLOC
| SEC_LOAD
;
3156 case lang_reloc_statement_enum
:
3160 s
->reloc_statement
.output_vma
=
3161 dot
- output_section_statement
->bfd_section
->vma
;
3162 s
->reloc_statement
.output_section
=
3163 output_section_statement
->bfd_section
;
3164 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3166 output_section_statement
->bfd_section
->_raw_size
+= size
;
3170 case lang_wild_statement_enum
:
3172 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
3173 output_section_statement
,
3174 &s
->wild_statement
.children
.head
,
3179 case lang_object_symbols_statement_enum
:
3180 link_info
.create_object_symbols_section
=
3181 output_section_statement
->bfd_section
;
3183 case lang_output_statement_enum
:
3184 case lang_target_statement_enum
:
3186 case lang_input_section_enum
:
3190 i
= (*prev
)->input_section
.section
;
3193 if (i
->_cooked_size
== 0)
3194 i
->_cooked_size
= i
->_raw_size
;
3200 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3201 einfo (_("%P%F: can't relax section: %E\n"));
3205 dot
= size_input_section (prev
, output_section_statement
,
3206 output_section_statement
->fill
, dot
);
3209 case lang_input_statement_enum
:
3211 case lang_fill_statement_enum
:
3212 s
->fill_statement
.output_section
=
3213 output_section_statement
->bfd_section
;
3215 fill
= s
->fill_statement
.fill
;
3217 case lang_assignment_statement_enum
:
3219 bfd_vma newdot
= dot
;
3221 exp_fold_tree (s
->assignment_statement
.exp
,
3222 output_section_statement
,
3223 lang_allocating_phase_enum
,
3229 if (output_section_statement
== abs_output_section
)
3231 /* If we don't have an output section, then just adjust
3232 the default memory address. */
3233 lang_memory_region_lookup ("*default*")->current
= newdot
;
3237 /* Insert a pad after this statement. We can't
3238 put the pad before when relaxing, in case the
3239 assignment references dot. */
3240 insert_pad (&s
->header
.next
, fill
, (newdot
- dot
) * opb
,
3241 output_section_statement
->bfd_section
, dot
);
3243 /* Don't neuter the pad below when relaxing. */
3252 case lang_padding_statement_enum
:
3253 /* If this is the first time lang_size_sections is called,
3254 we won't have any padding statements. If this is the
3255 second or later passes when relaxing, we should allow
3256 padding to shrink. If padding is needed on this pass, it
3257 will be added back in. */
3258 s
->padding_statement
.size
= 0;
3260 /* Make sure output_offset is valid. If relaxation shrinks
3261 the section and this pad isn't needed, it's possible to
3262 have output_offset larger than the final size of the
3263 section. bfd_set_section_contents will complain even for
3264 a pad size of zero. */
3265 s
->padding_statement
.output_offset
3266 = dot
- output_section_statement
->bfd_section
->vma
;
3269 case lang_group_statement_enum
:
3270 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
3271 output_section_statement
,
3272 &s
->group_statement
.children
.head
,
3280 /* We can only get here when relaxing is turned on. */
3281 case lang_address_statement_enum
:
3284 prev
= &s
->header
.next
;
3290 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
3291 lang_statement_union_type
*s
;
3292 lang_output_section_statement_type
*output_section_statement
;
3293 lang_statement_union_type
**prev
;
3300 exp_data_seg
.phase
= exp_dataseg_none
;
3301 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
3303 if (exp_data_seg
.phase
== exp_dataseg_end_seen
)
3305 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3306 a page could be saved in the data segment. */
3307 bfd_vma first
, last
;
3309 first
= -exp_data_seg
.base
& (exp_data_seg
.pagesize
- 1);
3310 last
= exp_data_seg
.end
& (exp_data_seg
.pagesize
- 1);
3312 && ((exp_data_seg
.base
& ~(exp_data_seg
.pagesize
- 1))
3313 != (exp_data_seg
.end
& ~(exp_data_seg
.pagesize
- 1)))
3314 && first
+ last
<= exp_data_seg
.pagesize
)
3316 exp_data_seg
.phase
= exp_dataseg_adjust
;
3317 result
= lang_size_sections_1 (s
, output_section_statement
, prev
,
3326 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3327 lang_statement_union_type
*s
;
3328 lang_output_section_statement_type
*output_section_statement
;
3332 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3333 ldfile_output_machine
);
3335 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3337 switch (s
->header
.type
)
3339 case lang_constructors_statement_enum
:
3340 dot
= lang_do_assignments (constructor_list
.head
,
3341 output_section_statement
,
3346 case lang_output_section_statement_enum
:
3348 lang_output_section_statement_type
*os
;
3350 os
= &(s
->output_section_statement
);
3351 if (os
->bfd_section
!= NULL
)
3353 dot
= os
->bfd_section
->vma
;
3354 (void) lang_do_assignments (os
->children
.head
, os
,
3356 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3361 /* If nothing has been placed into the output section then
3362 it won't have a bfd_section. */
3363 if (os
->bfd_section
)
3365 os
->bfd_section
->lma
3366 = exp_get_abs_int (os
->load_base
, 0, "load base",
3367 lang_final_phase_enum
);
3372 case lang_wild_statement_enum
:
3374 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3375 output_section_statement
,
3380 case lang_object_symbols_statement_enum
:
3381 case lang_output_statement_enum
:
3382 case lang_target_statement_enum
:
3384 case lang_common_statement_enum
:
3387 case lang_data_statement_enum
:
3389 etree_value_type value
;
3391 value
= exp_fold_tree (s
->data_statement
.exp
,
3393 lang_final_phase_enum
, dot
, &dot
);
3394 s
->data_statement
.value
= value
.value
;
3395 if (value
.valid_p
== false)
3396 einfo (_("%F%P: invalid data statement\n"));
3400 switch (s
->data_statement
.type
)
3424 case lang_reloc_statement_enum
:
3426 etree_value_type value
;
3428 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3430 lang_final_phase_enum
, dot
, &dot
);
3431 s
->reloc_statement
.addend_value
= value
.value
;
3432 if (value
.valid_p
== false)
3433 einfo (_("%F%P: invalid reloc statement\n"));
3435 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3438 case lang_input_section_enum
:
3440 asection
*in
= s
->input_section
.section
;
3442 if (in
->_cooked_size
!= 0)
3443 dot
+= in
->_cooked_size
/ opb
;
3445 dot
+= in
->_raw_size
/ opb
;
3449 case lang_input_statement_enum
:
3451 case lang_fill_statement_enum
:
3452 fill
= s
->fill_statement
.fill
;
3454 case lang_assignment_statement_enum
:
3456 exp_fold_tree (s
->assignment_statement
.exp
,
3457 output_section_statement
,
3458 lang_final_phase_enum
,
3464 case lang_padding_statement_enum
:
3465 dot
+= s
->padding_statement
.size
/ opb
;
3468 case lang_group_statement_enum
:
3469 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3470 output_section_statement
,
3478 case lang_address_statement_enum
:
3486 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3487 operator .startof. (section_name), it produces an undefined symbol
3488 .startof.section_name. Similarly, when it sees
3489 .sizeof. (section_name), it produces an undefined symbol
3490 .sizeof.section_name. For all the output sections, we look for
3491 such symbols, and set them to the correct value. */
3498 if (link_info
.relocateable
)
3501 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3503 const char *secname
;
3505 struct bfd_link_hash_entry
*h
;
3507 secname
= bfd_get_section_name (output_bfd
, s
);
3508 buf
= xmalloc (10 + strlen (secname
));
3510 sprintf (buf
, ".startof.%s", secname
);
3511 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3512 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3514 h
->type
= bfd_link_hash_defined
;
3515 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3516 h
->u
.def
.section
= bfd_abs_section_ptr
;
3519 sprintf (buf
, ".sizeof.%s", secname
);
3520 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3521 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3525 opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3526 ldfile_output_machine
);
3527 h
->type
= bfd_link_hash_defined
;
3528 if (s
->_cooked_size
!= 0)
3529 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3531 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3532 h
->u
.def
.section
= bfd_abs_section_ptr
;
3542 struct bfd_link_hash_entry
*h
;
3545 if (link_info
.relocateable
|| link_info
.shared
)
3550 if (entry_symbol
.name
== (const char *) NULL
)
3552 /* No entry has been specified. Look for start, but don't warn
3553 if we don't find it. */
3554 entry_symbol
.name
= "start";
3558 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
3559 false, false, true);
3560 if (h
!= (struct bfd_link_hash_entry
*) NULL
3561 && (h
->type
== bfd_link_hash_defined
3562 || h
->type
== bfd_link_hash_defweak
)
3563 && h
->u
.def
.section
->output_section
!= NULL
)
3567 val
= (h
->u
.def
.value
3568 + bfd_get_section_vma (output_bfd
,
3569 h
->u
.def
.section
->output_section
)
3570 + h
->u
.def
.section
->output_offset
);
3571 if (! bfd_set_start_address (output_bfd
, val
))
3572 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
3579 /* We couldn't find the entry symbol. Try parsing it as a
3581 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
3584 if (! bfd_set_start_address (output_bfd
, val
))
3585 einfo (_("%P%F: can't set start address\n"));
3591 /* Can't find the entry symbol, and it's not a number. Use
3592 the first address in the text section. */
3593 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
3594 if (ts
!= (asection
*) NULL
)
3597 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3599 bfd_get_section_vma (output_bfd
, ts
));
3600 if (! bfd_set_start_address (output_bfd
,
3601 bfd_get_section_vma (output_bfd
,
3603 einfo (_("%P%F: can't set start address\n"));
3608 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3615 /* This is a small function used when we want to ignore errors from
3619 #ifdef ANSI_PROTOTYPES
3620 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3622 ignore_bfd_errors (s
)
3623 const char *s ATTRIBUTE_UNUSED
;
3626 /* Don't do anything. */
3629 /* Check that the architecture of all the input files is compatible
3630 with the output file. Also call the backend to let it do any
3631 other checking that is needed. */
3636 lang_statement_union_type
*file
;
3638 const bfd_arch_info_type
*compatible
;
3640 for (file
= file_chain
.head
;
3641 file
!= (lang_statement_union_type
*) NULL
;
3642 file
= file
->input_statement
.next
)
3644 input_bfd
= file
->input_statement
.the_bfd
;
3645 compatible
= bfd_arch_get_compatible (input_bfd
, output_bfd
);
3647 /* In general it is not possible to perform a relocatable
3648 link between differing object formats when the input
3649 file has relocations, because the relocations in the
3650 input format may not have equivalent representations in
3651 the output format (and besides BFD does not translate
3652 relocs for other link purposes than a final link). */
3653 if ((link_info
.relocateable
|| link_info
.emitrelocations
)
3654 && (compatible
== NULL
3655 || bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
3656 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
3658 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3659 bfd_get_target (input_bfd
), input_bfd
,
3660 bfd_get_target (output_bfd
), output_bfd
);
3661 /* einfo with %F exits. */
3664 if (compatible
== NULL
)
3666 if (command_line
.warn_mismatch
)
3667 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3668 bfd_printable_name (input_bfd
), input_bfd
,
3669 bfd_printable_name (output_bfd
));
3671 else if (bfd_count_sections (input_bfd
))
3673 /* If the input bfd has no contents, it shouldn't set the
3674 private data of the output bfd. */
3676 bfd_error_handler_type pfn
= NULL
;
3678 /* If we aren't supposed to warn about mismatched input
3679 files, temporarily set the BFD error handler to a
3680 function which will do nothing. We still want to call
3681 bfd_merge_private_bfd_data, since it may set up
3682 information which is needed in the output file. */
3683 if (! command_line
.warn_mismatch
)
3684 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3685 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3687 if (command_line
.warn_mismatch
)
3688 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3691 if (! command_line
.warn_mismatch
)
3692 bfd_set_error_handler (pfn
);
3697 /* Look through all the global common symbols and attach them to the
3698 correct section. The -sort-common command line switch may be used
3699 to roughly sort the entries by size. */
3704 if (command_line
.inhibit_common_definition
)
3706 if (link_info
.relocateable
3707 && ! command_line
.force_common_definition
)
3710 if (! config
.sort_common
)
3711 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3716 for (power
= 4; power
>= 0; power
--)
3717 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3722 /* Place one common symbol in the correct section. */
3725 lang_one_common (h
, info
)
3726 struct bfd_link_hash_entry
*h
;
3729 unsigned int power_of_two
;
3732 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3733 ldfile_output_machine
);
3735 if (h
->type
!= bfd_link_hash_common
)
3739 power_of_two
= h
->u
.c
.p
->alignment_power
;
3741 if (config
.sort_common
3742 && power_of_two
< (unsigned int) *(int *) info
)
3745 section
= h
->u
.c
.p
->section
;
3747 /* Increase the size of the section. */
3748 section
->_cooked_size
= ALIGN_N ((section
->_cooked_size
+ opb
- 1) / opb
,
3749 (bfd_size_type
) (1 << power_of_two
)) * opb
;
3751 /* Adjust the alignment if necessary. */
3752 if (power_of_two
> section
->alignment_power
)
3753 section
->alignment_power
= power_of_two
;
3755 /* Change the symbol from common to defined. */
3756 h
->type
= bfd_link_hash_defined
;
3757 h
->u
.def
.section
= section
;
3758 h
->u
.def
.value
= section
->_cooked_size
;
3760 /* Increase the size of the section. */
3761 section
->_cooked_size
+= size
;
3763 /* Make sure the section is allocated in memory, and make sure that
3764 it is no longer a common section. */
3765 section
->flags
|= SEC_ALLOC
;
3766 section
->flags
&= ~SEC_IS_COMMON
;
3768 if (config
.map_file
!= NULL
)
3770 static boolean header_printed
;
3775 if (! header_printed
)
3777 minfo (_("\nAllocating common symbols\n"));
3778 minfo (_("Common symbol size file\n\n"));
3779 header_printed
= true;
3782 name
= demangle (h
->root
.string
);
3784 len
= strlen (name
);
3799 if (size
<= 0xffffffff)
3800 sprintf (buf
, "%lx", (unsigned long) size
);
3802 sprintf_vma (buf
, size
);
3812 minfo ("%B\n", section
->owner
);
3818 /* Run through the input files and ensure that every input section has
3819 somewhere to go. If one is found without a destination then create
3820 an input request and place it into the statement tree. */
3823 lang_place_orphans ()
3825 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3829 for (s
= file
->the_bfd
->sections
;
3830 s
!= (asection
*) NULL
;
3833 if (s
->output_section
== (asection
*) NULL
)
3835 /* This section of the file is not attatched, root
3836 around for a sensible place for it to go. */
3838 if (file
->just_syms_flag
)
3842 else if (strcmp (s
->name
, "COMMON") == 0)
3844 /* This is a lonely common section which must have
3845 come from an archive. We attach to the section
3846 with the wildcard. */
3847 if (! link_info
.relocateable
3848 || command_line
.force_common_definition
)
3850 if (default_common_section
== NULL
)
3853 /* This message happens when using the
3854 svr3.ifile linker script, so I have
3856 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3858 default_common_section
=
3859 lang_output_section_statement_lookup (".bss");
3862 lang_add_section (&default_common_section
->children
, s
,
3863 default_common_section
, file
);
3866 else if (ldemul_place_orphan (file
, s
))
3870 lang_output_section_statement_type
*os
;
3872 os
= lang_output_section_statement_lookup (s
->name
);
3873 lang_add_section (&os
->children
, s
, os
, file
);
3881 lang_set_flags (ptr
, flags
, invert
)
3882 lang_memory_region_type
*ptr
;
3886 flagword
*ptr_flags
;
3888 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3894 *ptr_flags
|= SEC_ALLOC
;
3898 *ptr_flags
|= SEC_READONLY
;
3902 *ptr_flags
|= SEC_DATA
;
3906 *ptr_flags
|= SEC_CODE
;
3911 *ptr_flags
|= SEC_LOAD
;
3915 einfo (_("%P%F: invalid syntax in flags\n"));
3922 /* Call a function on each input file. This function will be called
3923 on an archive, but not on the elements. */
3926 lang_for_each_input_file (func
)
3927 void (*func
) PARAMS ((lang_input_statement_type
*));
3929 lang_input_statement_type
*f
;
3931 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3933 f
= (lang_input_statement_type
*) f
->next_real_file
)
3937 /* Call a function on each file. The function will be called on all
3938 the elements of an archive which are included in the link, but will
3939 not be called on the archive file itself. */
3942 lang_for_each_file (func
)
3943 void (*func
) PARAMS ((lang_input_statement_type
*));
3945 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3956 lang_for_each_input_section (func
)
3957 void (*func
) PARAMS ((bfd
*ab
, asection
*as
));
3959 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3963 for (s
= f
->the_bfd
->sections
;
3964 s
!= (asection
*) NULL
;
3967 func (f
->the_bfd
, s
);
3975 ldlang_add_file (entry
)
3976 lang_input_statement_type
*entry
;
3980 lang_statement_append (&file_chain
,
3981 (lang_statement_union_type
*) entry
,
3984 /* The BFD linker needs to have a list of all input BFDs involved in
3986 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3987 ASSERT (entry
->the_bfd
!= output_bfd
);
3988 for (pp
= &link_info
.input_bfds
;
3989 *pp
!= (bfd
*) NULL
;
3990 pp
= &(*pp
)->link_next
)
3992 *pp
= entry
->the_bfd
;
3993 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3994 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3996 /* Look through the sections and check for any which should not be
3997 included in the link. We need to do this now, so that we can
3998 notice when the backend linker tries to report multiple
3999 definition errors for symbols which are in sections we aren't
4000 going to link. FIXME: It might be better to entirely ignore
4001 symbols which are defined in sections which are going to be
4002 discarded. This would require modifying the backend linker for
4003 each backend which might set the SEC_LINK_ONCE flag. If we do
4004 this, we should probably handle SEC_EXCLUDE in the same way. */
4006 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
4010 lang_add_output (name
, from_script
)
4014 /* Make -o on command line override OUTPUT in script. */
4015 if (had_output_filename
== false || !from_script
)
4017 output_filename
= name
;
4018 had_output_filename
= true;
4022 static lang_output_section_statement_type
*current_section
;
4034 for (l
= 0; l
< 32; l
++)
4036 if (i
>= (unsigned int) x
)
4044 lang_output_section_statement_type
*
4045 lang_enter_output_section_statement (output_section_statement_name
,
4046 address_exp
, sectype
, block_value
,
4047 align
, subalign
, ebase
)
4048 const char *output_section_statement_name
;
4049 etree_type
*address_exp
;
4050 enum section_type sectype
;
4051 bfd_vma block_value
;
4053 etree_type
*subalign
;
4056 lang_output_section_statement_type
*os
;
4060 lang_output_section_statement_lookup (output_section_statement_name
);
4062 /* Add this statement to tree. */
4064 add_statement (lang_output_section_statement_enum
,
4065 output_section_statement
);
4067 /* Make next things chain into subchain of this. */
4069 if (os
->addr_tree
== (etree_type
*) NULL
)
4071 os
->addr_tree
= address_exp
;
4073 os
->sectype
= sectype
;
4074 if (sectype
!= noload_section
)
4075 os
->flags
= SEC_NO_FLAGS
;
4077 os
->flags
= SEC_NEVER_LOAD
;
4078 os
->block_value
= block_value
? block_value
: 1;
4079 stat_ptr
= &os
->children
;
4081 os
->subsection_alignment
=
4082 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
4083 os
->section_alignment
=
4084 topower (exp_get_value_int (align
, -1, "section alignment", 0));
4086 os
->load_base
= ebase
;
4093 lang_output_statement_type
*new =
4094 new_stat (lang_output_statement
, stat_ptr
);
4096 new->name
= output_filename
;
4099 /* Reset the current counters in the regions. */
4102 lang_reset_memory_regions ()
4104 lang_memory_region_type
*p
= lang_memory_region_list
;
4107 for (p
= lang_memory_region_list
;
4108 p
!= (lang_memory_region_type
*) NULL
;
4111 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
4112 p
->current
= p
->origin
;
4115 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4119 /* If the wild pattern was marked KEEP, the member sections
4120 should be as well. */
4123 gc_section_callback (ptr
, sec
, section
, file
, data
)
4124 lang_wild_statement_type
*ptr
;
4125 struct wildcard_list
*sec ATTRIBUTE_UNUSED
;
4127 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
4128 PTR data ATTRIBUTE_UNUSED
;
4130 if (ptr
->keep_sections
)
4131 section
->flags
|= SEC_KEEP
;
4134 /* Handle a wild statement, marking it against GC. */
4138 lang_wild_statement_type
*s
;
4140 walk_wild (s
, gc_section_callback
, NULL
);
4143 /* Iterate over sections marking them against GC. */
4146 lang_gc_sections_1 (s
)
4147 lang_statement_union_type
*s
;
4149 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
4151 switch (s
->header
.type
)
4153 case lang_wild_statement_enum
:
4154 lang_gc_wild (&s
->wild_statement
);
4156 case lang_constructors_statement_enum
:
4157 lang_gc_sections_1 (constructor_list
.head
);
4159 case lang_output_section_statement_enum
:
4160 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4162 case lang_group_statement_enum
:
4163 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4174 struct bfd_link_hash_entry
*h
;
4175 ldlang_undef_chain_list_type
*ulist
;
4177 /* Keep all sections so marked in the link script. */
4179 lang_gc_sections_1 (statement_list
.head
);
4181 /* Keep all sections containing symbols undefined on the command-line,
4182 and the section containing the entry symbol. */
4184 for (ulist
= link_info
.gc_sym_list
; ulist
; ulist
= ulist
->next
)
4186 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4187 false, false, false);
4189 if (h
!= (struct bfd_link_hash_entry
*) NULL
4190 && (h
->type
== bfd_link_hash_defined
4191 || h
->type
== bfd_link_hash_defweak
)
4192 && ! bfd_is_abs_section (h
->u
.def
.section
))
4194 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4198 bfd_gc_sections (output_bfd
, &link_info
);
4204 lang_reasonable_defaults ();
4205 current_target
= default_target
;
4207 /* Open the output file. */
4208 lang_for_each_statement (ldlang_open_output
);
4210 ldemul_create_output_section_statements ();
4212 /* Add to the hash table all undefineds on the command line. */
4213 lang_place_undefineds ();
4215 already_linked_table_init ();
4217 /* Create a bfd for each input file. */
4218 current_target
= default_target
;
4219 open_input_bfds (statement_list
.head
, false);
4221 link_info
.gc_sym_list
= &entry_symbol
;
4222 if (entry_symbol
.name
== NULL
)
4223 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
4225 ldemul_after_open ();
4227 already_linked_table_free ();
4229 /* Make sure that we're not mixing architectures. We call this
4230 after all the input files have been opened, but before we do any
4231 other processing, so that any operations merge_private_bfd_data
4232 does on the output file will be known during the rest of the
4236 /* Handle .exports instead of a version script if we're told to do so. */
4237 if (command_line
.version_exports_section
)
4238 lang_do_version_exports_section ();
4240 /* Build all sets based on the information gathered from the input
4242 ldctor_build_sets ();
4244 /* Remove unreferenced sections if asked to. */
4245 if (command_line
.gc_sections
)
4246 lang_gc_sections ();
4248 /* If there were any SEC_MERGE sections, finish their merging, so that
4249 section sizes can be computed. This has to be done after GC of sections,
4250 so that GCed sections are not merged, but before assigning output
4251 sections, since removing whole input sections is hard then. */
4252 bfd_merge_sections (output_bfd
, &link_info
);
4254 /* Size up the common data. */
4257 /* Run through the contours of the script and attach input sections
4258 to the correct output sections. */
4259 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4260 (lang_output_section_statement_type
*) NULL
);
4262 /* Find any sections not attached explicitly and handle them. */
4263 lang_place_orphans ();
4265 if (! link_info
.relocateable
)
4267 /* Look for a text section and set the readonly attribute in it. */
4268 asection
*found
= bfd_get_section_by_name (output_bfd
, ".text");
4270 if (found
!= (asection
*) NULL
)
4272 if (config
.text_read_only
)
4273 found
->flags
|= SEC_READONLY
;
4275 found
->flags
&= ~SEC_READONLY
;
4279 /* Do anything special before sizing sections. This is where ELF
4280 and other back-ends size dynamic sections. */
4281 ldemul_before_allocation ();
4283 if (!link_info
.relocateable
)
4284 strip_excluded_output_sections ();
4286 /* We must record the program headers before we try to fix the
4287 section positions, since they will affect SIZEOF_HEADERS. */
4288 lang_record_phdrs ();
4290 /* Size up the sections. */
4291 lang_size_sections (statement_list
.head
,
4293 &statement_list
.head
, 0, (bfd_vma
) 0, NULL
);
4295 /* Now run around and relax if we can. */
4296 if (command_line
.relax
)
4298 /* Keep relaxing until bfd_relax_section gives up. */
4299 boolean relax_again
;
4303 lang_reset_memory_regions ();
4305 relax_again
= false;
4307 /* Note: pe-dll.c does something like this also. If you find
4308 you need to change this code, you probably need to change
4309 pe-dll.c also. DJ */
4311 /* Do all the assignments with our current guesses as to
4313 lang_do_assignments (statement_list
.head
,
4315 (fill_type
*) 0, (bfd_vma
) 0);
4317 /* Perform another relax pass - this time we know where the
4318 globals are, so can make a better guess. */
4319 lang_size_sections (statement_list
.head
,
4321 &statement_list
.head
, 0, (bfd_vma
) 0,
4324 while (relax_again
);
4327 /* See if anything special should be done now we know how big
4329 ldemul_after_allocation ();
4331 /* Fix any .startof. or .sizeof. symbols. */
4332 lang_set_startof ();
4334 /* Do all the assignments, now that we know the final resting places
4335 of all the symbols. */
4337 lang_do_assignments (statement_list
.head
,
4339 (fill_type
*) 0, (bfd_vma
) 0);
4341 /* Make sure that the section addresses make sense. */
4342 if (! link_info
.relocateable
4343 && command_line
.check_section_addresses
)
4344 lang_check_section_addresses ();
4352 /* EXPORTED TO YACC */
4355 lang_add_wild (filespec
, section_list
, keep_sections
)
4356 struct wildcard_spec
*filespec
;
4357 struct wildcard_list
*section_list
;
4358 boolean keep_sections
;
4360 struct wildcard_list
*curr
, *next
;
4361 lang_wild_statement_type
*new;
4363 /* Reverse the list as the parser puts it back to front. */
4364 for (curr
= section_list
, section_list
= NULL
;
4366 section_list
= curr
, curr
= next
)
4368 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
4369 placed_commons
= true;
4372 curr
->next
= section_list
;
4375 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
4377 if (strcmp (filespec
->name
, "*") == 0)
4378 filespec
->name
= NULL
;
4379 else if (! wildcardp (filespec
->name
))
4380 lang_has_input_file
= true;
4383 new = new_stat (lang_wild_statement
, stat_ptr
);
4384 new->filename
= NULL
;
4385 new->filenames_sorted
= false;
4386 if (filespec
!= NULL
)
4388 new->filename
= filespec
->name
;
4389 new->filenames_sorted
= filespec
->sorted
;
4391 new->section_list
= section_list
;
4392 new->keep_sections
= keep_sections
;
4393 lang_list_init (&new->children
);
4397 lang_section_start (name
, address
)
4399 etree_type
*address
;
4401 lang_address_statement_type
*ad
;
4403 ad
= new_stat (lang_address_statement
, stat_ptr
);
4404 ad
->section_name
= name
;
4405 ad
->address
= address
;
4408 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4409 because of a -e argument on the command line, or zero if this is
4410 called by ENTRY in a linker script. Command line arguments take
4414 lang_add_entry (name
, cmdline
)
4418 if (entry_symbol
.name
== NULL
4420 || ! entry_from_cmdline
)
4422 entry_symbol
.name
= name
;
4423 entry_from_cmdline
= cmdline
;
4428 lang_add_target (name
)
4431 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4447 map_option_f
= true;
4455 lang_add_fill (fill
)
4458 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4465 lang_add_data (type
, exp
)
4467 union etree_union
*exp
;
4470 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4478 /* Create a new reloc statement. RELOC is the BFD relocation type to
4479 generate. HOWTO is the corresponding howto structure (we could
4480 look this up, but the caller has already done so). SECTION is the
4481 section to generate a reloc against, or NAME is the name of the
4482 symbol to generate a reloc against. Exactly one of SECTION and
4483 NAME must be NULL. ADDEND is an expression for the addend. */
4486 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4487 bfd_reloc_code_real_type reloc
;
4488 reloc_howto_type
*howto
;
4491 union etree_union
*addend
;
4493 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4497 p
->section
= section
;
4499 p
->addend_exp
= addend
;
4501 p
->addend_value
= 0;
4502 p
->output_section
= NULL
;
4506 lang_assignment_statement_type
*
4507 lang_add_assignment (exp
)
4510 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4518 lang_add_attribute (attribute
)
4519 enum statement_enum attribute
;
4521 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4528 if (startup_file
!= (char *) NULL
)
4530 einfo (_("%P%Fmultiple STARTUP files\n"));
4532 first_file
->filename
= name
;
4533 first_file
->local_sym_name
= name
;
4534 first_file
->real
= true;
4536 startup_file
= name
;
4543 lang_float_flag
= maybe
;
4547 /* Work out the load- and run-time regions from a script statement, and
4548 store them in *LMA_REGION and *REGION respectively.
4550 MEMSPEC is the name of the run-time region, or "*default*" if the
4551 statement didn't specify one. LMA_MEMSPEC is the name of the
4552 load-time region, or null if the statement didn't specify one.
4553 HAVE_LMA_P is true if the statement had an explicit load address.
4555 It is an error to specify both a load region and a load address. */
4558 lang_get_regions (region
, lma_region
, memspec
, lma_memspec
, have_lma_p
)
4559 struct memory_region_struct
**region
, **lma_region
;
4560 const char *memspec
, *lma_memspec
;
4563 *lma_region
= lang_memory_region_lookup (lma_memspec
);
4565 /* If no runtime region has been given, but the load region has
4566 been, use the load region. */
4567 if (lma_memspec
!= 0 && strcmp (memspec
, "*default*") == 0)
4568 *region
= *lma_region
;
4570 *region
= lang_memory_region_lookup (memspec
);
4572 if (have_lma_p
&& lma_memspec
!= 0)
4573 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4577 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4579 const char *memspec
;
4580 struct lang_output_section_phdr_list
*phdrs
;
4581 const char *lma_memspec
;
4583 lang_get_regions (¤t_section
->region
,
4584 ¤t_section
->lma_region
,
4585 memspec
, lma_memspec
,
4586 current_section
->load_base
!= 0);
4587 current_section
->fill
= fill
;
4588 current_section
->phdrs
= phdrs
;
4589 stat_ptr
= &statement_list
;
4592 /* Create an absolute symbol with the given name with the value of the
4593 address of first byte of the section named.
4595 If the symbol already exists, then do nothing. */
4598 lang_abs_symbol_at_beginning_of (secname
, name
)
4599 const char *secname
;
4602 struct bfd_link_hash_entry
*h
;
4604 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4605 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4606 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4608 if (h
->type
== bfd_link_hash_new
4609 || h
->type
== bfd_link_hash_undefined
)
4613 h
->type
= bfd_link_hash_defined
;
4615 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4616 if (sec
== (asection
*) NULL
)
4619 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4621 h
->u
.def
.section
= bfd_abs_section_ptr
;
4625 /* Create an absolute symbol with the given name with the value of the
4626 address of the first byte after the end of the section named.
4628 If the symbol already exists, then do nothing. */
4631 lang_abs_symbol_at_end_of (secname
, name
)
4632 const char *secname
;
4635 struct bfd_link_hash_entry
*h
;
4637 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4638 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4639 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4641 if (h
->type
== bfd_link_hash_new
4642 || h
->type
== bfd_link_hash_undefined
)
4646 h
->type
= bfd_link_hash_defined
;
4648 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4649 if (sec
== (asection
*) NULL
)
4652 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4653 + bfd_section_size (output_bfd
, sec
) /
4654 bfd_octets_per_byte (output_bfd
));
4656 h
->u
.def
.section
= bfd_abs_section_ptr
;
4661 lang_statement_append (list
, element
, field
)
4662 lang_statement_list_type
*list
;
4663 lang_statement_union_type
*element
;
4664 lang_statement_union_type
**field
;
4666 *(list
->tail
) = element
;
4670 /* Set the output format type. -oformat overrides scripts. */
4673 lang_add_output_format (format
, big
, little
, from_script
)
4679 if (output_target
== NULL
|| !from_script
)
4681 if (command_line
.endian
== ENDIAN_BIG
4684 else if (command_line
.endian
== ENDIAN_LITTLE
4688 output_target
= format
;
4692 /* Enter a group. This creates a new lang_group_statement, and sets
4693 stat_ptr to build new statements within the group. */
4698 lang_group_statement_type
*g
;
4700 g
= new_stat (lang_group_statement
, stat_ptr
);
4701 lang_list_init (&g
->children
);
4702 stat_ptr
= &g
->children
;
4705 /* Leave a group. This just resets stat_ptr to start writing to the
4706 regular list of statements again. Note that this will not work if
4707 groups can occur inside anything else which can adjust stat_ptr,
4708 but currently they can't. */
4713 stat_ptr
= &statement_list
;
4716 /* Add a new program header. This is called for each entry in a PHDRS
4717 command in a linker script. */
4720 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4728 struct lang_phdr
*n
, **pp
;
4730 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4733 n
->type
= exp_get_value_int (type
, 0, "program header type",
4734 lang_final_phase_enum
);
4735 n
->filehdr
= filehdr
;
4740 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4745 /* Record the program header information in the output BFD. FIXME: We
4746 should not be calling an ELF specific function here. */
4749 lang_record_phdrs ()
4753 struct lang_output_section_phdr_list
*last
;
4754 struct lang_phdr
*l
;
4755 lang_statement_union_type
*u
;
4758 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4760 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4767 for (u
= lang_output_section_statement
.head
;
4769 u
= u
->output_section_statement
.next
)
4771 lang_output_section_statement_type
*os
;
4772 struct lang_output_section_phdr_list
*pl
;
4774 os
= &u
->output_section_statement
;
4781 if (os
->sectype
== noload_section
4782 || os
->bfd_section
== NULL
4783 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4788 if (os
->bfd_section
== NULL
)
4791 for (; pl
!= NULL
; pl
= pl
->next
)
4793 if (strcmp (pl
->name
, l
->name
) == 0)
4798 secs
= ((asection
**)
4799 xrealloc (secs
, alc
* sizeof (asection
*)));
4801 secs
[c
] = os
->bfd_section
;
4808 if (l
->flags
== NULL
)
4811 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4812 lang_final_phase_enum
);
4817 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4818 lang_final_phase_enum
);
4820 if (! bfd_record_phdr (output_bfd
, l
->type
,
4821 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
4822 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4823 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4828 /* Make sure all the phdr assignments succeeded. */
4829 for (u
= lang_output_section_statement
.head
;
4831 u
= u
->output_section_statement
.next
)
4833 struct lang_output_section_phdr_list
*pl
;
4835 if (u
->output_section_statement
.bfd_section
== NULL
)
4838 for (pl
= u
->output_section_statement
.phdrs
;
4841 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4842 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4843 u
->output_section_statement
.name
, pl
->name
);
4847 /* Record a list of sections which may not be cross referenced. */
4850 lang_add_nocrossref (l
)
4851 struct lang_nocrossref
*l
;
4853 struct lang_nocrossrefs
*n
;
4855 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4856 n
->next
= nocrossref_list
;
4858 nocrossref_list
= n
;
4860 /* Set notice_all so that we get informed about all symbols. */
4861 link_info
.notice_all
= true;
4864 /* Overlay handling. We handle overlays with some static variables. */
4866 /* The overlay virtual address. */
4867 static etree_type
*overlay_vma
;
4869 /* An expression for the maximum section size seen so far. */
4870 static etree_type
*overlay_max
;
4872 /* A list of all the sections in this overlay. */
4874 struct overlay_list
{
4875 struct overlay_list
*next
;
4876 lang_output_section_statement_type
*os
;
4879 static struct overlay_list
*overlay_list
;
4881 /* Start handling an overlay. */
4884 lang_enter_overlay (vma_expr
)
4885 etree_type
*vma_expr
;
4887 /* The grammar should prevent nested overlays from occurring. */
4888 ASSERT (overlay_vma
== NULL
&& overlay_max
== NULL
);
4890 overlay_vma
= vma_expr
;
4893 /* Start a section in an overlay. We handle this by calling
4894 lang_enter_output_section_statement with the correct VMA.
4895 lang_leave_overlay sets up the LMA and memory regions. */
4898 lang_enter_overlay_section (name
)
4901 struct overlay_list
*n
;
4904 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4907 /* If this is the first section, then base the VMA of future
4908 sections on this one. This will work correctly even if `.' is
4909 used in the addresses. */
4910 if (overlay_list
== NULL
)
4911 overlay_vma
= exp_nameop (ADDR
, name
);
4913 /* Remember the section. */
4914 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4915 n
->os
= current_section
;
4916 n
->next
= overlay_list
;
4919 size
= exp_nameop (SIZEOF
, name
);
4921 /* Arrange to work out the maximum section end address. */
4922 if (overlay_max
== NULL
)
4925 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4928 /* Finish a section in an overlay. There isn't any special to do
4932 lang_leave_overlay_section (fill
, phdrs
)
4934 struct lang_output_section_phdr_list
*phdrs
;
4941 name
= current_section
->name
;
4943 /* For now, assume that "*default*" is the run-time memory region and
4944 that no load-time region has been specified. It doesn't really
4945 matter what we say here, since lang_leave_overlay will override it. */
4946 lang_leave_output_section_statement (fill
, "*default*", phdrs
, 0);
4948 /* Define the magic symbols. */
4950 clean
= xmalloc (strlen (name
) + 1);
4952 for (s1
= name
; *s1
!= '\0'; s1
++)
4953 if (ISALNUM (*s1
) || *s1
== '_')
4957 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4958 sprintf (buf
, "__load_start_%s", clean
);
4959 lang_add_assignment (exp_assop ('=', buf
,
4960 exp_nameop (LOADADDR
, name
)));
4962 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4963 sprintf (buf
, "__load_stop_%s", clean
);
4964 lang_add_assignment (exp_assop ('=', buf
,
4966 exp_nameop (LOADADDR
, name
),
4967 exp_nameop (SIZEOF
, name
))));
4972 /* Finish an overlay. If there are any overlay wide settings, this
4973 looks through all the sections in the overlay and sets them. */
4976 lang_leave_overlay (lma_expr
, nocrossrefs
, fill
, memspec
, phdrs
, lma_memspec
)
4977 etree_type
*lma_expr
;
4980 const char *memspec
;
4981 struct lang_output_section_phdr_list
*phdrs
;
4982 const char *lma_memspec
;
4984 lang_memory_region_type
*region
;
4985 lang_memory_region_type
*lma_region
;
4986 struct overlay_list
*l
;
4987 struct lang_nocrossref
*nocrossref
;
4989 lang_get_regions (®ion
, &lma_region
,
4990 memspec
, lma_memspec
,
4995 /* After setting the size of the last section, set '.' to end of the
4997 if (overlay_list
!= NULL
)
4998 overlay_list
->os
->update_dot_tree
4999 = exp_assop ('=', ".", exp_binop ('+', overlay_vma
, overlay_max
));
5004 struct overlay_list
*next
;
5006 if (fill
!= (fill_type
*) 0 && l
->os
->fill
== (fill_type
*) 0)
5009 l
->os
->region
= region
;
5010 l
->os
->lma_region
= lma_region
;
5012 /* The first section has the load address specified in the
5013 OVERLAY statement. The rest are worked out from that.
5014 The base address is not needed (and should be null) if
5015 an LMA region was specified. */
5017 l
->os
->load_base
= lma_expr
;
5018 else if (lma_region
== 0)
5019 l
->os
->load_base
= exp_binop ('+',
5020 exp_nameop (LOADADDR
, l
->next
->os
->name
),
5021 exp_nameop (SIZEOF
, l
->next
->os
->name
));
5023 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
5024 l
->os
->phdrs
= phdrs
;
5028 struct lang_nocrossref
*nc
;
5030 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
5031 nc
->name
= l
->os
->name
;
5032 nc
->next
= nocrossref
;
5041 if (nocrossref
!= NULL
)
5042 lang_add_nocrossref (nocrossref
);
5045 overlay_list
= NULL
;
5049 /* Version handling. This is only useful for ELF. */
5051 /* This global variable holds the version tree that we build. */
5053 struct bfd_elf_version_tree
*lang_elf_version_info
;
5056 lang_vers_match_lang_c (expr
, sym
)
5057 struct bfd_elf_version_expr
*expr
;
5060 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5062 return fnmatch (expr
->pattern
, sym
, 0) == 0;
5066 lang_vers_match_lang_cplusplus (expr
, sym
)
5067 struct bfd_elf_version_expr
*expr
;
5073 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5076 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
5079 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5080 Should we early out false in this case? */
5081 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5085 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5093 lang_vers_match_lang_java (expr
, sym
)
5094 struct bfd_elf_version_expr
*expr
;
5100 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5103 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
5106 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5107 Should we early out false in this case? */
5108 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5112 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5119 /* This is called for each variable name or match expression. */
5121 struct bfd_elf_version_expr
*
5122 lang_new_vers_pattern (orig
, new, lang
)
5123 struct bfd_elf_version_expr
*orig
;
5127 struct bfd_elf_version_expr
*ret
;
5129 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
5133 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
5134 ret
->match
= lang_vers_match_lang_c
;
5135 else if (strcasecmp (lang
, "C++") == 0)
5136 ret
->match
= lang_vers_match_lang_cplusplus
;
5137 else if (strcasecmp (lang
, "Java") == 0)
5138 ret
->match
= lang_vers_match_lang_java
;
5141 einfo (_("%X%P: unknown language `%s' in version information\n"),
5143 ret
->match
= lang_vers_match_lang_c
;
5146 return ldemul_new_vers_pattern (ret
);
5149 /* This is called for each set of variable names and match
5152 struct bfd_elf_version_tree
*
5153 lang_new_vers_node (globals
, locals
)
5154 struct bfd_elf_version_expr
*globals
;
5155 struct bfd_elf_version_expr
*locals
;
5157 struct bfd_elf_version_tree
*ret
;
5159 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
5163 ret
->globals
= globals
;
5164 ret
->locals
= locals
;
5166 ret
->name_indx
= (unsigned int) -1;
5171 /* This static variable keeps track of version indices. */
5173 static int version_index
;
5175 /* This is called when we know the name and dependencies of the
5179 lang_register_vers_node (name
, version
, deps
)
5181 struct bfd_elf_version_tree
*version
;
5182 struct bfd_elf_version_deps
*deps
;
5184 struct bfd_elf_version_tree
*t
, **pp
;
5185 struct bfd_elf_version_expr
*e1
;
5190 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
5191 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
5193 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5197 /* Make sure this node has a unique name. */
5198 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5199 if (strcmp (t
->name
, name
) == 0)
5200 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5202 /* Check the global and local match names, and make sure there
5203 aren't any duplicates. */
5205 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5207 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5209 struct bfd_elf_version_expr
*e2
;
5211 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5212 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5213 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5218 for (e1
= version
->locals
; 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
->globals
; 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 version
->deps
= deps
;
5232 version
->name
= name
;
5233 if (name
[0] != '\0')
5236 version
->vernum
= version_index
;
5239 version
->vernum
= 0;
5241 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5246 /* This is called when we see a version dependency. */
5248 struct bfd_elf_version_deps
*
5249 lang_add_vers_depend (list
, name
)
5250 struct bfd_elf_version_deps
*list
;
5253 struct bfd_elf_version_deps
*ret
;
5254 struct bfd_elf_version_tree
*t
;
5256 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5259 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5261 if (strcmp (t
->name
, name
) == 0)
5263 ret
->version_needed
= t
;
5268 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5274 lang_do_version_exports_section ()
5276 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5278 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5280 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5287 len
= bfd_section_size (is
->the_bfd
, sec
);
5288 contents
= xmalloc (len
);
5289 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5290 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
5293 while (p
< contents
+ len
)
5295 greg
= lang_new_vers_pattern (greg
, p
, NULL
);
5296 p
= strchr (p
, '\0') + 1;
5299 /* Do not free the contents, as we used them creating the regex. */
5301 /* Do not include this section in the link. */
5302 bfd_set_section_flags (is
->the_bfd
, sec
,
5303 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5306 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
);
5307 lang_register_vers_node (command_line
.version_exports_section
,
5308 lang_new_vers_node (greg
, lreg
), NULL
);
5312 lang_add_unique (name
)
5315 struct unique_sections
*ent
;
5317 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5318 if (strcmp (ent
->name
, name
) == 0)
5321 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
5322 ent
->name
= xstrdup (name
);
5323 ent
->next
= unique_section_list
;
5324 unique_section_list
= ent
;