1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
6 This file is part of GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
26 #include "safe-ctype.h"
44 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
47 /* Locals variables. */
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 bfd_boolean placed_commons
= FALSE
;
55 static lang_output_section_statement_type
*default_common_section
;
56 static bfd_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
;
63 static struct bfd_hash_table lang_definedness_table
;
65 /* Forward declarations. */
66 static void exp_init_os (etree_type
*);
67 static bfd_boolean
wildcardp (const char *);
68 static lang_input_statement_type
*lookup_name (const char *);
69 static bfd_boolean
load_symbols (lang_input_statement_type
*,
70 lang_statement_list_type
*);
71 static struct bfd_hash_entry
*lang_definedness_newfunc
72 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
73 static void insert_undefined (const char *);
74 static void print_statement (lang_statement_union_type
*,
75 lang_output_section_statement_type
*);
76 static void print_statement_list (lang_statement_union_type
*,
77 lang_output_section_statement_type
*);
78 static void print_statements (void);
79 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
80 static void lang_record_phdrs (void);
81 static void lang_do_version_exports_section (void);
83 typedef void (*callback_t
) (lang_wild_statement_type
*, struct wildcard_list
*,
84 asection
*, lang_input_statement_type
*, void *);
86 /* Exported variables. */
87 lang_output_section_statement_type
*abs_output_section
;
88 lang_statement_list_type lang_output_section_statement
;
89 lang_statement_list_type
*stat_ptr
= &statement_list
;
90 lang_statement_list_type file_chain
= { NULL
, NULL
};
91 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
92 const char *entry_section
= ".text";
93 bfd_boolean entry_from_cmdline
;
94 bfd_boolean lang_has_input_file
= FALSE
;
95 bfd_boolean had_output_filename
= FALSE
;
96 bfd_boolean lang_float_flag
= FALSE
;
97 bfd_boolean delete_output_file_on_failure
= FALSE
;
98 struct lang_nocrossrefs
*nocrossref_list
;
99 struct unique_sections
*unique_section_list
;
100 static bfd_boolean ldlang_sysrooted_script
= FALSE
;
101 int lang_statement_iteration
= 0;
103 etree_type
*base
; /* Relocation base - or null */
105 #define new_stat(x, y) \
106 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
108 #define outside_section_address(q) \
109 ((q)->output_offset + (q)->output_section->vma)
111 #define outside_symbol_address(q) \
112 ((q)->value + outside_section_address (q->section))
114 #define SECTION_NAME_MAP_LENGTH (16)
117 stat_alloc (size_t size
)
119 return obstack_alloc (&stat_obstack
, size
);
123 unique_section_p (const char *secnam
)
125 struct unique_sections
*unam
;
127 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
128 if (wildcardp (unam
->name
)
129 ? fnmatch (unam
->name
, secnam
, 0) == 0
130 : strcmp (unam
->name
, secnam
) == 0)
138 /* Generic traversal routines for finding matching sections. */
141 walk_wild_section (lang_wild_statement_type
*ptr
,
142 lang_input_statement_type
*file
,
148 if (file
->just_syms_flag
)
151 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
153 struct wildcard_list
*sec
;
155 sec
= ptr
->section_list
;
157 (*callback
) (ptr
, sec
, s
, file
, data
);
161 bfd_boolean skip
= FALSE
;
162 struct name_list
*list_tmp
;
164 /* Don't process sections from files which were
166 for (list_tmp
= sec
->spec
.exclude_name_list
;
168 list_tmp
= list_tmp
->next
)
170 if (wildcardp (list_tmp
->name
))
171 skip
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
173 skip
= strcmp (list_tmp
->name
, file
->filename
) == 0;
175 /* If this file is part of an archive, and the archive is
176 excluded, exclude this file. */
177 if (! skip
&& file
->the_bfd
!= NULL
178 && file
->the_bfd
->my_archive
!= NULL
179 && file
->the_bfd
->my_archive
->filename
!= NULL
)
181 if (wildcardp (list_tmp
->name
))
182 skip
= fnmatch (list_tmp
->name
,
183 file
->the_bfd
->my_archive
->filename
,
186 skip
= strcmp (list_tmp
->name
,
187 file
->the_bfd
->my_archive
->filename
) == 0;
194 if (!skip
&& sec
->spec
.name
!= NULL
)
196 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
198 if (wildcardp (sec
->spec
.name
))
199 skip
= fnmatch (sec
->spec
.name
, sname
, 0) != 0;
201 skip
= strcmp (sec
->spec
.name
, sname
) != 0;
205 (*callback
) (ptr
, sec
, s
, file
, data
);
212 /* Handle a wild statement for a single file F. */
215 walk_wild_file (lang_wild_statement_type
*s
,
216 lang_input_statement_type
*f
,
220 if (f
->the_bfd
== NULL
221 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
222 walk_wild_section (s
, f
, callback
, data
);
227 /* This is an archive file. We must map each member of the
228 archive separately. */
229 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
230 while (member
!= NULL
)
232 /* When lookup_name is called, it will call the add_symbols
233 entry point for the archive. For each element of the
234 archive which is included, BFD will call ldlang_add_file,
235 which will set the usrdata field of the member to the
236 lang_input_statement. */
237 if (member
->usrdata
!= NULL
)
239 walk_wild_section (s
, member
->usrdata
, callback
, data
);
242 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
248 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
250 const char *file_spec
= s
->filename
;
252 if (file_spec
== NULL
)
254 /* Perform the iteration over all files in the list. */
255 LANG_FOR_EACH_INPUT_STATEMENT (f
)
257 walk_wild_file (s
, f
, callback
, data
);
260 else if (wildcardp (file_spec
))
262 LANG_FOR_EACH_INPUT_STATEMENT (f
)
264 if (fnmatch (file_spec
, f
->filename
, FNM_FILE_NAME
) == 0)
265 walk_wild_file (s
, f
, callback
, data
);
270 lang_input_statement_type
*f
;
272 /* Perform the iteration over a single file. */
273 f
= lookup_name (file_spec
);
275 walk_wild_file (s
, f
, callback
, data
);
279 /* lang_for_each_statement walks the parse tree and calls the provided
280 function for each node. */
283 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
284 lang_statement_union_type
*s
)
286 for (; s
!= NULL
; s
= s
->header
.next
)
290 switch (s
->header
.type
)
292 case lang_constructors_statement_enum
:
293 lang_for_each_statement_worker (func
, constructor_list
.head
);
295 case lang_output_section_statement_enum
:
296 lang_for_each_statement_worker
298 s
->output_section_statement
.children
.head
);
300 case lang_wild_statement_enum
:
301 lang_for_each_statement_worker
303 s
->wild_statement
.children
.head
);
305 case lang_group_statement_enum
:
306 lang_for_each_statement_worker (func
,
307 s
->group_statement
.children
.head
);
309 case lang_data_statement_enum
:
310 case lang_reloc_statement_enum
:
311 case lang_object_symbols_statement_enum
:
312 case lang_output_statement_enum
:
313 case lang_target_statement_enum
:
314 case lang_input_section_enum
:
315 case lang_input_statement_enum
:
316 case lang_assignment_statement_enum
:
317 case lang_padding_statement_enum
:
318 case lang_address_statement_enum
:
319 case lang_fill_statement_enum
:
329 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
331 lang_for_each_statement_worker (func
, statement_list
.head
);
334 /*----------------------------------------------------------------------*/
337 lang_list_init (lang_statement_list_type
*list
)
340 list
->tail
= &list
->head
;
343 /* Build a new statement node for the parse tree. */
345 static lang_statement_union_type
*
346 new_statement (enum statement_enum type
,
348 lang_statement_list_type
*list
)
350 lang_statement_union_type
*new;
352 new = stat_alloc (size
);
353 new->header
.type
= type
;
354 new->header
.next
= NULL
;
355 lang_statement_append (list
, new, &new->header
.next
);
359 /* Build a new input file node for the language. There are several
360 ways in which we treat an input file, eg, we only look at symbols,
361 or prefix it with a -l etc.
363 We can be supplied with requests for input files more than once;
364 they may, for example be split over several lines like foo.o(.text)
365 foo.o(.data) etc, so when asked for a file we check that we haven't
366 got it already so we don't duplicate the bfd. */
368 static lang_input_statement_type
*
369 new_afile (const char *name
,
370 lang_input_file_enum_type file_type
,
372 bfd_boolean add_to_list
)
374 lang_input_statement_type
*p
;
377 p
= new_stat (lang_input_statement
, stat_ptr
);
380 p
= stat_alloc (sizeof (lang_input_statement_type
));
381 p
->header
.next
= NULL
;
384 lang_has_input_file
= TRUE
;
386 p
->sysrooted
= FALSE
;
389 case lang_input_file_is_symbols_only_enum
:
391 p
->is_archive
= FALSE
;
393 p
->local_sym_name
= name
;
394 p
->just_syms_flag
= TRUE
;
395 p
->search_dirs_flag
= FALSE
;
397 case lang_input_file_is_fake_enum
:
399 p
->is_archive
= FALSE
;
401 p
->local_sym_name
= name
;
402 p
->just_syms_flag
= FALSE
;
403 p
->search_dirs_flag
= FALSE
;
405 case lang_input_file_is_l_enum
:
406 p
->is_archive
= TRUE
;
409 p
->local_sym_name
= concat ("-l", name
, NULL
);
410 p
->just_syms_flag
= FALSE
;
411 p
->search_dirs_flag
= TRUE
;
413 case lang_input_file_is_marker_enum
:
415 p
->is_archive
= FALSE
;
417 p
->local_sym_name
= name
;
418 p
->just_syms_flag
= FALSE
;
419 p
->search_dirs_flag
= TRUE
;
421 case lang_input_file_is_search_file_enum
:
422 p
->sysrooted
= ldlang_sysrooted_script
;
424 p
->is_archive
= FALSE
;
426 p
->local_sym_name
= name
;
427 p
->just_syms_flag
= FALSE
;
428 p
->search_dirs_flag
= TRUE
;
430 case lang_input_file_is_file_enum
:
432 p
->is_archive
= FALSE
;
434 p
->local_sym_name
= name
;
435 p
->just_syms_flag
= FALSE
;
436 p
->search_dirs_flag
= FALSE
;
443 p
->next_real_file
= NULL
;
446 p
->dynamic
= config
.dynamic_link
;
447 p
->whole_archive
= whole_archive
;
449 lang_statement_append (&input_file_chain
,
450 (lang_statement_union_type
*) p
,
455 lang_input_statement_type
*
456 lang_add_input_file (const char *name
,
457 lang_input_file_enum_type file_type
,
460 lang_has_input_file
= TRUE
;
461 return new_afile (name
, file_type
, target
, TRUE
);
464 /* Build enough state so that the parser can build its tree. */
469 obstack_begin (&stat_obstack
, 1000);
471 stat_ptr
= &statement_list
;
473 lang_list_init (stat_ptr
);
475 lang_list_init (&input_file_chain
);
476 lang_list_init (&lang_output_section_statement
);
477 lang_list_init (&file_chain
);
478 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
481 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
483 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
485 /* The value "3" is ad-hoc, somewhat related to the expected number of
486 DEFINED expressions in a linker script. For most default linker
487 scripts, there are none. Why a hash table then? Well, it's somewhat
488 simpler to re-use working machinery than using a linked list in terms
489 of code-complexity here in ld, besides the initialization which just
490 looks like other code here. */
491 if (bfd_hash_table_init_n (&lang_definedness_table
,
492 lang_definedness_newfunc
, 3) != TRUE
)
493 einfo (_("%P%F: out of memory during initialization"));
495 /* Callers of exp_fold_tree need to increment this. */
496 lang_statement_iteration
= 0;
499 /*----------------------------------------------------------------------
500 A region is an area of memory declared with the
501 MEMORY { name:org=exp, len=exp ... }
504 We maintain a list of all the regions here.
506 If no regions are specified in the script, then the default is used
507 which is created when looked up to be the entire data space.
509 If create is true we are creating a region inside a MEMORY block.
510 In this case it is probably an error to create a region that has
511 already been created. If we are not inside a MEMORY block it is
512 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
513 and so we issue a warning. */
515 static lang_memory_region_type
*lang_memory_region_list
;
516 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
518 lang_memory_region_type
*
519 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
521 lang_memory_region_type
*p
;
522 lang_memory_region_type
*new;
524 /* NAME is NULL for LMA memspecs if no region was specified. */
528 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
529 if (strcmp (p
->name
, name
) == 0)
532 einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"), name
);
537 /* This code used to always use the first region in the list as the
538 default region. I changed it to instead use a region
539 encompassing all of memory as the default region. This permits
540 NOLOAD sections to work reasonably without requiring a region.
541 People should specify what region they mean, if they really want
543 if (strcmp (name
, DEFAULT_MEMORY_REGION
) == 0)
545 if (lang_memory_region_list
!= NULL
)
546 return lang_memory_region_list
;
550 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
551 einfo (_("%P:%S: warning: memory region %s not declared\n"), name
);
553 new = stat_alloc (sizeof (lang_memory_region_type
));
555 new->name
= xstrdup (name
);
558 *lang_memory_region_list_tail
= new;
559 lang_memory_region_list_tail
= &new->next
;
563 new->length
= ~(bfd_size_type
) 0;
565 new->had_full_message
= FALSE
;
570 static lang_memory_region_type
*
571 lang_memory_default (asection
*section
)
573 lang_memory_region_type
*p
;
575 flagword sec_flags
= section
->flags
;
577 /* Override SEC_DATA to mean a writable section. */
578 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
579 sec_flags
|= SEC_DATA
;
581 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
583 if ((p
->flags
& sec_flags
) != 0
584 && (p
->not_flags
& sec_flags
) == 0)
589 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
592 lang_output_section_statement_type
*
593 lang_output_section_find (const char *const name
)
595 lang_statement_union_type
*u
;
596 lang_output_section_statement_type
*lookup
;
598 for (u
= lang_output_section_statement
.head
; u
!= NULL
; u
= lookup
->next
)
600 lookup
= &u
->output_section_statement
;
601 if (strcmp (name
, lookup
->name
) == 0)
607 lang_output_section_statement_type
*
608 lang_output_section_statement_lookup (const char *const name
)
610 lang_output_section_statement_type
*lookup
;
612 lookup
= lang_output_section_find (name
);
615 lookup
= new_stat (lang_output_section_statement
, stat_ptr
);
616 lookup
->region
= NULL
;
617 lookup
->lma_region
= NULL
;
619 lookup
->block_value
= 1;
623 lookup
->bfd_section
= NULL
;
624 lookup
->processed
= FALSE
;
625 lookup
->sectype
= normal_section
;
626 lookup
->addr_tree
= NULL
;
627 lang_list_init (&lookup
->children
);
629 lookup
->memspec
= NULL
;
631 lookup
->subsection_alignment
= -1;
632 lookup
->section_alignment
= -1;
633 lookup
->load_base
= NULL
;
634 lookup
->update_dot_tree
= NULL
;
635 lookup
->phdrs
= NULL
;
637 lang_statement_append (&lang_output_section_statement
,
638 (lang_statement_union_type
*) lookup
,
645 lang_map_flags (flagword flag
)
647 if (flag
& SEC_ALLOC
)
653 if (flag
& SEC_READONLY
)
666 lang_memory_region_type
*m
;
668 minfo (_("\nMemory Configuration\n\n"));
669 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
670 _("Name"), _("Origin"), _("Length"), _("Attributes"));
672 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
677 fprintf (config
.map_file
, "%-16s ", m
->name
);
679 sprintf_vma (buf
, m
->origin
);
680 minfo ("0x%s ", buf
);
688 minfo ("0x%V", m
->length
);
689 if (m
->flags
|| m
->not_flags
)
697 lang_map_flags (m
->flags
);
703 lang_map_flags (m
->not_flags
);
710 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
715 /* Initialize an output section. */
718 init_os (lang_output_section_statement_type
*s
)
720 section_userdata_type
*new;
722 if (s
->bfd_section
!= NULL
)
725 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
726 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
728 new = stat_alloc (sizeof (section_userdata_type
));
730 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
731 if (s
->bfd_section
== NULL
)
732 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
733 if (s
->bfd_section
== NULL
)
735 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
736 output_bfd
->xvec
->name
, s
->name
);
738 s
->bfd_section
->output_section
= s
->bfd_section
;
740 /* We initialize an output sections output offset to minus its own
741 vma to allow us to output a section through itself. */
742 s
->bfd_section
->output_offset
= 0;
743 get_userdata (s
->bfd_section
) = new;
745 /* If there is a base address, make sure that any sections it might
746 mention are initialized. */
747 if (s
->addr_tree
!= NULL
)
748 exp_init_os (s
->addr_tree
);
750 if (s
->load_base
!= NULL
)
751 exp_init_os (s
->load_base
);
754 /* Make sure that all output sections mentioned in an expression are
758 exp_init_os (etree_type
*exp
)
760 switch (exp
->type
.node_class
)
763 exp_init_os (exp
->assign
.src
);
767 exp_init_os (exp
->binary
.lhs
);
768 exp_init_os (exp
->binary
.rhs
);
772 exp_init_os (exp
->trinary
.cond
);
773 exp_init_os (exp
->trinary
.lhs
);
774 exp_init_os (exp
->trinary
.rhs
);
778 exp_init_os (exp
->unary
.child
);
782 switch (exp
->type
.node_code
)
788 lang_output_section_statement_type
*os
;
790 os
= lang_output_section_find (exp
->name
.name
);
791 if (os
!= NULL
&& os
->bfd_section
== NULL
)
802 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
803 once into the output. This routine checks each section, and
804 arrange to discard it if a section of the same name has already
805 been linked. If the section has COMDAT information, then it uses
806 that to decide whether the section should be included. This code
807 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
808 that is, it does not depend solely upon the section name.
809 section_already_linked is called via bfd_map_over_sections. */
811 /* This is the shape of the elements inside the already_linked hash
812 table. It maps a name onto a list of already_linked elements with
813 the same name. It's possible to get more than one element in a
814 list if the COMDAT sections have different names. */
816 struct already_linked_hash_entry
818 struct bfd_hash_entry root
;
819 struct already_linked
*entry
;
822 struct already_linked
824 struct already_linked
*next
;
828 /* The hash table. */
830 static struct bfd_hash_table already_linked_table
;
833 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
835 lang_input_statement_type
*entry
= data
;
838 struct already_linked
*l
;
839 struct already_linked_hash_entry
*already_linked_list
;
841 /* If we are only reading symbols from this object, then we want to
842 discard all sections. */
843 if (entry
->just_syms_flag
)
845 bfd_link_just_syms (sec
, &link_info
);
849 flags
= bfd_get_section_flags (abfd
, sec
);
851 if ((flags
& SEC_LINK_ONCE
) == 0)
854 /* FIXME: When doing a relocatable link, we may have trouble
855 copying relocations in other sections that refer to local symbols
856 in the section being discarded. Those relocations will have to
857 be converted somehow; as of this writing I'm not sure that any of
858 the backends handle that correctly.
860 It is tempting to instead not discard link once sections when
861 doing a relocatable link (technically, they should be discarded
862 whenever we are building constructors). However, that fails,
863 because the linker winds up combining all the link once sections
864 into a single large link once section, which defeats the purpose
865 of having link once sections in the first place.
867 Also, not merging link once sections in a relocatable link
868 causes trouble for MIPS ELF, which relies on link once semantics
869 to handle the .reginfo section correctly. */
871 name
= bfd_get_section_name (abfd
, sec
);
873 already_linked_list
=
874 ((struct already_linked_hash_entry
*)
875 bfd_hash_lookup (&already_linked_table
, name
, TRUE
, FALSE
));
877 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
879 if (sec
->comdat
== NULL
880 || l
->sec
->comdat
== NULL
881 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
883 /* The section has already been linked. See if we should
885 switch (flags
& SEC_LINK_DUPLICATES
)
890 case SEC_LINK_DUPLICATES_DISCARD
:
893 case SEC_LINK_DUPLICATES_ONE_ONLY
:
894 if (sec
->comdat
== NULL
)
895 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
898 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
899 abfd
, name
, sec
->comdat
->name
);
902 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
903 /* FIXME: We should really dig out the contents of both
904 sections and memcmp them. The COFF/PE spec says that
905 the Microsoft linker does not implement this
906 correctly, so I'm not going to bother doing it
909 case SEC_LINK_DUPLICATES_SAME_SIZE
:
910 if (bfd_section_size (abfd
, sec
)
911 != bfd_section_size (l
->sec
->owner
, l
->sec
))
912 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
917 /* Set the output_section field so that lang_add_section
918 does not create a lang_input_section structure for this
919 section. Since there might be a symbol in the section
920 being discarded, we must retain a pointer to the section
921 which we are really going to use. */
922 sec
->output_section
= bfd_abs_section_ptr
;
923 sec
->kept_section
= l
->sec
;
925 if (flags
& SEC_GROUP
)
926 bfd_discard_group (abfd
, sec
);
932 /* This is the first section with this name. Record it. Allocate
933 the memory from the same obstack as the hash table is kept in. */
935 l
= bfd_hash_allocate (&already_linked_table
, sizeof *l
);
938 l
->next
= already_linked_list
->entry
;
939 already_linked_list
->entry
= l
;
942 /* Support routines for the hash table used by section_already_linked,
943 initialize the table, fill in an entry and remove the table. */
945 static struct bfd_hash_entry
*
946 already_linked_newfunc (struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
,
947 struct bfd_hash_table
*table
,
948 const char *string ATTRIBUTE_UNUSED
)
950 struct already_linked_hash_entry
*ret
=
951 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
959 already_linked_table_init (void)
961 if (! bfd_hash_table_init_n (&already_linked_table
,
962 already_linked_newfunc
,
964 einfo (_("%P%F: Failed to create hash table\n"));
968 already_linked_table_free (void)
970 bfd_hash_table_free (&already_linked_table
);
973 /* The wild routines.
975 These expand statements like *(.text) and foo.o to a list of
976 explicit actions, like foo.o(.text), bar.o(.text) and
977 foo.o(.text, .data). */
979 /* Return TRUE if the PATTERN argument is a wildcard pattern.
980 Although backslashes are treated specially if a pattern contains
981 wildcards, we do not consider the mere presence of a backslash to
982 be enough to cause the pattern to be treated as a wildcard.
983 That lets us handle DOS filenames more naturally. */
986 wildcardp (const char *pattern
)
990 for (s
= pattern
; *s
!= '\0'; ++s
)
998 /* Add SECTION to the output section OUTPUT. Do this by creating a
999 lang_input_section statement which is placed at PTR. FILE is the
1000 input file which holds SECTION. */
1003 lang_add_section (lang_statement_list_type
*ptr
,
1005 lang_output_section_statement_type
*output
,
1006 lang_input_statement_type
*file
)
1009 bfd_boolean discard
;
1011 flags
= bfd_get_section_flags (section
->owner
, section
);
1015 /* Discard sections marked with SEC_EXCLUDE if we are doing a final
1016 link. Discard debugging sections marked with SEC_EXCLUDE on a
1017 relocatable link too. */
1018 if ((flags
& SEC_EXCLUDE
) != 0
1019 && ((flags
& SEC_DEBUGGING
) != 0 || !link_info
.relocatable
))
1022 /* Discard input sections which are assigned to a section named
1023 DISCARD_SECTION_NAME. */
1024 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1027 /* Discard debugging sections if we are stripping debugging
1029 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1030 && (flags
& SEC_DEBUGGING
) != 0)
1035 if (section
->output_section
== NULL
)
1037 /* This prevents future calls from assigning this section. */
1038 section
->output_section
= bfd_abs_section_ptr
;
1043 if (section
->output_section
== NULL
)
1046 lang_input_section_type
*new;
1049 if (output
->bfd_section
== NULL
)
1052 first
= ! output
->bfd_section
->linker_has_input
;
1053 output
->bfd_section
->linker_has_input
= 1;
1055 /* Add a section reference to the list. */
1056 new = new_stat (lang_input_section
, ptr
);
1058 new->section
= section
;
1060 section
->output_section
= output
->bfd_section
;
1062 flags
= section
->flags
;
1064 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1065 to an output section, because we want to be able to include a
1066 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1067 section (I don't know why we want to do this, but we do).
1068 build_link_order in ldwrite.c handles this case by turning
1069 the embedded SEC_NEVER_LOAD section into a fill. */
1071 flags
&= ~ SEC_NEVER_LOAD
;
1073 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1074 already been processed. One reason to do this is that on pe
1075 format targets, .text$foo sections go into .text and it's odd
1076 to see .text with SEC_LINK_ONCE set. */
1078 if (! link_info
.relocatable
)
1079 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1081 /* If this is not the first input section, and the SEC_READONLY
1082 flag is not currently set, then don't set it just because the
1083 input section has it set. */
1085 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1086 flags
&= ~ SEC_READONLY
;
1088 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1090 && ((section
->output_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1091 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1092 || ((flags
& SEC_MERGE
)
1093 && section
->output_section
->entsize
!= section
->entsize
)))
1095 section
->output_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1096 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1099 /* For now make .tbss normal section. */
1100 if ((flags
& SEC_THREAD_LOCAL
) && ! link_info
.relocatable
)
1103 section
->output_section
->flags
|= flags
;
1105 if (flags
& SEC_MERGE
)
1106 section
->output_section
->entsize
= section
->entsize
;
1108 /* If SEC_READONLY is not set in the input section, then clear
1109 it from the output section. */
1110 if ((section
->flags
& SEC_READONLY
) == 0)
1111 section
->output_section
->flags
&= ~SEC_READONLY
;
1113 switch (output
->sectype
)
1115 case normal_section
:
1120 case overlay_section
:
1121 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1123 case noload_section
:
1124 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1125 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1129 /* Copy over SEC_SMALL_DATA. */
1130 if (section
->flags
& SEC_SMALL_DATA
)
1131 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1133 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1134 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1136 /* If supplied an alignment, then force it. */
1137 if (output
->section_alignment
!= -1)
1138 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1140 if (section
->flags
& SEC_BLOCK
)
1142 section
->output_section
->flags
|= SEC_BLOCK
;
1143 /* FIXME: This value should really be obtained from the bfd... */
1144 output
->block_value
= 128;
1149 /* Handle wildcard sorting. This returns the lang_input_section which
1150 should follow the one we are going to create for SECTION and FILE,
1151 based on the sorting requirements of WILD. It returns NULL if the
1152 new section should just go at the end of the current list. */
1154 static lang_statement_union_type
*
1155 wild_sort (lang_wild_statement_type
*wild
,
1156 struct wildcard_list
*sec
,
1157 lang_input_statement_type
*file
,
1160 const char *section_name
;
1161 lang_statement_union_type
*l
;
1163 if (!wild
->filenames_sorted
&& (sec
== NULL
|| !sec
->spec
.sorted
))
1166 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1167 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
1169 lang_input_section_type
*ls
;
1171 if (l
->header
.type
!= lang_input_section_enum
)
1173 ls
= &l
->input_section
;
1175 /* Sorting by filename takes precedence over sorting by section
1178 if (wild
->filenames_sorted
)
1180 const char *fn
, *ln
;
1184 /* The PE support for the .idata section as generated by
1185 dlltool assumes that files will be sorted by the name of
1186 the archive and then the name of the file within the
1189 if (file
->the_bfd
!= NULL
1190 && bfd_my_archive (file
->the_bfd
) != NULL
)
1192 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1197 fn
= file
->filename
;
1201 if (ls
->ifile
->the_bfd
!= NULL
1202 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1204 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1209 ln
= ls
->ifile
->filename
;
1213 i
= strcmp (fn
, ln
);
1222 fn
= file
->filename
;
1224 ln
= ls
->ifile
->filename
;
1226 i
= strcmp (fn
, ln
);
1234 /* Here either the files are not sorted by name, or we are
1235 looking at the sections for this file. */
1237 if (sec
!= NULL
&& sec
->spec
.sorted
)
1239 if (strcmp (section_name
,
1240 bfd_get_section_name (ls
->ifile
->the_bfd
,
1250 /* Expand a wild statement for a particular FILE. SECTION may be
1251 NULL, in which case it is a wild card. */
1254 output_section_callback (lang_wild_statement_type
*ptr
,
1255 struct wildcard_list
*sec
,
1257 lang_input_statement_type
*file
,
1260 lang_statement_union_type
*before
;
1262 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1263 if (unique_section_p (bfd_get_section_name (file
->the_bfd
, section
)))
1266 /* If the wild pattern was marked KEEP, the member sections
1267 should be as well. */
1268 if (ptr
->keep_sections
)
1269 section
->flags
|= SEC_KEEP
;
1271 before
= wild_sort (ptr
, sec
, file
, section
);
1273 /* Here BEFORE points to the lang_input_section which
1274 should follow the one we are about to add. If BEFORE
1275 is NULL, then the section should just go at the end
1276 of the current list. */
1279 lang_add_section (&ptr
->children
, section
,
1280 (lang_output_section_statement_type
*) output
,
1284 lang_statement_list_type list
;
1285 lang_statement_union_type
**pp
;
1287 lang_list_init (&list
);
1288 lang_add_section (&list
, section
,
1289 (lang_output_section_statement_type
*) output
,
1292 /* If we are discarding the section, LIST.HEAD will
1294 if (list
.head
!= NULL
)
1296 ASSERT (list
.head
->header
.next
== NULL
);
1298 for (pp
= &ptr
->children
.head
;
1300 pp
= &(*pp
)->header
.next
)
1301 ASSERT (*pp
!= NULL
);
1303 list
.head
->header
.next
= *pp
;
1309 /* This is passed a file name which must have been seen already and
1310 added to the statement tree. We will see if it has been opened
1311 already and had its symbols read. If not then we'll read it. */
1313 static lang_input_statement_type
*
1314 lookup_name (const char *name
)
1316 lang_input_statement_type
*search
;
1318 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1320 search
= (lang_input_statement_type
*) search
->next_real_file
)
1322 if (search
->filename
== NULL
&& name
== NULL
)
1324 if (search
->filename
!= NULL
1326 && strcmp (search
->filename
, name
) == 0)
1331 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1334 /* If we have already added this file, or this file is not real
1335 (FIXME: can that ever actually happen?) or the name is NULL
1336 (FIXME: can that ever actually happen?) don't add this file. */
1339 || search
->filename
== NULL
)
1342 if (! load_symbols (search
, NULL
))
1348 /* Get the symbols for an input file. */
1351 load_symbols (lang_input_statement_type
*entry
,
1352 lang_statement_list_type
*place
)
1359 ldfile_open_file (entry
);
1361 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1362 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1365 lang_statement_list_type
*hold
;
1366 bfd_boolean bad_load
= TRUE
;
1367 bfd_boolean save_ldlang_sysrooted_script
;
1369 err
= bfd_get_error ();
1371 /* See if the emulation has some special knowledge. */
1372 if (ldemul_unrecognized_file (entry
))
1375 if (err
== bfd_error_file_ambiguously_recognized
)
1379 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1380 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1381 for (p
= matching
; *p
!= NULL
; p
++)
1385 else if (err
!= bfd_error_file_not_recognized
1387 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1391 bfd_close (entry
->the_bfd
);
1392 entry
->the_bfd
= NULL
;
1394 /* Try to interpret the file as a linker script. */
1395 ldfile_open_command_file (entry
->filename
);
1399 save_ldlang_sysrooted_script
= ldlang_sysrooted_script
;
1400 ldlang_sysrooted_script
= entry
->sysrooted
;
1402 ldfile_assumed_script
= TRUE
;
1403 parser_input
= input_script
;
1405 ldfile_assumed_script
= FALSE
;
1407 ldlang_sysrooted_script
= save_ldlang_sysrooted_script
;
1413 if (ldemul_recognized_file (entry
))
1416 /* We don't call ldlang_add_file for an archive. Instead, the
1417 add_symbols entry point will call ldlang_add_file, via the
1418 add_archive_element callback, for each element of the archive
1420 switch (bfd_get_format (entry
->the_bfd
))
1426 ldlang_add_file (entry
);
1427 if (trace_files
|| trace_file_tries
)
1428 info_msg ("%I\n", entry
);
1432 if (entry
->whole_archive
)
1435 bfd_boolean loaded
= TRUE
;
1439 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
1444 if (! bfd_check_format (member
, bfd_object
))
1446 einfo (_("%F%B: member %B in archive is not an object\n"),
1447 entry
->the_bfd
, member
);
1451 if (! ((*link_info
.callbacks
->add_archive_element
)
1452 (&link_info
, member
, "--whole-archive")))
1455 if (! bfd_link_add_symbols (member
, &link_info
))
1457 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1462 entry
->loaded
= loaded
;
1468 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1469 entry
->loaded
= TRUE
;
1471 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1473 return entry
->loaded
;
1476 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1477 may be NULL, indicating that it is a wildcard. Separate
1478 lang_input_section statements are created for each part of the
1479 expansion; they are added after the wild statement S. OUTPUT is
1480 the output section. */
1483 wild (lang_wild_statement_type
*s
,
1484 const char *target ATTRIBUTE_UNUSED
,
1485 lang_output_section_statement_type
*output
)
1487 struct wildcard_list
*sec
;
1489 walk_wild (s
, output_section_callback
, output
);
1491 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
1493 if (default_common_section
!= NULL
)
1495 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
1497 /* Remember the section that common is going to in case we
1498 later get something which doesn't know where to put it. */
1499 default_common_section
= output
;
1504 /* Return TRUE iff target is the sought target. */
1507 get_target (const bfd_target
*target
, void *data
)
1509 const char *sought
= data
;
1511 return strcmp (target
->name
, sought
) == 0;
1514 /* Like strcpy() but convert to lower case as well. */
1517 stricpy (char *dest
, char *src
)
1521 while ((c
= *src
++) != 0)
1522 *dest
++ = TOLOWER (c
);
1527 /* Remove the first occurrence of needle (if any) in haystack
1531 strcut (char *haystack
, char *needle
)
1533 haystack
= strstr (haystack
, needle
);
1539 for (src
= haystack
+ strlen (needle
); *src
;)
1540 *haystack
++ = *src
++;
1546 /* Compare two target format name strings.
1547 Return a value indicating how "similar" they are. */
1550 name_compare (char *first
, char *second
)
1556 copy1
= xmalloc (strlen (first
) + 1);
1557 copy2
= xmalloc (strlen (second
) + 1);
1559 /* Convert the names to lower case. */
1560 stricpy (copy1
, first
);
1561 stricpy (copy2
, second
);
1563 /* Remove size and endian strings from the name. */
1564 strcut (copy1
, "big");
1565 strcut (copy1
, "little");
1566 strcut (copy2
, "big");
1567 strcut (copy2
, "little");
1569 /* Return a value based on how many characters match,
1570 starting from the beginning. If both strings are
1571 the same then return 10 * their length. */
1572 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1573 if (copy1
[result
] == 0)
1585 /* Set by closest_target_match() below. */
1586 static const bfd_target
*winner
;
1588 /* Scan all the valid bfd targets looking for one that has the endianness
1589 requirement that was specified on the command line, and is the nearest
1590 match to the original output target. */
1593 closest_target_match (const bfd_target
*target
, void *data
)
1595 const bfd_target
*original
= data
;
1597 if (command_line
.endian
== ENDIAN_BIG
1598 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1601 if (command_line
.endian
== ENDIAN_LITTLE
1602 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1605 /* Must be the same flavour. */
1606 if (target
->flavour
!= original
->flavour
)
1609 /* If we have not found a potential winner yet, then record this one. */
1616 /* Oh dear, we now have two potential candidates for a successful match.
1617 Compare their names and choose the better one. */
1618 if (name_compare (target
->name
, original
->name
)
1619 > name_compare (winner
->name
, original
->name
))
1622 /* Keep on searching until wqe have checked them all. */
1626 /* Return the BFD target format of the first input file. */
1629 get_first_input_target (void)
1631 char *target
= NULL
;
1633 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1635 if (s
->header
.type
== lang_input_statement_enum
1638 ldfile_open_file (s
);
1640 if (s
->the_bfd
!= NULL
1641 && bfd_check_format (s
->the_bfd
, bfd_object
))
1643 target
= bfd_get_target (s
->the_bfd
);
1655 lang_get_output_target (void)
1659 /* Has the user told us which output format to use? */
1660 if (output_target
!= NULL
)
1661 return output_target
;
1663 /* No - has the current target been set to something other than
1665 if (current_target
!= default_target
)
1666 return current_target
;
1668 /* No - can we determine the format of the first input file? */
1669 target
= get_first_input_target ();
1673 /* Failed - use the default output target. */
1674 return default_target
;
1677 /* Open the output file. */
1680 open_output (const char *name
)
1684 output_target
= lang_get_output_target ();
1686 /* Has the user requested a particular endianness on the command
1688 if (command_line
.endian
!= ENDIAN_UNSET
)
1690 const bfd_target
*target
;
1691 enum bfd_endian desired_endian
;
1693 /* Get the chosen target. */
1694 target
= bfd_search_for_target (get_target
, (void *) output_target
);
1696 /* If the target is not supported, we cannot do anything. */
1699 if (command_line
.endian
== ENDIAN_BIG
)
1700 desired_endian
= BFD_ENDIAN_BIG
;
1702 desired_endian
= BFD_ENDIAN_LITTLE
;
1704 /* See if the target has the wrong endianness. This should
1705 not happen if the linker script has provided big and
1706 little endian alternatives, but some scrips don't do
1708 if (target
->byteorder
!= desired_endian
)
1710 /* If it does, then see if the target provides
1711 an alternative with the correct endianness. */
1712 if (target
->alternative_target
!= NULL
1713 && (target
->alternative_target
->byteorder
== desired_endian
))
1714 output_target
= target
->alternative_target
->name
;
1717 /* Try to find a target as similar as possible to
1718 the default target, but which has the desired
1719 endian characteristic. */
1720 bfd_search_for_target (closest_target_match
,
1723 /* Oh dear - we could not find any targets that
1724 satisfy our requirements. */
1726 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1728 output_target
= winner
->name
;
1734 output
= bfd_openw (name
, output_target
);
1738 if (bfd_get_error () == bfd_error_invalid_target
)
1739 einfo (_("%P%F: target %s not found\n"), output_target
);
1741 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1744 delete_output_file_on_failure
= TRUE
;
1747 output
->flags
|= D_PAGED
;
1750 if (! bfd_set_format (output
, bfd_object
))
1751 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1752 if (! bfd_set_arch_mach (output
,
1753 ldfile_output_architecture
,
1754 ldfile_output_machine
))
1755 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1757 link_info
.hash
= bfd_link_hash_table_create (output
);
1758 if (link_info
.hash
== NULL
)
1759 einfo (_("%P%F: can not create link hash table: %E\n"));
1761 bfd_set_gp_size (output
, g_switch_value
);
1766 ldlang_open_output (lang_statement_union_type
*statement
)
1768 switch (statement
->header
.type
)
1770 case lang_output_statement_enum
:
1771 ASSERT (output_bfd
== NULL
);
1772 output_bfd
= open_output (statement
->output_statement
.name
);
1773 ldemul_set_output_arch ();
1774 if (config
.magic_demand_paged
&& !link_info
.relocatable
)
1775 output_bfd
->flags
|= D_PAGED
;
1777 output_bfd
->flags
&= ~D_PAGED
;
1778 if (config
.text_read_only
)
1779 output_bfd
->flags
|= WP_TEXT
;
1781 output_bfd
->flags
&= ~WP_TEXT
;
1782 if (link_info
.traditional_format
)
1783 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1785 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1788 case lang_target_statement_enum
:
1789 current_target
= statement
->target_statement
.target
;
1796 /* Open all the input files. */
1799 open_input_bfds (lang_statement_union_type
*s
, bfd_boolean force
)
1801 for (; s
!= NULL
; s
= s
->header
.next
)
1803 switch (s
->header
.type
)
1805 case lang_constructors_statement_enum
:
1806 open_input_bfds (constructor_list
.head
, force
);
1808 case lang_output_section_statement_enum
:
1809 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1811 case lang_wild_statement_enum
:
1812 /* Maybe we should load the file's symbols. */
1813 if (s
->wild_statement
.filename
1814 && ! wildcardp (s
->wild_statement
.filename
))
1815 (void) lookup_name (s
->wild_statement
.filename
);
1816 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1818 case lang_group_statement_enum
:
1820 struct bfd_link_hash_entry
*undefs
;
1822 /* We must continually search the entries in the group
1823 until no new symbols are added to the list of undefined
1828 undefs
= link_info
.hash
->undefs_tail
;
1829 open_input_bfds (s
->group_statement
.children
.head
, TRUE
);
1831 while (undefs
!= link_info
.hash
->undefs_tail
);
1834 case lang_target_statement_enum
:
1835 current_target
= s
->target_statement
.target
;
1837 case lang_input_statement_enum
:
1838 if (s
->input_statement
.real
)
1840 lang_statement_list_type add
;
1842 s
->input_statement
.target
= current_target
;
1844 /* If we are being called from within a group, and this
1845 is an archive which has already been searched, then
1846 force it to be researched unless the whole archive
1847 has been loaded already. */
1849 && !s
->input_statement
.whole_archive
1850 && s
->input_statement
.loaded
1851 && bfd_check_format (s
->input_statement
.the_bfd
,
1853 s
->input_statement
.loaded
= FALSE
;
1855 lang_list_init (&add
);
1857 if (! load_symbols (&s
->input_statement
, &add
))
1858 config
.make_executable
= FALSE
;
1860 if (add
.head
!= NULL
)
1862 *add
.tail
= s
->header
.next
;
1863 s
->header
.next
= add
.head
;
1873 /* If there are [COMMONS] statements, put a wild one into the bss
1877 lang_reasonable_defaults (void)
1880 lang_output_section_statement_lookup (".text");
1881 lang_output_section_statement_lookup (".data");
1883 default_common_section
= lang_output_section_statement_lookup (".bss");
1885 if (!placed_commons
)
1887 lang_wild_statement_type
*new =
1888 new_stat (lang_wild_statement
,
1889 &default_common_section
->children
);
1891 new->section_name
= "COMMON";
1892 new->filename
= NULL
;
1893 lang_list_init (&new->children
);
1898 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
1901 lang_track_definedness (const char *name
)
1903 if (bfd_hash_lookup (&lang_definedness_table
, name
, TRUE
, FALSE
) == NULL
)
1904 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
1907 /* New-function for the definedness hash table. */
1909 static struct bfd_hash_entry
*
1910 lang_definedness_newfunc (struct bfd_hash_entry
*entry
,
1911 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
1912 const char *name ATTRIBUTE_UNUSED
)
1914 struct lang_definedness_hash_entry
*ret
1915 = (struct lang_definedness_hash_entry
*) entry
;
1918 ret
= (struct lang_definedness_hash_entry
*)
1919 bfd_hash_allocate (table
, sizeof (struct lang_definedness_hash_entry
));
1922 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
1924 ret
->iteration
= -1;
1928 /* Return the iteration when the definition of NAME was last updated. A
1929 value of -1 means that the symbol is not defined in the linker script
1930 or the command line, but may be defined in the linker symbol table. */
1933 lang_symbol_definition_iteration (const char *name
)
1935 struct lang_definedness_hash_entry
*defentry
1936 = (struct lang_definedness_hash_entry
*)
1937 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
1939 /* We've already created this one on the presence of DEFINED in the
1940 script, so it can't be NULL unless something is borked elsewhere in
1942 if (defentry
== NULL
)
1945 return defentry
->iteration
;
1948 /* Update the definedness state of NAME. */
1951 lang_update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
1953 struct lang_definedness_hash_entry
*defentry
1954 = (struct lang_definedness_hash_entry
*)
1955 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
1957 /* We don't keep track of symbols not tested with DEFINED. */
1958 if (defentry
== NULL
)
1961 /* If the symbol was already defined, and not from an earlier statement
1962 iteration, don't update the definedness iteration, because that'd
1963 make the symbol seem defined in the linker script at this point, and
1964 it wasn't; it was defined in some object. If we do anyway, DEFINED
1965 would start to yield false before this point and the construct "sym =
1966 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
1968 if (h
->type
!= bfd_link_hash_undefined
1969 && h
->type
!= bfd_link_hash_common
1970 && h
->type
!= bfd_link_hash_new
1971 && defentry
->iteration
== -1)
1974 defentry
->iteration
= lang_statement_iteration
;
1977 /* Add the supplied name to the symbol table as an undefined reference.
1978 This is a two step process as the symbol table doesn't even exist at
1979 the time the ld command line is processed. First we put the name
1980 on a list, then, once the output file has been opened, transfer the
1981 name to the symbol table. */
1983 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
1985 #define ldlang_undef_chain_list_head entry_symbol.next
1988 ldlang_add_undef (const char *const name
)
1990 ldlang_undef_chain_list_type
*new =
1991 stat_alloc (sizeof (ldlang_undef_chain_list_type
));
1993 new->next
= ldlang_undef_chain_list_head
;
1994 ldlang_undef_chain_list_head
= new;
1996 new->name
= xstrdup (name
);
1998 if (output_bfd
!= NULL
)
1999 insert_undefined (new->name
);
2002 /* Insert NAME as undefined in the symbol table. */
2005 insert_undefined (const char *name
)
2007 struct bfd_link_hash_entry
*h
;
2009 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
2011 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2012 if (h
->type
== bfd_link_hash_new
)
2014 h
->type
= bfd_link_hash_undefined
;
2015 h
->u
.undef
.abfd
= NULL
;
2016 bfd_link_add_undef (link_info
.hash
, h
);
2020 /* Run through the list of undefineds created above and place them
2021 into the linker hash table as undefined symbols belonging to the
2025 lang_place_undefineds (void)
2027 ldlang_undef_chain_list_type
*ptr
;
2029 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
2030 insert_undefined (ptr
->name
);
2033 /* Open input files and attach to output sections. */
2036 map_input_to_output_sections
2037 (lang_statement_union_type
*s
, const char *target
,
2038 lang_output_section_statement_type
*output_section_statement
)
2040 for (; s
!= NULL
; s
= s
->header
.next
)
2042 switch (s
->header
.type
)
2044 case lang_wild_statement_enum
:
2045 wild (&s
->wild_statement
, target
, output_section_statement
);
2047 case lang_constructors_statement_enum
:
2048 map_input_to_output_sections (constructor_list
.head
,
2050 output_section_statement
);
2052 case lang_output_section_statement_enum
:
2053 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2055 &s
->output_section_statement
);
2057 case lang_output_statement_enum
:
2059 case lang_target_statement_enum
:
2060 target
= s
->target_statement
.target
;
2062 case lang_group_statement_enum
:
2063 map_input_to_output_sections (s
->group_statement
.children
.head
,
2065 output_section_statement
);
2067 case lang_fill_statement_enum
:
2068 case lang_input_section_enum
:
2069 case lang_object_symbols_statement_enum
:
2070 case lang_data_statement_enum
:
2071 case lang_reloc_statement_enum
:
2072 case lang_padding_statement_enum
:
2073 case lang_input_statement_enum
:
2074 if (output_section_statement
!= NULL
2075 && output_section_statement
->bfd_section
== NULL
)
2076 init_os (output_section_statement
);
2078 case lang_assignment_statement_enum
:
2079 if (output_section_statement
!= NULL
2080 && output_section_statement
->bfd_section
== NULL
)
2081 init_os (output_section_statement
);
2083 /* Make sure that any sections mentioned in the assignment
2085 exp_init_os (s
->assignment_statement
.exp
);
2087 case lang_afile_asection_pair_statement_enum
:
2090 case lang_address_statement_enum
:
2091 /* Mark the specified section with the supplied address. */
2093 lang_output_section_statement_type
*os
=
2094 lang_output_section_statement_lookup
2095 (s
->address_statement
.section_name
);
2097 if (os
->bfd_section
== NULL
)
2099 os
->addr_tree
= s
->address_statement
.address
;
2106 /* An output section might have been removed after its statement was
2107 added. For example, ldemul_before_allocation can remove dynamic
2108 sections if they turn out to be not needed. Clean them up here. */
2111 strip_excluded_output_sections (void)
2113 lang_statement_union_type
*u
;
2115 for (u
= lang_output_section_statement
.head
;
2117 u
= u
->output_section_statement
.next
)
2119 lang_output_section_statement_type
*os
;
2122 os
= &u
->output_section_statement
;
2123 s
= os
->bfd_section
;
2124 if (s
!= NULL
&& (s
->flags
& SEC_EXCLUDE
) != 0)
2128 os
->bfd_section
= NULL
;
2130 for (p
= &output_bfd
->sections
; *p
; p
= &(*p
)->next
)
2133 bfd_section_list_remove (output_bfd
, p
);
2134 output_bfd
->section_count
--;
2142 print_output_section_statement
2143 (lang_output_section_statement_type
*output_section_statement
)
2145 asection
*section
= output_section_statement
->bfd_section
;
2148 if (output_section_statement
!= abs_output_section
)
2150 minfo ("\n%s", output_section_statement
->name
);
2152 if (section
!= NULL
)
2154 print_dot
= section
->vma
;
2156 len
= strlen (output_section_statement
->name
);
2157 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2162 while (len
< SECTION_NAME_MAP_LENGTH
)
2168 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2170 if (output_section_statement
->load_base
!= NULL
)
2174 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2175 "load base", lang_final_phase_enum
);
2176 minfo (_(" load address 0x%V"), addr
);
2183 print_statement_list (output_section_statement
->children
.head
,
2184 output_section_statement
);
2188 print_assignment (lang_assignment_statement_type
*assignment
,
2189 lang_output_section_statement_type
*output_section
)
2192 etree_value_type result
;
2194 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2197 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2198 lang_final_phase_enum
, print_dot
, &print_dot
);
2204 value
= result
.value
+ result
.section
->bfd_section
->vma
;
2205 dst
= assignment
->exp
->assign
.dst
;
2207 minfo ("0x%V", value
);
2208 if (dst
[0] == '.' && dst
[1] == 0)
2221 exp_print_tree (assignment
->exp
);
2227 print_input_statement (lang_input_statement_type
*statm
)
2229 if (statm
->filename
!= NULL
)
2231 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2235 /* Print all symbols defined in a particular section. This is called
2236 via bfd_link_hash_traverse. */
2239 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
2241 asection
*sec
= ptr
;
2243 if ((hash_entry
->type
== bfd_link_hash_defined
2244 || hash_entry
->type
== bfd_link_hash_defweak
)
2245 && sec
== hash_entry
->u
.def
.section
)
2249 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2252 (hash_entry
->u
.def
.value
2253 + hash_entry
->u
.def
.section
->output_offset
2254 + hash_entry
->u
.def
.section
->output_section
->vma
));
2256 minfo (" %T\n", hash_entry
->root
.string
);
2262 /* Print information about an input section to the map file. */
2265 print_input_section (lang_input_section_type
*in
)
2267 asection
*i
= in
->section
;
2268 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2269 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2270 ldfile_output_machine
);
2275 minfo ("%s", i
->name
);
2277 if (i
->output_section
!= NULL
)
2281 len
= 1 + strlen (i
->name
);
2282 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2287 while (len
< SECTION_NAME_MAP_LENGTH
)
2293 minfo ("0x%V %W %B\n",
2294 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2297 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2299 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2311 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2314 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
2316 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2322 print_fill_statement (lang_fill_statement_type
*fill
)
2326 fputs (" FILL mask 0x", config
.map_file
);
2327 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
2328 fprintf (config
.map_file
, "%02x", *p
);
2329 fputs ("\n", config
.map_file
);
2333 print_data_statement (lang_data_statement_type
*data
)
2339 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2340 ldfile_output_machine
);
2342 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2345 addr
= data
->output_vma
;
2346 if (data
->output_section
!= NULL
)
2347 addr
+= data
->output_section
->vma
;
2375 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2377 if (data
->exp
->type
.node_class
!= etree_value
)
2380 exp_print_tree (data
->exp
);
2385 print_dot
= addr
+ size
/ opb
;
2389 /* Print an address statement. These are generated by options like
2393 print_address_statement (lang_address_statement_type
*address
)
2395 minfo (_("Address of section %s set to "), address
->section_name
);
2396 exp_print_tree (address
->address
);
2400 /* Print a reloc statement. */
2403 print_reloc_statement (lang_reloc_statement_type
*reloc
)
2408 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2409 ldfile_output_machine
);
2411 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2414 addr
= reloc
->output_vma
;
2415 if (reloc
->output_section
!= NULL
)
2416 addr
+= reloc
->output_section
->vma
;
2418 size
= bfd_get_reloc_size (reloc
->howto
);
2420 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2422 if (reloc
->name
!= NULL
)
2423 minfo ("%s+", reloc
->name
);
2425 minfo ("%s+", reloc
->section
->name
);
2427 exp_print_tree (reloc
->addend_exp
);
2431 print_dot
= addr
+ size
/ opb
;
2435 print_padding_statement (lang_padding_statement_type
*s
)
2439 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2440 ldfile_output_machine
);
2444 len
= sizeof " *fill*" - 1;
2445 while (len
< SECTION_NAME_MAP_LENGTH
)
2451 addr
= s
->output_offset
;
2452 if (s
->output_section
!= NULL
)
2453 addr
+= s
->output_section
->vma
;
2454 minfo ("0x%V %W ", addr
, s
->size
);
2456 if (s
->fill
->size
!= 0)
2460 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
2461 fprintf (config
.map_file
, "%02x", *p
);
2466 print_dot
= addr
+ s
->size
/ opb
;
2470 print_wild_statement (lang_wild_statement_type
*w
,
2471 lang_output_section_statement_type
*os
)
2473 struct wildcard_list
*sec
;
2477 if (w
->filenames_sorted
)
2479 if (w
->filename
!= NULL
)
2480 minfo ("%s", w
->filename
);
2483 if (w
->filenames_sorted
)
2487 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
2489 if (sec
->spec
.sorted
)
2491 if (sec
->spec
.exclude_name_list
!= NULL
)
2494 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
2495 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
2496 minfo (" %s", tmp
->name
);
2499 if (sec
->spec
.name
!= NULL
)
2500 minfo ("%s", sec
->spec
.name
);
2503 if (sec
->spec
.sorted
)
2512 print_statement_list (w
->children
.head
, os
);
2515 /* Print a group statement. */
2518 print_group (lang_group_statement_type
*s
,
2519 lang_output_section_statement_type
*os
)
2521 fprintf (config
.map_file
, "START GROUP\n");
2522 print_statement_list (s
->children
.head
, os
);
2523 fprintf (config
.map_file
, "END GROUP\n");
2526 /* Print the list of statements in S.
2527 This can be called for any statement type. */
2530 print_statement_list (lang_statement_union_type
*s
,
2531 lang_output_section_statement_type
*os
)
2535 print_statement (s
, os
);
2540 /* Print the first statement in statement list S.
2541 This can be called for any statement type. */
2544 print_statement (lang_statement_union_type
*s
,
2545 lang_output_section_statement_type
*os
)
2547 switch (s
->header
.type
)
2550 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2553 case lang_constructors_statement_enum
:
2554 if (constructor_list
.head
!= NULL
)
2556 if (constructors_sorted
)
2557 minfo (" SORT (CONSTRUCTORS)\n");
2559 minfo (" CONSTRUCTORS\n");
2560 print_statement_list (constructor_list
.head
, os
);
2563 case lang_wild_statement_enum
:
2564 print_wild_statement (&s
->wild_statement
, os
);
2566 case lang_address_statement_enum
:
2567 print_address_statement (&s
->address_statement
);
2569 case lang_object_symbols_statement_enum
:
2570 minfo (" CREATE_OBJECT_SYMBOLS\n");
2572 case lang_fill_statement_enum
:
2573 print_fill_statement (&s
->fill_statement
);
2575 case lang_data_statement_enum
:
2576 print_data_statement (&s
->data_statement
);
2578 case lang_reloc_statement_enum
:
2579 print_reloc_statement (&s
->reloc_statement
);
2581 case lang_input_section_enum
:
2582 print_input_section (&s
->input_section
);
2584 case lang_padding_statement_enum
:
2585 print_padding_statement (&s
->padding_statement
);
2587 case lang_output_section_statement_enum
:
2588 print_output_section_statement (&s
->output_section_statement
);
2590 case lang_assignment_statement_enum
:
2591 print_assignment (&s
->assignment_statement
, os
);
2593 case lang_target_statement_enum
:
2594 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2596 case lang_output_statement_enum
:
2597 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2598 if (output_target
!= NULL
)
2599 minfo (" %s", output_target
);
2602 case lang_input_statement_enum
:
2603 print_input_statement (&s
->input_statement
);
2605 case lang_group_statement_enum
:
2606 print_group (&s
->group_statement
, os
);
2608 case lang_afile_asection_pair_statement_enum
:
2615 print_statements (void)
2617 print_statement_list (statement_list
.head
, abs_output_section
);
2620 /* Print the first N statements in statement list S to STDERR.
2621 If N == 0, nothing is printed.
2622 If N < 0, the entire list is printed.
2623 Intended to be called from GDB. */
2626 dprint_statement (lang_statement_union_type
*s
, int n
)
2628 FILE *map_save
= config
.map_file
;
2630 config
.map_file
= stderr
;
2633 print_statement_list (s
, abs_output_section
);
2636 while (s
&& --n
>= 0)
2638 print_statement (s
, abs_output_section
);
2643 config
.map_file
= map_save
;
2647 insert_pad (lang_statement_union_type
**ptr
,
2649 unsigned int alignment_needed
,
2650 asection
*output_section
,
2653 static fill_type zero_fill
= { 1, { 0 } };
2654 lang_statement_union_type
*pad
;
2656 pad
= ((lang_statement_union_type
*)
2657 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
2658 if (ptr
!= &statement_list
.head
2659 && pad
->header
.type
== lang_padding_statement_enum
2660 && pad
->padding_statement
.output_section
== output_section
)
2662 /* Use the existing pad statement. The above test on output
2663 section is probably redundant, but it doesn't hurt to check. */
2667 /* Make a new padding statement, linked into existing chain. */
2668 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
2669 pad
->header
.next
= *ptr
;
2671 pad
->header
.type
= lang_padding_statement_enum
;
2672 pad
->padding_statement
.output_section
= output_section
;
2675 pad
->padding_statement
.fill
= fill
;
2677 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
2678 pad
->padding_statement
.size
= alignment_needed
;
2679 output_section
->_raw_size
+= alignment_needed
;
2682 /* Work out how much this section will move the dot point. */
2685 size_input_section (lang_statement_union_type
**this_ptr
,
2686 lang_output_section_statement_type
*output_section_statement
,
2690 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2691 asection
*i
= is
->section
;
2693 if (!is
->ifile
->just_syms_flag
)
2695 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2696 ldfile_output_machine
);
2697 unsigned int alignment_needed
;
2700 /* Align this section first to the input sections requirement,
2701 then to the output section's requirement. If this alignment
2702 is greater than any seen before, then record it too. Perform
2703 the alignment by inserting a magic 'padding' statement. */
2705 if (output_section_statement
->subsection_alignment
!= -1)
2706 i
->alignment_power
= output_section_statement
->subsection_alignment
;
2708 o
= output_section_statement
->bfd_section
;
2709 if (o
->alignment_power
< i
->alignment_power
)
2710 o
->alignment_power
= i
->alignment_power
;
2712 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
2714 if (alignment_needed
!= 0)
2716 insert_pad (this_ptr
, fill
, alignment_needed
* opb
, o
, dot
);
2717 dot
+= alignment_needed
;
2720 /* Remember where in the output section this input section goes. */
2722 i
->output_offset
= dot
- o
->vma
;
2724 /* Mark how big the output section must be to contain this now. */
2725 if (i
->_cooked_size
!= 0)
2726 dot
+= i
->_cooked_size
/ opb
;
2728 dot
+= i
->_raw_size
/ opb
;
2729 o
->_raw_size
= (dot
- o
->vma
) * opb
;
2733 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2739 #define IGNORE_SECTION(bfd, s) \
2740 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2741 != (SEC_ALLOC | SEC_LOAD)) \
2742 || bfd_section_size (bfd, s) == 0)
2744 /* Check to see if any allocated sections overlap with other allocated
2745 sections. This can happen when the linker script specifically specifies
2746 the output section addresses of the two sections. */
2749 lang_check_section_addresses (void)
2752 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2754 /* Scan all sections in the output list. */
2755 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2759 /* Ignore sections which are not loaded or which have no contents. */
2760 if (IGNORE_SECTION (output_bfd
, s
))
2763 /* Once we reach section 's' stop our seach. This prevents two
2764 warning messages from being produced, one for 'section A overlaps
2765 section B' and one for 'section B overlaps section A'. */
2766 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2773 /* Only consider loadable sections with real contents. */
2774 if (IGNORE_SECTION (output_bfd
, os
))
2777 /* We must check the sections' LMA addresses not their
2778 VMA addresses because overlay sections can have
2779 overlapping VMAs but they must have distinct LMAs. */
2780 s_start
= bfd_section_lma (output_bfd
, s
);
2781 os_start
= bfd_section_lma (output_bfd
, os
);
2782 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2783 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2785 /* Look for an overlap. */
2786 if ((s_end
< os_start
) || (s_start
> os_end
))
2790 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2791 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2793 /* Once we have found one overlap for this section,
2794 stop looking for others. */
2800 /* Make sure the new address is within the region. We explicitly permit the
2801 current address to be at the exact end of the region when the address is
2802 non-zero, in case the region is at the end of addressable memory and the
2803 calculation wraps around. */
2806 os_region_check (lang_output_section_statement_type
*os
,
2807 struct memory_region_struct
*region
,
2811 if ((region
->current
< region
->origin
2812 || (region
->current
- region
->origin
> region
->length
))
2813 && ((region
->current
!= region
->origin
+ region
->length
)
2818 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2820 os
->bfd_section
->owner
,
2821 os
->bfd_section
->name
,
2826 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2828 os
->bfd_section
->owner
,
2829 os
->bfd_section
->name
);
2831 /* Reset the region pointer. */
2832 region
->current
= region
->origin
;
2836 /* Set the sizes for all the output sections. */
2839 lang_size_sections_1
2840 (lang_statement_union_type
*s
,
2841 lang_output_section_statement_type
*output_section_statement
,
2842 lang_statement_union_type
**prev
,
2846 bfd_boolean check_regions
)
2848 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2849 ldfile_output_machine
);
2851 /* Size up the sections from their constituent parts. */
2852 for (; s
!= NULL
; s
= s
->header
.next
)
2854 switch (s
->header
.type
)
2856 case lang_output_section_statement_enum
:
2859 lang_output_section_statement_type
*os
;
2861 os
= &s
->output_section_statement
;
2862 if (os
->bfd_section
== NULL
)
2863 /* This section was never actually created. */
2866 /* If this is a COFF shared library section, use the size and
2867 address from the input section. FIXME: This is COFF
2868 specific; it would be cleaner if there were some other way
2869 to do this, but nothing simple comes to mind. */
2870 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2874 if (os
->children
.head
== NULL
2875 || os
->children
.head
->header
.next
!= NULL
2876 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2877 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2880 input
= os
->children
.head
->input_section
.section
;
2881 bfd_set_section_vma (os
->bfd_section
->owner
,
2883 bfd_section_vma (input
->owner
, input
));
2884 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2888 if (bfd_is_abs_section (os
->bfd_section
))
2890 /* No matter what happens, an abs section starts at zero. */
2891 ASSERT (os
->bfd_section
->vma
== 0);
2895 if (os
->addr_tree
== NULL
)
2897 /* No address specified for this section, get one
2898 from the region specification. */
2899 if (os
->region
== NULL
2900 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2901 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2902 && os
->region
->name
[0] == '*'
2903 && strcmp (os
->region
->name
, DEFAULT_MEMORY_REGION
) == 0))
2905 os
->region
= lang_memory_default (os
->bfd_section
);
2908 /* If a loadable section is using the default memory
2909 region, and some non default memory regions were
2910 defined, issue an error message. */
2911 if (!IGNORE_SECTION (output_bfd
, os
->bfd_section
)
2912 && (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2913 & SEC_NEVER_LOAD
) == 0
2914 && ! link_info
.relocatable
2916 && strcmp (os
->region
->name
, DEFAULT_MEMORY_REGION
) == 0
2917 && lang_memory_region_list
!= NULL
2918 && (strcmp (lang_memory_region_list
->name
,
2919 DEFAULT_MEMORY_REGION
) != 0
2920 || lang_memory_region_list
->next
!= NULL
))
2922 /* By default this is an error rather than just a
2923 warning because if we allocate the section to the
2924 default memory region we can end up creating an
2925 excessivly large binary, or even seg faulting when
2926 attmepting to perform a negative seek. See
2927 http://sources.redhat.com/ml/binutils/2003-04/msg00423.html
2928 for an example of this. This behaviour can be
2929 overridden by the using the --no-check-sections
2931 if (command_line
.check_section_addresses
)
2932 einfo (_("%P%F: error: no memory region specified for loadable section `%s'\n"),
2933 bfd_get_section_name (output_bfd
,
2936 einfo (_("%P: warning: no memory region specified for loadable section `%s'\n"),
2937 bfd_get_section_name (output_bfd
,
2941 dot
= os
->region
->current
;
2943 if (os
->section_alignment
== -1)
2948 dot
= align_power (dot
,
2949 os
->bfd_section
->alignment_power
);
2951 if (dot
!= olddot
&& config
.warn_section_align
)
2952 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2953 os
->name
, (unsigned int) (dot
- olddot
));
2960 r
= exp_fold_tree (os
->addr_tree
,
2962 lang_allocating_phase_enum
,
2965 einfo (_("%F%S: non constant address expression for section %s\n"),
2968 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2971 /* The section starts here.
2972 First, align to what the section needs. */
2974 if (os
->section_alignment
!= -1)
2975 dot
= align_power (dot
, os
->section_alignment
);
2977 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2979 os
->bfd_section
->output_offset
= 0;
2982 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
2983 os
->fill
, dot
, relax
, check_regions
);
2985 /* Put the section within the requested block size, or
2986 align at the block boundary. */
2987 after
= align_n (os
->bfd_section
->vma
2988 + os
->bfd_section
->_raw_size
/ opb
,
2989 (bfd_vma
) os
->block_value
);
2991 if (bfd_is_abs_section (os
->bfd_section
))
2992 ASSERT (after
== os
->bfd_section
->vma
);
2993 else if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) == 0
2994 && (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
)
2995 && ! link_info
.relocatable
)
2996 os
->bfd_section
->_raw_size
= 0;
2998 os
->bfd_section
->_raw_size
=
2999 (after
- os
->bfd_section
->vma
) * opb
;
3001 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3002 os
->processed
= TRUE
;
3004 if (os
->update_dot_tree
!= 0)
3005 exp_fold_tree (os
->update_dot_tree
, abs_output_section
,
3006 lang_allocating_phase_enum
, dot
, &dot
);
3008 /* Update dot in the region ?
3009 We only do this if the section is going to be allocated,
3010 since unallocated sections do not contribute to the region's
3011 overall size in memory.
3013 If the SEC_NEVER_LOAD bit is not set, it will affect the
3014 addresses of sections after it. We have to update
3016 if (os
->region
!= NULL
3017 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3018 & SEC_NEVER_LOAD
) == 0
3019 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3020 & (SEC_ALLOC
| SEC_LOAD
))))
3022 os
->region
->current
= dot
;
3025 /* Make sure the new address is within the region. */
3026 os_region_check (os
, os
->region
, os
->addr_tree
,
3027 os
->bfd_section
->vma
);
3029 /* If there's no load address specified, use the run
3030 region as the load region. */
3031 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
3032 os
->lma_region
= os
->region
;
3034 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
)
3036 /* Set load_base, which will be handled later. */
3037 os
->load_base
= exp_intop (os
->lma_region
->current
);
3038 os
->lma_region
->current
+=
3039 os
->bfd_section
->_raw_size
/ opb
;
3041 os_region_check (os
, os
->lma_region
, NULL
,
3042 os
->bfd_section
->lma
);
3048 case lang_constructors_statement_enum
:
3049 dot
= lang_size_sections_1 (constructor_list
.head
,
3050 output_section_statement
,
3051 &s
->wild_statement
.children
.head
,
3052 fill
, dot
, relax
, check_regions
);
3055 case lang_data_statement_enum
:
3057 unsigned int size
= 0;
3059 s
->data_statement
.output_vma
=
3060 dot
- output_section_statement
->bfd_section
->vma
;
3061 s
->data_statement
.output_section
=
3062 output_section_statement
->bfd_section
;
3064 switch (s
->data_statement
.type
)
3085 output_section_statement
->bfd_section
->_raw_size
+= size
;
3086 /* The output section gets contents, and then we inspect for
3087 any flags set in the input script which override any ALLOC. */
3088 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3089 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3091 output_section_statement
->bfd_section
->flags
|=
3092 SEC_ALLOC
| SEC_LOAD
;
3097 case lang_reloc_statement_enum
:
3101 s
->reloc_statement
.output_vma
=
3102 dot
- output_section_statement
->bfd_section
->vma
;
3103 s
->reloc_statement
.output_section
=
3104 output_section_statement
->bfd_section
;
3105 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3107 output_section_statement
->bfd_section
->_raw_size
+= size
;
3111 case lang_wild_statement_enum
:
3113 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
3114 output_section_statement
,
3115 &s
->wild_statement
.children
.head
,
3116 fill
, dot
, relax
, check_regions
);
3120 case lang_object_symbols_statement_enum
:
3121 link_info
.create_object_symbols_section
=
3122 output_section_statement
->bfd_section
;
3124 case lang_output_statement_enum
:
3125 case lang_target_statement_enum
:
3127 case lang_input_section_enum
:
3131 i
= (*prev
)->input_section
.section
;
3134 if (i
->_cooked_size
== 0)
3135 i
->_cooked_size
= i
->_raw_size
;
3141 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3142 einfo (_("%P%F: can't relax section: %E\n"));
3146 dot
= size_input_section (prev
, output_section_statement
,
3147 output_section_statement
->fill
, dot
);
3150 case lang_input_statement_enum
:
3152 case lang_fill_statement_enum
:
3153 s
->fill_statement
.output_section
=
3154 output_section_statement
->bfd_section
;
3156 fill
= s
->fill_statement
.fill
;
3158 case lang_assignment_statement_enum
:
3160 bfd_vma newdot
= dot
;
3162 exp_fold_tree (s
->assignment_statement
.exp
,
3163 output_section_statement
,
3164 lang_allocating_phase_enum
,
3170 if (output_section_statement
== abs_output_section
)
3172 /* If we don't have an output section, then just adjust
3173 the default memory address. */
3174 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
)->current
= newdot
;
3178 /* Insert a pad after this statement. We can't
3179 put the pad before when relaxing, in case the
3180 assignment references dot. */
3181 insert_pad (&s
->header
.next
, fill
, (newdot
- dot
) * opb
,
3182 output_section_statement
->bfd_section
, dot
);
3184 /* Don't neuter the pad below when relaxing. */
3193 case lang_padding_statement_enum
:
3194 /* If this is the first time lang_size_sections is called,
3195 we won't have any padding statements. If this is the
3196 second or later passes when relaxing, we should allow
3197 padding to shrink. If padding is needed on this pass, it
3198 will be added back in. */
3199 s
->padding_statement
.size
= 0;
3201 /* Make sure output_offset is valid. If relaxation shrinks
3202 the section and this pad isn't needed, it's possible to
3203 have output_offset larger than the final size of the
3204 section. bfd_set_section_contents will complain even for
3205 a pad size of zero. */
3206 s
->padding_statement
.output_offset
3207 = dot
- output_section_statement
->bfd_section
->vma
;
3210 case lang_group_statement_enum
:
3211 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
3212 output_section_statement
,
3213 &s
->group_statement
.children
.head
,
3214 fill
, dot
, relax
, check_regions
);
3221 /* We can only get here when relaxing is turned on. */
3222 case lang_address_statement_enum
:
3225 prev
= &s
->header
.next
;
3232 (lang_statement_union_type
*s
,
3233 lang_output_section_statement_type
*output_section_statement
,
3234 lang_statement_union_type
**prev
,
3238 bfd_boolean check_regions
)
3243 /* Callers of exp_fold_tree need to increment this. */
3244 lang_statement_iteration
++;
3246 exp_data_seg
.phase
= exp_dataseg_none
;
3247 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
3248 dot
, relax
, check_regions
);
3249 if (exp_data_seg
.phase
== exp_dataseg_end_seen
)
3251 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3252 a page could be saved in the data segment. */
3253 bfd_vma first
, last
;
3255 first
= -exp_data_seg
.base
& (exp_data_seg
.pagesize
- 1);
3256 last
= exp_data_seg
.end
& (exp_data_seg
.pagesize
- 1);
3258 && ((exp_data_seg
.base
& ~(exp_data_seg
.pagesize
- 1))
3259 != (exp_data_seg
.end
& ~(exp_data_seg
.pagesize
- 1)))
3260 && first
+ last
<= exp_data_seg
.pagesize
)
3262 exp_data_seg
.phase
= exp_dataseg_adjust
;
3263 result
= lang_size_sections_1 (s
, output_section_statement
, prev
,
3264 fill
, dot
, relax
, check_regions
);
3268 /* Some backend relaxers want to refer to the output section size. Give
3269 them a section size that does not change on the next call while they
3270 relax. We can't set this at top because lang_reset_memory_regions
3271 which is called before we get here, sets _raw_size to 0 on relaxing
3273 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3274 o
->_cooked_size
= o
->_raw_size
;
3279 /* Worker function for lang_do_assignments. Recursiveness goes here. */
3282 lang_do_assignments_1
3283 (lang_statement_union_type
*s
,
3284 lang_output_section_statement_type
*output_section_statement
,
3288 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3289 ldfile_output_machine
);
3291 for (; s
!= NULL
; s
= s
->header
.next
)
3293 switch (s
->header
.type
)
3295 case lang_constructors_statement_enum
:
3296 dot
= lang_do_assignments_1 (constructor_list
.head
,
3297 output_section_statement
,
3302 case lang_output_section_statement_enum
:
3304 lang_output_section_statement_type
*os
;
3306 os
= &(s
->output_section_statement
);
3307 if (os
->bfd_section
!= NULL
)
3309 dot
= os
->bfd_section
->vma
;
3310 (void) lang_do_assignments_1 (os
->children
.head
, os
,
3312 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3317 /* If nothing has been placed into the output section then
3318 it won't have a bfd_section. */
3319 if (os
->bfd_section
)
3321 os
->bfd_section
->lma
3322 = exp_get_abs_int (os
->load_base
, 0, "load base",
3323 lang_final_phase_enum
);
3328 case lang_wild_statement_enum
:
3330 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
3331 output_section_statement
,
3336 case lang_object_symbols_statement_enum
:
3337 case lang_output_statement_enum
:
3338 case lang_target_statement_enum
:
3340 case lang_common_statement_enum
:
3343 case lang_data_statement_enum
:
3345 etree_value_type value
;
3347 value
= exp_fold_tree (s
->data_statement
.exp
,
3349 lang_final_phase_enum
, dot
, &dot
);
3350 s
->data_statement
.value
= value
.value
;
3352 einfo (_("%F%P: invalid data statement\n"));
3356 switch (s
->data_statement
.type
)
3380 case lang_reloc_statement_enum
:
3382 etree_value_type value
;
3384 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3386 lang_final_phase_enum
, dot
, &dot
);
3387 s
->reloc_statement
.addend_value
= value
.value
;
3389 einfo (_("%F%P: invalid reloc statement\n"));
3391 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3394 case lang_input_section_enum
:
3396 asection
*in
= s
->input_section
.section
;
3398 if (in
->_cooked_size
!= 0)
3399 dot
+= in
->_cooked_size
/ opb
;
3401 dot
+= in
->_raw_size
/ opb
;
3405 case lang_input_statement_enum
:
3407 case lang_fill_statement_enum
:
3408 fill
= s
->fill_statement
.fill
;
3410 case lang_assignment_statement_enum
:
3412 exp_fold_tree (s
->assignment_statement
.exp
,
3413 output_section_statement
,
3414 lang_final_phase_enum
,
3420 case lang_padding_statement_enum
:
3421 dot
+= s
->padding_statement
.size
/ opb
;
3424 case lang_group_statement_enum
:
3425 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
3426 output_section_statement
,
3434 case lang_address_statement_enum
:
3443 lang_do_assignments (lang_statement_union_type
*s
,
3444 lang_output_section_statement_type
3445 *output_section_statement
,
3449 /* Callers of exp_fold_tree need to increment this. */
3450 lang_statement_iteration
++;
3451 lang_do_assignments_1 (s
, output_section_statement
, fill
, dot
);
3454 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3455 operator .startof. (section_name), it produces an undefined symbol
3456 .startof.section_name. Similarly, when it sees
3457 .sizeof. (section_name), it produces an undefined symbol
3458 .sizeof.section_name. For all the output sections, we look for
3459 such symbols, and set them to the correct value. */
3462 lang_set_startof (void)
3466 if (link_info
.relocatable
)
3469 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3471 const char *secname
;
3473 struct bfd_link_hash_entry
*h
;
3475 secname
= bfd_get_section_name (output_bfd
, s
);
3476 buf
= xmalloc (10 + strlen (secname
));
3478 sprintf (buf
, ".startof.%s", secname
);
3479 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
3480 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3482 h
->type
= bfd_link_hash_defined
;
3483 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3484 h
->u
.def
.section
= bfd_abs_section_ptr
;
3487 sprintf (buf
, ".sizeof.%s", secname
);
3488 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
3489 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3493 opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3494 ldfile_output_machine
);
3495 h
->type
= bfd_link_hash_defined
;
3496 if (s
->_cooked_size
!= 0)
3497 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3499 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3500 h
->u
.def
.section
= bfd_abs_section_ptr
;
3510 struct bfd_link_hash_entry
*h
;
3513 if (link_info
.relocatable
|| link_info
.shared
)
3518 if (entry_symbol
.name
== NULL
)
3520 /* No entry has been specified. Look for start, but don't warn
3521 if we don't find it. */
3522 entry_symbol
.name
= "start";
3526 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
3527 FALSE
, FALSE
, TRUE
);
3529 && (h
->type
== bfd_link_hash_defined
3530 || h
->type
== bfd_link_hash_defweak
)
3531 && h
->u
.def
.section
->output_section
!= NULL
)
3535 val
= (h
->u
.def
.value
3536 + bfd_get_section_vma (output_bfd
,
3537 h
->u
.def
.section
->output_section
)
3538 + h
->u
.def
.section
->output_offset
);
3539 if (! bfd_set_start_address (output_bfd
, val
))
3540 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
3547 /* We couldn't find the entry symbol. Try parsing it as a
3549 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
3552 if (! bfd_set_start_address (output_bfd
, val
))
3553 einfo (_("%P%F: can't set start address\n"));
3559 /* Can't find the entry symbol, and it's not a number. Use
3560 the first address in the text section. */
3561 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
3565 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3567 bfd_get_section_vma (output_bfd
, ts
));
3568 if (! bfd_set_start_address (output_bfd
,
3569 bfd_get_section_vma (output_bfd
,
3571 einfo (_("%P%F: can't set start address\n"));
3576 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3582 bfd_hash_table_free (&lang_definedness_table
);
3585 /* This is a small function used when we want to ignore errors from
3589 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3591 /* Don't do anything. */
3594 /* Check that the architecture of all the input files is compatible
3595 with the output file. Also call the backend to let it do any
3596 other checking that is needed. */
3601 lang_statement_union_type
*file
;
3603 const bfd_arch_info_type
*compatible
;
3605 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
3607 input_bfd
= file
->input_statement
.the_bfd
;
3608 compatible
= bfd_arch_get_compatible (input_bfd
, output_bfd
,
3609 command_line
.accept_unknown_input_arch
);
3611 /* In general it is not possible to perform a relocatable
3612 link between differing object formats when the input
3613 file has relocations, because the relocations in the
3614 input format may not have equivalent representations in
3615 the output format (and besides BFD does not translate
3616 relocs for other link purposes than a final link). */
3617 if ((link_info
.relocatable
|| link_info
.emitrelocations
)
3618 && (compatible
== NULL
3619 || bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
3620 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
3622 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3623 bfd_get_target (input_bfd
), input_bfd
,
3624 bfd_get_target (output_bfd
), output_bfd
);
3625 /* einfo with %F exits. */
3628 if (compatible
== NULL
)
3630 if (command_line
.warn_mismatch
)
3631 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3632 bfd_printable_name (input_bfd
), input_bfd
,
3633 bfd_printable_name (output_bfd
));
3635 else if (bfd_count_sections (input_bfd
))
3637 /* If the input bfd has no contents, it shouldn't set the
3638 private data of the output bfd. */
3640 bfd_error_handler_type pfn
= NULL
;
3642 /* If we aren't supposed to warn about mismatched input
3643 files, temporarily set the BFD error handler to a
3644 function which will do nothing. We still want to call
3645 bfd_merge_private_bfd_data, since it may set up
3646 information which is needed in the output file. */
3647 if (! command_line
.warn_mismatch
)
3648 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3649 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3651 if (command_line
.warn_mismatch
)
3652 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3655 if (! command_line
.warn_mismatch
)
3656 bfd_set_error_handler (pfn
);
3661 /* Look through all the global common symbols and attach them to the
3662 correct section. The -sort-common command line switch may be used
3663 to roughly sort the entries by size. */
3668 if (command_line
.inhibit_common_definition
)
3670 if (link_info
.relocatable
3671 && ! command_line
.force_common_definition
)
3674 if (! config
.sort_common
)
3675 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
3680 for (power
= 4; power
>= 0; power
--)
3681 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
3685 /* Place one common symbol in the correct section. */
3688 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
3690 unsigned int power_of_two
;
3693 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3694 ldfile_output_machine
);
3696 if (h
->type
!= bfd_link_hash_common
)
3700 power_of_two
= h
->u
.c
.p
->alignment_power
;
3702 if (config
.sort_common
3703 && power_of_two
< (unsigned int) *(int *) info
)
3706 section
= h
->u
.c
.p
->section
;
3708 /* Increase the size of the section. */
3709 section
->_cooked_size
= align_n ((section
->_cooked_size
+ opb
- 1) / opb
,
3710 (bfd_vma
) 1 << power_of_two
) * opb
;
3712 /* Adjust the alignment if necessary. */
3713 if (power_of_two
> section
->alignment_power
)
3714 section
->alignment_power
= power_of_two
;
3716 /* Change the symbol from common to defined. */
3717 h
->type
= bfd_link_hash_defined
;
3718 h
->u
.def
.section
= section
;
3719 h
->u
.def
.value
= section
->_cooked_size
;
3721 /* Increase the size of the section. */
3722 section
->_cooked_size
+= size
;
3724 /* Make sure the section is allocated in memory, and make sure that
3725 it is no longer a common section. */
3726 section
->flags
|= SEC_ALLOC
;
3727 section
->flags
&= ~SEC_IS_COMMON
;
3729 if (config
.map_file
!= NULL
)
3731 static bfd_boolean header_printed
;
3736 if (! header_printed
)
3738 minfo (_("\nAllocating common symbols\n"));
3739 minfo (_("Common symbol size file\n\n"));
3740 header_printed
= TRUE
;
3743 name
= demangle (h
->root
.string
);
3745 len
= strlen (name
);
3760 if (size
<= 0xffffffff)
3761 sprintf (buf
, "%lx", (unsigned long) size
);
3763 sprintf_vma (buf
, size
);
3773 minfo ("%B\n", section
->owner
);
3779 /* Run through the input files and ensure that every input section has
3780 somewhere to go. If one is found without a destination then create
3781 an input request and place it into the statement tree. */
3784 lang_place_orphans (void)
3786 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3790 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3792 if (s
->output_section
== NULL
)
3794 /* This section of the file is not attached, root
3795 around for a sensible place for it to go. */
3797 if (file
->just_syms_flag
)
3801 else if (strcmp (s
->name
, "COMMON") == 0)
3803 /* This is a lonely common section which must have
3804 come from an archive. We attach to the section
3805 with the wildcard. */
3806 if (! link_info
.relocatable
3807 || command_line
.force_common_definition
)
3809 if (default_common_section
== NULL
)
3812 /* This message happens when using the
3813 svr3.ifile linker script, so I have
3815 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3817 default_common_section
=
3818 lang_output_section_statement_lookup (".bss");
3821 lang_add_section (&default_common_section
->children
, s
,
3822 default_common_section
, file
);
3825 else if (ldemul_place_orphan (file
, s
))
3829 lang_output_section_statement_type
*os
;
3831 os
= lang_output_section_statement_lookup (s
->name
);
3832 lang_add_section (&os
->children
, s
, os
, file
);
3840 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
3842 flagword
*ptr_flags
;
3844 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3850 *ptr_flags
|= SEC_ALLOC
;
3854 *ptr_flags
|= SEC_READONLY
;
3858 *ptr_flags
|= SEC_DATA
;
3862 *ptr_flags
|= SEC_CODE
;
3867 *ptr_flags
|= SEC_LOAD
;
3871 einfo (_("%P%F: invalid syntax in flags\n"));
3878 /* Call a function on each input file. This function will be called
3879 on an archive, but not on the elements. */
3882 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
3884 lang_input_statement_type
*f
;
3886 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3888 f
= (lang_input_statement_type
*) f
->next_real_file
)
3892 /* Call a function on each file. The function will be called on all
3893 the elements of an archive which are included in the link, but will
3894 not be called on the archive file itself. */
3897 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
3899 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3910 lang_for_each_input_section (void (*func
) (bfd
*ab
, asection
*as
))
3912 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3916 for (s
= f
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3917 func (f
->the_bfd
, s
);
3924 ldlang_add_file (lang_input_statement_type
*entry
)
3928 lang_statement_append (&file_chain
,
3929 (lang_statement_union_type
*) entry
,
3932 /* The BFD linker needs to have a list of all input BFDs involved in
3934 ASSERT (entry
->the_bfd
->link_next
== NULL
);
3935 ASSERT (entry
->the_bfd
!= output_bfd
);
3936 for (pp
= &link_info
.input_bfds
; *pp
!= NULL
; pp
= &(*pp
)->link_next
)
3938 *pp
= entry
->the_bfd
;
3939 entry
->the_bfd
->usrdata
= entry
;
3940 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3942 /* Look through the sections and check for any which should not be
3943 included in the link. We need to do this now, so that we can
3944 notice when the backend linker tries to report multiple
3945 definition errors for symbols which are in sections we aren't
3946 going to link. FIXME: It might be better to entirely ignore
3947 symbols which are defined in sections which are going to be
3948 discarded. This would require modifying the backend linker for
3949 each backend which might set the SEC_LINK_ONCE flag. If we do
3950 this, we should probably handle SEC_EXCLUDE in the same way. */
3952 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
3956 lang_add_output (const char *name
, int from_script
)
3958 /* Make -o on command line override OUTPUT in script. */
3959 if (!had_output_filename
|| !from_script
)
3961 output_filename
= name
;
3962 had_output_filename
= TRUE
;
3966 static lang_output_section_statement_type
*current_section
;
3977 for (l
= 0; l
< 32; l
++)
3979 if (i
>= (unsigned int) x
)
3987 lang_output_section_statement_type
*
3988 lang_enter_output_section_statement (const char *output_section_statement_name
,
3989 etree_type
*address_exp
,
3990 enum section_type sectype
,
3991 bfd_vma block_value
,
3993 etree_type
*subalign
,
3996 lang_output_section_statement_type
*os
;
4000 lang_output_section_statement_lookup (output_section_statement_name
);
4002 /* Add this statement to tree. */
4004 add_statement (lang_output_section_statement_enum
,
4005 output_section_statement
);
4007 /* Make next things chain into subchain of this. */
4009 if (os
->addr_tree
== NULL
)
4011 os
->addr_tree
= address_exp
;
4013 os
->sectype
= sectype
;
4014 if (sectype
!= noload_section
)
4015 os
->flags
= SEC_NO_FLAGS
;
4017 os
->flags
= SEC_NEVER_LOAD
;
4018 os
->block_value
= block_value
? block_value
: 1;
4019 stat_ptr
= &os
->children
;
4021 os
->subsection_alignment
=
4022 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
4023 os
->section_alignment
=
4024 topower (exp_get_value_int (align
, -1, "section alignment", 0));
4026 os
->load_base
= ebase
;
4033 lang_output_statement_type
*new =
4034 new_stat (lang_output_statement
, stat_ptr
);
4036 new->name
= output_filename
;
4039 /* Reset the current counters in the regions. */
4042 lang_reset_memory_regions (void)
4044 lang_memory_region_type
*p
= lang_memory_region_list
;
4047 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
4049 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
4050 p
->current
= p
->origin
;
4053 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4057 /* If the wild pattern was marked KEEP, the member sections
4058 should be as well. */
4061 gc_section_callback (lang_wild_statement_type
*ptr
,
4062 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
4064 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
4065 void *data ATTRIBUTE_UNUSED
)
4067 if (ptr
->keep_sections
)
4068 section
->flags
|= SEC_KEEP
;
4071 /* Handle a wild statement, marking it against GC. */
4074 lang_gc_wild (lang_wild_statement_type
*s
)
4076 walk_wild (s
, gc_section_callback
, NULL
);
4079 /* Iterate over sections marking them against GC. */
4082 lang_gc_sections_1 (lang_statement_union_type
*s
)
4084 for (; s
!= NULL
; s
= s
->header
.next
)
4086 switch (s
->header
.type
)
4088 case lang_wild_statement_enum
:
4089 lang_gc_wild (&s
->wild_statement
);
4091 case lang_constructors_statement_enum
:
4092 lang_gc_sections_1 (constructor_list
.head
);
4094 case lang_output_section_statement_enum
:
4095 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4097 case lang_group_statement_enum
:
4098 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4107 lang_gc_sections (void)
4109 struct bfd_link_hash_entry
*h
;
4110 ldlang_undef_chain_list_type
*ulist
;
4112 /* Keep all sections so marked in the link script. */
4114 lang_gc_sections_1 (statement_list
.head
);
4116 /* Keep all sections containing symbols undefined on the command-line,
4117 and the section containing the entry symbol. */
4119 for (ulist
= link_info
.gc_sym_list
; ulist
; ulist
= ulist
->next
)
4121 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4122 FALSE
, FALSE
, FALSE
);
4125 && (h
->type
== bfd_link_hash_defined
4126 || h
->type
== bfd_link_hash_defweak
)
4127 && ! bfd_is_abs_section (h
->u
.def
.section
))
4129 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4133 bfd_gc_sections (output_bfd
, &link_info
);
4139 lang_reasonable_defaults ();
4140 current_target
= default_target
;
4142 /* Open the output file. */
4143 lang_for_each_statement (ldlang_open_output
);
4145 ldemul_create_output_section_statements ();
4147 /* Add to the hash table all undefineds on the command line. */
4148 lang_place_undefineds ();
4150 already_linked_table_init ();
4152 /* Create a bfd for each input file. */
4153 current_target
= default_target
;
4154 open_input_bfds (statement_list
.head
, FALSE
);
4156 link_info
.gc_sym_list
= &entry_symbol
;
4157 if (entry_symbol
.name
== NULL
)
4158 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
4160 ldemul_after_open ();
4162 already_linked_table_free ();
4164 /* Make sure that we're not mixing architectures. We call this
4165 after all the input files have been opened, but before we do any
4166 other processing, so that any operations merge_private_bfd_data
4167 does on the output file will be known during the rest of the
4171 /* Handle .exports instead of a version script if we're told to do so. */
4172 if (command_line
.version_exports_section
)
4173 lang_do_version_exports_section ();
4175 /* Build all sets based on the information gathered from the input
4177 ldctor_build_sets ();
4179 /* Remove unreferenced sections if asked to. */
4180 if (command_line
.gc_sections
)
4181 lang_gc_sections ();
4183 /* If there were any SEC_MERGE sections, finish their merging, so that
4184 section sizes can be computed. This has to be done after GC of sections,
4185 so that GCed sections are not merged, but before assigning output
4186 sections, since removing whole input sections is hard then. */
4187 bfd_merge_sections (output_bfd
, &link_info
);
4189 /* Size up the common data. */
4192 /* Run through the contours of the script and attach input sections
4193 to the correct output sections. */
4194 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
4196 /* Find any sections not attached explicitly and handle them. */
4197 lang_place_orphans ();
4199 if (! link_info
.relocatable
)
4201 /* Look for a text section and set the readonly attribute in it. */
4202 asection
*found
= bfd_get_section_by_name (output_bfd
, ".text");
4206 if (config
.text_read_only
)
4207 found
->flags
|= SEC_READONLY
;
4209 found
->flags
&= ~SEC_READONLY
;
4213 /* Do anything special before sizing sections. This is where ELF
4214 and other back-ends size dynamic sections. */
4215 ldemul_before_allocation ();
4217 if (!link_info
.relocatable
)
4218 strip_excluded_output_sections ();
4220 /* We must record the program headers before we try to fix the
4221 section positions, since they will affect SIZEOF_HEADERS. */
4222 lang_record_phdrs ();
4224 /* Size up the sections. */
4225 lang_size_sections (statement_list
.head
, abs_output_section
,
4226 &statement_list
.head
, 0, 0, NULL
,
4227 command_line
.relax
? FALSE
: TRUE
);
4229 /* Now run around and relax if we can. */
4230 if (command_line
.relax
)
4232 /* Keep relaxing until bfd_relax_section gives up. */
4233 bfd_boolean relax_again
;
4237 lang_reset_memory_regions ();
4239 relax_again
= FALSE
;
4241 /* Note: pe-dll.c does something like this also. If you find
4242 you need to change this code, you probably need to change
4243 pe-dll.c also. DJ */
4245 /* Do all the assignments with our current guesses as to
4247 lang_do_assignments (statement_list
.head
, abs_output_section
,
4250 /* Perform another relax pass - this time we know where the
4251 globals are, so can make a better guess. */
4252 lang_size_sections (statement_list
.head
, abs_output_section
,
4253 &statement_list
.head
, 0, 0, &relax_again
, FALSE
);
4255 /* If the normal relax is done and the relax finalize pass
4256 is not performed yet, we perform another relax pass. */
4257 if (!relax_again
&& !link_info
.relax_finalizing
)
4259 link_info
.relax_finalizing
= TRUE
;
4263 while (relax_again
);
4265 /* Final extra sizing to report errors. */
4266 lang_reset_memory_regions ();
4267 lang_do_assignments (statement_list
.head
, abs_output_section
, NULL
, 0);
4268 lang_size_sections (statement_list
.head
, abs_output_section
,
4269 &statement_list
.head
, 0, 0, NULL
, TRUE
);
4272 /* See if anything special should be done now we know how big
4274 ldemul_after_allocation ();
4276 /* Fix any .startof. or .sizeof. symbols. */
4277 lang_set_startof ();
4279 /* Do all the assignments, now that we know the final resting places
4280 of all the symbols. */
4282 lang_do_assignments (statement_list
.head
, abs_output_section
, NULL
, 0);
4284 /* Make sure that the section addresses make sense. */
4285 if (! link_info
.relocatable
4286 && command_line
.check_section_addresses
)
4287 lang_check_section_addresses ();
4295 /* EXPORTED TO YACC */
4298 lang_add_wild (struct wildcard_spec
*filespec
,
4299 struct wildcard_list
*section_list
,
4300 bfd_boolean keep_sections
)
4302 struct wildcard_list
*curr
, *next
;
4303 lang_wild_statement_type
*new;
4305 /* Reverse the list as the parser puts it back to front. */
4306 for (curr
= section_list
, section_list
= NULL
;
4308 section_list
= curr
, curr
= next
)
4310 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
4311 placed_commons
= TRUE
;
4314 curr
->next
= section_list
;
4317 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
4319 if (strcmp (filespec
->name
, "*") == 0)
4320 filespec
->name
= NULL
;
4321 else if (! wildcardp (filespec
->name
))
4322 lang_has_input_file
= TRUE
;
4325 new = new_stat (lang_wild_statement
, stat_ptr
);
4326 new->filename
= NULL
;
4327 new->filenames_sorted
= FALSE
;
4328 if (filespec
!= NULL
)
4330 new->filename
= filespec
->name
;
4331 new->filenames_sorted
= filespec
->sorted
;
4333 new->section_list
= section_list
;
4334 new->keep_sections
= keep_sections
;
4335 lang_list_init (&new->children
);
4339 lang_section_start (const char *name
, etree_type
*address
)
4341 lang_address_statement_type
*ad
;
4343 ad
= new_stat (lang_address_statement
, stat_ptr
);
4344 ad
->section_name
= name
;
4345 ad
->address
= address
;
4348 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4349 because of a -e argument on the command line, or zero if this is
4350 called by ENTRY in a linker script. Command line arguments take
4354 lang_add_entry (const char *name
, bfd_boolean cmdline
)
4356 if (entry_symbol
.name
== NULL
4358 || ! entry_from_cmdline
)
4360 entry_symbol
.name
= name
;
4361 entry_from_cmdline
= cmdline
;
4366 lang_add_target (const char *name
)
4368 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4376 lang_add_map (const char *name
)
4383 map_option_f
= TRUE
;
4391 lang_add_fill (fill_type
*fill
)
4393 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4400 lang_add_data (int type
, union etree_union
*exp
)
4403 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4411 /* Create a new reloc statement. RELOC is the BFD relocation type to
4412 generate. HOWTO is the corresponding howto structure (we could
4413 look this up, but the caller has already done so). SECTION is the
4414 section to generate a reloc against, or NAME is the name of the
4415 symbol to generate a reloc against. Exactly one of SECTION and
4416 NAME must be NULL. ADDEND is an expression for the addend. */
4419 lang_add_reloc (bfd_reloc_code_real_type reloc
,
4420 reloc_howto_type
*howto
,
4423 union etree_union
*addend
)
4425 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4429 p
->section
= section
;
4431 p
->addend_exp
= addend
;
4433 p
->addend_value
= 0;
4434 p
->output_section
= NULL
;
4438 lang_assignment_statement_type
*
4439 lang_add_assignment (etree_type
*exp
)
4441 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4449 lang_add_attribute (enum statement_enum attribute
)
4451 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4455 lang_startup (const char *name
)
4457 if (startup_file
!= NULL
)
4459 einfo (_("%P%Fmultiple STARTUP files\n"));
4461 first_file
->filename
= name
;
4462 first_file
->local_sym_name
= name
;
4463 first_file
->real
= TRUE
;
4465 startup_file
= name
;
4469 lang_float (bfd_boolean maybe
)
4471 lang_float_flag
= maybe
;
4475 /* Work out the load- and run-time regions from a script statement, and
4476 store them in *LMA_REGION and *REGION respectively.
4478 MEMSPEC is the name of the run-time region, or the value of
4479 DEFAULT_MEMORY_REGION if the statement didn't specify one.
4480 LMA_MEMSPEC is the name of the load-time region, or null if the
4481 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
4482 had an explicit load address.
4484 It is an error to specify both a load region and a load address. */
4487 lang_get_regions (struct memory_region_struct
**region
,
4488 struct memory_region_struct
**lma_region
,
4489 const char *memspec
,
4490 const char *lma_memspec
,
4493 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
4495 /* If no runtime region has been given, but the load region has
4496 been, use the load region. */
4497 if (lma_memspec
!= 0 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
4498 *region
= *lma_region
;
4500 *region
= lang_memory_region_lookup (memspec
, FALSE
);
4502 if (have_lma_p
&& lma_memspec
!= 0)
4503 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4507 lang_leave_output_section_statement
4508 (fill_type
*fill
, const char *memspec
,
4509 struct lang_output_section_phdr_list
*phdrs
, const char *lma_memspec
)
4511 lang_get_regions (¤t_section
->region
,
4512 ¤t_section
->lma_region
,
4513 memspec
, lma_memspec
,
4514 current_section
->load_base
!= 0);
4515 current_section
->fill
= fill
;
4516 current_section
->phdrs
= phdrs
;
4517 stat_ptr
= &statement_list
;
4520 /* Create an absolute symbol with the given name with the value of the
4521 address of first byte of the section named.
4523 If the symbol already exists, then do nothing. */
4526 lang_abs_symbol_at_beginning_of (const char *secname
, const char *name
)
4528 struct bfd_link_hash_entry
*h
;
4530 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
4532 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4534 if (h
->type
== bfd_link_hash_new
4535 || h
->type
== bfd_link_hash_undefined
)
4539 h
->type
= bfd_link_hash_defined
;
4541 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4545 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4547 h
->u
.def
.section
= bfd_abs_section_ptr
;
4551 /* Create an absolute symbol with the given name with the value of the
4552 address of the first byte after the end of the section named.
4554 If the symbol already exists, then do nothing. */
4557 lang_abs_symbol_at_end_of (const char *secname
, const char *name
)
4559 struct bfd_link_hash_entry
*h
;
4561 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
4563 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4565 if (h
->type
== bfd_link_hash_new
4566 || h
->type
== bfd_link_hash_undefined
)
4570 h
->type
= bfd_link_hash_defined
;
4572 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4576 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4577 + bfd_section_size (output_bfd
, sec
) /
4578 bfd_octets_per_byte (output_bfd
));
4580 h
->u
.def
.section
= bfd_abs_section_ptr
;
4585 lang_statement_append (lang_statement_list_type
*list
,
4586 lang_statement_union_type
*element
,
4587 lang_statement_union_type
**field
)
4589 *(list
->tail
) = element
;
4593 /* Set the output format type. -oformat overrides scripts. */
4596 lang_add_output_format (const char *format
,
4601 if (output_target
== NULL
|| !from_script
)
4603 if (command_line
.endian
== ENDIAN_BIG
4606 else if (command_line
.endian
== ENDIAN_LITTLE
4610 output_target
= format
;
4614 /* Enter a group. This creates a new lang_group_statement, and sets
4615 stat_ptr to build new statements within the group. */
4618 lang_enter_group (void)
4620 lang_group_statement_type
*g
;
4622 g
= new_stat (lang_group_statement
, stat_ptr
);
4623 lang_list_init (&g
->children
);
4624 stat_ptr
= &g
->children
;
4627 /* Leave a group. This just resets stat_ptr to start writing to the
4628 regular list of statements again. Note that this will not work if
4629 groups can occur inside anything else which can adjust stat_ptr,
4630 but currently they can't. */
4633 lang_leave_group (void)
4635 stat_ptr
= &statement_list
;
4638 /* Add a new program header. This is called for each entry in a PHDRS
4639 command in a linker script. */
4642 lang_new_phdr (const char *name
,
4644 bfd_boolean filehdr
,
4649 struct lang_phdr
*n
, **pp
;
4651 n
= stat_alloc (sizeof (struct lang_phdr
));
4654 n
->type
= exp_get_value_int (type
, 0, "program header type",
4655 lang_final_phase_enum
);
4656 n
->filehdr
= filehdr
;
4661 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4666 /* Record the program header information in the output BFD. FIXME: We
4667 should not be calling an ELF specific function here. */
4670 lang_record_phdrs (void)
4674 struct lang_output_section_phdr_list
*last
;
4675 struct lang_phdr
*l
;
4676 lang_statement_union_type
*u
;
4679 secs
= xmalloc (alc
* sizeof (asection
*));
4681 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4688 for (u
= lang_output_section_statement
.head
;
4690 u
= u
->output_section_statement
.next
)
4692 lang_output_section_statement_type
*os
;
4693 struct lang_output_section_phdr_list
*pl
;
4695 os
= &u
->output_section_statement
;
4702 if (os
->sectype
== noload_section
4703 || os
->bfd_section
== NULL
4704 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4709 if (os
->bfd_section
== NULL
)
4712 for (; pl
!= NULL
; pl
= pl
->next
)
4714 if (strcmp (pl
->name
, l
->name
) == 0)
4719 secs
= xrealloc (secs
, alc
* sizeof (asection
*));
4721 secs
[c
] = os
->bfd_section
;
4728 if (l
->flags
== NULL
)
4731 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4732 lang_final_phase_enum
);
4737 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4738 lang_final_phase_enum
);
4740 if (! bfd_record_phdr (output_bfd
, l
->type
,
4741 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
4742 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4743 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4748 /* Make sure all the phdr assignments succeeded. */
4749 for (u
= lang_output_section_statement
.head
;
4751 u
= u
->output_section_statement
.next
)
4753 struct lang_output_section_phdr_list
*pl
;
4755 if (u
->output_section_statement
.bfd_section
== NULL
)
4758 for (pl
= u
->output_section_statement
.phdrs
;
4761 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4762 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4763 u
->output_section_statement
.name
, pl
->name
);
4767 /* Record a list of sections which may not be cross referenced. */
4770 lang_add_nocrossref (struct lang_nocrossref
*l
)
4772 struct lang_nocrossrefs
*n
;
4774 n
= xmalloc (sizeof *n
);
4775 n
->next
= nocrossref_list
;
4777 nocrossref_list
= n
;
4779 /* Set notice_all so that we get informed about all symbols. */
4780 link_info
.notice_all
= TRUE
;
4783 /* Overlay handling. We handle overlays with some static variables. */
4785 /* The overlay virtual address. */
4786 static etree_type
*overlay_vma
;
4787 /* And subsection alignment. */
4788 static etree_type
*overlay_subalign
;
4790 /* An expression for the maximum section size seen so far. */
4791 static etree_type
*overlay_max
;
4793 /* A list of all the sections in this overlay. */
4795 struct overlay_list
{
4796 struct overlay_list
*next
;
4797 lang_output_section_statement_type
*os
;
4800 static struct overlay_list
*overlay_list
;
4802 /* Start handling an overlay. */
4805 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
4807 /* The grammar should prevent nested overlays from occurring. */
4808 ASSERT (overlay_vma
== NULL
4809 && overlay_subalign
== NULL
4810 && overlay_max
== NULL
);
4812 overlay_vma
= vma_expr
;
4813 overlay_subalign
= subalign
;
4816 /* Start a section in an overlay. We handle this by calling
4817 lang_enter_output_section_statement with the correct VMA.
4818 lang_leave_overlay sets up the LMA and memory regions. */
4821 lang_enter_overlay_section (const char *name
)
4823 struct overlay_list
*n
;
4826 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4827 0, 0, overlay_subalign
, 0);
4829 /* If this is the first section, then base the VMA of future
4830 sections on this one. This will work correctly even if `.' is
4831 used in the addresses. */
4832 if (overlay_list
== NULL
)
4833 overlay_vma
= exp_nameop (ADDR
, name
);
4835 /* Remember the section. */
4836 n
= xmalloc (sizeof *n
);
4837 n
->os
= current_section
;
4838 n
->next
= overlay_list
;
4841 size
= exp_nameop (SIZEOF
, name
);
4843 /* Arrange to work out the maximum section end address. */
4844 if (overlay_max
== NULL
)
4847 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4850 /* Finish a section in an overlay. There isn't any special to do
4854 lang_leave_overlay_section (fill_type
*fill
,
4855 struct lang_output_section_phdr_list
*phdrs
)
4862 name
= current_section
->name
;
4864 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
4865 region and that no load-time region has been specified. It doesn't
4866 really matter what we say here, since lang_leave_overlay will
4868 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
4870 /* Define the magic symbols. */
4872 clean
= xmalloc (strlen (name
) + 1);
4874 for (s1
= name
; *s1
!= '\0'; s1
++)
4875 if (ISALNUM (*s1
) || *s1
== '_')
4879 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4880 sprintf (buf
, "__load_start_%s", clean
);
4881 lang_add_assignment (exp_assop ('=', buf
,
4882 exp_nameop (LOADADDR
, name
)));
4884 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4885 sprintf (buf
, "__load_stop_%s", clean
);
4886 lang_add_assignment (exp_assop ('=', buf
,
4888 exp_nameop (LOADADDR
, name
),
4889 exp_nameop (SIZEOF
, name
))));
4894 /* Finish an overlay. If there are any overlay wide settings, this
4895 looks through all the sections in the overlay and sets them. */
4898 lang_leave_overlay (etree_type
*lma_expr
,
4901 const char *memspec
,
4902 struct lang_output_section_phdr_list
*phdrs
,
4903 const char *lma_memspec
)
4905 lang_memory_region_type
*region
;
4906 lang_memory_region_type
*lma_region
;
4907 struct overlay_list
*l
;
4908 struct lang_nocrossref
*nocrossref
;
4910 lang_get_regions (®ion
, &lma_region
,
4911 memspec
, lma_memspec
,
4916 /* After setting the size of the last section, set '.' to end of the
4918 if (overlay_list
!= NULL
)
4919 overlay_list
->os
->update_dot_tree
4920 = exp_assop ('=', ".", exp_binop ('+', overlay_vma
, overlay_max
));
4925 struct overlay_list
*next
;
4927 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
4930 l
->os
->region
= region
;
4931 l
->os
->lma_region
= lma_region
;
4933 /* The first section has the load address specified in the
4934 OVERLAY statement. The rest are worked out from that.
4935 The base address is not needed (and should be null) if
4936 an LMA region was specified. */
4938 l
->os
->load_base
= lma_expr
;
4939 else if (lma_region
== 0)
4940 l
->os
->load_base
= exp_binop ('+',
4941 exp_nameop (LOADADDR
, l
->next
->os
->name
),
4942 exp_nameop (SIZEOF
, l
->next
->os
->name
));
4944 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4945 l
->os
->phdrs
= phdrs
;
4949 struct lang_nocrossref
*nc
;
4951 nc
= xmalloc (sizeof *nc
);
4952 nc
->name
= l
->os
->name
;
4953 nc
->next
= nocrossref
;
4962 if (nocrossref
!= NULL
)
4963 lang_add_nocrossref (nocrossref
);
4966 overlay_list
= NULL
;
4970 /* Version handling. This is only useful for ELF. */
4972 /* This global variable holds the version tree that we build. */
4974 struct bfd_elf_version_tree
*lang_elf_version_info
;
4977 lang_vers_match_lang_c (struct bfd_elf_version_expr
*expr
,
4980 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4982 return fnmatch (expr
->pattern
, sym
, 0) == 0;
4986 lang_vers_match_lang_cplusplus (struct bfd_elf_version_expr
*expr
,
4992 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4995 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
4998 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4999 Should we early out FALSE in this case? */
5000 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5004 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5012 lang_vers_match_lang_java (struct bfd_elf_version_expr
*expr
,
5018 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5021 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
5024 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5025 Should we early out FALSE in this case? */
5026 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5030 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5037 /* This is called for each variable name or match expression. */
5039 struct bfd_elf_version_expr
*
5040 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
5044 struct bfd_elf_version_expr
*ret
;
5046 ret
= xmalloc (sizeof *ret
);
5052 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
5053 ret
->match
= lang_vers_match_lang_c
;
5054 else if (strcasecmp (lang
, "C++") == 0)
5055 ret
->match
= lang_vers_match_lang_cplusplus
;
5056 else if (strcasecmp (lang
, "Java") == 0)
5057 ret
->match
= lang_vers_match_lang_java
;
5060 einfo (_("%X%P: unknown language `%s' in version information\n"),
5062 ret
->match
= lang_vers_match_lang_c
;
5065 return ldemul_new_vers_pattern (ret
);
5068 /* This is called for each set of variable names and match
5071 struct bfd_elf_version_tree
*
5072 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
5073 struct bfd_elf_version_expr
*locals
)
5075 struct bfd_elf_version_tree
*ret
;
5077 ret
= xmalloc (sizeof *ret
);
5081 ret
->globals
= globals
;
5082 ret
->locals
= locals
;
5084 ret
->name_indx
= (unsigned int) -1;
5089 /* This static variable keeps track of version indices. */
5091 static int version_index
;
5093 /* This is called when we know the name and dependencies of the
5097 lang_register_vers_node (const char *name
,
5098 struct bfd_elf_version_tree
*version
,
5099 struct bfd_elf_version_deps
*deps
)
5101 struct bfd_elf_version_tree
*t
, **pp
;
5102 struct bfd_elf_version_expr
*e1
;
5107 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
5108 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
5110 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5115 /* Make sure this node has a unique name. */
5116 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5117 if (strcmp (t
->name
, name
) == 0)
5118 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5120 /* Check the global and local match names, and make sure there
5121 aren't any duplicates. */
5123 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5125 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5127 struct bfd_elf_version_expr
*e2
;
5129 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5130 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5131 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5136 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
5138 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5140 struct bfd_elf_version_expr
*e2
;
5142 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
5143 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5144 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5149 version
->deps
= deps
;
5150 version
->name
= name
;
5151 if (name
[0] != '\0')
5154 version
->vernum
= version_index
;
5157 version
->vernum
= 0;
5159 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5164 /* This is called when we see a version dependency. */
5166 struct bfd_elf_version_deps
*
5167 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
5169 struct bfd_elf_version_deps
*ret
;
5170 struct bfd_elf_version_tree
*t
;
5172 ret
= xmalloc (sizeof *ret
);
5175 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5177 if (strcmp (t
->name
, name
) == 0)
5179 ret
->version_needed
= t
;
5184 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5190 lang_do_version_exports_section (void)
5192 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5194 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5196 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5203 len
= bfd_section_size (is
->the_bfd
, sec
);
5204 contents
= xmalloc (len
);
5205 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5206 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
5209 while (p
< contents
+ len
)
5211 greg
= lang_new_vers_pattern (greg
, p
, NULL
);
5212 p
= strchr (p
, '\0') + 1;
5215 /* Do not free the contents, as we used them creating the regex. */
5217 /* Do not include this section in the link. */
5218 bfd_set_section_flags (is
->the_bfd
, sec
,
5219 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5222 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
);
5223 lang_register_vers_node (command_line
.version_exports_section
,
5224 lang_new_vers_node (greg
, lreg
), NULL
);
5228 lang_add_unique (const char *name
)
5230 struct unique_sections
*ent
;
5232 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5233 if (strcmp (ent
->name
, name
) == 0)
5236 ent
= xmalloc (sizeof *ent
);
5237 ent
->name
= xstrdup (name
);
5238 ent
->next
= unique_section_list
;
5239 unique_section_list
= ent
;