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"
45 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
48 /* Locals variables. */
49 static struct obstack stat_obstack
;
50 static struct obstack map_obstack
;
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
54 static const char *startup_file
;
55 static lang_statement_list_type input_file_chain
;
56 static bfd_boolean placed_commons
= FALSE
;
57 static lang_output_section_statement_type
*default_common_section
;
58 static bfd_boolean map_option_f
;
59 static bfd_vma print_dot
;
60 static lang_input_statement_type
*first_file
;
61 static const char *current_target
;
62 static const char *output_target
;
63 static lang_statement_list_type statement_list
;
64 static struct lang_phdr
*lang_phdr_list
;
65 static struct bfd_hash_table lang_definedness_table
;
67 /* Forward declarations. */
68 static void exp_init_os (etree_type
*);
69 static void init_map_userdata (bfd
*, asection
*, void *);
70 static bfd_boolean
wildcardp (const char *);
71 static lang_input_statement_type
*lookup_name (const char *);
72 static bfd_boolean
load_symbols (lang_input_statement_type
*,
73 lang_statement_list_type
*);
74 static struct bfd_hash_entry
*lang_definedness_newfunc
75 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
76 static void insert_undefined (const char *);
77 static void print_all_symbols (asection
*);
78 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
79 static void print_statement (lang_statement_union_type
*,
80 lang_output_section_statement_type
*);
81 static void print_statement_list (lang_statement_union_type
*,
82 lang_output_section_statement_type
*);
83 static void print_statements (void);
84 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
85 static void lang_record_phdrs (void);
86 static void lang_do_version_exports_section (void);
88 typedef void (*callback_t
) (lang_wild_statement_type
*, struct wildcard_list
*,
89 asection
*, lang_input_statement_type
*, void *);
91 /* Exported variables. */
92 lang_output_section_statement_type
*abs_output_section
;
93 lang_statement_list_type lang_output_section_statement
;
94 lang_statement_list_type
*stat_ptr
= &statement_list
;
95 lang_statement_list_type file_chain
= { NULL
, NULL
};
96 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
97 const char *entry_section
= ".text";
98 bfd_boolean entry_from_cmdline
;
99 bfd_boolean lang_has_input_file
= FALSE
;
100 bfd_boolean had_output_filename
= FALSE
;
101 bfd_boolean lang_float_flag
= FALSE
;
102 bfd_boolean delete_output_file_on_failure
= FALSE
;
103 struct lang_nocrossrefs
*nocrossref_list
;
104 struct unique_sections
*unique_section_list
;
105 static bfd_boolean ldlang_sysrooted_script
= FALSE
;
106 int lang_statement_iteration
= 0;
108 etree_type
*base
; /* Relocation base - or null */
110 #define new_stat(x, y) \
111 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
113 #define outside_section_address(q) \
114 ((q)->output_offset + (q)->output_section->vma)
116 #define outside_symbol_address(q) \
117 ((q)->value + outside_section_address (q->section))
119 #define SECTION_NAME_MAP_LENGTH (16)
122 stat_alloc (size_t size
)
124 return obstack_alloc (&stat_obstack
, size
);
128 unique_section_p (const asection
*sec
)
130 struct unique_sections
*unam
;
133 if (link_info
.relocatable
134 && sec
->owner
!= NULL
135 && bfd_is_group_section (sec
->owner
, sec
))
139 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
140 if (wildcardp (unam
->name
)
141 ? fnmatch (unam
->name
, secnam
, 0) == 0
142 : strcmp (unam
->name
, secnam
) == 0)
150 /* Generic traversal routines for finding matching sections. */
153 walk_wild_section (lang_wild_statement_type
*ptr
,
154 lang_input_statement_type
*file
,
160 if (file
->just_syms_flag
)
163 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
165 struct wildcard_list
*sec
;
167 sec
= ptr
->section_list
;
169 (*callback
) (ptr
, sec
, s
, file
, data
);
173 bfd_boolean skip
= FALSE
;
174 struct name_list
*list_tmp
;
176 /* Don't process sections from files which were
178 for (list_tmp
= sec
->spec
.exclude_name_list
;
180 list_tmp
= list_tmp
->next
)
182 if (wildcardp (list_tmp
->name
))
183 skip
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
185 skip
= strcmp (list_tmp
->name
, file
->filename
) == 0;
187 /* If this file is part of an archive, and the archive is
188 excluded, exclude this file. */
189 if (! skip
&& file
->the_bfd
!= NULL
190 && file
->the_bfd
->my_archive
!= NULL
191 && file
->the_bfd
->my_archive
->filename
!= NULL
)
193 if (wildcardp (list_tmp
->name
))
194 skip
= fnmatch (list_tmp
->name
,
195 file
->the_bfd
->my_archive
->filename
,
198 skip
= strcmp (list_tmp
->name
,
199 file
->the_bfd
->my_archive
->filename
) == 0;
206 if (!skip
&& sec
->spec
.name
!= NULL
)
208 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
210 if (wildcardp (sec
->spec
.name
))
211 skip
= fnmatch (sec
->spec
.name
, sname
, 0) != 0;
213 skip
= strcmp (sec
->spec
.name
, sname
) != 0;
217 (*callback
) (ptr
, sec
, s
, file
, data
);
224 /* Handle a wild statement for a single file F. */
227 walk_wild_file (lang_wild_statement_type
*s
,
228 lang_input_statement_type
*f
,
232 if (f
->the_bfd
== NULL
233 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
234 walk_wild_section (s
, f
, callback
, data
);
239 /* This is an archive file. We must map each member of the
240 archive separately. */
241 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
242 while (member
!= NULL
)
244 /* When lookup_name is called, it will call the add_symbols
245 entry point for the archive. For each element of the
246 archive which is included, BFD will call ldlang_add_file,
247 which will set the usrdata field of the member to the
248 lang_input_statement. */
249 if (member
->usrdata
!= NULL
)
251 walk_wild_section (s
, member
->usrdata
, callback
, data
);
254 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
260 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
262 const char *file_spec
= s
->filename
;
264 if (file_spec
== NULL
)
266 /* Perform the iteration over all files in the list. */
267 LANG_FOR_EACH_INPUT_STATEMENT (f
)
269 walk_wild_file (s
, f
, callback
, data
);
272 else if (wildcardp (file_spec
))
274 LANG_FOR_EACH_INPUT_STATEMENT (f
)
276 if (fnmatch (file_spec
, f
->filename
, FNM_FILE_NAME
) == 0)
277 walk_wild_file (s
, f
, callback
, data
);
282 lang_input_statement_type
*f
;
284 /* Perform the iteration over a single file. */
285 f
= lookup_name (file_spec
);
287 walk_wild_file (s
, f
, callback
, data
);
291 /* lang_for_each_statement walks the parse tree and calls the provided
292 function for each node. */
295 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
296 lang_statement_union_type
*s
)
298 for (; s
!= NULL
; s
= s
->header
.next
)
302 switch (s
->header
.type
)
304 case lang_constructors_statement_enum
:
305 lang_for_each_statement_worker (func
, constructor_list
.head
);
307 case lang_output_section_statement_enum
:
308 lang_for_each_statement_worker
310 s
->output_section_statement
.children
.head
);
312 case lang_wild_statement_enum
:
313 lang_for_each_statement_worker
315 s
->wild_statement
.children
.head
);
317 case lang_group_statement_enum
:
318 lang_for_each_statement_worker (func
,
319 s
->group_statement
.children
.head
);
321 case lang_data_statement_enum
:
322 case lang_reloc_statement_enum
:
323 case lang_object_symbols_statement_enum
:
324 case lang_output_statement_enum
:
325 case lang_target_statement_enum
:
326 case lang_input_section_enum
:
327 case lang_input_statement_enum
:
328 case lang_assignment_statement_enum
:
329 case lang_padding_statement_enum
:
330 case lang_address_statement_enum
:
331 case lang_fill_statement_enum
:
341 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
343 lang_for_each_statement_worker (func
, statement_list
.head
);
346 /*----------------------------------------------------------------------*/
349 lang_list_init (lang_statement_list_type
*list
)
352 list
->tail
= &list
->head
;
355 /* Build a new statement node for the parse tree. */
357 static lang_statement_union_type
*
358 new_statement (enum statement_enum type
,
360 lang_statement_list_type
*list
)
362 lang_statement_union_type
*new;
364 new = stat_alloc (size
);
365 new->header
.type
= type
;
366 new->header
.next
= NULL
;
367 lang_statement_append (list
, new, &new->header
.next
);
371 /* Build a new input file node for the language. There are several
372 ways in which we treat an input file, eg, we only look at symbols,
373 or prefix it with a -l etc.
375 We can be supplied with requests for input files more than once;
376 they may, for example be split over several lines like foo.o(.text)
377 foo.o(.data) etc, so when asked for a file we check that we haven't
378 got it already so we don't duplicate the bfd. */
380 static lang_input_statement_type
*
381 new_afile (const char *name
,
382 lang_input_file_enum_type file_type
,
384 bfd_boolean add_to_list
)
386 lang_input_statement_type
*p
;
389 p
= new_stat (lang_input_statement
, stat_ptr
);
392 p
= stat_alloc (sizeof (lang_input_statement_type
));
393 p
->header
.next
= NULL
;
396 lang_has_input_file
= TRUE
;
398 p
->sysrooted
= FALSE
;
401 case lang_input_file_is_symbols_only_enum
:
403 p
->is_archive
= FALSE
;
405 p
->local_sym_name
= name
;
406 p
->just_syms_flag
= TRUE
;
407 p
->search_dirs_flag
= FALSE
;
409 case lang_input_file_is_fake_enum
:
411 p
->is_archive
= FALSE
;
413 p
->local_sym_name
= name
;
414 p
->just_syms_flag
= FALSE
;
415 p
->search_dirs_flag
= FALSE
;
417 case lang_input_file_is_l_enum
:
418 p
->is_archive
= TRUE
;
421 p
->local_sym_name
= concat ("-l", name
, NULL
);
422 p
->just_syms_flag
= FALSE
;
423 p
->search_dirs_flag
= TRUE
;
425 case lang_input_file_is_marker_enum
:
427 p
->is_archive
= FALSE
;
429 p
->local_sym_name
= name
;
430 p
->just_syms_flag
= FALSE
;
431 p
->search_dirs_flag
= TRUE
;
433 case lang_input_file_is_search_file_enum
:
434 p
->sysrooted
= ldlang_sysrooted_script
;
436 p
->is_archive
= FALSE
;
438 p
->local_sym_name
= name
;
439 p
->just_syms_flag
= FALSE
;
440 p
->search_dirs_flag
= TRUE
;
442 case lang_input_file_is_file_enum
:
444 p
->is_archive
= FALSE
;
446 p
->local_sym_name
= name
;
447 p
->just_syms_flag
= FALSE
;
448 p
->search_dirs_flag
= FALSE
;
455 p
->next_real_file
= NULL
;
458 p
->dynamic
= config
.dynamic_link
;
459 p
->as_needed
= as_needed
;
460 p
->whole_archive
= whole_archive
;
462 lang_statement_append (&input_file_chain
,
463 (lang_statement_union_type
*) p
,
468 lang_input_statement_type
*
469 lang_add_input_file (const char *name
,
470 lang_input_file_enum_type file_type
,
473 lang_has_input_file
= TRUE
;
474 return new_afile (name
, file_type
, target
, TRUE
);
477 /* Build enough state so that the parser can build its tree. */
482 obstack_begin (&stat_obstack
, 1000);
484 stat_ptr
= &statement_list
;
486 lang_list_init (stat_ptr
);
488 lang_list_init (&input_file_chain
);
489 lang_list_init (&lang_output_section_statement
);
490 lang_list_init (&file_chain
);
491 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
494 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
496 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
498 /* The value "3" is ad-hoc, somewhat related to the expected number of
499 DEFINED expressions in a linker script. For most default linker
500 scripts, there are none. Why a hash table then? Well, it's somewhat
501 simpler to re-use working machinery than using a linked list in terms
502 of code-complexity here in ld, besides the initialization which just
503 looks like other code here. */
504 if (bfd_hash_table_init_n (&lang_definedness_table
,
505 lang_definedness_newfunc
, 3) != TRUE
)
506 einfo (_("%P%F: out of memory during initialization"));
508 /* Callers of exp_fold_tree need to increment this. */
509 lang_statement_iteration
= 0;
512 /*----------------------------------------------------------------------
513 A region is an area of memory declared with the
514 MEMORY { name:org=exp, len=exp ... }
517 We maintain a list of all the regions here.
519 If no regions are specified in the script, then the default is used
520 which is created when looked up to be the entire data space.
522 If create is true we are creating a region inside a MEMORY block.
523 In this case it is probably an error to create a region that has
524 already been created. If we are not inside a MEMORY block it is
525 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
526 and so we issue a warning. */
528 static lang_memory_region_type
*lang_memory_region_list
;
529 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
531 lang_memory_region_type
*
532 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
534 lang_memory_region_type
*p
;
535 lang_memory_region_type
*new;
537 /* NAME is NULL for LMA memspecs if no region was specified. */
541 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
542 if (strcmp (p
->name
, name
) == 0)
545 einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"), name
);
550 /* This code used to always use the first region in the list as the
551 default region. I changed it to instead use a region
552 encompassing all of memory as the default region. This permits
553 NOLOAD sections to work reasonably without requiring a region.
554 People should specify what region they mean, if they really want
556 if (strcmp (name
, DEFAULT_MEMORY_REGION
) == 0)
558 if (lang_memory_region_list
!= NULL
)
559 return lang_memory_region_list
;
563 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
564 einfo (_("%P:%S: warning: memory region %s not declared\n"), name
);
566 new = stat_alloc (sizeof (lang_memory_region_type
));
568 new->name
= xstrdup (name
);
571 *lang_memory_region_list_tail
= new;
572 lang_memory_region_list_tail
= &new->next
;
576 new->length
= ~(bfd_size_type
) 0;
578 new->had_full_message
= FALSE
;
583 static lang_memory_region_type
*
584 lang_memory_default (asection
*section
)
586 lang_memory_region_type
*p
;
588 flagword sec_flags
= section
->flags
;
590 /* Override SEC_DATA to mean a writable section. */
591 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
592 sec_flags
|= SEC_DATA
;
594 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
596 if ((p
->flags
& sec_flags
) != 0
597 && (p
->not_flags
& sec_flags
) == 0)
602 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
605 static lang_output_section_statement_type
*
606 lang_output_section_find_1 (const char *const name
, int constraint
)
608 lang_statement_union_type
*u
;
609 lang_output_section_statement_type
*lookup
;
611 for (u
= lang_output_section_statement
.head
; u
!= NULL
; u
= lookup
->next
)
613 lookup
= &u
->output_section_statement
;
614 if (strcmp (name
, lookup
->name
) == 0
615 && lookup
->constraint
!= -1
616 && (constraint
== 0 || constraint
== lookup
->constraint
))
622 lang_output_section_statement_type
*
623 lang_output_section_find (const char *const name
)
625 return lang_output_section_find_1 (name
, 0);
628 static lang_output_section_statement_type
*
629 lang_output_section_statement_lookup_1 (const char *const name
, int constraint
)
631 lang_output_section_statement_type
*lookup
;
633 lookup
= lang_output_section_find_1 (name
, constraint
);
636 lookup
= new_stat (lang_output_section_statement
, stat_ptr
);
637 lookup
->region
= NULL
;
638 lookup
->lma_region
= NULL
;
640 lookup
->block_value
= 1;
644 lookup
->bfd_section
= NULL
;
645 lookup
->processed
= 0;
646 lookup
->constraint
= constraint
;
647 lookup
->sectype
= normal_section
;
648 lookup
->addr_tree
= NULL
;
649 lang_list_init (&lookup
->children
);
651 lookup
->memspec
= NULL
;
653 lookup
->subsection_alignment
= -1;
654 lookup
->section_alignment
= -1;
655 lookup
->load_base
= NULL
;
656 lookup
->update_dot_tree
= NULL
;
657 lookup
->phdrs
= NULL
;
659 lang_statement_append (&lang_output_section_statement
,
660 (lang_statement_union_type
*) lookup
,
666 lang_output_section_statement_type
*
667 lang_output_section_statement_lookup (const char *const name
)
669 return lang_output_section_statement_lookup_1 (name
, 0);
673 lang_map_flags (flagword flag
)
675 if (flag
& SEC_ALLOC
)
681 if (flag
& SEC_READONLY
)
694 lang_memory_region_type
*m
;
697 minfo (_("\nMemory Configuration\n\n"));
698 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
699 _("Name"), _("Origin"), _("Length"), _("Attributes"));
701 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
706 fprintf (config
.map_file
, "%-16s ", m
->name
);
708 sprintf_vma (buf
, m
->origin
);
709 minfo ("0x%s ", buf
);
717 minfo ("0x%V", m
->length
);
718 if (m
->flags
|| m
->not_flags
)
726 lang_map_flags (m
->flags
);
732 lang_map_flags (m
->not_flags
);
739 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
741 if (! command_line
.reduce_memory_overheads
)
743 obstack_begin (&map_obstack
, 1000);
744 for (p
= link_info
.input_bfds
; p
!= (bfd
*) NULL
; p
= p
->link_next
)
745 bfd_map_over_sections (p
, init_map_userdata
, 0);
746 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
752 init_map_userdata (abfd
, sec
, data
)
753 bfd
*abfd ATTRIBUTE_UNUSED
;
755 void *data ATTRIBUTE_UNUSED
;
757 fat_section_userdata_type
*new_data
758 = ((fat_section_userdata_type
*) (stat_alloc
759 (sizeof (fat_section_userdata_type
))));
761 ASSERT (get_userdata (sec
) == NULL
);
762 get_userdata (sec
) = new_data
;
763 new_data
->map_symbol_def_tail
= &new_data
->map_symbol_def_head
;
767 sort_def_symbol (hash_entry
, info
)
768 struct bfd_link_hash_entry
*hash_entry
;
769 void *info ATTRIBUTE_UNUSED
;
771 if (hash_entry
->type
== bfd_link_hash_defined
772 || hash_entry
->type
== bfd_link_hash_defweak
)
774 struct fat_user_section_struct
*ud
;
775 struct map_symbol_def
*def
;
777 ud
= get_userdata (hash_entry
->u
.def
.section
);
780 /* ??? What do we have to do to initialize this beforehand? */
781 /* The first time we get here is bfd_abs_section... */
782 init_map_userdata (0, hash_entry
->u
.def
.section
, 0);
783 ud
= get_userdata (hash_entry
->u
.def
.section
);
785 else if (!ud
->map_symbol_def_tail
)
786 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
787 def
= (struct map_symbol_def
*) obstack_alloc (&map_obstack
, sizeof *def
);
788 def
->entry
= hash_entry
;
789 *ud
->map_symbol_def_tail
= def
;
790 ud
->map_symbol_def_tail
= &def
->next
;
795 /* Initialize an output section. */
798 init_os (lang_output_section_statement_type
*s
)
800 lean_section_userdata_type
*new;
802 if (s
->bfd_section
!= NULL
)
805 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
806 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
808 new = stat_alloc (SECTION_USERDATA_SIZE
);
810 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
811 if (s
->bfd_section
== NULL
)
812 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
813 if (s
->bfd_section
== NULL
)
815 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
816 output_bfd
->xvec
->name
, s
->name
);
818 s
->bfd_section
->output_section
= s
->bfd_section
;
820 /* We initialize an output sections output offset to minus its own
821 vma to allow us to output a section through itself. */
822 s
->bfd_section
->output_offset
= 0;
823 get_userdata (s
->bfd_section
) = new;
825 /* If there is a base address, make sure that any sections it might
826 mention are initialized. */
827 if (s
->addr_tree
!= NULL
)
828 exp_init_os (s
->addr_tree
);
830 if (s
->load_base
!= NULL
)
831 exp_init_os (s
->load_base
);
834 /* Make sure that all output sections mentioned in an expression are
838 exp_init_os (etree_type
*exp
)
840 switch (exp
->type
.node_class
)
843 exp_init_os (exp
->assign
.src
);
847 exp_init_os (exp
->binary
.lhs
);
848 exp_init_os (exp
->binary
.rhs
);
852 exp_init_os (exp
->trinary
.cond
);
853 exp_init_os (exp
->trinary
.lhs
);
854 exp_init_os (exp
->trinary
.rhs
);
858 exp_init_os (exp
->assert_s
.child
);
862 exp_init_os (exp
->unary
.child
);
866 switch (exp
->type
.node_code
)
872 lang_output_section_statement_type
*os
;
874 os
= lang_output_section_find (exp
->name
.name
);
875 if (os
!= NULL
&& os
->bfd_section
== NULL
)
886 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
887 once into the output. This routine checks each section, and
888 arrange to discard it if a section of the same name has already
889 been linked. If the section has COMDAT information, then it uses
890 that to decide whether the section should be included. This code
891 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
892 that is, it does not depend solely upon the section name.
893 section_already_linked is called via bfd_map_over_sections. */
895 /* This is the shape of the elements inside the already_linked hash
896 table. It maps a name onto a list of already_linked elements with
897 the same name. It's possible to get more than one element in a
898 list if the COMDAT sections have different names. */
900 struct already_linked_hash_entry
902 struct bfd_hash_entry root
;
903 struct already_linked
*entry
;
906 struct already_linked
908 struct already_linked
*next
;
912 /* The hash table. */
914 static struct bfd_hash_table already_linked_table
;
917 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
919 lang_input_statement_type
*entry
= data
;
922 struct already_linked
*l
;
923 struct already_linked_hash_entry
*already_linked_list
;
925 /* If we are only reading symbols from this object, then we want to
926 discard all sections. */
927 if (entry
->just_syms_flag
)
929 bfd_link_just_syms (sec
, &link_info
);
933 flags
= bfd_get_section_flags (abfd
, sec
);
935 if ((flags
& SEC_LINK_ONCE
) == 0)
938 /* FIXME: When doing a relocatable link, we may have trouble
939 copying relocations in other sections that refer to local symbols
940 in the section being discarded. Those relocations will have to
941 be converted somehow; as of this writing I'm not sure that any of
942 the backends handle that correctly.
944 It is tempting to instead not discard link once sections when
945 doing a relocatable link (technically, they should be discarded
946 whenever we are building constructors). However, that fails,
947 because the linker winds up combining all the link once sections
948 into a single large link once section, which defeats the purpose
949 of having link once sections in the first place.
951 Also, not merging link once sections in a relocatable link
952 causes trouble for MIPS ELF, which relies on link once semantics
953 to handle the .reginfo section correctly. */
955 name
= bfd_get_section_name (abfd
, sec
);
957 already_linked_list
=
958 ((struct already_linked_hash_entry
*)
959 bfd_hash_lookup (&already_linked_table
, name
, TRUE
, FALSE
));
961 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
963 if (sec
->comdat
== NULL
964 || l
->sec
->comdat
== NULL
965 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
967 /* The section has already been linked. See if we should
969 switch (flags
& SEC_LINK_DUPLICATES
)
974 case SEC_LINK_DUPLICATES_DISCARD
:
977 case SEC_LINK_DUPLICATES_ONE_ONLY
:
978 if (sec
->comdat
== NULL
)
979 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
982 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
983 abfd
, name
, sec
->comdat
->name
);
986 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
987 /* FIXME: We should really dig out the contents of both
988 sections and memcmp them. The COFF/PE spec says that
989 the Microsoft linker does not implement this
990 correctly, so I'm not going to bother doing it
993 case SEC_LINK_DUPLICATES_SAME_SIZE
:
994 if (bfd_section_size (abfd
, sec
)
995 != bfd_section_size (l
->sec
->owner
, l
->sec
))
996 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1001 /* Set the output_section field so that lang_add_section
1002 does not create a lang_input_section structure for this
1003 section. Since there might be a symbol in the section
1004 being discarded, we must retain a pointer to the section
1005 which we are really going to use. */
1006 sec
->output_section
= bfd_abs_section_ptr
;
1007 sec
->kept_section
= l
->sec
;
1009 if (flags
& SEC_GROUP
)
1010 bfd_discard_group (abfd
, sec
);
1016 /* This is the first section with this name. Record it. Allocate
1017 the memory from the same obstack as the hash table is kept in. */
1019 l
= bfd_hash_allocate (&already_linked_table
, sizeof *l
);
1022 l
->next
= already_linked_list
->entry
;
1023 already_linked_list
->entry
= l
;
1026 /* Support routines for the hash table used by section_already_linked,
1027 initialize the table, fill in an entry and remove the table. */
1029 static struct bfd_hash_entry
*
1030 already_linked_newfunc (struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
,
1031 struct bfd_hash_table
*table
,
1032 const char *string ATTRIBUTE_UNUSED
)
1034 struct already_linked_hash_entry
*ret
=
1035 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1043 already_linked_table_init (void)
1045 if (! bfd_hash_table_init_n (&already_linked_table
,
1046 already_linked_newfunc
,
1048 einfo (_("%P%F: Failed to create hash table\n"));
1052 already_linked_table_free (void)
1054 bfd_hash_table_free (&already_linked_table
);
1057 /* The wild routines.
1059 These expand statements like *(.text) and foo.o to a list of
1060 explicit actions, like foo.o(.text), bar.o(.text) and
1061 foo.o(.text, .data). */
1063 /* Return TRUE if the PATTERN argument is a wildcard pattern.
1064 Although backslashes are treated specially if a pattern contains
1065 wildcards, we do not consider the mere presence of a backslash to
1066 be enough to cause the pattern to be treated as a wildcard.
1067 That lets us handle DOS filenames more naturally. */
1070 wildcardp (const char *pattern
)
1074 for (s
= pattern
; *s
!= '\0'; ++s
)
1082 /* Add SECTION to the output section OUTPUT. Do this by creating a
1083 lang_input_section statement which is placed at PTR. FILE is the
1084 input file which holds SECTION. */
1087 lang_add_section (lang_statement_list_type
*ptr
,
1089 lang_output_section_statement_type
*output
,
1090 lang_input_statement_type
*file
)
1093 bfd_boolean discard
;
1095 flags
= bfd_get_section_flags (section
->owner
, section
);
1099 if (link_info
.relocatable
)
1101 /* SEC_EXCLUDE is ignored when doing a relocatable link,
1102 except in the special case of debug info. (See bfd/stabs.c) */
1103 if ((flags
& SEC_DEBUGGING
) == 0)
1104 flags
&= ~SEC_EXCLUDE
;
1108 /* SEC_GROUP sections should be dropped on a final link. */
1109 if ((flags
& SEC_GROUP
) != 0)
1110 flags
|= SEC_EXCLUDE
;
1113 /* Write SEC_EXCLUDE flag back, to simplify later linker code. */
1114 if (section
->owner
!= NULL
)
1115 bfd_set_section_flags (section
->owner
, section
, flags
);
1117 /* Discard sections marked with SEC_EXCLUDE. */
1118 if ((flags
& SEC_EXCLUDE
) != 0)
1121 /* Discard input sections which are assigned to a section named
1122 DISCARD_SECTION_NAME. */
1123 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1126 /* Discard debugging sections if we are stripping debugging
1128 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1129 && (flags
& SEC_DEBUGGING
) != 0)
1134 if (section
->output_section
== NULL
)
1136 /* This prevents future calls from assigning this section. */
1137 section
->output_section
= bfd_abs_section_ptr
;
1142 if (section
->output_section
== NULL
)
1145 lang_input_section_type
*new;
1148 if (output
->bfd_section
== NULL
)
1151 first
= ! output
->bfd_section
->linker_has_input
;
1152 output
->bfd_section
->linker_has_input
= 1;
1154 /* Add a section reference to the list. */
1155 new = new_stat (lang_input_section
, ptr
);
1157 new->section
= section
;
1159 section
->output_section
= output
->bfd_section
;
1161 flags
= section
->flags
;
1163 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1164 to an output section, because we want to be able to include a
1165 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1166 section (I don't know why we want to do this, but we do).
1167 build_link_order in ldwrite.c handles this case by turning
1168 the embedded SEC_NEVER_LOAD section into a fill. */
1170 flags
&= ~ SEC_NEVER_LOAD
;
1172 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1173 already been processed. One reason to do this is that on pe
1174 format targets, .text$foo sections go into .text and it's odd
1175 to see .text with SEC_LINK_ONCE set. */
1177 if (! link_info
.relocatable
)
1178 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1180 /* If this is not the first input section, and the SEC_READONLY
1181 flag is not currently set, then don't set it just because the
1182 input section has it set. */
1184 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1185 flags
&= ~ SEC_READONLY
;
1187 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1189 && ((section
->output_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1190 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1191 || ((flags
& SEC_MERGE
)
1192 && section
->output_section
->entsize
!= section
->entsize
)))
1194 section
->output_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1195 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1198 section
->output_section
->flags
|= flags
;
1200 if (flags
& SEC_MERGE
)
1201 section
->output_section
->entsize
= section
->entsize
;
1203 /* If SEC_READONLY is not set in the input section, then clear
1204 it from the output section. */
1205 if ((section
->flags
& SEC_READONLY
) == 0)
1206 section
->output_section
->flags
&= ~SEC_READONLY
;
1208 switch (output
->sectype
)
1210 case normal_section
:
1215 case overlay_section
:
1216 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1218 case noload_section
:
1219 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1220 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1224 /* Copy over SEC_SMALL_DATA. */
1225 if (section
->flags
& SEC_SMALL_DATA
)
1226 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1228 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1229 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1231 /* If supplied an alignment, then force it. */
1232 if (output
->section_alignment
!= -1)
1233 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1235 if (section
->flags
& SEC_BLOCK
)
1237 section
->output_section
->flags
|= SEC_BLOCK
;
1238 /* FIXME: This value should really be obtained from the bfd... */
1239 output
->block_value
= 128;
1244 /* Handle wildcard sorting. This returns the lang_input_section which
1245 should follow the one we are going to create for SECTION and FILE,
1246 based on the sorting requirements of WILD. It returns NULL if the
1247 new section should just go at the end of the current list. */
1249 static lang_statement_union_type
*
1250 wild_sort (lang_wild_statement_type
*wild
,
1251 struct wildcard_list
*sec
,
1252 lang_input_statement_type
*file
,
1255 const char *section_name
;
1256 lang_statement_union_type
*l
;
1258 if (!wild
->filenames_sorted
&& (sec
== NULL
|| !sec
->spec
.sorted
))
1261 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1262 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
1264 lang_input_section_type
*ls
;
1266 if (l
->header
.type
!= lang_input_section_enum
)
1268 ls
= &l
->input_section
;
1270 /* Sorting by filename takes precedence over sorting by section
1273 if (wild
->filenames_sorted
)
1275 const char *fn
, *ln
;
1279 /* The PE support for the .idata section as generated by
1280 dlltool assumes that files will be sorted by the name of
1281 the archive and then the name of the file within the
1284 if (file
->the_bfd
!= NULL
1285 && bfd_my_archive (file
->the_bfd
) != NULL
)
1287 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1292 fn
= file
->filename
;
1296 if (ls
->ifile
->the_bfd
!= NULL
1297 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1299 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1304 ln
= ls
->ifile
->filename
;
1308 i
= strcmp (fn
, ln
);
1317 fn
= file
->filename
;
1319 ln
= ls
->ifile
->filename
;
1321 i
= strcmp (fn
, ln
);
1329 /* Here either the files are not sorted by name, or we are
1330 looking at the sections for this file. */
1332 if (sec
!= NULL
&& sec
->spec
.sorted
)
1334 if (strcmp (section_name
,
1335 bfd_get_section_name (ls
->ifile
->the_bfd
,
1345 /* Expand a wild statement for a particular FILE. SECTION may be
1346 NULL, in which case it is a wild card. */
1349 output_section_callback (lang_wild_statement_type
*ptr
,
1350 struct wildcard_list
*sec
,
1352 lang_input_statement_type
*file
,
1355 lang_statement_union_type
*before
;
1357 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1358 if (unique_section_p (section
))
1361 /* If the wild pattern was marked KEEP, the member sections
1362 should be as well. */
1363 if (ptr
->keep_sections
)
1364 section
->flags
|= SEC_KEEP
;
1366 before
= wild_sort (ptr
, sec
, file
, section
);
1368 /* Here BEFORE points to the lang_input_section which
1369 should follow the one we are about to add. If BEFORE
1370 is NULL, then the section should just go at the end
1371 of the current list. */
1374 lang_add_section (&ptr
->children
, section
,
1375 (lang_output_section_statement_type
*) output
,
1379 lang_statement_list_type list
;
1380 lang_statement_union_type
**pp
;
1382 lang_list_init (&list
);
1383 lang_add_section (&list
, section
,
1384 (lang_output_section_statement_type
*) output
,
1387 /* If we are discarding the section, LIST.HEAD will
1389 if (list
.head
!= NULL
)
1391 ASSERT (list
.head
->header
.next
== NULL
);
1393 for (pp
= &ptr
->children
.head
;
1395 pp
= &(*pp
)->header
.next
)
1396 ASSERT (*pp
!= NULL
);
1398 list
.head
->header
.next
= *pp
;
1404 /* Check if all sections in a wild statement for a particular FILE
1408 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
1409 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
1411 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
1414 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1415 if (unique_section_p (section
))
1418 if (section
->output_section
== NULL
)
1420 flagword flags
= bfd_get_section_flags (section
->owner
, section
);
1422 if ((flags
& SEC_READONLY
) == 0)
1423 ((lang_output_section_statement_type
*) output
)->all_input_readonly
1428 /* This is passed a file name which must have been seen already and
1429 added to the statement tree. We will see if it has been opened
1430 already and had its symbols read. If not then we'll read it. */
1432 static lang_input_statement_type
*
1433 lookup_name (const char *name
)
1435 lang_input_statement_type
*search
;
1437 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1439 search
= (lang_input_statement_type
*) search
->next_real_file
)
1441 /* Use the local_sym_name as the name of the file that has
1442 already been loaded as filename might have been transformed
1443 via the search directory lookup mechanism. */
1444 const char * filename
= search
->local_sym_name
;
1446 if (filename
== NULL
&& name
== NULL
)
1448 if (filename
!= NULL
1450 && strcmp (filename
, name
) == 0)
1455 search
= new_afile (name
, lang_input_file_is_search_file_enum
, default_target
,
1458 /* If we have already added this file, or this file is not real
1459 (FIXME: can that ever actually happen?) or the name is NULL
1460 (FIXME: can that ever actually happen?) don't add this file. */
1463 || search
->filename
== NULL
)
1466 if (! load_symbols (search
, NULL
))
1472 /* Get the symbols for an input file. */
1475 load_symbols (lang_input_statement_type
*entry
,
1476 lang_statement_list_type
*place
)
1483 ldfile_open_file (entry
);
1485 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1486 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1489 lang_statement_list_type
*hold
;
1490 bfd_boolean bad_load
= TRUE
;
1491 bfd_boolean save_ldlang_sysrooted_script
;
1493 err
= bfd_get_error ();
1495 /* See if the emulation has some special knowledge. */
1496 if (ldemul_unrecognized_file (entry
))
1499 if (err
== bfd_error_file_ambiguously_recognized
)
1503 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1504 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1505 for (p
= matching
; *p
!= NULL
; p
++)
1509 else if (err
!= bfd_error_file_not_recognized
1511 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1515 bfd_close (entry
->the_bfd
);
1516 entry
->the_bfd
= NULL
;
1518 /* Try to interpret the file as a linker script. */
1519 ldfile_open_command_file (entry
->filename
);
1523 save_ldlang_sysrooted_script
= ldlang_sysrooted_script
;
1524 ldlang_sysrooted_script
= entry
->sysrooted
;
1526 ldfile_assumed_script
= TRUE
;
1527 parser_input
= input_script
;
1529 ldfile_assumed_script
= FALSE
;
1531 ldlang_sysrooted_script
= save_ldlang_sysrooted_script
;
1537 if (ldemul_recognized_file (entry
))
1540 /* We don't call ldlang_add_file for an archive. Instead, the
1541 add_symbols entry point will call ldlang_add_file, via the
1542 add_archive_element callback, for each element of the archive
1544 switch (bfd_get_format (entry
->the_bfd
))
1550 ldlang_add_file (entry
);
1551 if (trace_files
|| trace_file_tries
)
1552 info_msg ("%I\n", entry
);
1556 if (entry
->whole_archive
)
1559 bfd_boolean loaded
= TRUE
;
1563 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
1568 if (! bfd_check_format (member
, bfd_object
))
1570 einfo (_("%F%B: member %B in archive is not an object\n"),
1571 entry
->the_bfd
, member
);
1575 if (! ((*link_info
.callbacks
->add_archive_element
)
1576 (&link_info
, member
, "--whole-archive")))
1579 if (! bfd_link_add_symbols (member
, &link_info
))
1581 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1586 entry
->loaded
= loaded
;
1592 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1593 entry
->loaded
= TRUE
;
1595 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1597 return entry
->loaded
;
1600 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1601 may be NULL, indicating that it is a wildcard. Separate
1602 lang_input_section statements are created for each part of the
1603 expansion; they are added after the wild statement S. OUTPUT is
1604 the output section. */
1607 wild (lang_wild_statement_type
*s
,
1608 const char *target ATTRIBUTE_UNUSED
,
1609 lang_output_section_statement_type
*output
)
1611 struct wildcard_list
*sec
;
1613 walk_wild (s
, output_section_callback
, output
);
1615 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
1617 if (default_common_section
!= NULL
)
1619 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
1621 /* Remember the section that common is going to in case we
1622 later get something which doesn't know where to put it. */
1623 default_common_section
= output
;
1628 /* Return TRUE iff target is the sought target. */
1631 get_target (const bfd_target
*target
, void *data
)
1633 const char *sought
= data
;
1635 return strcmp (target
->name
, sought
) == 0;
1638 /* Like strcpy() but convert to lower case as well. */
1641 stricpy (char *dest
, char *src
)
1645 while ((c
= *src
++) != 0)
1646 *dest
++ = TOLOWER (c
);
1651 /* Remove the first occurrence of needle (if any) in haystack
1655 strcut (char *haystack
, char *needle
)
1657 haystack
= strstr (haystack
, needle
);
1663 for (src
= haystack
+ strlen (needle
); *src
;)
1664 *haystack
++ = *src
++;
1670 /* Compare two target format name strings.
1671 Return a value indicating how "similar" they are. */
1674 name_compare (char *first
, char *second
)
1680 copy1
= xmalloc (strlen (first
) + 1);
1681 copy2
= xmalloc (strlen (second
) + 1);
1683 /* Convert the names to lower case. */
1684 stricpy (copy1
, first
);
1685 stricpy (copy2
, second
);
1687 /* Remove size and endian strings from the name. */
1688 strcut (copy1
, "big");
1689 strcut (copy1
, "little");
1690 strcut (copy2
, "big");
1691 strcut (copy2
, "little");
1693 /* Return a value based on how many characters match,
1694 starting from the beginning. If both strings are
1695 the same then return 10 * their length. */
1696 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1697 if (copy1
[result
] == 0)
1709 /* Set by closest_target_match() below. */
1710 static const bfd_target
*winner
;
1712 /* Scan all the valid bfd targets looking for one that has the endianness
1713 requirement that was specified on the command line, and is the nearest
1714 match to the original output target. */
1717 closest_target_match (const bfd_target
*target
, void *data
)
1719 const bfd_target
*original
= data
;
1721 if (command_line
.endian
== ENDIAN_BIG
1722 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1725 if (command_line
.endian
== ENDIAN_LITTLE
1726 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1729 /* Must be the same flavour. */
1730 if (target
->flavour
!= original
->flavour
)
1733 /* If we have not found a potential winner yet, then record this one. */
1740 /* Oh dear, we now have two potential candidates for a successful match.
1741 Compare their names and choose the better one. */
1742 if (name_compare (target
->name
, original
->name
)
1743 > name_compare (winner
->name
, original
->name
))
1746 /* Keep on searching until wqe have checked them all. */
1750 /* Return the BFD target format of the first input file. */
1753 get_first_input_target (void)
1755 char *target
= NULL
;
1757 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1759 if (s
->header
.type
== lang_input_statement_enum
1762 ldfile_open_file (s
);
1764 if (s
->the_bfd
!= NULL
1765 && bfd_check_format (s
->the_bfd
, bfd_object
))
1767 target
= bfd_get_target (s
->the_bfd
);
1779 lang_get_output_target (void)
1783 /* Has the user told us which output format to use? */
1784 if (output_target
!= NULL
)
1785 return output_target
;
1787 /* No - has the current target been set to something other than
1789 if (current_target
!= default_target
)
1790 return current_target
;
1792 /* No - can we determine the format of the first input file? */
1793 target
= get_first_input_target ();
1797 /* Failed - use the default output target. */
1798 return default_target
;
1801 /* Open the output file. */
1804 open_output (const char *name
)
1808 output_target
= lang_get_output_target ();
1810 /* Has the user requested a particular endianness on the command
1812 if (command_line
.endian
!= ENDIAN_UNSET
)
1814 const bfd_target
*target
;
1815 enum bfd_endian desired_endian
;
1817 /* Get the chosen target. */
1818 target
= bfd_search_for_target (get_target
, (void *) output_target
);
1820 /* If the target is not supported, we cannot do anything. */
1823 if (command_line
.endian
== ENDIAN_BIG
)
1824 desired_endian
= BFD_ENDIAN_BIG
;
1826 desired_endian
= BFD_ENDIAN_LITTLE
;
1828 /* See if the target has the wrong endianness. This should
1829 not happen if the linker script has provided big and
1830 little endian alternatives, but some scrips don't do
1832 if (target
->byteorder
!= desired_endian
)
1834 /* If it does, then see if the target provides
1835 an alternative with the correct endianness. */
1836 if (target
->alternative_target
!= NULL
1837 && (target
->alternative_target
->byteorder
== desired_endian
))
1838 output_target
= target
->alternative_target
->name
;
1841 /* Try to find a target as similar as possible to
1842 the default target, but which has the desired
1843 endian characteristic. */
1844 bfd_search_for_target (closest_target_match
,
1847 /* Oh dear - we could not find any targets that
1848 satisfy our requirements. */
1850 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1852 output_target
= winner
->name
;
1858 output
= bfd_openw (name
, output_target
);
1862 if (bfd_get_error () == bfd_error_invalid_target
)
1863 einfo (_("%P%F: target %s not found\n"), output_target
);
1865 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1868 delete_output_file_on_failure
= TRUE
;
1871 output
->flags
|= D_PAGED
;
1874 if (! bfd_set_format (output
, bfd_object
))
1875 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1876 if (! bfd_set_arch_mach (output
,
1877 ldfile_output_architecture
,
1878 ldfile_output_machine
))
1879 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1881 link_info
.hash
= bfd_link_hash_table_create (output
);
1882 if (link_info
.hash
== NULL
)
1883 einfo (_("%P%F: can not create link hash table: %E\n"));
1885 bfd_set_gp_size (output
, g_switch_value
);
1890 ldlang_open_output (lang_statement_union_type
*statement
)
1892 switch (statement
->header
.type
)
1894 case lang_output_statement_enum
:
1895 ASSERT (output_bfd
== NULL
);
1896 output_bfd
= open_output (statement
->output_statement
.name
);
1897 ldemul_set_output_arch ();
1898 if (config
.magic_demand_paged
&& !link_info
.relocatable
)
1899 output_bfd
->flags
|= D_PAGED
;
1901 output_bfd
->flags
&= ~D_PAGED
;
1902 if (config
.text_read_only
)
1903 output_bfd
->flags
|= WP_TEXT
;
1905 output_bfd
->flags
&= ~WP_TEXT
;
1906 if (link_info
.traditional_format
)
1907 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1909 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1912 case lang_target_statement_enum
:
1913 current_target
= statement
->target_statement
.target
;
1920 /* Convert between addresses in bytes and sizes in octets.
1921 For currently supported targets, octets_per_byte is always a power
1922 of two, so we can use shifts. */
1923 #define TO_ADDR(X) ((X) >> opb_shift)
1924 #define TO_SIZE(X) ((X) << opb_shift)
1926 /* Support the above. */
1927 static unsigned int opb_shift
= 0;
1932 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
1933 ldfile_output_machine
);
1936 while ((x
& 1) == 0)
1944 /* Open all the input files. */
1947 open_input_bfds (lang_statement_union_type
*s
, bfd_boolean force
)
1949 for (; s
!= NULL
; s
= s
->header
.next
)
1951 switch (s
->header
.type
)
1953 case lang_constructors_statement_enum
:
1954 open_input_bfds (constructor_list
.head
, force
);
1956 case lang_output_section_statement_enum
:
1957 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1959 case lang_wild_statement_enum
:
1960 /* Maybe we should load the file's symbols. */
1961 if (s
->wild_statement
.filename
1962 && ! wildcardp (s
->wild_statement
.filename
))
1963 lookup_name (s
->wild_statement
.filename
);
1964 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1966 case lang_group_statement_enum
:
1968 struct bfd_link_hash_entry
*undefs
;
1970 /* We must continually search the entries in the group
1971 until no new symbols are added to the list of undefined
1976 undefs
= link_info
.hash
->undefs_tail
;
1977 open_input_bfds (s
->group_statement
.children
.head
, TRUE
);
1979 while (undefs
!= link_info
.hash
->undefs_tail
);
1982 case lang_target_statement_enum
:
1983 current_target
= s
->target_statement
.target
;
1985 case lang_input_statement_enum
:
1986 if (s
->input_statement
.real
)
1988 lang_statement_list_type add
;
1990 s
->input_statement
.target
= current_target
;
1992 /* If we are being called from within a group, and this
1993 is an archive which has already been searched, then
1994 force it to be researched unless the whole archive
1995 has been loaded already. */
1997 && !s
->input_statement
.whole_archive
1998 && s
->input_statement
.loaded
1999 && bfd_check_format (s
->input_statement
.the_bfd
,
2001 s
->input_statement
.loaded
= FALSE
;
2003 lang_list_init (&add
);
2005 if (! load_symbols (&s
->input_statement
, &add
))
2006 config
.make_executable
= FALSE
;
2008 if (add
.head
!= NULL
)
2010 *add
.tail
= s
->header
.next
;
2011 s
->header
.next
= add
.head
;
2021 /* If there are [COMMONS] statements, put a wild one into the bss
2025 lang_reasonable_defaults (void)
2028 lang_output_section_statement_lookup (".text");
2029 lang_output_section_statement_lookup (".data");
2031 default_common_section
= lang_output_section_statement_lookup (".bss");
2033 if (!placed_commons
)
2035 lang_wild_statement_type
*new =
2036 new_stat (lang_wild_statement
,
2037 &default_common_section
->children
);
2039 new->section_name
= "COMMON";
2040 new->filename
= NULL
;
2041 lang_list_init (&new->children
);
2046 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
2049 lang_track_definedness (const char *name
)
2051 if (bfd_hash_lookup (&lang_definedness_table
, name
, TRUE
, FALSE
) == NULL
)
2052 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
2055 /* New-function for the definedness hash table. */
2057 static struct bfd_hash_entry
*
2058 lang_definedness_newfunc (struct bfd_hash_entry
*entry
,
2059 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
2060 const char *name ATTRIBUTE_UNUSED
)
2062 struct lang_definedness_hash_entry
*ret
2063 = (struct lang_definedness_hash_entry
*) entry
;
2066 ret
= (struct lang_definedness_hash_entry
*)
2067 bfd_hash_allocate (table
, sizeof (struct lang_definedness_hash_entry
));
2070 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
2072 ret
->iteration
= -1;
2076 /* Return the iteration when the definition of NAME was last updated. A
2077 value of -1 means that the symbol is not defined in the linker script
2078 or the command line, but may be defined in the linker symbol table. */
2081 lang_symbol_definition_iteration (const char *name
)
2083 struct lang_definedness_hash_entry
*defentry
2084 = (struct lang_definedness_hash_entry
*)
2085 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
2087 /* We've already created this one on the presence of DEFINED in the
2088 script, so it can't be NULL unless something is borked elsewhere in
2090 if (defentry
== NULL
)
2093 return defentry
->iteration
;
2096 /* Update the definedness state of NAME. */
2099 lang_update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
2101 struct lang_definedness_hash_entry
*defentry
2102 = (struct lang_definedness_hash_entry
*)
2103 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
2105 /* We don't keep track of symbols not tested with DEFINED. */
2106 if (defentry
== NULL
)
2109 /* If the symbol was already defined, and not from an earlier statement
2110 iteration, don't update the definedness iteration, because that'd
2111 make the symbol seem defined in the linker script at this point, and
2112 it wasn't; it was defined in some object. If we do anyway, DEFINED
2113 would start to yield false before this point and the construct "sym =
2114 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
2116 if (h
->type
!= bfd_link_hash_undefined
2117 && h
->type
!= bfd_link_hash_common
2118 && h
->type
!= bfd_link_hash_new
2119 && defentry
->iteration
== -1)
2122 defentry
->iteration
= lang_statement_iteration
;
2125 /* Add the supplied name to the symbol table as an undefined reference.
2126 This is a two step process as the symbol table doesn't even exist at
2127 the time the ld command line is processed. First we put the name
2128 on a list, then, once the output file has been opened, transfer the
2129 name to the symbol table. */
2131 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
2133 #define ldlang_undef_chain_list_head entry_symbol.next
2136 ldlang_add_undef (const char *const name
)
2138 ldlang_undef_chain_list_type
*new =
2139 stat_alloc (sizeof (ldlang_undef_chain_list_type
));
2141 new->next
= ldlang_undef_chain_list_head
;
2142 ldlang_undef_chain_list_head
= new;
2144 new->name
= xstrdup (name
);
2146 if (output_bfd
!= NULL
)
2147 insert_undefined (new->name
);
2150 /* Insert NAME as undefined in the symbol table. */
2153 insert_undefined (const char *name
)
2155 struct bfd_link_hash_entry
*h
;
2157 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
2159 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2160 if (h
->type
== bfd_link_hash_new
)
2162 h
->type
= bfd_link_hash_undefined
;
2163 h
->u
.undef
.abfd
= NULL
;
2164 bfd_link_add_undef (link_info
.hash
, h
);
2168 /* Run through the list of undefineds created above and place them
2169 into the linker hash table as undefined symbols belonging to the
2173 lang_place_undefineds (void)
2175 ldlang_undef_chain_list_type
*ptr
;
2177 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
2178 insert_undefined (ptr
->name
);
2181 /* Check for all readonly or some readwrite sections. */
2184 check_input_sections (lang_statement_union_type
*s
,
2185 lang_output_section_statement_type
*output_section_statement
)
2187 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2189 switch (s
->header
.type
)
2191 case lang_wild_statement_enum
:
2192 walk_wild (&s
->wild_statement
, check_section_callback
,
2193 output_section_statement
);
2194 if (! output_section_statement
->all_input_readonly
)
2197 case lang_constructors_statement_enum
:
2198 check_input_sections (constructor_list
.head
,
2199 output_section_statement
);
2200 if (! output_section_statement
->all_input_readonly
)
2203 case lang_group_statement_enum
:
2204 check_input_sections (s
->group_statement
.children
.head
,
2205 output_section_statement
);
2206 if (! output_section_statement
->all_input_readonly
)
2215 /* Open input files and attach to output sections. */
2218 map_input_to_output_sections
2219 (lang_statement_union_type
*s
, const char *target
,
2220 lang_output_section_statement_type
*output_section_statement
)
2222 for (; s
!= NULL
; s
= s
->header
.next
)
2224 switch (s
->header
.type
)
2226 case lang_wild_statement_enum
:
2227 wild (&s
->wild_statement
, target
, output_section_statement
);
2229 case lang_constructors_statement_enum
:
2230 map_input_to_output_sections (constructor_list
.head
,
2232 output_section_statement
);
2234 case lang_output_section_statement_enum
:
2235 if (s
->output_section_statement
.constraint
)
2237 if (s
->output_section_statement
.constraint
== -1)
2239 s
->output_section_statement
.all_input_readonly
= TRUE
;
2240 check_input_sections (s
->output_section_statement
.children
.head
,
2241 &s
->output_section_statement
);
2242 if ((s
->output_section_statement
.all_input_readonly
2243 && s
->output_section_statement
.constraint
== ONLY_IF_RW
)
2244 || (!s
->output_section_statement
.all_input_readonly
2245 && s
->output_section_statement
.constraint
== ONLY_IF_RO
))
2247 s
->output_section_statement
.constraint
= -1;
2252 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2254 &s
->output_section_statement
);
2256 case lang_output_statement_enum
:
2258 case lang_target_statement_enum
:
2259 target
= s
->target_statement
.target
;
2261 case lang_group_statement_enum
:
2262 map_input_to_output_sections (s
->group_statement
.children
.head
,
2264 output_section_statement
);
2266 case lang_data_statement_enum
:
2267 /* Make sure that any sections mentioned in the expression
2269 exp_init_os (s
->data_statement
.exp
);
2271 case lang_fill_statement_enum
:
2272 case lang_input_section_enum
:
2273 case lang_object_symbols_statement_enum
:
2274 case lang_reloc_statement_enum
:
2275 case lang_padding_statement_enum
:
2276 case lang_input_statement_enum
:
2277 if (output_section_statement
!= NULL
2278 && output_section_statement
->bfd_section
== NULL
)
2279 init_os (output_section_statement
);
2281 case lang_assignment_statement_enum
:
2282 if (output_section_statement
!= NULL
2283 && output_section_statement
->bfd_section
== NULL
)
2284 init_os (output_section_statement
);
2286 /* Make sure that any sections mentioned in the assignment
2288 exp_init_os (s
->assignment_statement
.exp
);
2290 case lang_afile_asection_pair_statement_enum
:
2293 case lang_address_statement_enum
:
2294 /* Mark the specified section with the supplied address. */
2296 lang_output_section_statement_type
*os
=
2297 lang_output_section_statement_lookup
2298 (s
->address_statement
.section_name
);
2300 if (os
->bfd_section
== NULL
)
2302 os
->addr_tree
= s
->address_statement
.address
;
2309 /* An output section might have been removed after its statement was
2310 added. For example, ldemul_before_allocation can remove dynamic
2311 sections if they turn out to be not needed. Clean them up here. */
2314 strip_excluded_output_sections (void)
2316 lang_statement_union_type
*u
;
2318 for (u
= lang_output_section_statement
.head
;
2320 u
= u
->output_section_statement
.next
)
2322 lang_output_section_statement_type
*os
;
2325 os
= &u
->output_section_statement
;
2326 if (os
->constraint
== -1)
2328 s
= os
->bfd_section
;
2329 if (s
!= NULL
&& (s
->flags
& SEC_EXCLUDE
) != 0)
2333 os
->bfd_section
= NULL
;
2335 for (p
= &output_bfd
->sections
; *p
; p
= &(*p
)->next
)
2338 bfd_section_list_remove (output_bfd
, p
);
2339 output_bfd
->section_count
--;
2347 print_output_section_statement
2348 (lang_output_section_statement_type
*output_section_statement
)
2350 asection
*section
= output_section_statement
->bfd_section
;
2353 if (output_section_statement
!= abs_output_section
)
2355 minfo ("\n%s", output_section_statement
->name
);
2357 if (section
!= NULL
)
2359 print_dot
= section
->vma
;
2361 len
= strlen (output_section_statement
->name
);
2362 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2367 while (len
< SECTION_NAME_MAP_LENGTH
)
2373 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2375 if (output_section_statement
->load_base
!= NULL
)
2379 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2380 "load base", lang_final_phase_enum
);
2381 minfo (_(" load address 0x%V"), addr
);
2388 print_statement_list (output_section_statement
->children
.head
,
2389 output_section_statement
);
2393 print_assignment (lang_assignment_statement_type
*assignment
,
2394 lang_output_section_statement_type
*output_section
)
2397 etree_value_type result
;
2399 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2402 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2403 lang_final_phase_enum
, print_dot
, &print_dot
);
2409 value
= result
.value
+ result
.section
->bfd_section
->vma
;
2410 dst
= assignment
->exp
->assign
.dst
;
2412 minfo ("0x%V", value
);
2413 if (dst
[0] == '.' && dst
[1] == 0)
2426 exp_print_tree (assignment
->exp
);
2432 print_input_statement (lang_input_statement_type
*statm
)
2434 if (statm
->filename
!= NULL
)
2436 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2440 /* Print all symbols defined in a particular section. This is called
2441 via bfd_link_hash_traverse, or by print_all_symbols. */
2444 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
2446 asection
*sec
= ptr
;
2448 if ((hash_entry
->type
== bfd_link_hash_defined
2449 || hash_entry
->type
== bfd_link_hash_defweak
)
2450 && sec
== hash_entry
->u
.def
.section
)
2454 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2457 (hash_entry
->u
.def
.value
2458 + hash_entry
->u
.def
.section
->output_offset
2459 + hash_entry
->u
.def
.section
->output_section
->vma
));
2461 minfo (" %T\n", hash_entry
->root
.string
);
2468 print_all_symbols (sec
)
2471 struct fat_user_section_struct
*ud
= get_userdata (sec
);
2472 struct map_symbol_def
*def
;
2474 *ud
->map_symbol_def_tail
= 0;
2475 for (def
= ud
->map_symbol_def_head
; def
; def
= def
->next
)
2476 print_one_symbol (def
->entry
, sec
);
2479 /* Print information about an input section to the map file. */
2482 print_input_section (lang_input_section_type
*in
)
2484 asection
*i
= in
->section
;
2485 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2494 minfo ("%s", i
->name
);
2496 len
= 1 + strlen (i
->name
);
2497 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2502 while (len
< SECTION_NAME_MAP_LENGTH
)
2508 if (i
->output_section
!= NULL
&& (i
->flags
& SEC_EXCLUDE
) == 0)
2509 addr
= i
->output_section
->vma
+ i
->output_offset
;
2516 minfo ("0x%V %W %B\n", addr
, TO_ADDR (size
), i
->owner
);
2518 if (size
!= i
->_raw_size
)
2520 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2532 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2535 if (i
->output_section
!= NULL
&& (i
->flags
& SEC_EXCLUDE
) == 0)
2537 if (command_line
.reduce_memory_overheads
)
2538 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
2540 print_all_symbols (i
);
2542 print_dot
= addr
+ TO_ADDR (size
);
2548 print_fill_statement (lang_fill_statement_type
*fill
)
2552 fputs (" FILL mask 0x", config
.map_file
);
2553 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
2554 fprintf (config
.map_file
, "%02x", *p
);
2555 fputs ("\n", config
.map_file
);
2559 print_data_statement (lang_data_statement_type
*data
)
2567 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2570 addr
= data
->output_vma
;
2571 if (data
->output_section
!= NULL
)
2572 addr
+= data
->output_section
->vma
;
2600 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2602 if (data
->exp
->type
.node_class
!= etree_value
)
2605 exp_print_tree (data
->exp
);
2610 print_dot
= addr
+ TO_ADDR (size
);
2613 /* Print an address statement. These are generated by options like
2617 print_address_statement (lang_address_statement_type
*address
)
2619 minfo (_("Address of section %s set to "), address
->section_name
);
2620 exp_print_tree (address
->address
);
2624 /* Print a reloc statement. */
2627 print_reloc_statement (lang_reloc_statement_type
*reloc
)
2634 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2637 addr
= reloc
->output_vma
;
2638 if (reloc
->output_section
!= NULL
)
2639 addr
+= reloc
->output_section
->vma
;
2641 size
= bfd_get_reloc_size (reloc
->howto
);
2643 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2645 if (reloc
->name
!= NULL
)
2646 minfo ("%s+", reloc
->name
);
2648 minfo ("%s+", reloc
->section
->name
);
2650 exp_print_tree (reloc
->addend_exp
);
2654 print_dot
= addr
+ TO_ADDR (size
);
2658 print_padding_statement (lang_padding_statement_type
*s
)
2666 len
= sizeof " *fill*" - 1;
2667 while (len
< SECTION_NAME_MAP_LENGTH
)
2673 addr
= s
->output_offset
;
2674 if (s
->output_section
!= NULL
)
2675 addr
+= s
->output_section
->vma
;
2676 minfo ("0x%V %W ", addr
, (bfd_vma
) s
->size
);
2678 if (s
->fill
->size
!= 0)
2682 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
2683 fprintf (config
.map_file
, "%02x", *p
);
2688 print_dot
= addr
+ TO_ADDR (s
->size
);
2692 print_wild_statement (lang_wild_statement_type
*w
,
2693 lang_output_section_statement_type
*os
)
2695 struct wildcard_list
*sec
;
2699 if (w
->filenames_sorted
)
2701 if (w
->filename
!= NULL
)
2702 minfo ("%s", w
->filename
);
2705 if (w
->filenames_sorted
)
2709 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
2711 if (sec
->spec
.sorted
)
2713 if (sec
->spec
.exclude_name_list
!= NULL
)
2716 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
2717 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
2718 minfo (" %s", tmp
->name
);
2721 if (sec
->spec
.name
!= NULL
)
2722 minfo ("%s", sec
->spec
.name
);
2725 if (sec
->spec
.sorted
)
2734 print_statement_list (w
->children
.head
, os
);
2737 /* Print a group statement. */
2740 print_group (lang_group_statement_type
*s
,
2741 lang_output_section_statement_type
*os
)
2743 fprintf (config
.map_file
, "START GROUP\n");
2744 print_statement_list (s
->children
.head
, os
);
2745 fprintf (config
.map_file
, "END GROUP\n");
2748 /* Print the list of statements in S.
2749 This can be called for any statement type. */
2752 print_statement_list (lang_statement_union_type
*s
,
2753 lang_output_section_statement_type
*os
)
2757 print_statement (s
, os
);
2762 /* Print the first statement in statement list S.
2763 This can be called for any statement type. */
2766 print_statement (lang_statement_union_type
*s
,
2767 lang_output_section_statement_type
*os
)
2769 switch (s
->header
.type
)
2772 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2775 case lang_constructors_statement_enum
:
2776 if (constructor_list
.head
!= NULL
)
2778 if (constructors_sorted
)
2779 minfo (" SORT (CONSTRUCTORS)\n");
2781 minfo (" CONSTRUCTORS\n");
2782 print_statement_list (constructor_list
.head
, os
);
2785 case lang_wild_statement_enum
:
2786 print_wild_statement (&s
->wild_statement
, os
);
2788 case lang_address_statement_enum
:
2789 print_address_statement (&s
->address_statement
);
2791 case lang_object_symbols_statement_enum
:
2792 minfo (" CREATE_OBJECT_SYMBOLS\n");
2794 case lang_fill_statement_enum
:
2795 print_fill_statement (&s
->fill_statement
);
2797 case lang_data_statement_enum
:
2798 print_data_statement (&s
->data_statement
);
2800 case lang_reloc_statement_enum
:
2801 print_reloc_statement (&s
->reloc_statement
);
2803 case lang_input_section_enum
:
2804 print_input_section (&s
->input_section
);
2806 case lang_padding_statement_enum
:
2807 print_padding_statement (&s
->padding_statement
);
2809 case lang_output_section_statement_enum
:
2810 print_output_section_statement (&s
->output_section_statement
);
2812 case lang_assignment_statement_enum
:
2813 print_assignment (&s
->assignment_statement
, os
);
2815 case lang_target_statement_enum
:
2816 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2818 case lang_output_statement_enum
:
2819 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2820 if (output_target
!= NULL
)
2821 minfo (" %s", output_target
);
2824 case lang_input_statement_enum
:
2825 print_input_statement (&s
->input_statement
);
2827 case lang_group_statement_enum
:
2828 print_group (&s
->group_statement
, os
);
2830 case lang_afile_asection_pair_statement_enum
:
2837 print_statements (void)
2839 print_statement_list (statement_list
.head
, abs_output_section
);
2842 /* Print the first N statements in statement list S to STDERR.
2843 If N == 0, nothing is printed.
2844 If N < 0, the entire list is printed.
2845 Intended to be called from GDB. */
2848 dprint_statement (lang_statement_union_type
*s
, int n
)
2850 FILE *map_save
= config
.map_file
;
2852 config
.map_file
= stderr
;
2855 print_statement_list (s
, abs_output_section
);
2858 while (s
&& --n
>= 0)
2860 print_statement (s
, abs_output_section
);
2865 config
.map_file
= map_save
;
2869 insert_pad (lang_statement_union_type
**ptr
,
2871 unsigned int alignment_needed
,
2872 asection
*output_section
,
2875 static fill_type zero_fill
= { 1, { 0 } };
2876 lang_statement_union_type
*pad
;
2878 pad
= ((lang_statement_union_type
*)
2879 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
2880 if (ptr
!= &statement_list
.head
2881 && pad
->header
.type
== lang_padding_statement_enum
2882 && pad
->padding_statement
.output_section
== output_section
)
2884 /* Use the existing pad statement. The above test on output
2885 section is probably redundant, but it doesn't hurt to check. */
2889 /* Make a new padding statement, linked into existing chain. */
2890 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
2891 pad
->header
.next
= *ptr
;
2893 pad
->header
.type
= lang_padding_statement_enum
;
2894 pad
->padding_statement
.output_section
= output_section
;
2897 pad
->padding_statement
.fill
= fill
;
2899 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
2900 pad
->padding_statement
.size
= alignment_needed
;
2901 output_section
->_raw_size
+= alignment_needed
;
2904 /* Work out how much this section will move the dot point. */
2907 size_input_section (lang_statement_union_type
**this_ptr
,
2908 lang_output_section_statement_type
*output_section_statement
,
2912 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2913 asection
*i
= is
->section
;
2915 if (!is
->ifile
->just_syms_flag
&& (i
->flags
& SEC_EXCLUDE
) == 0)
2917 unsigned int alignment_needed
;
2920 /* Align this section first to the input sections requirement,
2921 then to the output section's requirement. If this alignment
2922 is greater than any seen before, then record it too. Perform
2923 the alignment by inserting a magic 'padding' statement. */
2925 if (output_section_statement
->subsection_alignment
!= -1)
2926 i
->alignment_power
= output_section_statement
->subsection_alignment
;
2928 o
= output_section_statement
->bfd_section
;
2929 if (o
->alignment_power
< i
->alignment_power
)
2930 o
->alignment_power
= i
->alignment_power
;
2932 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
2934 if (alignment_needed
!= 0)
2936 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
2937 dot
+= alignment_needed
;
2940 /* Remember where in the output section this input section goes. */
2942 i
->output_offset
= dot
- o
->vma
;
2944 /* Mark how big the output section must be to contain this now. */
2945 if (i
->_cooked_size
!= 0)
2946 dot
+= TO_ADDR (i
->_cooked_size
);
2948 dot
+= TO_ADDR (i
->_raw_size
);
2949 o
->_raw_size
= TO_SIZE (dot
- o
->vma
);
2953 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2959 #define IGNORE_SECTION(bfd, s) \
2960 (((bfd_get_section_flags (bfd, s) & SEC_THREAD_LOCAL) \
2961 ? ((bfd_get_section_flags (bfd, s) & (SEC_LOAD | SEC_NEVER_LOAD)) \
2963 : ((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_NEVER_LOAD)) \
2965 || bfd_section_size (bfd, s) == 0)
2967 /* Check to see if any allocated sections overlap with other allocated
2968 sections. This can happen when the linker script specifically specifies
2969 the output section addresses of the two sections. */
2972 lang_check_section_addresses (void)
2976 /* Scan all sections in the output list. */
2977 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2981 /* Ignore sections which are not loaded or which have no contents. */
2982 if (IGNORE_SECTION (output_bfd
, s
))
2985 /* Once we reach section 's' stop our seach. This prevents two
2986 warning messages from being produced, one for 'section A overlaps
2987 section B' and one for 'section B overlaps section A'. */
2988 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2995 /* Only consider loadable sections with real contents. */
2996 if (IGNORE_SECTION (output_bfd
, os
))
2999 /* We must check the sections' LMA addresses not their
3000 VMA addresses because overlay sections can have
3001 overlapping VMAs but they must have distinct LMAs. */
3002 s_start
= bfd_section_lma (output_bfd
, s
);
3003 os_start
= bfd_section_lma (output_bfd
, os
);
3004 s_end
= s_start
+ TO_ADDR (bfd_section_size (output_bfd
, s
)) - 1;
3005 os_end
= os_start
+ TO_ADDR (bfd_section_size (output_bfd
, os
)) - 1;
3007 /* Look for an overlap. */
3008 if ((s_end
< os_start
) || (s_start
> os_end
))
3012 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
3013 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
3015 /* Once we have found one overlap for this section,
3016 stop looking for others. */
3022 /* Make sure the new address is within the region. We explicitly permit the
3023 current address to be at the exact end of the region when the address is
3024 non-zero, in case the region is at the end of addressable memory and the
3025 calculation wraps around. */
3028 os_region_check (lang_output_section_statement_type
*os
,
3029 lang_memory_region_type
*region
,
3033 if ((region
->current
< region
->origin
3034 || (region
->current
- region
->origin
> region
->length
))
3035 && ((region
->current
!= region
->origin
+ region
->length
)
3040 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
3042 os
->bfd_section
->owner
,
3043 os
->bfd_section
->name
,
3048 einfo (_("%X%P: region %s is full (%B section %s)\n"),
3050 os
->bfd_section
->owner
,
3051 os
->bfd_section
->name
);
3053 /* Reset the region pointer. */
3054 region
->current
= region
->origin
;
3058 /* Set the sizes for all the output sections. */
3061 lang_size_sections_1
3062 (lang_statement_union_type
*s
,
3063 lang_output_section_statement_type
*output_section_statement
,
3064 lang_statement_union_type
**prev
,
3068 bfd_boolean check_regions
)
3070 /* Size up the sections from their constituent parts. */
3071 for (; s
!= NULL
; s
= s
->header
.next
)
3073 switch (s
->header
.type
)
3075 case lang_output_section_statement_enum
:
3078 lang_output_section_statement_type
*os
;
3080 os
= &s
->output_section_statement
;
3081 if (os
->bfd_section
== NULL
)
3082 /* This section was never actually created. */
3085 /* If this is a COFF shared library section, use the size and
3086 address from the input section. FIXME: This is COFF
3087 specific; it would be cleaner if there were some other way
3088 to do this, but nothing simple comes to mind. */
3089 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
3093 if (os
->children
.head
== NULL
3094 || os
->children
.head
->header
.next
!= NULL
3095 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
3096 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
3099 input
= os
->children
.head
->input_section
.section
;
3100 bfd_set_section_vma (os
->bfd_section
->owner
,
3102 bfd_section_vma (input
->owner
, input
));
3103 os
->bfd_section
->_raw_size
= input
->_raw_size
;
3107 if (bfd_is_abs_section (os
->bfd_section
))
3109 /* No matter what happens, an abs section starts at zero. */
3110 ASSERT (os
->bfd_section
->vma
== 0);
3114 if (os
->addr_tree
== NULL
)
3116 /* No address specified for this section, get one
3117 from the region specification. */
3118 if (os
->region
== NULL
3119 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3120 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
3121 && os
->region
->name
[0] == '*'
3122 && strcmp (os
->region
->name
, DEFAULT_MEMORY_REGION
) == 0))
3124 os
->region
= lang_memory_default (os
->bfd_section
);
3127 /* If a loadable section is using the default memory
3128 region, and some non default memory regions were
3129 defined, issue an error message. */
3130 if (!IGNORE_SECTION (output_bfd
, os
->bfd_section
)
3131 && ! link_info
.relocatable
3133 && strcmp (os
->region
->name
, DEFAULT_MEMORY_REGION
) == 0
3134 && lang_memory_region_list
!= NULL
3135 && (strcmp (lang_memory_region_list
->name
,
3136 DEFAULT_MEMORY_REGION
) != 0
3137 || lang_memory_region_list
->next
!= NULL
))
3139 /* By default this is an error rather than just a
3140 warning because if we allocate the section to the
3141 default memory region we can end up creating an
3142 excessively large binary, or even seg faulting when
3143 attempting to perform a negative seek. See
3144 http://sources.redhat.com/ml/binutils/2003-04/msg00423.html
3145 for an example of this. This behaviour can be
3146 overridden by the using the --no-check-sections
3148 if (command_line
.check_section_addresses
)
3149 einfo (_("%P%F: error: no memory region specified for loadable section `%s'\n"),
3150 bfd_get_section_name (output_bfd
,
3153 einfo (_("%P: warning: no memory region specified for loadable section `%s'\n"),
3154 bfd_get_section_name (output_bfd
,
3158 dot
= os
->region
->current
;
3160 if (os
->section_alignment
== -1)
3165 dot
= align_power (dot
,
3166 os
->bfd_section
->alignment_power
);
3168 if (dot
!= olddot
&& config
.warn_section_align
)
3169 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
3170 os
->name
, (unsigned int) (dot
- olddot
));
3178 r
= exp_fold_tree (os
->addr_tree
,
3180 lang_allocating_phase_enum
,
3185 einfo (_("%F%S: non constant or forward reference address expression for section %s\n"),
3188 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
3191 /* The section starts here.
3192 First, align to what the section needs. */
3194 if (os
->section_alignment
!= -1)
3195 dot
= align_power (dot
, os
->section_alignment
);
3197 bfd_set_section_vma (0, os
->bfd_section
, dot
);
3199 os
->bfd_section
->output_offset
= 0;
3202 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
3203 os
->fill
, dot
, relax
, check_regions
);
3205 /* Put the section within the requested block size, or
3206 align at the block boundary. */
3207 after
= ((os
->bfd_section
->vma
3208 + TO_ADDR (os
->bfd_section
->_raw_size
)
3209 + os
->block_value
- 1)
3210 & - (bfd_vma
) os
->block_value
);
3212 if (bfd_is_abs_section (os
->bfd_section
))
3213 ASSERT (after
== os
->bfd_section
->vma
);
3215 os
->bfd_section
->_raw_size
3216 = TO_SIZE (after
- os
->bfd_section
->vma
);
3218 dot
= os
->bfd_section
->vma
;
3219 /* .tbss sections effectively have zero size. */
3220 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
3221 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
3222 || link_info
.relocatable
)
3223 dot
+= TO_ADDR (os
->bfd_section
->_raw_size
);
3227 if (os
->update_dot_tree
!= 0)
3228 exp_fold_tree (os
->update_dot_tree
, abs_output_section
,
3229 lang_allocating_phase_enum
, dot
, &dot
);
3231 /* Update dot in the region ?
3232 We only do this if the section is going to be allocated,
3233 since unallocated sections do not contribute to the region's
3234 overall size in memory.
3236 If the SEC_NEVER_LOAD bit is not set, it will affect the
3237 addresses of sections after it. We have to update
3239 if (os
->region
!= NULL
3240 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3241 & SEC_NEVER_LOAD
) == 0
3242 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3243 & (SEC_ALLOC
| SEC_LOAD
))))
3245 os
->region
->current
= dot
;
3248 /* Make sure the new address is within the region. */
3249 os_region_check (os
, os
->region
, os
->addr_tree
,
3250 os
->bfd_section
->vma
);
3252 /* If there's no load address specified, use the run
3253 region as the load region. */
3254 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
3255 os
->lma_region
= os
->region
;
3257 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
)
3259 /* Set load_base, which will be handled later. */
3260 os
->load_base
= exp_intop (os
->lma_region
->current
);
3261 os
->lma_region
->current
+=
3262 TO_ADDR (os
->bfd_section
->_raw_size
);
3264 os_region_check (os
, os
->lma_region
, NULL
,
3265 os
->bfd_section
->lma
);
3271 case lang_constructors_statement_enum
:
3272 dot
= lang_size_sections_1 (constructor_list
.head
,
3273 output_section_statement
,
3274 &s
->wild_statement
.children
.head
,
3275 fill
, dot
, relax
, check_regions
);
3278 case lang_data_statement_enum
:
3280 unsigned int size
= 0;
3282 s
->data_statement
.output_vma
=
3283 dot
- output_section_statement
->bfd_section
->vma
;
3284 s
->data_statement
.output_section
=
3285 output_section_statement
->bfd_section
;
3287 /* We might refer to provided symbols in the expression, and
3288 need to mark them as needed. */
3289 exp_fold_tree (s
->data_statement
.exp
, abs_output_section
,
3290 lang_allocating_phase_enum
, dot
, &dot
);
3292 switch (s
->data_statement
.type
)
3310 if (size
< TO_SIZE ((unsigned) 1))
3311 size
= TO_SIZE ((unsigned) 1);
3312 dot
+= TO_ADDR (size
);
3313 output_section_statement
->bfd_section
->_raw_size
+= size
;
3314 /* The output section gets contents, and then we inspect for
3315 any flags set in the input script which override any ALLOC. */
3316 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3317 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3319 output_section_statement
->bfd_section
->flags
|=
3320 SEC_ALLOC
| SEC_LOAD
;
3325 case lang_reloc_statement_enum
:
3329 s
->reloc_statement
.output_vma
=
3330 dot
- output_section_statement
->bfd_section
->vma
;
3331 s
->reloc_statement
.output_section
=
3332 output_section_statement
->bfd_section
;
3333 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3334 dot
+= TO_ADDR (size
);
3335 output_section_statement
->bfd_section
->_raw_size
+= size
;
3339 case lang_wild_statement_enum
:
3341 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
3342 output_section_statement
,
3343 &s
->wild_statement
.children
.head
,
3344 fill
, dot
, relax
, check_regions
);
3348 case lang_object_symbols_statement_enum
:
3349 link_info
.create_object_symbols_section
=
3350 output_section_statement
->bfd_section
;
3352 case lang_output_statement_enum
:
3353 case lang_target_statement_enum
:
3355 case lang_input_section_enum
:
3359 i
= (*prev
)->input_section
.section
;
3362 if (i
->_cooked_size
== 0)
3363 i
->_cooked_size
= i
->_raw_size
;
3369 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3370 einfo (_("%P%F: can't relax section: %E\n"));
3374 dot
= size_input_section (prev
, output_section_statement
,
3375 output_section_statement
->fill
, dot
);
3378 case lang_input_statement_enum
:
3380 case lang_fill_statement_enum
:
3381 s
->fill_statement
.output_section
=
3382 output_section_statement
->bfd_section
;
3384 fill
= s
->fill_statement
.fill
;
3386 case lang_assignment_statement_enum
:
3388 bfd_vma newdot
= dot
;
3390 exp_fold_tree (s
->assignment_statement
.exp
,
3391 output_section_statement
,
3392 lang_allocating_phase_enum
,
3398 if (output_section_statement
== abs_output_section
)
3400 /* If we don't have an output section, then just adjust
3401 the default memory address. */
3402 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
)->current
= newdot
;
3406 /* Insert a pad after this statement. We can't
3407 put the pad before when relaxing, in case the
3408 assignment references dot. */
3409 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
3410 output_section_statement
->bfd_section
, dot
);
3412 /* Don't neuter the pad below when relaxing. */
3416 /* If dot is advanced, this implies that the section should
3417 have space allocated to it, unless the user has explicitly
3418 stated that the section should never be loaded. */
3419 if (!(output_section_statement
->flags
& (SEC_NEVER_LOAD
| SEC_ALLOC
)))
3420 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
3427 case lang_padding_statement_enum
:
3428 /* If this is the first time lang_size_sections is called,
3429 we won't have any padding statements. If this is the
3430 second or later passes when relaxing, we should allow
3431 padding to shrink. If padding is needed on this pass, it
3432 will be added back in. */
3433 s
->padding_statement
.size
= 0;
3435 /* Make sure output_offset is valid. If relaxation shrinks
3436 the section and this pad isn't needed, it's possible to
3437 have output_offset larger than the final size of the
3438 section. bfd_set_section_contents will complain even for
3439 a pad size of zero. */
3440 s
->padding_statement
.output_offset
3441 = dot
- output_section_statement
->bfd_section
->vma
;
3444 case lang_group_statement_enum
:
3445 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
3446 output_section_statement
,
3447 &s
->group_statement
.children
.head
,
3448 fill
, dot
, relax
, check_regions
);
3455 /* We can only get here when relaxing is turned on. */
3456 case lang_address_statement_enum
:
3459 prev
= &s
->header
.next
;
3466 (lang_statement_union_type
*s
,
3467 lang_output_section_statement_type
*output_section_statement
,
3468 lang_statement_union_type
**prev
,
3472 bfd_boolean check_regions
)
3477 /* Callers of exp_fold_tree need to increment this. */
3478 lang_statement_iteration
++;
3480 exp_data_seg
.phase
= exp_dataseg_none
;
3481 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
3482 dot
, relax
, check_regions
);
3483 if (exp_data_seg
.phase
== exp_dataseg_end_seen
3484 && link_info
.relro
&& exp_data_seg
.relro_end
)
3486 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
3487 to put exp_data_seg.relro on a (common) page boundary. */
3489 exp_data_seg
.phase
= exp_dataseg_relro_adjust
;
3490 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
3491 dot
, relax
, check_regions
);
3492 link_info
.relro_start
= exp_data_seg
.base
;
3493 link_info
.relro_end
= exp_data_seg
.relro_end
;
3495 else if (exp_data_seg
.phase
== exp_dataseg_end_seen
)
3497 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3498 a page could be saved in the data segment. */
3499 bfd_vma first
, last
;
3501 first
= -exp_data_seg
.base
& (exp_data_seg
.pagesize
- 1);
3502 last
= exp_data_seg
.end
& (exp_data_seg
.pagesize
- 1);
3504 && ((exp_data_seg
.base
& ~(exp_data_seg
.pagesize
- 1))
3505 != (exp_data_seg
.end
& ~(exp_data_seg
.pagesize
- 1)))
3506 && first
+ last
<= exp_data_seg
.pagesize
)
3508 exp_data_seg
.phase
= exp_dataseg_adjust
;
3509 lang_statement_iteration
++;
3510 result
= lang_size_sections_1 (s
, output_section_statement
, prev
,
3511 fill
, dot
, relax
, check_regions
);
3515 /* Some backend relaxers want to refer to the output section size. Give
3516 them a section size that does not change on the next call while they
3517 relax. We can't set this at top because lang_reset_memory_regions
3518 which is called before we get here, sets _raw_size to 0 on relaxing
3520 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
3521 o
->_cooked_size
= o
->_raw_size
;
3526 /* Worker function for lang_do_assignments. Recursiveness goes here. */
3529 lang_do_assignments_1
3530 (lang_statement_union_type
*s
,
3531 lang_output_section_statement_type
*output_section_statement
,
3535 for (; s
!= NULL
; s
= s
->header
.next
)
3537 switch (s
->header
.type
)
3539 case lang_constructors_statement_enum
:
3540 dot
= lang_do_assignments_1 (constructor_list
.head
,
3541 output_section_statement
,
3546 case lang_output_section_statement_enum
:
3548 lang_output_section_statement_type
*os
;
3550 os
= &(s
->output_section_statement
);
3551 if (os
->bfd_section
!= NULL
)
3553 dot
= os
->bfd_section
->vma
;
3554 lang_do_assignments_1 (os
->children
.head
, os
, os
->fill
, dot
);
3555 /* .tbss sections effectively have zero size. */
3556 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
3557 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
3558 || link_info
.relocatable
)
3559 dot
+= TO_ADDR (os
->bfd_section
->_raw_size
);
3563 /* If nothing has been placed into the output section then
3564 it won't have a bfd_section. */
3565 if (os
->bfd_section
)
3567 os
->bfd_section
->lma
3568 = exp_get_abs_int (os
->load_base
, 0, "load base",
3569 lang_final_phase_enum
);
3574 case lang_wild_statement_enum
:
3576 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
3577 output_section_statement
,
3582 case lang_object_symbols_statement_enum
:
3583 case lang_output_statement_enum
:
3584 case lang_target_statement_enum
:
3586 case lang_common_statement_enum
:
3589 case lang_data_statement_enum
:
3591 etree_value_type value
;
3593 value
= exp_fold_tree (s
->data_statement
.exp
,
3595 lang_final_phase_enum
, dot
, &dot
);
3597 einfo (_("%F%P: invalid data statement\n"));
3598 s
->data_statement
.value
3599 = value
.value
+ value
.section
->bfd_section
->vma
;
3603 switch (s
->data_statement
.type
)
3621 if (size
< TO_SIZE ((unsigned) 1))
3622 size
= TO_SIZE ((unsigned) 1);
3623 dot
+= TO_ADDR (size
);
3627 case lang_reloc_statement_enum
:
3629 etree_value_type value
;
3631 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3633 lang_final_phase_enum
, dot
, &dot
);
3634 s
->reloc_statement
.addend_value
= value
.value
;
3636 einfo (_("%F%P: invalid reloc statement\n"));
3638 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
3641 case lang_input_section_enum
:
3643 asection
*in
= s
->input_section
.section
;
3645 if ((in
->flags
& SEC_EXCLUDE
) == 0)
3647 if (in
->_cooked_size
!= 0)
3648 dot
+= TO_ADDR (in
->_cooked_size
);
3650 dot
+= TO_ADDR (in
->_raw_size
);
3655 case lang_input_statement_enum
:
3657 case lang_fill_statement_enum
:
3658 fill
= s
->fill_statement
.fill
;
3660 case lang_assignment_statement_enum
:
3662 exp_fold_tree (s
->assignment_statement
.exp
,
3663 output_section_statement
,
3664 lang_final_phase_enum
,
3670 case lang_padding_statement_enum
:
3671 dot
+= TO_ADDR (s
->padding_statement
.size
);
3674 case lang_group_statement_enum
:
3675 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
3676 output_section_statement
,
3684 case lang_address_statement_enum
:
3693 lang_do_assignments (lang_statement_union_type
*s
,
3694 lang_output_section_statement_type
*output_section_statement
,
3698 /* Callers of exp_fold_tree need to increment this. */
3699 lang_statement_iteration
++;
3700 lang_do_assignments_1 (s
, output_section_statement
, fill
, dot
);
3703 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3704 operator .startof. (section_name), it produces an undefined symbol
3705 .startof.section_name. Similarly, when it sees
3706 .sizeof. (section_name), it produces an undefined symbol
3707 .sizeof.section_name. For all the output sections, we look for
3708 such symbols, and set them to the correct value. */
3711 lang_set_startof (void)
3715 if (link_info
.relocatable
)
3718 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3720 const char *secname
;
3722 struct bfd_link_hash_entry
*h
;
3724 secname
= bfd_get_section_name (output_bfd
, s
);
3725 buf
= xmalloc (10 + strlen (secname
));
3727 sprintf (buf
, ".startof.%s", secname
);
3728 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
3729 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3731 h
->type
= bfd_link_hash_defined
;
3732 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3733 h
->u
.def
.section
= bfd_abs_section_ptr
;
3736 sprintf (buf
, ".sizeof.%s", secname
);
3737 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
3738 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3740 h
->type
= bfd_link_hash_defined
;
3741 if (s
->_cooked_size
!= 0)
3742 h
->u
.def
.value
= TO_ADDR (s
->_cooked_size
);
3744 h
->u
.def
.value
= TO_ADDR (s
->_raw_size
);
3745 h
->u
.def
.section
= bfd_abs_section_ptr
;
3755 struct bfd_link_hash_entry
*h
;
3758 if (link_info
.relocatable
|| link_info
.shared
)
3763 if (entry_symbol
.name
== NULL
)
3765 /* No entry has been specified. Look for start, but don't warn
3766 if we don't find it. */
3767 entry_symbol
.name
= "start";
3771 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
3772 FALSE
, FALSE
, TRUE
);
3774 && (h
->type
== bfd_link_hash_defined
3775 || h
->type
== bfd_link_hash_defweak
)
3776 && h
->u
.def
.section
->output_section
!= NULL
)
3780 val
= (h
->u
.def
.value
3781 + bfd_get_section_vma (output_bfd
,
3782 h
->u
.def
.section
->output_section
)
3783 + h
->u
.def
.section
->output_offset
);
3784 if (! bfd_set_start_address (output_bfd
, val
))
3785 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
3792 /* We couldn't find the entry symbol. Try parsing it as a
3794 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
3797 if (! bfd_set_start_address (output_bfd
, val
))
3798 einfo (_("%P%F: can't set start address\n"));
3804 /* Can't find the entry symbol, and it's not a number. Use
3805 the first address in the text section. */
3806 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
3810 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3812 bfd_get_section_vma (output_bfd
, ts
));
3813 if (! bfd_set_start_address (output_bfd
,
3814 bfd_get_section_vma (output_bfd
,
3816 einfo (_("%P%F: can't set start address\n"));
3821 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3827 bfd_hash_table_free (&lang_definedness_table
);
3830 /* This is a small function used when we want to ignore errors from
3834 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3836 /* Don't do anything. */
3839 /* Check that the architecture of all the input files is compatible
3840 with the output file. Also call the backend to let it do any
3841 other checking that is needed. */
3846 lang_statement_union_type
*file
;
3848 const bfd_arch_info_type
*compatible
;
3850 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
3852 input_bfd
= file
->input_statement
.the_bfd
;
3853 compatible
= bfd_arch_get_compatible (input_bfd
, output_bfd
,
3854 command_line
.accept_unknown_input_arch
);
3856 /* In general it is not possible to perform a relocatable
3857 link between differing object formats when the input
3858 file has relocations, because the relocations in the
3859 input format may not have equivalent representations in
3860 the output format (and besides BFD does not translate
3861 relocs for other link purposes than a final link). */
3862 if ((link_info
.relocatable
|| link_info
.emitrelocations
)
3863 && (compatible
== NULL
3864 || bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
3865 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
3867 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3868 bfd_get_target (input_bfd
), input_bfd
,
3869 bfd_get_target (output_bfd
), output_bfd
);
3870 /* einfo with %F exits. */
3873 if (compatible
== NULL
)
3875 if (command_line
.warn_mismatch
)
3876 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3877 bfd_printable_name (input_bfd
), input_bfd
,
3878 bfd_printable_name (output_bfd
));
3880 else if (bfd_count_sections (input_bfd
))
3882 /* If the input bfd has no contents, it shouldn't set the
3883 private data of the output bfd. */
3885 bfd_error_handler_type pfn
= NULL
;
3887 /* If we aren't supposed to warn about mismatched input
3888 files, temporarily set the BFD error handler to a
3889 function which will do nothing. We still want to call
3890 bfd_merge_private_bfd_data, since it may set up
3891 information which is needed in the output file. */
3892 if (! command_line
.warn_mismatch
)
3893 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3894 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3896 if (command_line
.warn_mismatch
)
3897 einfo (_("%P%X: failed to merge target specific data of file %B\n"),
3900 if (! command_line
.warn_mismatch
)
3901 bfd_set_error_handler (pfn
);
3906 /* Look through all the global common symbols and attach them to the
3907 correct section. The -sort-common command line switch may be used
3908 to roughly sort the entries by size. */
3913 if (command_line
.inhibit_common_definition
)
3915 if (link_info
.relocatable
3916 && ! command_line
.force_common_definition
)
3919 if (! config
.sort_common
)
3920 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
3925 for (power
= 4; power
>= 0; power
--)
3926 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
3930 /* Place one common symbol in the correct section. */
3933 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
3935 unsigned int power_of_two
;
3939 if (h
->type
!= bfd_link_hash_common
)
3943 power_of_two
= h
->u
.c
.p
->alignment_power
;
3945 if (config
.sort_common
3946 && power_of_two
< (unsigned int) *(int *) info
)
3949 section
= h
->u
.c
.p
->section
;
3951 /* Increase the size of the section to align the common sym. */
3952 section
->_cooked_size
+= ((bfd_vma
) 1 << (power_of_two
+ opb_shift
)) - 1;
3953 section
->_cooked_size
&= (- (bfd_vma
) 1 << (power_of_two
+ opb_shift
));
3955 /* Adjust the alignment if necessary. */
3956 if (power_of_two
> section
->alignment_power
)
3957 section
->alignment_power
= power_of_two
;
3959 /* Change the symbol from common to defined. */
3960 h
->type
= bfd_link_hash_defined
;
3961 h
->u
.def
.section
= section
;
3962 h
->u
.def
.value
= section
->_cooked_size
;
3964 /* Increase the size of the section. */
3965 section
->_cooked_size
+= size
;
3967 /* Make sure the section is allocated in memory, and make sure that
3968 it is no longer a common section. */
3969 section
->flags
|= SEC_ALLOC
;
3970 section
->flags
&= ~SEC_IS_COMMON
;
3972 if (config
.map_file
!= NULL
)
3974 static bfd_boolean header_printed
;
3979 if (! header_printed
)
3981 minfo (_("\nAllocating common symbols\n"));
3982 minfo (_("Common symbol size file\n\n"));
3983 header_printed
= TRUE
;
3986 name
= demangle (h
->root
.string
);
3988 len
= strlen (name
);
4003 if (size
<= 0xffffffff)
4004 sprintf (buf
, "%lx", (unsigned long) size
);
4006 sprintf_vma (buf
, size
);
4016 minfo ("%B\n", section
->owner
);
4022 /* Run through the input files and ensure that every input section has
4023 somewhere to go. If one is found without a destination then create
4024 an input request and place it into the statement tree. */
4027 lang_place_orphans (void)
4029 LANG_FOR_EACH_INPUT_STATEMENT (file
)
4033 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4035 if (s
->output_section
== NULL
)
4037 /* This section of the file is not attached, root
4038 around for a sensible place for it to go. */
4040 if (file
->just_syms_flag
)
4044 else if (strcmp (s
->name
, "COMMON") == 0)
4046 /* This is a lonely common section which must have
4047 come from an archive. We attach to the section
4048 with the wildcard. */
4049 if (! link_info
.relocatable
4050 || command_line
.force_common_definition
)
4052 if (default_common_section
== NULL
)
4055 /* This message happens when using the
4056 svr3.ifile linker script, so I have
4058 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
4060 default_common_section
=
4061 lang_output_section_statement_lookup (".bss");
4064 lang_add_section (&default_common_section
->children
, s
,
4065 default_common_section
, file
);
4068 else if (ldemul_place_orphan (file
, s
))
4072 lang_output_section_statement_type
*os
;
4074 os
= lang_output_section_statement_lookup (s
->name
);
4075 lang_add_section (&os
->children
, s
, os
, file
);
4083 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
4085 flagword
*ptr_flags
;
4087 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
4093 *ptr_flags
|= SEC_ALLOC
;
4097 *ptr_flags
|= SEC_READONLY
;
4101 *ptr_flags
|= SEC_DATA
;
4105 *ptr_flags
|= SEC_CODE
;
4110 *ptr_flags
|= SEC_LOAD
;
4114 einfo (_("%P%F: invalid syntax in flags\n"));
4121 /* Call a function on each input file. This function will be called
4122 on an archive, but not on the elements. */
4125 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
4127 lang_input_statement_type
*f
;
4129 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
4131 f
= (lang_input_statement_type
*) f
->next_real_file
)
4135 /* Call a function on each file. The function will be called on all
4136 the elements of an archive which are included in the link, but will
4137 not be called on the archive file itself. */
4140 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
4142 LANG_FOR_EACH_INPUT_STATEMENT (f
)
4149 ldlang_add_file (lang_input_statement_type
*entry
)
4153 lang_statement_append (&file_chain
,
4154 (lang_statement_union_type
*) entry
,
4157 /* The BFD linker needs to have a list of all input BFDs involved in
4159 ASSERT (entry
->the_bfd
->link_next
== NULL
);
4160 ASSERT (entry
->the_bfd
!= output_bfd
);
4161 for (pp
= &link_info
.input_bfds
; *pp
!= NULL
; pp
= &(*pp
)->link_next
)
4163 *pp
= entry
->the_bfd
;
4164 entry
->the_bfd
->usrdata
= entry
;
4165 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
4167 /* Look through the sections and check for any which should not be
4168 included in the link. We need to do this now, so that we can
4169 notice when the backend linker tries to report multiple
4170 definition errors for symbols which are in sections we aren't
4171 going to link. FIXME: It might be better to entirely ignore
4172 symbols which are defined in sections which are going to be
4173 discarded. This would require modifying the backend linker for
4174 each backend which might set the SEC_LINK_ONCE flag. If we do
4175 this, we should probably handle SEC_EXCLUDE in the same way. */
4177 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
4181 lang_add_output (const char *name
, int from_script
)
4183 /* Make -o on command line override OUTPUT in script. */
4184 if (!had_output_filename
|| !from_script
)
4186 output_filename
= name
;
4187 had_output_filename
= TRUE
;
4191 static lang_output_section_statement_type
*current_section
;
4202 for (l
= 0; l
< 32; l
++)
4204 if (i
>= (unsigned int) x
)
4212 lang_output_section_statement_type
*
4213 lang_enter_output_section_statement (const char *output_section_statement_name
,
4214 etree_type
*address_exp
,
4215 enum section_type sectype
,
4217 etree_type
*subalign
,
4221 lang_output_section_statement_type
*os
;
4225 lang_output_section_statement_lookup_1 (output_section_statement_name
,
4228 /* Add this statement to tree. */
4230 add_statement (lang_output_section_statement_enum
,
4231 output_section_statement
);
4233 /* Make next things chain into subchain of this. */
4235 if (os
->addr_tree
== NULL
)
4237 os
->addr_tree
= address_exp
;
4239 os
->sectype
= sectype
;
4240 if (sectype
!= noload_section
)
4241 os
->flags
= SEC_NO_FLAGS
;
4243 os
->flags
= SEC_NEVER_LOAD
;
4244 os
->block_value
= 1;
4245 stat_ptr
= &os
->children
;
4247 os
->subsection_alignment
=
4248 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
4249 os
->section_alignment
=
4250 topower (exp_get_value_int (align
, -1, "section alignment", 0));
4252 os
->load_base
= ebase
;
4259 lang_output_statement_type
*new =
4260 new_stat (lang_output_statement
, stat_ptr
);
4262 new->name
= output_filename
;
4265 /* Reset the current counters in the regions. */
4268 lang_reset_memory_regions (void)
4270 lang_memory_region_type
*p
= lang_memory_region_list
;
4273 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
4275 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
4276 p
->current
= p
->origin
;
4279 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4283 /* If the wild pattern was marked KEEP, the member sections
4284 should be as well. */
4287 gc_section_callback (lang_wild_statement_type
*ptr
,
4288 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
4290 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
4291 void *data ATTRIBUTE_UNUSED
)
4293 if (ptr
->keep_sections
)
4294 section
->flags
|= SEC_KEEP
;
4297 /* Handle a wild statement, marking it against GC. */
4300 lang_gc_wild (lang_wild_statement_type
*s
)
4302 walk_wild (s
, gc_section_callback
, NULL
);
4305 /* Iterate over sections marking them against GC. */
4308 lang_gc_sections_1 (lang_statement_union_type
*s
)
4310 for (; s
!= NULL
; s
= s
->header
.next
)
4312 switch (s
->header
.type
)
4314 case lang_wild_statement_enum
:
4315 lang_gc_wild (&s
->wild_statement
);
4317 case lang_constructors_statement_enum
:
4318 lang_gc_sections_1 (constructor_list
.head
);
4320 case lang_output_section_statement_enum
:
4321 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4323 case lang_group_statement_enum
:
4324 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4333 lang_gc_sections (void)
4335 struct bfd_link_hash_entry
*h
;
4336 ldlang_undef_chain_list_type
*ulist
;
4338 /* Keep all sections so marked in the link script. */
4340 lang_gc_sections_1 (statement_list
.head
);
4342 /* Keep all sections containing symbols undefined on the command-line,
4343 and the section containing the entry symbol. */
4345 for (ulist
= link_info
.gc_sym_list
; ulist
; ulist
= ulist
->next
)
4347 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4348 FALSE
, FALSE
, FALSE
);
4351 && (h
->type
== bfd_link_hash_defined
4352 || h
->type
== bfd_link_hash_defweak
)
4353 && ! bfd_is_abs_section (h
->u
.def
.section
))
4355 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4359 bfd_gc_sections (output_bfd
, &link_info
);
4365 lang_reasonable_defaults ();
4366 current_target
= default_target
;
4368 /* Open the output file. */
4369 lang_for_each_statement (ldlang_open_output
);
4372 ldemul_create_output_section_statements ();
4374 /* Add to the hash table all undefineds on the command line. */
4375 lang_place_undefineds ();
4377 already_linked_table_init ();
4379 /* Create a bfd for each input file. */
4380 current_target
= default_target
;
4381 open_input_bfds (statement_list
.head
, FALSE
);
4383 link_info
.gc_sym_list
= &entry_symbol
;
4384 if (entry_symbol
.name
== NULL
)
4385 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
4387 ldemul_after_open ();
4389 already_linked_table_free ();
4391 /* Make sure that we're not mixing architectures. We call this
4392 after all the input files have been opened, but before we do any
4393 other processing, so that any operations merge_private_bfd_data
4394 does on the output file will be known during the rest of the
4398 /* Handle .exports instead of a version script if we're told to do so. */
4399 if (command_line
.version_exports_section
)
4400 lang_do_version_exports_section ();
4402 /* Build all sets based on the information gathered from the input
4404 ldctor_build_sets ();
4406 /* Remove unreferenced sections if asked to. */
4407 if (command_line
.gc_sections
)
4408 lang_gc_sections ();
4410 /* Size up the common data. */
4413 /* Run through the contours of the script and attach input sections
4414 to the correct output sections. */
4415 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
4417 /* Find any sections not attached explicitly and handle them. */
4418 lang_place_orphans ();
4420 if (! link_info
.relocatable
)
4424 /* Merge SEC_MERGE sections. This has to be done after GC of
4425 sections, so that GCed sections are not merged, but before
4426 assigning dynamic symbols, since removing whole input sections
4428 bfd_merge_sections (output_bfd
, &link_info
);
4430 /* Look for a text section and set the readonly attribute in it. */
4431 found
= bfd_get_section_by_name (output_bfd
, ".text");
4435 if (config
.text_read_only
)
4436 found
->flags
|= SEC_READONLY
;
4438 found
->flags
&= ~SEC_READONLY
;
4442 /* Do anything special before sizing sections. This is where ELF
4443 and other back-ends size dynamic sections. */
4444 ldemul_before_allocation ();
4446 if (!link_info
.relocatable
)
4447 strip_excluded_output_sections ();
4449 /* We must record the program headers before we try to fix the
4450 section positions, since they will affect SIZEOF_HEADERS. */
4451 lang_record_phdrs ();
4453 /* Size up the sections. */
4454 lang_size_sections (statement_list
.head
, abs_output_section
,
4455 &statement_list
.head
, 0, 0, NULL
,
4456 command_line
.relax
? FALSE
: TRUE
);
4458 /* Now run around and relax if we can. */
4459 if (command_line
.relax
)
4461 /* Keep relaxing until bfd_relax_section gives up. */
4462 bfd_boolean relax_again
;
4466 relax_again
= FALSE
;
4468 /* Note: pe-dll.c does something like this also. If you find
4469 you need to change this code, you probably need to change
4470 pe-dll.c also. DJ */
4472 /* Do all the assignments with our current guesses as to
4474 lang_do_assignments (statement_list
.head
, abs_output_section
,
4477 /* We must do this after lang_do_assignments, because it uses
4479 lang_reset_memory_regions ();
4481 /* Perform another relax pass - this time we know where the
4482 globals are, so can make a better guess. */
4483 lang_size_sections (statement_list
.head
, abs_output_section
,
4484 &statement_list
.head
, 0, 0, &relax_again
, FALSE
);
4486 /* If the normal relax is done and the relax finalize pass
4487 is not performed yet, we perform another relax pass. */
4488 if (!relax_again
&& link_info
.need_relax_finalize
)
4490 link_info
.need_relax_finalize
= FALSE
;
4494 while (relax_again
);
4496 /* Final extra sizing to report errors. */
4497 lang_do_assignments (statement_list
.head
, abs_output_section
, NULL
, 0);
4498 lang_reset_memory_regions ();
4499 lang_size_sections (statement_list
.head
, abs_output_section
,
4500 &statement_list
.head
, 0, 0, NULL
, TRUE
);
4503 /* See if anything special should be done now we know how big
4505 ldemul_after_allocation ();
4507 /* Fix any .startof. or .sizeof. symbols. */
4508 lang_set_startof ();
4510 /* Do all the assignments, now that we know the final resting places
4511 of all the symbols. */
4513 lang_do_assignments (statement_list
.head
, abs_output_section
, NULL
, 0);
4515 /* Make sure that the section addresses make sense. */
4516 if (! link_info
.relocatable
4517 && command_line
.check_section_addresses
)
4518 lang_check_section_addresses ();
4526 /* EXPORTED TO YACC */
4529 lang_add_wild (struct wildcard_spec
*filespec
,
4530 struct wildcard_list
*section_list
,
4531 bfd_boolean keep_sections
)
4533 struct wildcard_list
*curr
, *next
;
4534 lang_wild_statement_type
*new;
4536 /* Reverse the list as the parser puts it back to front. */
4537 for (curr
= section_list
, section_list
= NULL
;
4539 section_list
= curr
, curr
= next
)
4541 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
4542 placed_commons
= TRUE
;
4545 curr
->next
= section_list
;
4548 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
4550 if (strcmp (filespec
->name
, "*") == 0)
4551 filespec
->name
= NULL
;
4552 else if (! wildcardp (filespec
->name
))
4553 lang_has_input_file
= TRUE
;
4556 new = new_stat (lang_wild_statement
, stat_ptr
);
4557 new->filename
= NULL
;
4558 new->filenames_sorted
= FALSE
;
4559 if (filespec
!= NULL
)
4561 new->filename
= filespec
->name
;
4562 new->filenames_sorted
= filespec
->sorted
;
4564 new->section_list
= section_list
;
4565 new->keep_sections
= keep_sections
;
4566 lang_list_init (&new->children
);
4570 lang_section_start (const char *name
, etree_type
*address
)
4572 lang_address_statement_type
*ad
;
4574 ad
= new_stat (lang_address_statement
, stat_ptr
);
4575 ad
->section_name
= name
;
4576 ad
->address
= address
;
4579 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4580 because of a -e argument on the command line, or zero if this is
4581 called by ENTRY in a linker script. Command line arguments take
4585 lang_add_entry (const char *name
, bfd_boolean cmdline
)
4587 if (entry_symbol
.name
== NULL
4589 || ! entry_from_cmdline
)
4591 entry_symbol
.name
= name
;
4592 entry_from_cmdline
= cmdline
;
4597 lang_add_target (const char *name
)
4599 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4607 lang_add_map (const char *name
)
4614 map_option_f
= TRUE
;
4622 lang_add_fill (fill_type
*fill
)
4624 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4631 lang_add_data (int type
, union etree_union
*exp
)
4634 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4642 /* Create a new reloc statement. RELOC is the BFD relocation type to
4643 generate. HOWTO is the corresponding howto structure (we could
4644 look this up, but the caller has already done so). SECTION is the
4645 section to generate a reloc against, or NAME is the name of the
4646 symbol to generate a reloc against. Exactly one of SECTION and
4647 NAME must be NULL. ADDEND is an expression for the addend. */
4650 lang_add_reloc (bfd_reloc_code_real_type reloc
,
4651 reloc_howto_type
*howto
,
4654 union etree_union
*addend
)
4656 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4660 p
->section
= section
;
4662 p
->addend_exp
= addend
;
4664 p
->addend_value
= 0;
4665 p
->output_section
= NULL
;
4669 lang_assignment_statement_type
*
4670 lang_add_assignment (etree_type
*exp
)
4672 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4680 lang_add_attribute (enum statement_enum attribute
)
4682 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4686 lang_startup (const char *name
)
4688 if (startup_file
!= NULL
)
4690 einfo (_("%P%Fmultiple STARTUP files\n"));
4692 first_file
->filename
= name
;
4693 first_file
->local_sym_name
= name
;
4694 first_file
->real
= TRUE
;
4696 startup_file
= name
;
4700 lang_float (bfd_boolean maybe
)
4702 lang_float_flag
= maybe
;
4706 /* Work out the load- and run-time regions from a script statement, and
4707 store them in *LMA_REGION and *REGION respectively.
4709 MEMSPEC is the name of the run-time region, or the value of
4710 DEFAULT_MEMORY_REGION if the statement didn't specify one.
4711 LMA_MEMSPEC is the name of the load-time region, or null if the
4712 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
4713 had an explicit load address.
4715 It is an error to specify both a load region and a load address. */
4718 lang_get_regions (lang_memory_region_type
**region
,
4719 lang_memory_region_type
**lma_region
,
4720 const char *memspec
,
4721 const char *lma_memspec
,
4722 bfd_boolean have_lma
,
4723 bfd_boolean have_vma
)
4725 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
4727 /* If no runtime region or VMA has been specified, but the load region has
4728 been specified, then use the load region for the runtime region as well. */
4729 if (lma_memspec
!= NULL
4731 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
4732 *region
= *lma_region
;
4734 *region
= lang_memory_region_lookup (memspec
, FALSE
);
4736 if (have_lma
&& lma_memspec
!= 0)
4737 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4741 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
4742 lang_output_section_phdr_list
*phdrs
,
4743 const char *lma_memspec
)
4745 lang_get_regions (¤t_section
->region
,
4746 ¤t_section
->lma_region
,
4747 memspec
, lma_memspec
,
4748 current_section
->load_base
!= NULL
,
4749 current_section
->addr_tree
!= NULL
);
4750 current_section
->fill
= fill
;
4751 current_section
->phdrs
= phdrs
;
4752 stat_ptr
= &statement_list
;
4755 /* Create an absolute symbol with the given name with the value of the
4756 address of first byte of the section named.
4758 If the symbol already exists, then do nothing. */
4761 lang_abs_symbol_at_beginning_of (const char *secname
, const char *name
)
4763 struct bfd_link_hash_entry
*h
;
4765 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
4767 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4769 if (h
->type
== bfd_link_hash_new
4770 || h
->type
== bfd_link_hash_undefined
)
4774 h
->type
= bfd_link_hash_defined
;
4776 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4780 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4782 h
->u
.def
.section
= bfd_abs_section_ptr
;
4786 /* Create an absolute symbol with the given name with the value of the
4787 address of the first byte after the end of the section named.
4789 If the symbol already exists, then do nothing. */
4792 lang_abs_symbol_at_end_of (const char *secname
, const char *name
)
4794 struct bfd_link_hash_entry
*h
;
4796 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
4798 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4800 if (h
->type
== bfd_link_hash_new
4801 || h
->type
== bfd_link_hash_undefined
)
4805 h
->type
= bfd_link_hash_defined
;
4807 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4811 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4812 + TO_ADDR (bfd_section_size (output_bfd
, sec
)));
4814 h
->u
.def
.section
= bfd_abs_section_ptr
;
4819 lang_statement_append (lang_statement_list_type
*list
,
4820 lang_statement_union_type
*element
,
4821 lang_statement_union_type
**field
)
4823 *(list
->tail
) = element
;
4827 /* Set the output format type. -oformat overrides scripts. */
4830 lang_add_output_format (const char *format
,
4835 if (output_target
== NULL
|| !from_script
)
4837 if (command_line
.endian
== ENDIAN_BIG
4840 else if (command_line
.endian
== ENDIAN_LITTLE
4844 output_target
= format
;
4848 /* Enter a group. This creates a new lang_group_statement, and sets
4849 stat_ptr to build new statements within the group. */
4852 lang_enter_group (void)
4854 lang_group_statement_type
*g
;
4856 g
= new_stat (lang_group_statement
, stat_ptr
);
4857 lang_list_init (&g
->children
);
4858 stat_ptr
= &g
->children
;
4861 /* Leave a group. This just resets stat_ptr to start writing to the
4862 regular list of statements again. Note that this will not work if
4863 groups can occur inside anything else which can adjust stat_ptr,
4864 but currently they can't. */
4867 lang_leave_group (void)
4869 stat_ptr
= &statement_list
;
4872 /* Add a new program header. This is called for each entry in a PHDRS
4873 command in a linker script. */
4876 lang_new_phdr (const char *name
,
4878 bfd_boolean filehdr
,
4883 struct lang_phdr
*n
, **pp
;
4885 n
= stat_alloc (sizeof (struct lang_phdr
));
4888 n
->type
= exp_get_value_int (type
, 0, "program header type",
4889 lang_final_phase_enum
);
4890 n
->filehdr
= filehdr
;
4895 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4900 /* Record the program header information in the output BFD. FIXME: We
4901 should not be calling an ELF specific function here. */
4904 lang_record_phdrs (void)
4908 lang_output_section_phdr_list
*last
;
4909 struct lang_phdr
*l
;
4910 lang_statement_union_type
*u
;
4913 secs
= xmalloc (alc
* sizeof (asection
*));
4915 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4922 for (u
= lang_output_section_statement
.head
;
4924 u
= u
->output_section_statement
.next
)
4926 lang_output_section_statement_type
*os
;
4927 lang_output_section_phdr_list
*pl
;
4929 os
= &u
->output_section_statement
;
4930 if (os
->constraint
== -1)
4938 if (os
->sectype
== noload_section
4939 || os
->bfd_section
== NULL
4940 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4945 if (os
->bfd_section
== NULL
)
4948 for (; pl
!= NULL
; pl
= pl
->next
)
4950 if (strcmp (pl
->name
, l
->name
) == 0)
4955 secs
= xrealloc (secs
, alc
* sizeof (asection
*));
4957 secs
[c
] = os
->bfd_section
;
4964 if (l
->flags
== NULL
)
4967 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4968 lang_final_phase_enum
);
4973 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4974 lang_final_phase_enum
);
4976 if (! bfd_record_phdr (output_bfd
, l
->type
,
4977 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
4978 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4979 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4984 /* Make sure all the phdr assignments succeeded. */
4985 for (u
= lang_output_section_statement
.head
;
4987 u
= u
->output_section_statement
.next
)
4989 lang_output_section_phdr_list
*pl
;
4991 if (u
->output_section_statement
.constraint
== -1
4992 || u
->output_section_statement
.bfd_section
== NULL
)
4995 for (pl
= u
->output_section_statement
.phdrs
;
4998 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4999 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
5000 u
->output_section_statement
.name
, pl
->name
);
5004 /* Record a list of sections which may not be cross referenced. */
5007 lang_add_nocrossref (lang_nocrossref_type
*l
)
5009 struct lang_nocrossrefs
*n
;
5011 n
= xmalloc (sizeof *n
);
5012 n
->next
= nocrossref_list
;
5014 nocrossref_list
= n
;
5016 /* Set notice_all so that we get informed about all symbols. */
5017 link_info
.notice_all
= TRUE
;
5020 /* Overlay handling. We handle overlays with some static variables. */
5022 /* The overlay virtual address. */
5023 static etree_type
*overlay_vma
;
5024 /* And subsection alignment. */
5025 static etree_type
*overlay_subalign
;
5027 /* An expression for the maximum section size seen so far. */
5028 static etree_type
*overlay_max
;
5030 /* A list of all the sections in this overlay. */
5032 struct overlay_list
{
5033 struct overlay_list
*next
;
5034 lang_output_section_statement_type
*os
;
5037 static struct overlay_list
*overlay_list
;
5039 /* Start handling an overlay. */
5042 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
5044 /* The grammar should prevent nested overlays from occurring. */
5045 ASSERT (overlay_vma
== NULL
5046 && overlay_subalign
== NULL
5047 && overlay_max
== NULL
);
5049 overlay_vma
= vma_expr
;
5050 overlay_subalign
= subalign
;
5053 /* Start a section in an overlay. We handle this by calling
5054 lang_enter_output_section_statement with the correct VMA.
5055 lang_leave_overlay sets up the LMA and memory regions. */
5058 lang_enter_overlay_section (const char *name
)
5060 struct overlay_list
*n
;
5063 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
5064 0, overlay_subalign
, 0, 0);
5066 /* If this is the first section, then base the VMA of future
5067 sections on this one. This will work correctly even if `.' is
5068 used in the addresses. */
5069 if (overlay_list
== NULL
)
5070 overlay_vma
= exp_nameop (ADDR
, name
);
5072 /* Remember the section. */
5073 n
= xmalloc (sizeof *n
);
5074 n
->os
= current_section
;
5075 n
->next
= overlay_list
;
5078 size
= exp_nameop (SIZEOF
, name
);
5080 /* Arrange to work out the maximum section end address. */
5081 if (overlay_max
== NULL
)
5084 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
5087 /* Finish a section in an overlay. There isn't any special to do
5091 lang_leave_overlay_section (fill_type
*fill
,
5092 lang_output_section_phdr_list
*phdrs
)
5099 name
= current_section
->name
;
5101 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
5102 region and that no load-time region has been specified. It doesn't
5103 really matter what we say here, since lang_leave_overlay will
5105 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
5107 /* Define the magic symbols. */
5109 clean
= xmalloc (strlen (name
) + 1);
5111 for (s1
= name
; *s1
!= '\0'; s1
++)
5112 if (ISALNUM (*s1
) || *s1
== '_')
5116 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
5117 sprintf (buf
, "__load_start_%s", clean
);
5118 lang_add_assignment (exp_assop ('=', buf
,
5119 exp_nameop (LOADADDR
, name
)));
5121 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
5122 sprintf (buf
, "__load_stop_%s", clean
);
5123 lang_add_assignment (exp_assop ('=', buf
,
5125 exp_nameop (LOADADDR
, name
),
5126 exp_nameop (SIZEOF
, name
))));
5131 /* Finish an overlay. If there are any overlay wide settings, this
5132 looks through all the sections in the overlay and sets them. */
5135 lang_leave_overlay (etree_type
*lma_expr
,
5138 const char *memspec
,
5139 lang_output_section_phdr_list
*phdrs
,
5140 const char *lma_memspec
)
5142 lang_memory_region_type
*region
;
5143 lang_memory_region_type
*lma_region
;
5144 struct overlay_list
*l
;
5145 lang_nocrossref_type
*nocrossref
;
5147 lang_get_regions (®ion
, &lma_region
,
5148 memspec
, lma_memspec
,
5149 lma_expr
!= NULL
, FALSE
);
5153 /* After setting the size of the last section, set '.' to end of the
5155 if (overlay_list
!= NULL
)
5156 overlay_list
->os
->update_dot_tree
5157 = exp_assop ('=', ".", exp_binop ('+', overlay_vma
, overlay_max
));
5162 struct overlay_list
*next
;
5164 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
5167 l
->os
->region
= region
;
5168 l
->os
->lma_region
= lma_region
;
5170 /* The first section has the load address specified in the
5171 OVERLAY statement. The rest are worked out from that.
5172 The base address is not needed (and should be null) if
5173 an LMA region was specified. */
5175 l
->os
->load_base
= lma_expr
;
5176 else if (lma_region
== 0)
5177 l
->os
->load_base
= exp_binop ('+',
5178 exp_nameop (LOADADDR
, l
->next
->os
->name
),
5179 exp_nameop (SIZEOF
, l
->next
->os
->name
));
5181 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
5182 l
->os
->phdrs
= phdrs
;
5186 lang_nocrossref_type
*nc
;
5188 nc
= xmalloc (sizeof *nc
);
5189 nc
->name
= l
->os
->name
;
5190 nc
->next
= nocrossref
;
5199 if (nocrossref
!= NULL
)
5200 lang_add_nocrossref (nocrossref
);
5203 overlay_list
= NULL
;
5207 /* Version handling. This is only useful for ELF. */
5209 /* This global variable holds the version tree that we build. */
5211 struct bfd_elf_version_tree
*lang_elf_version_info
;
5213 /* If PREV is NULL, return first version pattern matching particular symbol.
5214 If PREV is non-NULL, return first version pattern matching particular
5215 symbol after PREV (previously returned by lang_vers_match). */
5217 static struct bfd_elf_version_expr
*
5218 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
5219 struct bfd_elf_version_expr
*prev
,
5222 const char *cxx_sym
= sym
;
5223 const char *java_sym
= sym
;
5224 struct bfd_elf_version_expr
*expr
= NULL
;
5226 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
5228 cxx_sym
= cplus_demangle (sym
, DMGL_PARAMS
| DMGL_ANSI
);
5232 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
5234 java_sym
= cplus_demangle (sym
, DMGL_JAVA
);
5239 if (head
->htab
&& (prev
== NULL
|| prev
->symbol
))
5241 struct bfd_elf_version_expr e
;
5243 switch (prev
? prev
->mask
: 0)
5246 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
5249 expr
= htab_find (head
->htab
, &e
);
5250 while (expr
&& strcmp (expr
->symbol
, sym
) == 0)
5251 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
5257 case BFD_ELF_VERSION_C_TYPE
:
5258 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
5261 expr
= htab_find (head
->htab
, &e
);
5262 while (expr
&& strcmp (expr
->symbol
, cxx_sym
) == 0)
5263 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
5269 case BFD_ELF_VERSION_CXX_TYPE
:
5270 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
5272 e
.symbol
= java_sym
;
5273 expr
= htab_find (head
->htab
, &e
);
5274 while (expr
&& strcmp (expr
->symbol
, java_sym
) == 0)
5275 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
5286 /* Finally, try the wildcards. */
5287 if (prev
== NULL
|| prev
->symbol
)
5288 expr
= head
->remaining
;
5295 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5298 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
5300 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
5304 if (fnmatch (expr
->pattern
, s
, 0) == 0)
5311 free ((char *) cxx_sym
);
5312 if (java_sym
!= sym
)
5313 free ((char *) java_sym
);
5317 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
5318 return a string pointing to the symbol name. */
5321 realsymbol (const char *pattern
)
5324 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
5325 char *s
, *symbol
= xmalloc (strlen (pattern
) + 1);
5327 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
5329 /* It is a glob pattern only if there is no preceding
5331 if (! backslash
&& (*p
== '?' || *p
== '*' || *p
== '['))
5339 /* Remove the preceding backslash. */
5346 backslash
= *p
== '\\';
5361 /* This is called for each variable name or match expression. */
5363 struct bfd_elf_version_expr
*
5364 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
5368 struct bfd_elf_version_expr
*ret
;
5370 ret
= xmalloc (sizeof *ret
);
5375 ret
->symbol
= realsymbol (new);
5377 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
5378 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
5379 else if (strcasecmp (lang
, "C++") == 0)
5380 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
5381 else if (strcasecmp (lang
, "Java") == 0)
5382 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
5385 einfo (_("%X%P: unknown language `%s' in version information\n"),
5387 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
5390 return ldemul_new_vers_pattern (ret
);
5393 /* This is called for each set of variable names and match
5396 struct bfd_elf_version_tree
*
5397 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
5398 struct bfd_elf_version_expr
*locals
)
5400 struct bfd_elf_version_tree
*ret
;
5402 ret
= xcalloc (1, sizeof *ret
);
5403 ret
->globals
.list
= globals
;
5404 ret
->locals
.list
= locals
;
5405 ret
->match
= lang_vers_match
;
5406 ret
->name_indx
= (unsigned int) -1;
5410 /* This static variable keeps track of version indices. */
5412 static int version_index
;
5415 version_expr_head_hash (const void *p
)
5417 const struct bfd_elf_version_expr
*e
= p
;
5419 return htab_hash_string (e
->symbol
);
5423 version_expr_head_eq (const void *p1
, const void *p2
)
5425 const struct bfd_elf_version_expr
*e1
= p1
;
5426 const struct bfd_elf_version_expr
*e2
= p2
;
5428 return strcmp (e1
->symbol
, e2
->symbol
) == 0;
5432 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
5435 struct bfd_elf_version_expr
*e
, *next
;
5436 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
5438 for (e
= head
->list
; e
; e
= e
->next
)
5442 head
->mask
|= e
->mask
;
5447 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
5448 version_expr_head_eq
, NULL
);
5449 list_loc
= &head
->list
;
5450 remaining_loc
= &head
->remaining
;
5451 for (e
= head
->list
; e
; e
= next
)
5457 remaining_loc
= &e
->next
;
5461 void **loc
= htab_find_slot (head
->htab
, e
, INSERT
);
5465 struct bfd_elf_version_expr
*e1
, *last
;
5471 if (e1
->mask
== e
->mask
)
5479 while (e1
&& strcmp (e1
->symbol
, e
->symbol
) == 0);
5483 /* This is a duplicate. */
5484 /* FIXME: Memory leak. Sometimes pattern is not
5485 xmalloced alone, but in larger chunk of memory. */
5486 /* free (e->symbol); */
5491 e
->next
= last
->next
;
5499 list_loc
= &e
->next
;
5503 *remaining_loc
= NULL
;
5504 *list_loc
= head
->remaining
;
5507 head
->remaining
= head
->list
;
5510 /* This is called when we know the name and dependencies of the
5514 lang_register_vers_node (const char *name
,
5515 struct bfd_elf_version_tree
*version
,
5516 struct bfd_elf_version_deps
*deps
)
5518 struct bfd_elf_version_tree
*t
, **pp
;
5519 struct bfd_elf_version_expr
*e1
;
5524 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
5525 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
5527 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5532 /* Make sure this node has a unique name. */
5533 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5534 if (strcmp (t
->name
, name
) == 0)
5535 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5537 lang_finalize_version_expr_head (&version
->globals
);
5538 lang_finalize_version_expr_head (&version
->locals
);
5540 /* Check the global and local match names, and make sure there
5541 aren't any duplicates. */
5543 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
5545 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5547 struct bfd_elf_version_expr
*e2
;
5549 if (t
->locals
.htab
&& e1
->symbol
)
5551 e2
= htab_find (t
->locals
.htab
, e1
);
5552 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
5554 if (e1
->mask
== e2
->mask
)
5555 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5560 else if (!e1
->symbol
)
5561 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
5562 if (strcmp (e1
->pattern
, e2
->pattern
) == 0 && e1
->mask
== e2
->mask
)
5563 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5568 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
5570 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5572 struct bfd_elf_version_expr
*e2
;
5574 if (t
->globals
.htab
&& e1
->symbol
)
5576 e2
= htab_find (t
->globals
.htab
, e1
);
5577 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
5579 if (e1
->mask
== e2
->mask
)
5580 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5585 else if (!e1
->symbol
)
5586 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
5587 if (strcmp (e1
->pattern
, e2
->pattern
) == 0 && e1
->mask
== e2
->mask
)
5588 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5593 version
->deps
= deps
;
5594 version
->name
= name
;
5595 if (name
[0] != '\0')
5598 version
->vernum
= version_index
;
5601 version
->vernum
= 0;
5603 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5608 /* This is called when we see a version dependency. */
5610 struct bfd_elf_version_deps
*
5611 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
5613 struct bfd_elf_version_deps
*ret
;
5614 struct bfd_elf_version_tree
*t
;
5616 ret
= xmalloc (sizeof *ret
);
5619 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5621 if (strcmp (t
->name
, name
) == 0)
5623 ret
->version_needed
= t
;
5628 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5634 lang_do_version_exports_section (void)
5636 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5638 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5640 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5647 len
= bfd_section_size (is
->the_bfd
, sec
);
5648 contents
= xmalloc (len
);
5649 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5650 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
5653 while (p
< contents
+ len
)
5655 greg
= lang_new_vers_pattern (greg
, p
, NULL
);
5656 p
= strchr (p
, '\0') + 1;
5659 /* Do not free the contents, as we used them creating the regex. */
5661 /* Do not include this section in the link. */
5662 bfd_set_section_flags (is
->the_bfd
, sec
,
5663 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5666 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
);
5667 lang_register_vers_node (command_line
.version_exports_section
,
5668 lang_new_vers_node (greg
, lreg
), NULL
);
5672 lang_add_unique (const char *name
)
5674 struct unique_sections
*ent
;
5676 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5677 if (strcmp (ent
->name
, name
) == 0)
5680 ent
= xmalloc (sizeof *ent
);
5681 ent
->name
= xstrdup (name
);
5682 ent
->next
= unique_section_list
;
5683 unique_section_list
= ent
;