1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
6 This file is part of GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
26 #include "safe-ctype.h"
44 #define offsetof(TYPE,MEMBER) ((size_t)&(((TYPE*)0)->MEMBER))
48 static lang_statement_union_type
*new_statement
49 PARAMS ((enum statement_enum
, size_t, lang_statement_list_type
*));
52 static struct obstack stat_obstack
;
54 #define obstack_chunk_alloc xmalloc
55 #define obstack_chunk_free free
56 static const char *startup_file
;
57 static lang_statement_list_type input_file_chain
;
58 static bfd_boolean placed_commons
= FALSE
;
59 static lang_output_section_statement_type
*default_common_section
;
60 static bfd_boolean map_option_f
;
61 static bfd_vma print_dot
;
62 static lang_input_statement_type
*first_file
;
63 static const char *current_target
;
64 static const char *output_target
;
65 static lang_statement_list_type statement_list
;
66 static struct lang_phdr
*lang_phdr_list
;
68 static void lang_for_each_statement_worker
69 PARAMS ((void (*) (lang_statement_union_type
*),
70 lang_statement_union_type
*));
71 static lang_input_statement_type
*new_afile
72 PARAMS ((const char *, lang_input_file_enum_type
, const char *,
74 static lang_memory_region_type
*lang_memory_default
75 PARAMS ((asection
*));
76 static void lang_map_flags
79 PARAMS ((lang_output_section_statement_type
*));
80 static void exp_init_os
81 PARAMS ((etree_type
*));
82 static void section_already_linked
83 PARAMS ((bfd
*, asection
*, PTR
));
84 static struct bfd_hash_entry
*already_linked_newfunc
85 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
86 static void already_linked_table_init
88 static void already_linked_table_free
90 static bfd_boolean wildcardp
91 PARAMS ((const char *));
92 static lang_statement_union_type
*wild_sort
93 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*,
94 lang_input_statement_type
*, asection
*));
95 static void output_section_callback
96 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
97 lang_input_statement_type
*, PTR
));
98 static lang_input_statement_type
*lookup_name
99 PARAMS ((const char *));
100 static bfd_boolean load_symbols
101 PARAMS ((lang_input_statement_type
*, lang_statement_list_type
*));
103 PARAMS ((lang_wild_statement_type
*,
104 const char *, lang_output_section_statement_type
*));
105 static bfd
*open_output
106 PARAMS ((const char *));
107 static void ldlang_open_output
108 PARAMS ((lang_statement_union_type
*));
109 static void open_input_bfds
110 PARAMS ((lang_statement_union_type
*, bfd_boolean
));
111 static void lang_reasonable_defaults
113 static void insert_undefined
114 PARAMS ((const char *));
115 static void lang_place_undefineds
117 static void map_input_to_output_sections
118 PARAMS ((lang_statement_union_type
*, const char *,
119 lang_output_section_statement_type
*));
120 static void strip_excluded_output_sections
122 static void print_output_section_statement
123 PARAMS ((lang_output_section_statement_type
*));
124 static void print_assignment
125 PARAMS ((lang_assignment_statement_type
*,
126 lang_output_section_statement_type
*));
127 static void print_input_statement
128 PARAMS ((lang_input_statement_type
*));
129 static bfd_boolean print_one_symbol
130 PARAMS ((struct bfd_link_hash_entry
*, PTR
));
131 static void print_input_section
132 PARAMS ((lang_input_section_type
*));
133 static void print_fill_statement
134 PARAMS ((lang_fill_statement_type
*));
135 static void print_data_statement
136 PARAMS ((lang_data_statement_type
*));
137 static void print_address_statement
138 PARAMS ((lang_address_statement_type
*));
139 static void print_reloc_statement
140 PARAMS ((lang_reloc_statement_type
*));
141 static void print_padding_statement
142 PARAMS ((lang_padding_statement_type
*));
143 static void print_wild_statement
144 PARAMS ((lang_wild_statement_type
*, lang_output_section_statement_type
*));
145 static void print_group
146 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
147 static void print_statement
148 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
149 static void print_statement_list
150 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
151 static void print_statements
153 static void insert_pad
154 PARAMS ((lang_statement_union_type
**, fill_type
*,
155 unsigned int, asection
*, bfd_vma
));
156 static bfd_vma size_input_section
157 PARAMS ((lang_statement_union_type
**, lang_output_section_statement_type
*,
158 fill_type
*, bfd_vma
));
159 static void lang_finish
161 static void ignore_bfd_errors
162 PARAMS ((const char *, ...));
163 static void lang_check
165 static void lang_common
167 static bfd_boolean lang_one_common
168 PARAMS ((struct bfd_link_hash_entry
*, PTR
));
169 static void lang_place_orphans
173 static void lang_set_startof
175 static void gc_section_callback
176 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
177 lang_input_statement_type
*, PTR
));
178 static void lang_get_regions
179 PARAMS ((struct memory_region_struct
**, struct memory_region_struct
**,
180 const char *, const char *, int));
181 static void lang_record_phdrs
183 static void lang_gc_wild
184 PARAMS ((lang_wild_statement_type
*));
185 static void lang_gc_sections_1
186 PARAMS ((lang_statement_union_type
*));
187 static void lang_gc_sections
189 static int lang_vers_match_lang_c
190 PARAMS ((struct bfd_elf_version_expr
*, const char *));
191 static int lang_vers_match_lang_cplusplus
192 PARAMS ((struct bfd_elf_version_expr
*, const char *));
193 static int lang_vers_match_lang_java
194 PARAMS ((struct bfd_elf_version_expr
*, const char *));
195 static void lang_do_version_exports_section
197 static void lang_check_section_addresses
199 static void os_region_check
200 PARAMS ((lang_output_section_statement_type
*,
201 struct memory_region_struct
*, etree_type
*, bfd_vma
));
202 static bfd_vma lang_size_sections_1
203 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*,
204 lang_statement_union_type
**, fill_type
*, bfd_vma
, bfd_boolean
*));
205 typedef void (*callback_t
)
206 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
207 lang_input_statement_type
*, PTR
));
208 static void walk_wild
209 PARAMS ((lang_wild_statement_type
*, callback_t
, PTR
));
210 static void walk_wild_section
211 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
213 static void walk_wild_file
214 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
216 static int get_target
217 PARAMS ((const bfd_target
*, PTR
));
219 PARAMS ((char *, char *));
221 PARAMS ((char *, char *));
222 static int name_compare
223 PARAMS ((char *, char *));
224 static int closest_target_match
225 PARAMS ((const bfd_target
*, PTR
));
226 static char * get_first_input_target
230 lang_output_section_statement_type
*abs_output_section
;
231 lang_statement_list_type lang_output_section_statement
;
232 lang_statement_list_type
*stat_ptr
= &statement_list
;
233 lang_statement_list_type file_chain
= { NULL
, NULL
};
234 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
235 const char *entry_section
= ".text";
236 bfd_boolean entry_from_cmdline
;
237 bfd_boolean lang_has_input_file
= FALSE
;
238 bfd_boolean had_output_filename
= FALSE
;
239 bfd_boolean lang_float_flag
= FALSE
;
240 bfd_boolean delete_output_file_on_failure
= FALSE
;
241 struct lang_nocrossrefs
*nocrossref_list
;
242 struct unique_sections
*unique_section_list
;
244 etree_type
*base
; /* Relocation base - or null */
246 #if defined (__STDC__) || defined (ALMOST_STDC)
247 #define cat(a,b) a##b
249 #define cat(a,b) a/**/b
252 /* Don't beautify the line below with "innocent" whitespace, it breaks
253 the K&R C preprocessor! */
254 #define new_stat(x, y) \
255 (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
257 #define outside_section_address(q) \
258 ((q)->output_offset + (q)->output_section->vma)
260 #define outside_symbol_address(q) \
261 ((q)->value + outside_section_address (q->section))
263 #define SECTION_NAME_MAP_LENGTH (16)
269 return obstack_alloc (&stat_obstack
, size
);
273 unique_section_p (secnam
)
276 struct unique_sections
*unam
;
278 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
279 if (wildcardp (unam
->name
)
280 ? fnmatch (unam
->name
, secnam
, 0) == 0
281 : strcmp (unam
->name
, secnam
) == 0)
289 /* Generic traversal routines for finding matching sections. */
292 walk_wild_section (ptr
, file
, callback
, data
)
293 lang_wild_statement_type
*ptr
;
294 lang_input_statement_type
*file
;
300 if (file
->just_syms_flag
)
303 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
305 struct wildcard_list
*sec
;
307 sec
= ptr
->section_list
;
309 (*callback
) (ptr
, sec
, s
, file
, data
);
313 bfd_boolean skip
= FALSE
;
314 struct name_list
*list_tmp
;
316 /* Don't process sections from files which were
318 for (list_tmp
= sec
->spec
.exclude_name_list
;
320 list_tmp
= list_tmp
->next
)
322 if (wildcardp (list_tmp
->name
))
323 skip
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
325 skip
= strcmp (list_tmp
->name
, file
->filename
) == 0;
327 /* If this file is part of an archive, and the archive is
328 excluded, exclude this file. */
329 if (! skip
&& file
->the_bfd
!= NULL
330 && file
->the_bfd
->my_archive
!= NULL
331 && file
->the_bfd
->my_archive
->filename
!= NULL
)
333 if (wildcardp (list_tmp
->name
))
334 skip
= fnmatch (list_tmp
->name
,
335 file
->the_bfd
->my_archive
->filename
,
338 skip
= strcmp (list_tmp
->name
,
339 file
->the_bfd
->my_archive
->filename
) == 0;
346 if (!skip
&& sec
->spec
.name
!= NULL
)
348 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
350 if (wildcardp (sec
->spec
.name
))
351 skip
= fnmatch (sec
->spec
.name
, sname
, 0) != 0;
353 skip
= strcmp (sec
->spec
.name
, sname
) != 0;
357 (*callback
) (ptr
, sec
, s
, file
, data
);
364 /* Handle a wild statement for a single file F. */
367 walk_wild_file (s
, f
, callback
, data
)
368 lang_wild_statement_type
*s
;
369 lang_input_statement_type
*f
;
373 if (f
->the_bfd
== NULL
374 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
375 walk_wild_section (s
, f
, callback
, data
);
380 /* This is an archive file. We must map each member of the
381 archive separately. */
382 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
383 while (member
!= NULL
)
385 /* When lookup_name is called, it will call the add_symbols
386 entry point for the archive. For each element of the
387 archive which is included, BFD will call ldlang_add_file,
388 which will set the usrdata field of the member to the
389 lang_input_statement. */
390 if (member
->usrdata
!= NULL
)
392 walk_wild_section (s
,
393 (lang_input_statement_type
*) member
->usrdata
,
397 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
403 walk_wild (s
, callback
, data
)
404 lang_wild_statement_type
*s
;
408 const char *file_spec
= s
->filename
;
410 if (file_spec
== NULL
)
412 /* Perform the iteration over all files in the list. */
413 LANG_FOR_EACH_INPUT_STATEMENT (f
)
415 walk_wild_file (s
, f
, callback
, data
);
418 else if (wildcardp (file_spec
))
420 LANG_FOR_EACH_INPUT_STATEMENT (f
)
422 if (fnmatch (file_spec
, f
->filename
, FNM_FILE_NAME
) == 0)
423 walk_wild_file (s
, f
, callback
, data
);
428 lang_input_statement_type
*f
;
430 /* Perform the iteration over a single file. */
431 f
= lookup_name (file_spec
);
433 walk_wild_file (s
, f
, callback
, data
);
437 /* lang_for_each_statement walks the parse tree and calls the provided
438 function for each node. */
441 lang_for_each_statement_worker (func
, s
)
442 void (*func
) PARAMS ((lang_statement_union_type
*));
443 lang_statement_union_type
*s
;
445 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
449 switch (s
->header
.type
)
451 case lang_constructors_statement_enum
:
452 lang_for_each_statement_worker (func
, constructor_list
.head
);
454 case lang_output_section_statement_enum
:
455 lang_for_each_statement_worker
457 s
->output_section_statement
.children
.head
);
459 case lang_wild_statement_enum
:
460 lang_for_each_statement_worker
462 s
->wild_statement
.children
.head
);
464 case lang_group_statement_enum
:
465 lang_for_each_statement_worker (func
,
466 s
->group_statement
.children
.head
);
468 case lang_data_statement_enum
:
469 case lang_reloc_statement_enum
:
470 case lang_object_symbols_statement_enum
:
471 case lang_output_statement_enum
:
472 case lang_target_statement_enum
:
473 case lang_input_section_enum
:
474 case lang_input_statement_enum
:
475 case lang_assignment_statement_enum
:
476 case lang_padding_statement_enum
:
477 case lang_address_statement_enum
:
478 case lang_fill_statement_enum
:
488 lang_for_each_statement (func
)
489 void (*func
) PARAMS ((lang_statement_union_type
*));
491 lang_for_each_statement_worker (func
, statement_list
.head
);
494 /*----------------------------------------------------------------------*/
497 lang_list_init (list
)
498 lang_statement_list_type
*list
;
500 list
->head
= (lang_statement_union_type
*) NULL
;
501 list
->tail
= &list
->head
;
504 /* Build a new statement node for the parse tree. */
506 static lang_statement_union_type
*
507 new_statement (type
, size
, list
)
508 enum statement_enum type
;
510 lang_statement_list_type
*list
;
512 lang_statement_union_type
*new = (lang_statement_union_type
*)
515 new->header
.type
= type
;
516 new->header
.next
= (lang_statement_union_type
*) NULL
;
517 lang_statement_append (list
, new, &new->header
.next
);
521 /* Build a new input file node for the language. There are several
522 ways in which we treat an input file, eg, we only look at symbols,
523 or prefix it with a -l etc.
525 We can be supplied with requests for input files more than once;
526 they may, for example be split over serveral lines like foo.o(.text)
527 foo.o(.data) etc, so when asked for a file we check that we haven't
528 got it already so we don't duplicate the bfd. */
530 static lang_input_statement_type
*
531 new_afile (name
, file_type
, target
, add_to_list
)
533 lang_input_file_enum_type file_type
;
535 bfd_boolean add_to_list
;
537 lang_input_statement_type
*p
;
540 p
= new_stat (lang_input_statement
, stat_ptr
);
543 p
= ((lang_input_statement_type
*)
544 stat_alloc (sizeof (lang_input_statement_type
)));
545 p
->header
.next
= NULL
;
548 lang_has_input_file
= TRUE
;
552 case lang_input_file_is_symbols_only_enum
:
554 p
->is_archive
= FALSE
;
556 p
->local_sym_name
= name
;
557 p
->just_syms_flag
= TRUE
;
558 p
->search_dirs_flag
= FALSE
;
560 case lang_input_file_is_fake_enum
:
562 p
->is_archive
= FALSE
;
564 p
->local_sym_name
= name
;
565 p
->just_syms_flag
= FALSE
;
566 p
->search_dirs_flag
= FALSE
;
568 case lang_input_file_is_l_enum
:
569 p
->is_archive
= TRUE
;
572 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
573 p
->just_syms_flag
= FALSE
;
574 p
->search_dirs_flag
= TRUE
;
576 case lang_input_file_is_marker_enum
:
578 p
->is_archive
= FALSE
;
580 p
->local_sym_name
= name
;
581 p
->just_syms_flag
= FALSE
;
582 p
->search_dirs_flag
= TRUE
;
584 case lang_input_file_is_search_file_enum
:
586 p
->is_archive
= FALSE
;
588 p
->local_sym_name
= name
;
589 p
->just_syms_flag
= FALSE
;
590 p
->search_dirs_flag
= TRUE
;
592 case lang_input_file_is_file_enum
:
594 p
->is_archive
= FALSE
;
596 p
->local_sym_name
= name
;
597 p
->just_syms_flag
= FALSE
;
598 p
->search_dirs_flag
= FALSE
;
603 p
->the_bfd
= (bfd
*) NULL
;
604 p
->asymbols
= (asymbol
**) NULL
;
605 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
606 p
->next
= (lang_statement_union_type
*) NULL
;
608 p
->dynamic
= config
.dynamic_link
;
609 p
->whole_archive
= whole_archive
;
611 lang_statement_append (&input_file_chain
,
612 (lang_statement_union_type
*) p
,
617 lang_input_statement_type
*
618 lang_add_input_file (name
, file_type
, target
)
620 lang_input_file_enum_type file_type
;
623 lang_has_input_file
= TRUE
;
624 return new_afile (name
, file_type
, target
, TRUE
);
627 /* Build enough state so that the parser can build its tree. */
632 obstack_begin (&stat_obstack
, 1000);
634 stat_ptr
= &statement_list
;
636 lang_list_init (stat_ptr
);
638 lang_list_init (&input_file_chain
);
639 lang_list_init (&lang_output_section_statement
);
640 lang_list_init (&file_chain
);
641 first_file
= lang_add_input_file ((char *) NULL
,
642 lang_input_file_is_marker_enum
,
645 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
647 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
651 /*----------------------------------------------------------------------
652 A region is an area of memory declared with the
653 MEMORY { name:org=exp, len=exp ... }
656 We maintain a list of all the regions here.
658 If no regions are specified in the script, then the default is used
659 which is created when looked up to be the entire data space. */
661 static lang_memory_region_type
*lang_memory_region_list
;
662 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
664 lang_memory_region_type
*
665 lang_memory_region_lookup (name
)
666 const char *const name
;
668 lang_memory_region_type
*p
;
670 /* NAME is NULL for LMA memspecs if no region was specified. */
674 for (p
= lang_memory_region_list
;
675 p
!= (lang_memory_region_type
*) NULL
;
678 if (strcmp (p
->name
, name
) == 0)
685 /* This code used to always use the first region in the list as the
686 default region. I changed it to instead use a region
687 encompassing all of memory as the default region. This permits
688 NOLOAD sections to work reasonably without requiring a region.
689 People should specify what region they mean, if they really want
691 if (strcmp (name
, "*default*") == 0)
693 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
695 return lang_memory_region_list
;
701 lang_memory_region_type
*new =
702 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
704 new->name
= xstrdup (name
);
705 new->next
= (lang_memory_region_type
*) NULL
;
707 *lang_memory_region_list_tail
= new;
708 lang_memory_region_list_tail
= &new->next
;
712 new->length
= ~(bfd_size_type
) 0;
714 new->had_full_message
= FALSE
;
720 static lang_memory_region_type
*
721 lang_memory_default (section
)
724 lang_memory_region_type
*p
;
726 flagword sec_flags
= section
->flags
;
728 /* Override SEC_DATA to mean a writable section. */
729 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
730 sec_flags
|= SEC_DATA
;
732 for (p
= lang_memory_region_list
;
733 p
!= (lang_memory_region_type
*) NULL
;
736 if ((p
->flags
& sec_flags
) != 0
737 && (p
->not_flags
& sec_flags
) == 0)
742 return lang_memory_region_lookup ("*default*");
745 lang_output_section_statement_type
*
746 lang_output_section_find (name
)
747 const char *const name
;
749 lang_statement_union_type
*u
;
750 lang_output_section_statement_type
*lookup
;
752 for (u
= lang_output_section_statement
.head
;
753 u
!= (lang_statement_union_type
*) NULL
;
756 lookup
= &u
->output_section_statement
;
757 if (strcmp (name
, lookup
->name
) == 0)
762 return (lang_output_section_statement_type
*) NULL
;
765 lang_output_section_statement_type
*
766 lang_output_section_statement_lookup (name
)
767 const char *const name
;
769 lang_output_section_statement_type
*lookup
;
771 lookup
= lang_output_section_find (name
);
772 if (lookup
== (lang_output_section_statement_type
*) NULL
)
775 lookup
= (lang_output_section_statement_type
*)
776 new_stat (lang_output_section_statement
, stat_ptr
);
777 lookup
->region
= (lang_memory_region_type
*) NULL
;
778 lookup
->lma_region
= (lang_memory_region_type
*) NULL
;
779 lookup
->fill
= (fill_type
*) 0;
780 lookup
->block_value
= 1;
783 lookup
->next
= (lang_statement_union_type
*) NULL
;
784 lookup
->bfd_section
= (asection
*) NULL
;
785 lookup
->processed
= FALSE
;
786 lookup
->sectype
= normal_section
;
787 lookup
->addr_tree
= (etree_type
*) NULL
;
788 lang_list_init (&lookup
->children
);
790 lookup
->memspec
= (const char *) NULL
;
792 lookup
->subsection_alignment
= -1;
793 lookup
->section_alignment
= -1;
794 lookup
->load_base
= (union etree_union
*) NULL
;
795 lookup
->update_dot_tree
= NULL
;
796 lookup
->phdrs
= NULL
;
798 lang_statement_append (&lang_output_section_statement
,
799 (lang_statement_union_type
*) lookup
,
806 lang_map_flags (flag
)
809 if (flag
& SEC_ALLOC
)
815 if (flag
& SEC_READONLY
)
828 lang_memory_region_type
*m
;
830 minfo (_("\nMemory Configuration\n\n"));
831 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
832 _("Name"), _("Origin"), _("Length"), _("Attributes"));
834 for (m
= lang_memory_region_list
;
835 m
!= (lang_memory_region_type
*) NULL
;
841 fprintf (config
.map_file
, "%-16s ", m
->name
);
843 sprintf_vma (buf
, m
->origin
);
844 minfo ("0x%s ", buf
);
852 minfo ("0x%V", m
->length
);
853 if (m
->flags
|| m
->not_flags
)
861 lang_map_flags (m
->flags
);
867 lang_map_flags (m
->not_flags
);
874 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
879 /* Initialize an output section. */
883 lang_output_section_statement_type
*s
;
885 section_userdata_type
*new;
887 if (s
->bfd_section
!= NULL
)
890 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
891 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
893 new = ((section_userdata_type
*)
894 stat_alloc (sizeof (section_userdata_type
)));
896 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
897 if (s
->bfd_section
== (asection
*) NULL
)
898 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
899 if (s
->bfd_section
== (asection
*) NULL
)
901 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
902 output_bfd
->xvec
->name
, s
->name
);
904 s
->bfd_section
->output_section
= s
->bfd_section
;
906 /* We initialize an output sections output offset to minus its own
907 vma to allow us to output a section through itself. */
908 s
->bfd_section
->output_offset
= 0;
909 get_userdata (s
->bfd_section
) = (PTR
) new;
911 /* If there is a base address, make sure that any sections it might
912 mention are initialized. */
913 if (s
->addr_tree
!= NULL
)
914 exp_init_os (s
->addr_tree
);
917 /* Make sure that all output sections mentioned in an expression are
924 switch (exp
->type
.node_class
)
927 exp_init_os (exp
->assign
.src
);
931 exp_init_os (exp
->binary
.lhs
);
932 exp_init_os (exp
->binary
.rhs
);
936 exp_init_os (exp
->trinary
.cond
);
937 exp_init_os (exp
->trinary
.lhs
);
938 exp_init_os (exp
->trinary
.rhs
);
942 exp_init_os (exp
->unary
.child
);
946 switch (exp
->type
.node_code
)
952 lang_output_section_statement_type
*os
;
954 os
= lang_output_section_find (exp
->name
.name
);
955 if (os
!= NULL
&& os
->bfd_section
== NULL
)
966 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
967 once into the output. This routine checks each section, and
968 arrange to discard it if a section of the same name has already
969 been linked. If the section has COMDAT information, then it uses
970 that to decide whether the section should be included. This code
971 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
972 that is, it does not depend solely upon the section name.
973 section_already_linked is called via bfd_map_over_sections. */
975 /* This is the shape of the elements inside the already_linked hash
976 table. It maps a name onto a list of already_linked elements with
977 the same name. It's possible to get more than one element in a
978 list if the COMDAT sections have different names. */
980 struct already_linked_hash_entry
982 struct bfd_hash_entry root
;
983 struct already_linked
*entry
;
986 struct already_linked
988 struct already_linked
*next
;
992 /* The hash table. */
994 static struct bfd_hash_table already_linked_table
;
997 section_already_linked (abfd
, sec
, data
)
1002 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
1005 struct already_linked
*l
;
1006 struct already_linked_hash_entry
*already_linked_list
;
1008 /* If we are only reading symbols from this object, then we want to
1009 discard all sections. */
1010 if (entry
->just_syms_flag
)
1012 bfd_link_just_syms (sec
, &link_info
);
1016 flags
= bfd_get_section_flags (abfd
, sec
);
1018 if ((flags
& SEC_LINK_ONCE
) == 0)
1021 /* FIXME: When doing a relocatable link, we may have trouble
1022 copying relocations in other sections that refer to local symbols
1023 in the section being discarded. Those relocations will have to
1024 be converted somehow; as of this writing I'm not sure that any of
1025 the backends handle that correctly.
1027 It is tempting to instead not discard link once sections when
1028 doing a relocatable link (technically, they should be discarded
1029 whenever we are building constructors). However, that fails,
1030 because the linker winds up combining all the link once sections
1031 into a single large link once section, which defeats the purpose
1032 of having link once sections in the first place.
1034 Also, not merging link once sections in a relocatable link
1035 causes trouble for MIPS ELF, which relies on link once semantics
1036 to handle the .reginfo section correctly. */
1038 name
= bfd_get_section_name (abfd
, sec
);
1040 already_linked_list
=
1041 ((struct already_linked_hash_entry
*)
1042 bfd_hash_lookup (&already_linked_table
, name
, TRUE
, FALSE
));
1044 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
1046 if (sec
->comdat
== NULL
1047 || l
->sec
->comdat
== NULL
1048 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
1050 /* The section has already been linked. See if we should
1052 switch (flags
& SEC_LINK_DUPLICATES
)
1057 case SEC_LINK_DUPLICATES_DISCARD
:
1060 case SEC_LINK_DUPLICATES_ONE_ONLY
:
1061 if (sec
->comdat
== NULL
)
1062 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
1065 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
1066 abfd
, name
, sec
->comdat
->name
);
1069 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
1070 /* FIXME: We should really dig out the contents of both
1071 sections and memcmp them. The COFF/PE spec says that
1072 the Microsoft linker does not implement this
1073 correctly, so I'm not going to bother doing it
1076 case SEC_LINK_DUPLICATES_SAME_SIZE
:
1077 if (bfd_section_size (abfd
, sec
)
1078 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1079 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1084 /* Set the output_section field so that lang_add_section
1085 does not create a lang_input_section structure for this
1087 sec
->output_section
= bfd_abs_section_ptr
;
1089 if (flags
& SEC_GROUP
)
1090 bfd_discard_group (abfd
, sec
);
1096 /* This is the first section with this name. Record it. Allocate
1097 the memory from the same obstack as the hash table is kept in. */
1099 l
= ((struct already_linked
*)
1100 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1103 l
->next
= already_linked_list
->entry
;
1104 already_linked_list
->entry
= l
;
1107 /* Support routines for the hash table used by section_already_linked,
1108 initialize the table, fill in an entry and remove the table. */
1110 static struct bfd_hash_entry
*
1111 already_linked_newfunc (entry
, table
, string
)
1112 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1113 struct bfd_hash_table
*table
;
1114 const char *string ATTRIBUTE_UNUSED
;
1116 struct already_linked_hash_entry
*ret
=
1117 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1121 return (struct bfd_hash_entry
*) ret
;
1125 already_linked_table_init ()
1127 if (! bfd_hash_table_init_n (&already_linked_table
,
1128 already_linked_newfunc
,
1130 einfo (_("%P%F: Failed to create hash table\n"));
1134 already_linked_table_free ()
1136 bfd_hash_table_free (&already_linked_table
);
1139 /* The wild routines.
1141 These expand statements like *(.text) and foo.o to a list of
1142 explicit actions, like foo.o(.text), bar.o(.text) and
1143 foo.o(.text, .data). */
1145 /* Return TRUE if the PATTERN argument is a wildcard pattern.
1146 Although backslashes are treated specially if a pattern contains
1147 wildcards, we do not consider the mere presence of a backslash to
1148 be enough to cause the pattern to be treated as a wildcard.
1149 That lets us handle DOS filenames more naturally. */
1153 const char *pattern
;
1157 for (s
= pattern
; *s
!= '\0'; ++s
)
1165 /* Add SECTION to the output section OUTPUT. Do this by creating a
1166 lang_input_section statement which is placed at PTR. FILE is the
1167 input file which holds SECTION. */
1170 lang_add_section (ptr
, section
, output
, file
)
1171 lang_statement_list_type
*ptr
;
1173 lang_output_section_statement_type
*output
;
1174 lang_input_statement_type
*file
;
1177 bfd_boolean discard
;
1179 flags
= bfd_get_section_flags (section
->owner
, section
);
1183 /* Discard sections marked with SEC_EXCLUDE if we are doing a final
1184 link. Discard debugging sections marked with SEC_EXCLUDE on a
1185 relocatable link too. */
1186 if ((flags
& SEC_EXCLUDE
) != 0
1187 && ((flags
& SEC_DEBUGGING
) != 0 || !link_info
.relocateable
))
1190 /* Discard input sections which are assigned to a section named
1191 DISCARD_SECTION_NAME. */
1192 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1195 /* Discard debugging sections if we are stripping debugging
1197 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1198 && (flags
& SEC_DEBUGGING
) != 0)
1203 if (section
->output_section
== NULL
)
1205 /* This prevents future calls from assigning this section. */
1206 section
->output_section
= bfd_abs_section_ptr
;
1211 if (section
->output_section
== NULL
)
1214 lang_input_section_type
*new;
1217 if (output
->bfd_section
== NULL
)
1220 first
= ! output
->bfd_section
->linker_has_input
;
1221 output
->bfd_section
->linker_has_input
= 1;
1223 /* Add a section reference to the list. */
1224 new = new_stat (lang_input_section
, ptr
);
1226 new->section
= section
;
1228 section
->output_section
= output
->bfd_section
;
1230 flags
= section
->flags
;
1232 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1233 to an output section, because we want to be able to include a
1234 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1235 section (I don't know why we want to do this, but we do).
1236 build_link_order in ldwrite.c handles this case by turning
1237 the embedded SEC_NEVER_LOAD section into a fill. */
1239 flags
&= ~ SEC_NEVER_LOAD
;
1241 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1242 already been processed. One reason to do this is that on pe
1243 format targets, .text$foo sections go into .text and it's odd
1244 to see .text with SEC_LINK_ONCE set. */
1246 if (! link_info
.relocateable
)
1247 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1249 /* If this is not the first input section, and the SEC_READONLY
1250 flag is not currently set, then don't set it just because the
1251 input section has it set. */
1253 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1254 flags
&= ~ SEC_READONLY
;
1256 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1258 && ((section
->output_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1259 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1260 || ((flags
& SEC_MERGE
)
1261 && section
->output_section
->entsize
!= section
->entsize
)))
1263 section
->output_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1264 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1267 /* For now make .tbss normal section. */
1268 if ((flags
& SEC_THREAD_LOCAL
) && ! link_info
.relocateable
)
1271 section
->output_section
->flags
|= flags
;
1273 if (flags
& SEC_MERGE
)
1274 section
->output_section
->entsize
= section
->entsize
;
1276 /* If SEC_READONLY is not set in the input section, then clear
1277 it from the output section. */
1278 if ((section
->flags
& SEC_READONLY
) == 0)
1279 section
->output_section
->flags
&= ~SEC_READONLY
;
1281 switch (output
->sectype
)
1283 case normal_section
:
1288 case overlay_section
:
1289 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1291 case noload_section
:
1292 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1293 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1297 /* Copy over SEC_SMALL_DATA. */
1298 if (section
->flags
& SEC_SMALL_DATA
)
1299 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1301 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1302 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1304 /* If supplied an aligment, then force it. */
1305 if (output
->section_alignment
!= -1)
1306 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1308 if (section
->flags
& SEC_BLOCK
)
1310 section
->output_section
->flags
|= SEC_BLOCK
;
1311 /* FIXME: This value should really be obtained from the bfd... */
1312 output
->block_value
= 128;
1317 /* Handle wildcard sorting. This returns the lang_input_section which
1318 should follow the one we are going to create for SECTION and FILE,
1319 based on the sorting requirements of WILD. It returns NULL if the
1320 new section should just go at the end of the current list. */
1322 static lang_statement_union_type
*
1323 wild_sort (wild
, sec
, file
, section
)
1324 lang_wild_statement_type
*wild
;
1325 struct wildcard_list
*sec
;
1326 lang_input_statement_type
*file
;
1329 const char *section_name
;
1330 lang_statement_union_type
*l
;
1332 if (!wild
->filenames_sorted
&& (sec
== NULL
|| !sec
->spec
.sorted
))
1335 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1336 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
1338 lang_input_section_type
*ls
;
1340 if (l
->header
.type
!= lang_input_section_enum
)
1342 ls
= &l
->input_section
;
1344 /* Sorting by filename takes precedence over sorting by section
1347 if (wild
->filenames_sorted
)
1349 const char *fn
, *ln
;
1353 /* The PE support for the .idata section as generated by
1354 dlltool assumes that files will be sorted by the name of
1355 the archive and then the name of the file within the
1358 if (file
->the_bfd
!= NULL
1359 && bfd_my_archive (file
->the_bfd
) != NULL
)
1361 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1366 fn
= file
->filename
;
1370 if (ls
->ifile
->the_bfd
!= NULL
1371 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1373 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1378 ln
= ls
->ifile
->filename
;
1382 i
= strcmp (fn
, ln
);
1391 fn
= file
->filename
;
1393 ln
= ls
->ifile
->filename
;
1395 i
= strcmp (fn
, ln
);
1403 /* Here either the files are not sorted by name, or we are
1404 looking at the sections for this file. */
1406 if (sec
!= NULL
&& sec
->spec
.sorted
)
1408 if (strcmp (section_name
,
1409 bfd_get_section_name (ls
->ifile
->the_bfd
,
1419 /* Expand a wild statement for a particular FILE. SECTION may be
1420 NULL, in which case it is a wild card. */
1423 output_section_callback (ptr
, sec
, section
, file
, output
)
1424 lang_wild_statement_type
*ptr
;
1425 struct wildcard_list
*sec
;
1427 lang_input_statement_type
*file
;
1430 lang_statement_union_type
*before
;
1432 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1433 if (unique_section_p (bfd_get_section_name (file
->the_bfd
, section
)))
1436 /* If the wild pattern was marked KEEP, the member sections
1437 should be as well. */
1438 if (ptr
->keep_sections
)
1439 section
->flags
|= SEC_KEEP
;
1441 before
= wild_sort (ptr
, sec
, file
, section
);
1443 /* Here BEFORE points to the lang_input_section which
1444 should follow the one we are about to add. If BEFORE
1445 is NULL, then the section should just go at the end
1446 of the current list. */
1449 lang_add_section (&ptr
->children
, section
,
1450 (lang_output_section_statement_type
*) output
,
1454 lang_statement_list_type list
;
1455 lang_statement_union_type
**pp
;
1457 lang_list_init (&list
);
1458 lang_add_section (&list
, section
,
1459 (lang_output_section_statement_type
*) output
,
1462 /* If we are discarding the section, LIST.HEAD will
1464 if (list
.head
!= NULL
)
1466 ASSERT (list
.head
->header
.next
== NULL
);
1468 for (pp
= &ptr
->children
.head
;
1470 pp
= &(*pp
)->header
.next
)
1471 ASSERT (*pp
!= NULL
);
1473 list
.head
->header
.next
= *pp
;
1479 /* This is passed a file name which must have been seen already and
1480 added to the statement tree. We will see if it has been opened
1481 already and had its symbols read. If not then we'll read it. */
1483 static lang_input_statement_type
*
1487 lang_input_statement_type
*search
;
1489 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1490 search
!= (lang_input_statement_type
*) NULL
;
1491 search
= (lang_input_statement_type
*) search
->next_real_file
)
1493 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1495 if (search
->filename
!= (char *) NULL
1496 && name
!= (char *) NULL
1497 && strcmp (search
->filename
, name
) == 0)
1501 if (search
== (lang_input_statement_type
*) NULL
)
1502 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1505 /* If we have already added this file, or this file is not real
1506 (FIXME: can that ever actually happen?) or the name is NULL
1507 (FIXME: can that ever actually happen?) don't add this file. */
1510 || search
->filename
== (const char *) NULL
)
1513 if (! load_symbols (search
, (lang_statement_list_type
*) NULL
))
1519 /* Get the symbols for an input file. */
1522 load_symbols (entry
, place
)
1523 lang_input_statement_type
*entry
;
1524 lang_statement_list_type
*place
;
1531 ldfile_open_file (entry
);
1533 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1534 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1537 lang_statement_list_type
*hold
;
1538 bfd_boolean bad_load
= TRUE
;
1540 err
= bfd_get_error ();
1542 /* See if the emulation has some special knowledge. */
1543 if (ldemul_unrecognized_file (entry
))
1546 if (err
== bfd_error_file_ambiguously_recognized
)
1550 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1551 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1552 for (p
= matching
; *p
!= NULL
; p
++)
1556 else if (err
!= bfd_error_file_not_recognized
1558 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1562 bfd_close (entry
->the_bfd
);
1563 entry
->the_bfd
= NULL
;
1565 /* Try to interpret the file as a linker script. */
1566 ldfile_open_command_file (entry
->filename
);
1571 ldfile_assumed_script
= TRUE
;
1572 parser_input
= input_script
;
1574 ldfile_assumed_script
= FALSE
;
1581 if (ldemul_recognized_file (entry
))
1584 /* We don't call ldlang_add_file for an archive. Instead, the
1585 add_symbols entry point will call ldlang_add_file, via the
1586 add_archive_element callback, for each element of the archive
1588 switch (bfd_get_format (entry
->the_bfd
))
1594 ldlang_add_file (entry
);
1595 if (trace_files
|| trace_file_tries
)
1596 info_msg ("%I\n", entry
);
1600 if (entry
->whole_archive
)
1603 bfd_boolean loaded
= TRUE
;
1607 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
1612 if (! bfd_check_format (member
, bfd_object
))
1614 einfo (_("%F%B: member %B in archive is not an object\n"),
1615 entry
->the_bfd
, member
);
1619 if (! ((*link_info
.callbacks
->add_archive_element
)
1620 (&link_info
, member
, "--whole-archive")))
1623 if (! bfd_link_add_symbols (member
, &link_info
))
1625 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1630 entry
->loaded
= loaded
;
1636 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1637 entry
->loaded
= TRUE
;
1639 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1641 return entry
->loaded
;
1644 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1645 may be NULL, indicating that it is a wildcard. Separate
1646 lang_input_section statements are created for each part of the
1647 expansion; they are added after the wild statement S. OUTPUT is
1648 the output section. */
1651 wild (s
, target
, output
)
1652 lang_wild_statement_type
*s
;
1653 const char *target ATTRIBUTE_UNUSED
;
1654 lang_output_section_statement_type
*output
;
1656 struct wildcard_list
*sec
;
1658 walk_wild (s
, output_section_callback
, (PTR
) output
);
1660 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
1662 if (default_common_section
!= NULL
)
1664 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
1666 /* Remember the section that common is going to in case we
1667 later get something which doesn't know where to put it. */
1668 default_common_section
= output
;
1673 /* Return TRUE iff target is the sought target. */
1676 get_target (target
, data
)
1677 const bfd_target
*target
;
1680 const char *sought
= (const char *) data
;
1682 return strcmp (target
->name
, sought
) == 0;
1685 /* Like strcpy() but convert to lower case as well. */
1694 while ((c
= *src
++) != 0)
1695 *dest
++ = TOLOWER (c
);
1700 /* Remove the first occurance of needle (if any) in haystack
1704 strcut (haystack
, needle
)
1708 haystack
= strstr (haystack
, needle
);
1714 for (src
= haystack
+ strlen (needle
); *src
;)
1715 *haystack
++ = *src
++;
1721 /* Compare two target format name strings.
1722 Return a value indicating how "similar" they are. */
1725 name_compare (first
, second
)
1733 copy1
= xmalloc (strlen (first
) + 1);
1734 copy2
= xmalloc (strlen (second
) + 1);
1736 /* Convert the names to lower case. */
1737 stricpy (copy1
, first
);
1738 stricpy (copy2
, second
);
1740 /* Remove and endian strings from the name. */
1741 strcut (copy1
, "big");
1742 strcut (copy1
, "little");
1743 strcut (copy2
, "big");
1744 strcut (copy2
, "little");
1746 /* Return a value based on how many characters match,
1747 starting from the beginning. If both strings are
1748 the same then return 10 * their length. */
1749 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1750 if (copy1
[result
] == 0)
1762 /* Set by closest_target_match() below. */
1763 static const bfd_target
*winner
;
1765 /* Scan all the valid bfd targets looking for one that has the endianness
1766 requirement that was specified on the command line, and is the nearest
1767 match to the original output target. */
1770 closest_target_match (target
, data
)
1771 const bfd_target
*target
;
1774 const bfd_target
*original
= (const bfd_target
*) data
;
1776 if (command_line
.endian
== ENDIAN_BIG
1777 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1780 if (command_line
.endian
== ENDIAN_LITTLE
1781 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1784 /* Must be the same flavour. */
1785 if (target
->flavour
!= original
->flavour
)
1788 /* If we have not found a potential winner yet, then record this one. */
1795 /* Oh dear, we now have two potential candidates for a successful match.
1796 Compare their names and choose the better one. */
1797 if (name_compare (target
->name
, original
->name
)
1798 > name_compare (winner
->name
, original
->name
))
1801 /* Keep on searching until wqe have checked them all. */
1805 /* Return the BFD target format of the first input file. */
1808 get_first_input_target ()
1810 char *target
= NULL
;
1812 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1814 if (s
->header
.type
== lang_input_statement_enum
1817 ldfile_open_file (s
);
1819 if (s
->the_bfd
!= NULL
1820 && bfd_check_format (s
->the_bfd
, bfd_object
))
1822 target
= bfd_get_target (s
->the_bfd
);
1834 lang_get_output_target ()
1838 /* Has the user told us which output format to use? */
1839 if (output_target
!= (char *) NULL
)
1840 return output_target
;
1842 /* No - has the current target been set to something other than
1844 if (current_target
!= default_target
)
1845 return current_target
;
1847 /* No - can we determine the format of the first input file? */
1848 target
= get_first_input_target ();
1852 /* Failed - use the default output target. */
1853 return default_target
;
1856 /* Open the output file. */
1864 output_target
= lang_get_output_target ();
1866 /* Has the user requested a particular endianness on the command
1868 if (command_line
.endian
!= ENDIAN_UNSET
)
1870 const bfd_target
*target
;
1871 enum bfd_endian desired_endian
;
1873 /* Get the chosen target. */
1874 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1876 /* If the target is not supported, we cannot do anything. */
1879 if (command_line
.endian
== ENDIAN_BIG
)
1880 desired_endian
= BFD_ENDIAN_BIG
;
1882 desired_endian
= BFD_ENDIAN_LITTLE
;
1884 /* See if the target has the wrong endianness. This should
1885 not happen if the linker script has provided big and
1886 little endian alternatives, but some scrips don't do
1888 if (target
->byteorder
!= desired_endian
)
1890 /* If it does, then see if the target provides
1891 an alternative with the correct endianness. */
1892 if (target
->alternative_target
!= NULL
1893 && (target
->alternative_target
->byteorder
== desired_endian
))
1894 output_target
= target
->alternative_target
->name
;
1897 /* Try to find a target as similar as possible to
1898 the default target, but which has the desired
1899 endian characteristic. */
1900 (void) bfd_search_for_target (closest_target_match
,
1903 /* Oh dear - we could not find any targets that
1904 satisfy our requirements. */
1906 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1908 output_target
= winner
->name
;
1914 output
= bfd_openw (name
, output_target
);
1916 if (output
== (bfd
*) NULL
)
1918 if (bfd_get_error () == bfd_error_invalid_target
)
1919 einfo (_("%P%F: target %s not found\n"), output_target
);
1921 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1924 delete_output_file_on_failure
= TRUE
;
1927 output
->flags
|= D_PAGED
;
1930 if (! bfd_set_format (output
, bfd_object
))
1931 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1932 if (! bfd_set_arch_mach (output
,
1933 ldfile_output_architecture
,
1934 ldfile_output_machine
))
1935 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1937 link_info
.hash
= bfd_link_hash_table_create (output
);
1938 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1939 einfo (_("%P%F: can not create link hash table: %E\n"));
1941 bfd_set_gp_size (output
, g_switch_value
);
1946 ldlang_open_output (statement
)
1947 lang_statement_union_type
*statement
;
1949 switch (statement
->header
.type
)
1951 case lang_output_statement_enum
:
1952 ASSERT (output_bfd
== (bfd
*) NULL
);
1953 output_bfd
= open_output (statement
->output_statement
.name
);
1954 ldemul_set_output_arch ();
1955 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1956 output_bfd
->flags
|= D_PAGED
;
1958 output_bfd
->flags
&= ~D_PAGED
;
1959 if (config
.text_read_only
)
1960 output_bfd
->flags
|= WP_TEXT
;
1962 output_bfd
->flags
&= ~WP_TEXT
;
1963 if (link_info
.traditional_format
)
1964 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1966 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1969 case lang_target_statement_enum
:
1970 current_target
= statement
->target_statement
.target
;
1977 /* Open all the input files. */
1980 open_input_bfds (s
, force
)
1981 lang_statement_union_type
*s
;
1984 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
1986 switch (s
->header
.type
)
1988 case lang_constructors_statement_enum
:
1989 open_input_bfds (constructor_list
.head
, force
);
1991 case lang_output_section_statement_enum
:
1992 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1994 case lang_wild_statement_enum
:
1995 /* Maybe we should load the file's symbols. */
1996 if (s
->wild_statement
.filename
1997 && ! wildcardp (s
->wild_statement
.filename
))
1998 (void) lookup_name (s
->wild_statement
.filename
);
1999 open_input_bfds (s
->wild_statement
.children
.head
, force
);
2001 case lang_group_statement_enum
:
2003 struct bfd_link_hash_entry
*undefs
;
2005 /* We must continually search the entries in the group
2006 until no new symbols are added to the list of undefined
2011 undefs
= link_info
.hash
->undefs_tail
;
2012 open_input_bfds (s
->group_statement
.children
.head
, TRUE
);
2014 while (undefs
!= link_info
.hash
->undefs_tail
);
2017 case lang_target_statement_enum
:
2018 current_target
= s
->target_statement
.target
;
2020 case lang_input_statement_enum
:
2021 if (s
->input_statement
.real
)
2023 lang_statement_list_type add
;
2025 s
->input_statement
.target
= current_target
;
2027 /* If we are being called from within a group, and this
2028 is an archive which has already been searched, then
2029 force it to be researched unless the whole archive
2030 has been loaded already. */
2032 && !s
->input_statement
.whole_archive
2033 && s
->input_statement
.loaded
2034 && bfd_check_format (s
->input_statement
.the_bfd
,
2036 s
->input_statement
.loaded
= FALSE
;
2038 lang_list_init (&add
);
2040 if (! load_symbols (&s
->input_statement
, &add
))
2041 config
.make_executable
= FALSE
;
2043 if (add
.head
!= NULL
)
2045 *add
.tail
= s
->header
.next
;
2046 s
->header
.next
= add
.head
;
2056 /* If there are [COMMONS] statements, put a wild one into the bss
2060 lang_reasonable_defaults ()
2063 lang_output_section_statement_lookup (".text");
2064 lang_output_section_statement_lookup (".data");
2066 default_common_section
= lang_output_section_statement_lookup (".bss");
2068 if (!placed_commons
)
2070 lang_wild_statement_type
*new =
2071 new_stat (lang_wild_statement
,
2072 &default_common_section
->children
);
2074 new->section_name
= "COMMON";
2075 new->filename
= (char *) NULL
;
2076 lang_list_init (&new->children
);
2081 /* Add the supplied name to the symbol table as an undefined reference.
2082 This is a two step process as the symbol table doesn't even exist at
2083 the time the ld command line is processed. First we put the name
2084 on a list, then, once the output file has been opened, transfer the
2085 name to the symbol table. */
2087 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
2089 #define ldlang_undef_chain_list_head entry_symbol.next
2092 ldlang_add_undef (name
)
2093 const char *const name
;
2095 ldlang_undef_chain_list_type
*new =
2096 ((ldlang_undef_chain_list_type
*)
2097 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
2099 new->next
= ldlang_undef_chain_list_head
;
2100 ldlang_undef_chain_list_head
= new;
2102 new->name
= xstrdup (name
);
2104 if (output_bfd
!= NULL
)
2105 insert_undefined (new->name
);
2108 /* Insert NAME as undefined in the symbol table. */
2111 insert_undefined (name
)
2114 struct bfd_link_hash_entry
*h
;
2116 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
2117 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2118 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2119 if (h
->type
== bfd_link_hash_new
)
2121 h
->type
= bfd_link_hash_undefined
;
2122 h
->u
.undef
.abfd
= NULL
;
2123 bfd_link_add_undef (link_info
.hash
, h
);
2127 /* Run through the list of undefineds created above and place them
2128 into the linker hash table as undefined symbols belonging to the
2132 lang_place_undefineds ()
2134 ldlang_undef_chain_list_type
*ptr
;
2136 for (ptr
= ldlang_undef_chain_list_head
;
2137 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
2140 insert_undefined (ptr
->name
);
2144 /* Open input files and attatch to output sections. */
2147 map_input_to_output_sections (s
, target
, output_section_statement
)
2148 lang_statement_union_type
*s
;
2150 lang_output_section_statement_type
*output_section_statement
;
2152 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2154 switch (s
->header
.type
)
2156 case lang_wild_statement_enum
:
2157 wild (&s
->wild_statement
, target
, output_section_statement
);
2159 case lang_constructors_statement_enum
:
2160 map_input_to_output_sections (constructor_list
.head
,
2162 output_section_statement
);
2164 case lang_output_section_statement_enum
:
2165 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2167 &s
->output_section_statement
);
2169 case lang_output_statement_enum
:
2171 case lang_target_statement_enum
:
2172 target
= s
->target_statement
.target
;
2174 case lang_group_statement_enum
:
2175 map_input_to_output_sections (s
->group_statement
.children
.head
,
2177 output_section_statement
);
2179 case lang_fill_statement_enum
:
2180 case lang_input_section_enum
:
2181 case lang_object_symbols_statement_enum
:
2182 case lang_data_statement_enum
:
2183 case lang_reloc_statement_enum
:
2184 case lang_padding_statement_enum
:
2185 case lang_input_statement_enum
:
2186 if (output_section_statement
!= NULL
2187 && output_section_statement
->bfd_section
== NULL
)
2188 init_os (output_section_statement
);
2190 case lang_assignment_statement_enum
:
2191 if (output_section_statement
!= NULL
2192 && output_section_statement
->bfd_section
== NULL
)
2193 init_os (output_section_statement
);
2195 /* Make sure that any sections mentioned in the assignment
2197 exp_init_os (s
->assignment_statement
.exp
);
2199 case lang_afile_asection_pair_statement_enum
:
2202 case lang_address_statement_enum
:
2203 /* Mark the specified section with the supplied address. */
2205 lang_output_section_statement_type
*os
=
2206 lang_output_section_statement_lookup
2207 (s
->address_statement
.section_name
);
2209 if (os
->bfd_section
== NULL
)
2211 os
->addr_tree
= s
->address_statement
.address
;
2218 /* An output section might have been removed after its statement was
2219 added. For example, ldemul_before_allocation can remove dynamic
2220 sections if they turn out to be not needed. Clean them up here. */
2223 strip_excluded_output_sections ()
2225 lang_statement_union_type
*u
;
2227 for (u
= lang_output_section_statement
.head
;
2229 u
= u
->output_section_statement
.next
)
2231 lang_output_section_statement_type
*os
;
2234 os
= &u
->output_section_statement
;
2235 s
= os
->bfd_section
;
2236 if (s
!= NULL
&& (s
->flags
& SEC_EXCLUDE
) != 0)
2240 os
->bfd_section
= NULL
;
2242 for (p
= &output_bfd
->sections
; *p
; p
= &(*p
)->next
)
2245 bfd_section_list_remove (output_bfd
, p
);
2246 output_bfd
->section_count
--;
2254 print_output_section_statement (output_section_statement
)
2255 lang_output_section_statement_type
*output_section_statement
;
2257 asection
*section
= output_section_statement
->bfd_section
;
2260 if (output_section_statement
!= abs_output_section
)
2262 minfo ("\n%s", output_section_statement
->name
);
2264 if (section
!= NULL
)
2266 print_dot
= section
->vma
;
2268 len
= strlen (output_section_statement
->name
);
2269 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2274 while (len
< SECTION_NAME_MAP_LENGTH
)
2280 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2282 if (output_section_statement
->load_base
!= NULL
)
2286 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2287 "load base", lang_final_phase_enum
);
2288 minfo (_(" load address 0x%V"), addr
);
2295 print_statement_list (output_section_statement
->children
.head
,
2296 output_section_statement
);
2300 print_assignment (assignment
, output_section
)
2301 lang_assignment_statement_type
*assignment
;
2302 lang_output_section_statement_type
*output_section
;
2305 etree_value_type result
;
2307 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2310 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2311 lang_final_phase_enum
, print_dot
, &print_dot
);
2317 value
= result
.value
+ result
.section
->bfd_section
->vma
;
2318 dst
= assignment
->exp
->assign
.dst
;
2320 minfo ("0x%V", value
);
2321 if (dst
[0] == '.' && dst
[1] == 0)
2334 exp_print_tree (assignment
->exp
);
2340 print_input_statement (statm
)
2341 lang_input_statement_type
*statm
;
2343 if (statm
->filename
!= (char *) NULL
)
2345 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2349 /* Print all symbols defined in a particular section. This is called
2350 via bfd_link_hash_traverse. */
2353 print_one_symbol (hash_entry
, ptr
)
2354 struct bfd_link_hash_entry
*hash_entry
;
2357 asection
*sec
= (asection
*) ptr
;
2359 if ((hash_entry
->type
== bfd_link_hash_defined
2360 || hash_entry
->type
== bfd_link_hash_defweak
)
2361 && sec
== hash_entry
->u
.def
.section
)
2365 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2368 (hash_entry
->u
.def
.value
2369 + hash_entry
->u
.def
.section
->output_offset
2370 + hash_entry
->u
.def
.section
->output_section
->vma
));
2372 minfo (" %T\n", hash_entry
->root
.string
);
2378 /* Print information about an input section to the map file. */
2381 print_input_section (in
)
2382 lang_input_section_type
*in
;
2384 asection
*i
= in
->section
;
2385 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2386 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2387 ldfile_output_machine
);
2392 minfo ("%s", i
->name
);
2394 if (i
->output_section
!= NULL
)
2398 len
= 1 + strlen (i
->name
);
2399 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2404 while (len
< SECTION_NAME_MAP_LENGTH
)
2410 minfo ("0x%V %W %B\n",
2411 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2414 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2416 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2428 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2431 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2433 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2439 print_fill_statement (fill
)
2440 lang_fill_statement_type
*fill
;
2444 fputs (" FILL mask 0x", config
.map_file
);
2445 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
2446 fprintf (config
.map_file
, "%02x", *p
);
2447 fputs ("\n", config
.map_file
);
2451 print_data_statement (data
)
2452 lang_data_statement_type
*data
;
2458 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2459 ldfile_output_machine
);
2461 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2464 addr
= data
->output_vma
;
2465 if (data
->output_section
!= NULL
)
2466 addr
+= data
->output_section
->vma
;
2494 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2496 if (data
->exp
->type
.node_class
!= etree_value
)
2499 exp_print_tree (data
->exp
);
2504 print_dot
= addr
+ size
/ opb
;
2508 /* Print an address statement. These are generated by options like
2512 print_address_statement (address
)
2513 lang_address_statement_type
*address
;
2515 minfo (_("Address of section %s set to "), address
->section_name
);
2516 exp_print_tree (address
->address
);
2520 /* Print a reloc statement. */
2523 print_reloc_statement (reloc
)
2524 lang_reloc_statement_type
*reloc
;
2529 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2530 ldfile_output_machine
);
2532 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2535 addr
= reloc
->output_vma
;
2536 if (reloc
->output_section
!= NULL
)
2537 addr
+= reloc
->output_section
->vma
;
2539 size
= bfd_get_reloc_size (reloc
->howto
);
2541 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2543 if (reloc
->name
!= NULL
)
2544 minfo ("%s+", reloc
->name
);
2546 minfo ("%s+", reloc
->section
->name
);
2548 exp_print_tree (reloc
->addend_exp
);
2552 print_dot
= addr
+ size
/ opb
;
2556 print_padding_statement (s
)
2557 lang_padding_statement_type
*s
;
2561 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2562 ldfile_output_machine
);
2566 len
= sizeof " *fill*" - 1;
2567 while (len
< SECTION_NAME_MAP_LENGTH
)
2573 addr
= s
->output_offset
;
2574 if (s
->output_section
!= NULL
)
2575 addr
+= s
->output_section
->vma
;
2576 minfo ("0x%V %W ", addr
, s
->size
);
2578 if (s
->fill
->size
!= 0)
2582 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
2583 fprintf (config
.map_file
, "%02x", *p
);
2588 print_dot
= addr
+ s
->size
/ opb
;
2592 print_wild_statement (w
, os
)
2593 lang_wild_statement_type
*w
;
2594 lang_output_section_statement_type
*os
;
2596 struct wildcard_list
*sec
;
2600 if (w
->filenames_sorted
)
2602 if (w
->filename
!= NULL
)
2603 minfo ("%s", w
->filename
);
2606 if (w
->filenames_sorted
)
2610 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
2612 if (sec
->spec
.sorted
)
2614 if (sec
->spec
.exclude_name_list
!= NULL
)
2617 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
2618 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
2619 minfo (" %s", tmp
->name
);
2622 if (sec
->spec
.name
!= NULL
)
2623 minfo ("%s", sec
->spec
.name
);
2626 if (sec
->spec
.sorted
)
2635 print_statement_list (w
->children
.head
, os
);
2638 /* Print a group statement. */
2642 lang_group_statement_type
*s
;
2643 lang_output_section_statement_type
*os
;
2645 fprintf (config
.map_file
, "START GROUP\n");
2646 print_statement_list (s
->children
.head
, os
);
2647 fprintf (config
.map_file
, "END GROUP\n");
2650 /* Print the list of statements in S.
2651 This can be called for any statement type. */
2654 print_statement_list (s
, os
)
2655 lang_statement_union_type
*s
;
2656 lang_output_section_statement_type
*os
;
2660 print_statement (s
, os
);
2665 /* Print the first statement in statement list S.
2666 This can be called for any statement type. */
2669 print_statement (s
, os
)
2670 lang_statement_union_type
*s
;
2671 lang_output_section_statement_type
*os
;
2673 switch (s
->header
.type
)
2676 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2679 case lang_constructors_statement_enum
:
2680 if (constructor_list
.head
!= NULL
)
2682 if (constructors_sorted
)
2683 minfo (" SORT (CONSTRUCTORS)\n");
2685 minfo (" CONSTRUCTORS\n");
2686 print_statement_list (constructor_list
.head
, os
);
2689 case lang_wild_statement_enum
:
2690 print_wild_statement (&s
->wild_statement
, os
);
2692 case lang_address_statement_enum
:
2693 print_address_statement (&s
->address_statement
);
2695 case lang_object_symbols_statement_enum
:
2696 minfo (" CREATE_OBJECT_SYMBOLS\n");
2698 case lang_fill_statement_enum
:
2699 print_fill_statement (&s
->fill_statement
);
2701 case lang_data_statement_enum
:
2702 print_data_statement (&s
->data_statement
);
2704 case lang_reloc_statement_enum
:
2705 print_reloc_statement (&s
->reloc_statement
);
2707 case lang_input_section_enum
:
2708 print_input_section (&s
->input_section
);
2710 case lang_padding_statement_enum
:
2711 print_padding_statement (&s
->padding_statement
);
2713 case lang_output_section_statement_enum
:
2714 print_output_section_statement (&s
->output_section_statement
);
2716 case lang_assignment_statement_enum
:
2717 print_assignment (&s
->assignment_statement
, os
);
2719 case lang_target_statement_enum
:
2720 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2722 case lang_output_statement_enum
:
2723 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2724 if (output_target
!= NULL
)
2725 minfo (" %s", output_target
);
2728 case lang_input_statement_enum
:
2729 print_input_statement (&s
->input_statement
);
2731 case lang_group_statement_enum
:
2732 print_group (&s
->group_statement
, os
);
2734 case lang_afile_asection_pair_statement_enum
:
2743 print_statement_list (statement_list
.head
, abs_output_section
);
2746 /* Print the first N statements in statement list S to STDERR.
2747 If N == 0, nothing is printed.
2748 If N < 0, the entire list is printed.
2749 Intended to be called from GDB. */
2752 dprint_statement (s
, n
)
2753 lang_statement_union_type
*s
;
2756 FILE *map_save
= config
.map_file
;
2758 config
.map_file
= stderr
;
2761 print_statement_list (s
, abs_output_section
);
2764 while (s
&& --n
>= 0)
2766 print_statement (s
, abs_output_section
);
2771 config
.map_file
= map_save
;
2775 insert_pad (ptr
, fill
, alignment_needed
, output_section
, dot
)
2776 lang_statement_union_type
**ptr
;
2778 unsigned int alignment_needed
;
2779 asection
*output_section
;
2782 static fill_type zero_fill
= { 1, { 0 } };
2783 lang_statement_union_type
*pad
;
2785 pad
= ((lang_statement_union_type
*)
2786 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
2787 if (ptr
!= &statement_list
.head
2788 && pad
->header
.type
== lang_padding_statement_enum
2789 && pad
->padding_statement
.output_section
== output_section
)
2791 /* Use the existing pad statement. The above test on output
2792 section is probably redundant, but it doesn't hurt to check. */
2796 /* Make a new padding statement, linked into existing chain. */
2797 pad
= ((lang_statement_union_type
*)
2798 stat_alloc (sizeof (lang_padding_statement_type
)));
2799 pad
->header
.next
= *ptr
;
2801 pad
->header
.type
= lang_padding_statement_enum
;
2802 pad
->padding_statement
.output_section
= output_section
;
2803 if (fill
== (fill_type
*) 0)
2805 pad
->padding_statement
.fill
= fill
;
2807 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
2808 pad
->padding_statement
.size
= alignment_needed
;
2809 output_section
->_raw_size
+= alignment_needed
;
2812 /* Work out how much this section will move the dot point. */
2815 size_input_section (this_ptr
, output_section_statement
, fill
, dot
)
2816 lang_statement_union_type
**this_ptr
;
2817 lang_output_section_statement_type
*output_section_statement
;
2821 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2822 asection
*i
= is
->section
;
2824 if (!is
->ifile
->just_syms_flag
)
2826 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2827 ldfile_output_machine
);
2828 unsigned int alignment_needed
;
2831 /* Align this section first to the input sections requirement,
2832 then to the output section's requirement. If this alignment
2833 is greater than any seen before, then record it too. Perform
2834 the alignment by inserting a magic 'padding' statement. */
2836 if (output_section_statement
->subsection_alignment
!= -1)
2837 i
->alignment_power
= output_section_statement
->subsection_alignment
;
2839 o
= output_section_statement
->bfd_section
;
2840 if (o
->alignment_power
< i
->alignment_power
)
2841 o
->alignment_power
= i
->alignment_power
;
2843 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
2845 if (alignment_needed
!= 0)
2847 insert_pad (this_ptr
, fill
, alignment_needed
* opb
, o
, dot
);
2848 dot
+= alignment_needed
;
2851 /* Remember where in the output section this input section goes. */
2853 i
->output_offset
= dot
- o
->vma
;
2855 /* Mark how big the output section must be to contain this now. */
2856 if (i
->_cooked_size
!= 0)
2857 dot
+= i
->_cooked_size
/ opb
;
2859 dot
+= i
->_raw_size
/ opb
;
2860 o
->_raw_size
= (dot
- o
->vma
) * opb
;
2864 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2870 #define IGNORE_SECTION(bfd, s) \
2871 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2872 != (SEC_ALLOC | SEC_LOAD)) \
2873 || bfd_section_size (bfd, s) == 0)
2875 /* Check to see if any allocated sections overlap with other allocated
2876 sections. This can happen when the linker script specifically specifies
2877 the output section addresses of the two sections. */
2880 lang_check_section_addresses ()
2883 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2885 /* Scan all sections in the output list. */
2886 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2890 /* Ignore sections which are not loaded or which have no contents. */
2891 if (IGNORE_SECTION (output_bfd
, s
))
2894 /* Once we reach section 's' stop our seach. This prevents two
2895 warning messages from being produced, one for 'section A overlaps
2896 section B' and one for 'section B overlaps section A'. */
2897 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2904 /* Only consider loadable sections with real contents. */
2905 if (IGNORE_SECTION (output_bfd
, os
))
2908 /* We must check the sections' LMA addresses not their
2909 VMA addresses because overlay sections can have
2910 overlapping VMAs but they must have distinct LMAs. */
2911 s_start
= bfd_section_lma (output_bfd
, s
);
2912 os_start
= bfd_section_lma (output_bfd
, os
);
2913 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2914 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2916 /* Look for an overlap. */
2917 if ((s_end
< os_start
) || (s_start
> os_end
))
2921 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2922 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2924 /* Once we have found one overlap for this section,
2925 stop looking for others. */
2931 /* Make sure the new address is within the region. We explicitly permit the
2932 current address to be at the exact end of the region when the address is
2933 non-zero, in case the region is at the end of addressable memory and the
2934 calculation wraps around. */
2937 os_region_check (os
, region
, tree
, base
)
2938 lang_output_section_statement_type
*os
;
2939 struct memory_region_struct
*region
;
2943 if ((region
->current
< region
->origin
2944 || (region
->current
- region
->origin
> region
->length
))
2945 && ((region
->current
!= region
->origin
+ region
->length
)
2948 if (tree
!= (etree_type
*) NULL
)
2950 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2952 os
->bfd_section
->owner
,
2953 os
->bfd_section
->name
,
2958 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2960 os
->bfd_section
->owner
,
2961 os
->bfd_section
->name
);
2963 /* Reset the region pointer. */
2964 region
->current
= region
->origin
;
2968 /* Set the sizes for all the output sections. */
2971 lang_size_sections_1 (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2972 lang_statement_union_type
*s
;
2973 lang_output_section_statement_type
*output_section_statement
;
2974 lang_statement_union_type
**prev
;
2979 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2980 ldfile_output_machine
);
2982 /* Size up the sections from their constituent parts. */
2983 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2985 switch (s
->header
.type
)
2987 case lang_output_section_statement_enum
:
2990 lang_output_section_statement_type
*os
;
2992 os
= &s
->output_section_statement
;
2993 if (os
->bfd_section
== NULL
)
2994 /* This section was never actually created. */
2997 /* If this is a COFF shared library section, use the size and
2998 address from the input section. FIXME: This is COFF
2999 specific; it would be cleaner if there were some other way
3000 to do this, but nothing simple comes to mind. */
3001 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
3005 if (os
->children
.head
== NULL
3006 || os
->children
.head
->header
.next
!= NULL
3007 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
3008 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
3011 input
= os
->children
.head
->input_section
.section
;
3012 bfd_set_section_vma (os
->bfd_section
->owner
,
3014 bfd_section_vma (input
->owner
, input
));
3015 os
->bfd_section
->_raw_size
= input
->_raw_size
;
3019 if (bfd_is_abs_section (os
->bfd_section
))
3021 /* No matter what happens, an abs section starts at zero. */
3022 ASSERT (os
->bfd_section
->vma
== 0);
3026 if (os
->addr_tree
== (etree_type
*) NULL
)
3028 /* No address specified for this section, get one
3029 from the region specification. */
3030 if (os
->region
== (lang_memory_region_type
*) NULL
3031 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3032 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
3033 && os
->region
->name
[0] == '*'
3034 && strcmp (os
->region
->name
, "*default*") == 0))
3036 os
->region
= lang_memory_default (os
->bfd_section
);
3039 /* If a loadable section is using the default memory
3040 region, and some non default memory regions were
3041 defined, issue a warning. */
3042 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3043 & (SEC_ALLOC
| SEC_LOAD
)) != 0
3044 && (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3045 & SEC_NEVER_LOAD
) == 0
3046 && ! link_info
.relocateable
3047 && strcmp (os
->region
->name
, "*default*") == 0
3048 && lang_memory_region_list
!= NULL
3049 && (strcmp (lang_memory_region_list
->name
,
3051 || lang_memory_region_list
->next
!= NULL
))
3052 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
3053 bfd_get_section_name (output_bfd
,
3056 dot
= os
->region
->current
;
3058 if (os
->section_alignment
== -1)
3063 dot
= align_power (dot
,
3064 os
->bfd_section
->alignment_power
);
3066 if (dot
!= olddot
&& config
.warn_section_align
)
3067 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
3068 os
->name
, (unsigned int) (dot
- olddot
));
3075 r
= exp_fold_tree (os
->addr_tree
,
3077 lang_allocating_phase_enum
,
3080 einfo (_("%F%S: non constant address expression for section %s\n"),
3083 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
3086 /* The section starts here.
3087 First, align to what the section needs. */
3089 if (os
->section_alignment
!= -1)
3090 dot
= align_power (dot
, os
->section_alignment
);
3092 bfd_set_section_vma (0, os
->bfd_section
, dot
);
3094 os
->bfd_section
->output_offset
= 0;
3097 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
3098 os
->fill
, dot
, relax
);
3100 /* Put the section within the requested block size, or
3101 align at the block boundary. */
3102 after
= align_n (os
->bfd_section
->vma
3103 + os
->bfd_section
->_raw_size
/ opb
,
3104 (bfd_vma
) os
->block_value
);
3106 if (bfd_is_abs_section (os
->bfd_section
))
3107 ASSERT (after
== os
->bfd_section
->vma
);
3108 else if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) == 0
3109 && (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
)
3110 && ! link_info
.relocateable
)
3111 os
->bfd_section
->_raw_size
= 0;
3113 os
->bfd_section
->_raw_size
=
3114 (after
- os
->bfd_section
->vma
) * opb
;
3116 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3117 os
->processed
= TRUE
;
3119 if (os
->update_dot_tree
!= 0)
3120 exp_fold_tree (os
->update_dot_tree
, abs_output_section
,
3121 lang_allocating_phase_enum
, dot
, &dot
);
3123 /* Update dot in the region ?
3124 We only do this if the section is going to be allocated,
3125 since unallocated sections do not contribute to the region's
3126 overall size in memory.
3128 If the SEC_NEVER_LOAD bit is not set, it will affect the
3129 addresses of sections after it. We have to update
3131 if (os
->region
!= (lang_memory_region_type
*) NULL
3132 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3133 & SEC_NEVER_LOAD
) == 0
3134 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3135 & (SEC_ALLOC
| SEC_LOAD
))))
3137 os
->region
->current
= dot
;
3139 /* Make sure the new address is within the region. */
3140 os_region_check (os
, os
->region
, os
->addr_tree
,
3141 os
->bfd_section
->vma
);
3143 /* If there's no load address specified, use the run
3144 region as the load region. */
3145 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
3146 os
->lma_region
= os
->region
;
3148 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
)
3150 /* Set load_base, which will be handled later. */
3151 os
->load_base
= exp_intop (os
->lma_region
->current
);
3152 os
->lma_region
->current
+=
3153 os
->bfd_section
->_raw_size
/ opb
;
3154 os_region_check (os
, os
->lma_region
, NULL
,
3155 os
->bfd_section
->lma
);
3161 case lang_constructors_statement_enum
:
3162 dot
= lang_size_sections_1 (constructor_list
.head
,
3163 output_section_statement
,
3164 &s
->wild_statement
.children
.head
,
3168 case lang_data_statement_enum
:
3170 unsigned int size
= 0;
3172 s
->data_statement
.output_vma
=
3173 dot
- output_section_statement
->bfd_section
->vma
;
3174 s
->data_statement
.output_section
=
3175 output_section_statement
->bfd_section
;
3177 switch (s
->data_statement
.type
)
3198 output_section_statement
->bfd_section
->_raw_size
+= size
;
3199 /* The output section gets contents, and then we inspect for
3200 any flags set in the input script which override any ALLOC. */
3201 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3202 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3204 output_section_statement
->bfd_section
->flags
|=
3205 SEC_ALLOC
| SEC_LOAD
;
3210 case lang_reloc_statement_enum
:
3214 s
->reloc_statement
.output_vma
=
3215 dot
- output_section_statement
->bfd_section
->vma
;
3216 s
->reloc_statement
.output_section
=
3217 output_section_statement
->bfd_section
;
3218 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3220 output_section_statement
->bfd_section
->_raw_size
+= size
;
3224 case lang_wild_statement_enum
:
3226 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
3227 output_section_statement
,
3228 &s
->wild_statement
.children
.head
,
3233 case lang_object_symbols_statement_enum
:
3234 link_info
.create_object_symbols_section
=
3235 output_section_statement
->bfd_section
;
3237 case lang_output_statement_enum
:
3238 case lang_target_statement_enum
:
3240 case lang_input_section_enum
:
3244 i
= (*prev
)->input_section
.section
;
3247 if (i
->_cooked_size
== 0)
3248 i
->_cooked_size
= i
->_raw_size
;
3254 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3255 einfo (_("%P%F: can't relax section: %E\n"));
3259 dot
= size_input_section (prev
, output_section_statement
,
3260 output_section_statement
->fill
, dot
);
3263 case lang_input_statement_enum
:
3265 case lang_fill_statement_enum
:
3266 s
->fill_statement
.output_section
=
3267 output_section_statement
->bfd_section
;
3269 fill
= s
->fill_statement
.fill
;
3271 case lang_assignment_statement_enum
:
3273 bfd_vma newdot
= dot
;
3275 exp_fold_tree (s
->assignment_statement
.exp
,
3276 output_section_statement
,
3277 lang_allocating_phase_enum
,
3283 if (output_section_statement
== abs_output_section
)
3285 /* If we don't have an output section, then just adjust
3286 the default memory address. */
3287 lang_memory_region_lookup ("*default*")->current
= newdot
;
3291 /* Insert a pad after this statement. We can't
3292 put the pad before when relaxing, in case the
3293 assignment references dot. */
3294 insert_pad (&s
->header
.next
, fill
, (newdot
- dot
) * opb
,
3295 output_section_statement
->bfd_section
, dot
);
3297 /* Don't neuter the pad below when relaxing. */
3306 case lang_padding_statement_enum
:
3307 /* If this is the first time lang_size_sections is called,
3308 we won't have any padding statements. If this is the
3309 second or later passes when relaxing, we should allow
3310 padding to shrink. If padding is needed on this pass, it
3311 will be added back in. */
3312 s
->padding_statement
.size
= 0;
3314 /* Make sure output_offset is valid. If relaxation shrinks
3315 the section and this pad isn't needed, it's possible to
3316 have output_offset larger than the final size of the
3317 section. bfd_set_section_contents will complain even for
3318 a pad size of zero. */
3319 s
->padding_statement
.output_offset
3320 = dot
- output_section_statement
->bfd_section
->vma
;
3323 case lang_group_statement_enum
:
3324 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
3325 output_section_statement
,
3326 &s
->group_statement
.children
.head
,
3334 /* We can only get here when relaxing is turned on. */
3335 case lang_address_statement_enum
:
3338 prev
= &s
->header
.next
;
3344 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
3345 lang_statement_union_type
*s
;
3346 lang_output_section_statement_type
*output_section_statement
;
3347 lang_statement_union_type
**prev
;
3354 exp_data_seg
.phase
= exp_dataseg_none
;
3355 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
3357 if (exp_data_seg
.phase
== exp_dataseg_end_seen
)
3359 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3360 a page could be saved in the data segment. */
3361 bfd_vma first
, last
;
3363 first
= -exp_data_seg
.base
& (exp_data_seg
.pagesize
- 1);
3364 last
= exp_data_seg
.end
& (exp_data_seg
.pagesize
- 1);
3366 && ((exp_data_seg
.base
& ~(exp_data_seg
.pagesize
- 1))
3367 != (exp_data_seg
.end
& ~(exp_data_seg
.pagesize
- 1)))
3368 && first
+ last
<= exp_data_seg
.pagesize
)
3370 exp_data_seg
.phase
= exp_dataseg_adjust
;
3371 result
= lang_size_sections_1 (s
, output_section_statement
, prev
,
3380 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3381 lang_statement_union_type
*s
;
3382 lang_output_section_statement_type
*output_section_statement
;
3386 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3387 ldfile_output_machine
);
3389 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3391 switch (s
->header
.type
)
3393 case lang_constructors_statement_enum
:
3394 dot
= lang_do_assignments (constructor_list
.head
,
3395 output_section_statement
,
3400 case lang_output_section_statement_enum
:
3402 lang_output_section_statement_type
*os
;
3404 os
= &(s
->output_section_statement
);
3405 if (os
->bfd_section
!= NULL
)
3407 dot
= os
->bfd_section
->vma
;
3408 (void) lang_do_assignments (os
->children
.head
, os
,
3410 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3415 /* If nothing has been placed into the output section then
3416 it won't have a bfd_section. */
3417 if (os
->bfd_section
)
3419 os
->bfd_section
->lma
3420 = exp_get_abs_int (os
->load_base
, 0, "load base",
3421 lang_final_phase_enum
);
3426 case lang_wild_statement_enum
:
3428 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3429 output_section_statement
,
3434 case lang_object_symbols_statement_enum
:
3435 case lang_output_statement_enum
:
3436 case lang_target_statement_enum
:
3438 case lang_common_statement_enum
:
3441 case lang_data_statement_enum
:
3443 etree_value_type value
;
3445 value
= exp_fold_tree (s
->data_statement
.exp
,
3447 lang_final_phase_enum
, dot
, &dot
);
3448 s
->data_statement
.value
= value
.value
;
3450 einfo (_("%F%P: invalid data statement\n"));
3454 switch (s
->data_statement
.type
)
3478 case lang_reloc_statement_enum
:
3480 etree_value_type value
;
3482 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3484 lang_final_phase_enum
, dot
, &dot
);
3485 s
->reloc_statement
.addend_value
= value
.value
;
3487 einfo (_("%F%P: invalid reloc statement\n"));
3489 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3492 case lang_input_section_enum
:
3494 asection
*in
= s
->input_section
.section
;
3496 if (in
->_cooked_size
!= 0)
3497 dot
+= in
->_cooked_size
/ opb
;
3499 dot
+= in
->_raw_size
/ opb
;
3503 case lang_input_statement_enum
:
3505 case lang_fill_statement_enum
:
3506 fill
= s
->fill_statement
.fill
;
3508 case lang_assignment_statement_enum
:
3510 exp_fold_tree (s
->assignment_statement
.exp
,
3511 output_section_statement
,
3512 lang_final_phase_enum
,
3518 case lang_padding_statement_enum
:
3519 dot
+= s
->padding_statement
.size
/ opb
;
3522 case lang_group_statement_enum
:
3523 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3524 output_section_statement
,
3532 case lang_address_statement_enum
:
3540 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3541 operator .startof. (section_name), it produces an undefined symbol
3542 .startof.section_name. Similarly, when it sees
3543 .sizeof. (section_name), it produces an undefined symbol
3544 .sizeof.section_name. For all the output sections, we look for
3545 such symbols, and set them to the correct value. */
3552 if (link_info
.relocateable
)
3555 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3557 const char *secname
;
3559 struct bfd_link_hash_entry
*h
;
3561 secname
= bfd_get_section_name (output_bfd
, s
);
3562 buf
= xmalloc (10 + strlen (secname
));
3564 sprintf (buf
, ".startof.%s", secname
);
3565 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
3566 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3568 h
->type
= bfd_link_hash_defined
;
3569 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3570 h
->u
.def
.section
= bfd_abs_section_ptr
;
3573 sprintf (buf
, ".sizeof.%s", secname
);
3574 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
3575 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3579 opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3580 ldfile_output_machine
);
3581 h
->type
= bfd_link_hash_defined
;
3582 if (s
->_cooked_size
!= 0)
3583 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3585 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3586 h
->u
.def
.section
= bfd_abs_section_ptr
;
3596 struct bfd_link_hash_entry
*h
;
3599 if (link_info
.relocateable
|| link_info
.shared
)
3604 if (entry_symbol
.name
== (const char *) NULL
)
3606 /* No entry has been specified. Look for start, but don't warn
3607 if we don't find it. */
3608 entry_symbol
.name
= "start";
3612 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
3613 FALSE
, FALSE
, TRUE
);
3614 if (h
!= (struct bfd_link_hash_entry
*) NULL
3615 && (h
->type
== bfd_link_hash_defined
3616 || h
->type
== bfd_link_hash_defweak
)
3617 && h
->u
.def
.section
->output_section
!= NULL
)
3621 val
= (h
->u
.def
.value
3622 + bfd_get_section_vma (output_bfd
,
3623 h
->u
.def
.section
->output_section
)
3624 + h
->u
.def
.section
->output_offset
);
3625 if (! bfd_set_start_address (output_bfd
, val
))
3626 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
3633 /* We couldn't find the entry symbol. Try parsing it as a
3635 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
3638 if (! bfd_set_start_address (output_bfd
, val
))
3639 einfo (_("%P%F: can't set start address\n"));
3645 /* Can't find the entry symbol, and it's not a number. Use
3646 the first address in the text section. */
3647 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
3648 if (ts
!= (asection
*) NULL
)
3651 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3653 bfd_get_section_vma (output_bfd
, ts
));
3654 if (! bfd_set_start_address (output_bfd
,
3655 bfd_get_section_vma (output_bfd
,
3657 einfo (_("%P%F: can't set start address\n"));
3662 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3669 /* This is a small function used when we want to ignore errors from
3673 #ifdef ANSI_PROTOTYPES
3674 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3676 ignore_bfd_errors (s
)
3677 const char *s ATTRIBUTE_UNUSED
;
3680 /* Don't do anything. */
3683 /* Check that the architecture of all the input files is compatible
3684 with the output file. Also call the backend to let it do any
3685 other checking that is needed. */
3690 lang_statement_union_type
*file
;
3692 const bfd_arch_info_type
*compatible
;
3694 for (file
= file_chain
.head
;
3695 file
!= (lang_statement_union_type
*) NULL
;
3696 file
= file
->input_statement
.next
)
3698 input_bfd
= file
->input_statement
.the_bfd
;
3699 compatible
= bfd_arch_get_compatible (input_bfd
, output_bfd
);
3701 /* In general it is not possible to perform a relocatable
3702 link between differing object formats when the input
3703 file has relocations, because the relocations in the
3704 input format may not have equivalent representations in
3705 the output format (and besides BFD does not translate
3706 relocs for other link purposes than a final link). */
3707 if ((link_info
.relocateable
|| link_info
.emitrelocations
)
3708 && (compatible
== NULL
3709 || bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
3710 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
3712 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3713 bfd_get_target (input_bfd
), input_bfd
,
3714 bfd_get_target (output_bfd
), output_bfd
);
3715 /* einfo with %F exits. */
3718 if (compatible
== NULL
)
3720 if (command_line
.warn_mismatch
)
3721 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3722 bfd_printable_name (input_bfd
), input_bfd
,
3723 bfd_printable_name (output_bfd
));
3725 else if (bfd_count_sections (input_bfd
))
3727 /* If the input bfd has no contents, it shouldn't set the
3728 private data of the output bfd. */
3730 bfd_error_handler_type pfn
= NULL
;
3732 /* If we aren't supposed to warn about mismatched input
3733 files, temporarily set the BFD error handler to a
3734 function which will do nothing. We still want to call
3735 bfd_merge_private_bfd_data, since it may set up
3736 information which is needed in the output file. */
3737 if (! command_line
.warn_mismatch
)
3738 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3739 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3741 if (command_line
.warn_mismatch
)
3742 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3745 if (! command_line
.warn_mismatch
)
3746 bfd_set_error_handler (pfn
);
3751 /* Look through all the global common symbols and attach them to the
3752 correct section. The -sort-common command line switch may be used
3753 to roughly sort the entries by size. */
3758 if (command_line
.inhibit_common_definition
)
3760 if (link_info
.relocateable
3761 && ! command_line
.force_common_definition
)
3764 if (! config
.sort_common
)
3765 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3770 for (power
= 4; power
>= 0; power
--)
3771 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3776 /* Place one common symbol in the correct section. */
3779 lang_one_common (h
, info
)
3780 struct bfd_link_hash_entry
*h
;
3783 unsigned int power_of_two
;
3786 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3787 ldfile_output_machine
);
3789 if (h
->type
!= bfd_link_hash_common
)
3793 power_of_two
= h
->u
.c
.p
->alignment_power
;
3795 if (config
.sort_common
3796 && power_of_two
< (unsigned int) *(int *) info
)
3799 section
= h
->u
.c
.p
->section
;
3801 /* Increase the size of the section. */
3802 section
->_cooked_size
= align_n ((section
->_cooked_size
+ opb
- 1) / opb
,
3803 (bfd_vma
) 1 << power_of_two
) * opb
;
3805 /* Adjust the alignment if necessary. */
3806 if (power_of_two
> section
->alignment_power
)
3807 section
->alignment_power
= power_of_two
;
3809 /* Change the symbol from common to defined. */
3810 h
->type
= bfd_link_hash_defined
;
3811 h
->u
.def
.section
= section
;
3812 h
->u
.def
.value
= section
->_cooked_size
;
3814 /* Increase the size of the section. */
3815 section
->_cooked_size
+= size
;
3817 /* Make sure the section is allocated in memory, and make sure that
3818 it is no longer a common section. */
3819 section
->flags
|= SEC_ALLOC
;
3820 section
->flags
&= ~SEC_IS_COMMON
;
3822 if (config
.map_file
!= NULL
)
3824 static bfd_boolean header_printed
;
3829 if (! header_printed
)
3831 minfo (_("\nAllocating common symbols\n"));
3832 minfo (_("Common symbol size file\n\n"));
3833 header_printed
= TRUE
;
3836 name
= demangle (h
->root
.string
);
3838 len
= strlen (name
);
3853 if (size
<= 0xffffffff)
3854 sprintf (buf
, "%lx", (unsigned long) size
);
3856 sprintf_vma (buf
, size
);
3866 minfo ("%B\n", section
->owner
);
3872 /* Run through the input files and ensure that every input section has
3873 somewhere to go. If one is found without a destination then create
3874 an input request and place it into the statement tree. */
3877 lang_place_orphans ()
3879 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3883 for (s
= file
->the_bfd
->sections
;
3884 s
!= (asection
*) NULL
;
3887 if (s
->output_section
== (asection
*) NULL
)
3889 /* This section of the file is not attatched, root
3890 around for a sensible place for it to go. */
3892 if (file
->just_syms_flag
)
3896 else if (strcmp (s
->name
, "COMMON") == 0)
3898 /* This is a lonely common section which must have
3899 come from an archive. We attach to the section
3900 with the wildcard. */
3901 if (! link_info
.relocateable
3902 || command_line
.force_common_definition
)
3904 if (default_common_section
== NULL
)
3907 /* This message happens when using the
3908 svr3.ifile linker script, so I have
3910 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3912 default_common_section
=
3913 lang_output_section_statement_lookup (".bss");
3916 lang_add_section (&default_common_section
->children
, s
,
3917 default_common_section
, file
);
3920 else if (ldemul_place_orphan (file
, s
))
3924 lang_output_section_statement_type
*os
;
3926 os
= lang_output_section_statement_lookup (s
->name
);
3927 lang_add_section (&os
->children
, s
, os
, file
);
3935 lang_set_flags (ptr
, flags
, invert
)
3936 lang_memory_region_type
*ptr
;
3940 flagword
*ptr_flags
;
3942 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3948 *ptr_flags
|= SEC_ALLOC
;
3952 *ptr_flags
|= SEC_READONLY
;
3956 *ptr_flags
|= SEC_DATA
;
3960 *ptr_flags
|= SEC_CODE
;
3965 *ptr_flags
|= SEC_LOAD
;
3969 einfo (_("%P%F: invalid syntax in flags\n"));
3976 /* Call a function on each input file. This function will be called
3977 on an archive, but not on the elements. */
3980 lang_for_each_input_file (func
)
3981 void (*func
) PARAMS ((lang_input_statement_type
*));
3983 lang_input_statement_type
*f
;
3985 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3987 f
= (lang_input_statement_type
*) f
->next_real_file
)
3991 /* Call a function on each file. The function will be called on all
3992 the elements of an archive which are included in the link, but will
3993 not be called on the archive file itself. */
3996 lang_for_each_file (func
)
3997 void (*func
) PARAMS ((lang_input_statement_type
*));
3999 LANG_FOR_EACH_INPUT_STATEMENT (f
)
4010 lang_for_each_input_section (func
)
4011 void (*func
) PARAMS ((bfd
*ab
, asection
*as
));
4013 LANG_FOR_EACH_INPUT_STATEMENT (f
)
4017 for (s
= f
->the_bfd
->sections
;
4018 s
!= (asection
*) NULL
;
4021 func (f
->the_bfd
, s
);
4029 ldlang_add_file (entry
)
4030 lang_input_statement_type
*entry
;
4034 lang_statement_append (&file_chain
,
4035 (lang_statement_union_type
*) entry
,
4038 /* The BFD linker needs to have a list of all input BFDs involved in
4040 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
4041 ASSERT (entry
->the_bfd
!= output_bfd
);
4042 for (pp
= &link_info
.input_bfds
;
4043 *pp
!= (bfd
*) NULL
;
4044 pp
= &(*pp
)->link_next
)
4046 *pp
= entry
->the_bfd
;
4047 entry
->the_bfd
->usrdata
= (PTR
) entry
;
4048 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
4050 /* Look through the sections and check for any which should not be
4051 included in the link. We need to do this now, so that we can
4052 notice when the backend linker tries to report multiple
4053 definition errors for symbols which are in sections we aren't
4054 going to link. FIXME: It might be better to entirely ignore
4055 symbols which are defined in sections which are going to be
4056 discarded. This would require modifying the backend linker for
4057 each backend which might set the SEC_LINK_ONCE flag. If we do
4058 this, we should probably handle SEC_EXCLUDE in the same way. */
4060 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
4064 lang_add_output (name
, from_script
)
4068 /* Make -o on command line override OUTPUT in script. */
4069 if (!had_output_filename
|| !from_script
)
4071 output_filename
= name
;
4072 had_output_filename
= TRUE
;
4076 static lang_output_section_statement_type
*current_section
;
4088 for (l
= 0; l
< 32; l
++)
4090 if (i
>= (unsigned int) x
)
4098 lang_output_section_statement_type
*
4099 lang_enter_output_section_statement (output_section_statement_name
,
4100 address_exp
, sectype
, block_value
,
4101 align
, subalign
, ebase
)
4102 const char *output_section_statement_name
;
4103 etree_type
*address_exp
;
4104 enum section_type sectype
;
4105 bfd_vma block_value
;
4107 etree_type
*subalign
;
4110 lang_output_section_statement_type
*os
;
4114 lang_output_section_statement_lookup (output_section_statement_name
);
4116 /* Add this statement to tree. */
4118 add_statement (lang_output_section_statement_enum
,
4119 output_section_statement
);
4121 /* Make next things chain into subchain of this. */
4123 if (os
->addr_tree
== (etree_type
*) NULL
)
4125 os
->addr_tree
= address_exp
;
4127 os
->sectype
= sectype
;
4128 if (sectype
!= noload_section
)
4129 os
->flags
= SEC_NO_FLAGS
;
4131 os
->flags
= SEC_NEVER_LOAD
;
4132 os
->block_value
= block_value
? block_value
: 1;
4133 stat_ptr
= &os
->children
;
4135 os
->subsection_alignment
=
4136 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
4137 os
->section_alignment
=
4138 topower (exp_get_value_int (align
, -1, "section alignment", 0));
4140 os
->load_base
= ebase
;
4147 lang_output_statement_type
*new =
4148 new_stat (lang_output_statement
, stat_ptr
);
4150 new->name
= output_filename
;
4153 /* Reset the current counters in the regions. */
4156 lang_reset_memory_regions ()
4158 lang_memory_region_type
*p
= lang_memory_region_list
;
4161 for (p
= lang_memory_region_list
;
4162 p
!= (lang_memory_region_type
*) NULL
;
4165 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
4166 p
->current
= p
->origin
;
4169 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4173 /* If the wild pattern was marked KEEP, the member sections
4174 should be as well. */
4177 gc_section_callback (ptr
, sec
, section
, file
, data
)
4178 lang_wild_statement_type
*ptr
;
4179 struct wildcard_list
*sec ATTRIBUTE_UNUSED
;
4181 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
4182 PTR data ATTRIBUTE_UNUSED
;
4184 if (ptr
->keep_sections
)
4185 section
->flags
|= SEC_KEEP
;
4188 /* Handle a wild statement, marking it against GC. */
4192 lang_wild_statement_type
*s
;
4194 walk_wild (s
, gc_section_callback
, NULL
);
4197 /* Iterate over sections marking them against GC. */
4200 lang_gc_sections_1 (s
)
4201 lang_statement_union_type
*s
;
4203 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
4205 switch (s
->header
.type
)
4207 case lang_wild_statement_enum
:
4208 lang_gc_wild (&s
->wild_statement
);
4210 case lang_constructors_statement_enum
:
4211 lang_gc_sections_1 (constructor_list
.head
);
4213 case lang_output_section_statement_enum
:
4214 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4216 case lang_group_statement_enum
:
4217 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4228 struct bfd_link_hash_entry
*h
;
4229 ldlang_undef_chain_list_type
*ulist
;
4231 /* Keep all sections so marked in the link script. */
4233 lang_gc_sections_1 (statement_list
.head
);
4235 /* Keep all sections containing symbols undefined on the command-line,
4236 and the section containing the entry symbol. */
4238 for (ulist
= link_info
.gc_sym_list
; ulist
; ulist
= ulist
->next
)
4240 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4241 FALSE
, FALSE
, FALSE
);
4243 if (h
!= (struct bfd_link_hash_entry
*) NULL
4244 && (h
->type
== bfd_link_hash_defined
4245 || h
->type
== bfd_link_hash_defweak
)
4246 && ! bfd_is_abs_section (h
->u
.def
.section
))
4248 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4252 bfd_gc_sections (output_bfd
, &link_info
);
4258 lang_reasonable_defaults ();
4259 current_target
= default_target
;
4261 /* Open the output file. */
4262 lang_for_each_statement (ldlang_open_output
);
4264 ldemul_create_output_section_statements ();
4266 /* Add to the hash table all undefineds on the command line. */
4267 lang_place_undefineds ();
4269 already_linked_table_init ();
4271 /* Create a bfd for each input file. */
4272 current_target
= default_target
;
4273 open_input_bfds (statement_list
.head
, FALSE
);
4275 link_info
.gc_sym_list
= &entry_symbol
;
4276 if (entry_symbol
.name
== NULL
)
4277 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
4279 ldemul_after_open ();
4281 already_linked_table_free ();
4283 /* Make sure that we're not mixing architectures. We call this
4284 after all the input files have been opened, but before we do any
4285 other processing, so that any operations merge_private_bfd_data
4286 does on the output file will be known during the rest of the
4290 /* Handle .exports instead of a version script if we're told to do so. */
4291 if (command_line
.version_exports_section
)
4292 lang_do_version_exports_section ();
4294 /* Build all sets based on the information gathered from the input
4296 ldctor_build_sets ();
4298 /* Remove unreferenced sections if asked to. */
4299 if (command_line
.gc_sections
)
4300 lang_gc_sections ();
4302 /* If there were any SEC_MERGE sections, finish their merging, so that
4303 section sizes can be computed. This has to be done after GC of sections,
4304 so that GCed sections are not merged, but before assigning output
4305 sections, since removing whole input sections is hard then. */
4306 bfd_merge_sections (output_bfd
, &link_info
);
4308 /* Size up the common data. */
4311 /* Run through the contours of the script and attach input sections
4312 to the correct output sections. */
4313 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4314 (lang_output_section_statement_type
*) NULL
);
4316 /* Find any sections not attached explicitly and handle them. */
4317 lang_place_orphans ();
4319 if (! link_info
.relocateable
)
4321 /* Look for a text section and set the readonly attribute in it. */
4322 asection
*found
= bfd_get_section_by_name (output_bfd
, ".text");
4324 if (found
!= (asection
*) NULL
)
4326 if (config
.text_read_only
)
4327 found
->flags
|= SEC_READONLY
;
4329 found
->flags
&= ~SEC_READONLY
;
4333 /* Do anything special before sizing sections. This is where ELF
4334 and other back-ends size dynamic sections. */
4335 ldemul_before_allocation ();
4337 if (!link_info
.relocateable
)
4338 strip_excluded_output_sections ();
4340 /* We must record the program headers before we try to fix the
4341 section positions, since they will affect SIZEOF_HEADERS. */
4342 lang_record_phdrs ();
4344 /* Size up the sections. */
4345 lang_size_sections (statement_list
.head
,
4347 &statement_list
.head
, 0, (bfd_vma
) 0, NULL
);
4349 /* Now run around and relax if we can. */
4350 if (command_line
.relax
)
4352 /* Keep relaxing until bfd_relax_section gives up. */
4353 bfd_boolean relax_again
;
4357 lang_reset_memory_regions ();
4359 relax_again
= FALSE
;
4361 /* Note: pe-dll.c does something like this also. If you find
4362 you need to change this code, you probably need to change
4363 pe-dll.c also. DJ */
4365 /* Do all the assignments with our current guesses as to
4367 lang_do_assignments (statement_list
.head
,
4369 (fill_type
*) 0, (bfd_vma
) 0);
4371 /* Perform another relax pass - this time we know where the
4372 globals are, so can make a better guess. */
4373 lang_size_sections (statement_list
.head
,
4375 &statement_list
.head
, 0, (bfd_vma
) 0,
4378 while (relax_again
);
4381 /* See if anything special should be done now we know how big
4383 ldemul_after_allocation ();
4385 /* Fix any .startof. or .sizeof. symbols. */
4386 lang_set_startof ();
4388 /* Do all the assignments, now that we know the final resting places
4389 of all the symbols. */
4391 lang_do_assignments (statement_list
.head
,
4393 (fill_type
*) 0, (bfd_vma
) 0);
4395 /* Make sure that the section addresses make sense. */
4396 if (! link_info
.relocateable
4397 && command_line
.check_section_addresses
)
4398 lang_check_section_addresses ();
4406 /* EXPORTED TO YACC */
4409 lang_add_wild (filespec
, section_list
, keep_sections
)
4410 struct wildcard_spec
*filespec
;
4411 struct wildcard_list
*section_list
;
4412 bfd_boolean keep_sections
;
4414 struct wildcard_list
*curr
, *next
;
4415 lang_wild_statement_type
*new;
4417 /* Reverse the list as the parser puts it back to front. */
4418 for (curr
= section_list
, section_list
= NULL
;
4420 section_list
= curr
, curr
= next
)
4422 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
4423 placed_commons
= TRUE
;
4426 curr
->next
= section_list
;
4429 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
4431 if (strcmp (filespec
->name
, "*") == 0)
4432 filespec
->name
= NULL
;
4433 else if (! wildcardp (filespec
->name
))
4434 lang_has_input_file
= TRUE
;
4437 new = new_stat (lang_wild_statement
, stat_ptr
);
4438 new->filename
= NULL
;
4439 new->filenames_sorted
= FALSE
;
4440 if (filespec
!= NULL
)
4442 new->filename
= filespec
->name
;
4443 new->filenames_sorted
= filespec
->sorted
;
4445 new->section_list
= section_list
;
4446 new->keep_sections
= keep_sections
;
4447 lang_list_init (&new->children
);
4451 lang_section_start (name
, address
)
4453 etree_type
*address
;
4455 lang_address_statement_type
*ad
;
4457 ad
= new_stat (lang_address_statement
, stat_ptr
);
4458 ad
->section_name
= name
;
4459 ad
->address
= address
;
4462 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4463 because of a -e argument on the command line, or zero if this is
4464 called by ENTRY in a linker script. Command line arguments take
4468 lang_add_entry (name
, cmdline
)
4470 bfd_boolean cmdline
;
4472 if (entry_symbol
.name
== NULL
4474 || ! entry_from_cmdline
)
4476 entry_symbol
.name
= name
;
4477 entry_from_cmdline
= cmdline
;
4482 lang_add_target (name
)
4485 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4501 map_option_f
= TRUE
;
4509 lang_add_fill (fill
)
4512 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4519 lang_add_data (type
, exp
)
4521 union etree_union
*exp
;
4524 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4532 /* Create a new reloc statement. RELOC is the BFD relocation type to
4533 generate. HOWTO is the corresponding howto structure (we could
4534 look this up, but the caller has already done so). SECTION is the
4535 section to generate a reloc against, or NAME is the name of the
4536 symbol to generate a reloc against. Exactly one of SECTION and
4537 NAME must be NULL. ADDEND is an expression for the addend. */
4540 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4541 bfd_reloc_code_real_type reloc
;
4542 reloc_howto_type
*howto
;
4545 union etree_union
*addend
;
4547 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4551 p
->section
= section
;
4553 p
->addend_exp
= addend
;
4555 p
->addend_value
= 0;
4556 p
->output_section
= NULL
;
4560 lang_assignment_statement_type
*
4561 lang_add_assignment (exp
)
4564 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4572 lang_add_attribute (attribute
)
4573 enum statement_enum attribute
;
4575 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4582 if (startup_file
!= (char *) NULL
)
4584 einfo (_("%P%Fmultiple STARTUP files\n"));
4586 first_file
->filename
= name
;
4587 first_file
->local_sym_name
= name
;
4588 first_file
->real
= TRUE
;
4590 startup_file
= name
;
4597 lang_float_flag
= maybe
;
4601 /* Work out the load- and run-time regions from a script statement, and
4602 store them in *LMA_REGION and *REGION respectively.
4604 MEMSPEC is the name of the run-time region, or "*default*" if the
4605 statement didn't specify one. LMA_MEMSPEC is the name of the
4606 load-time region, or null if the statement didn't specify one.
4607 HAVE_LMA_P is TRUE if the statement had an explicit load address.
4609 It is an error to specify both a load region and a load address. */
4612 lang_get_regions (region
, lma_region
, memspec
, lma_memspec
, have_lma_p
)
4613 struct memory_region_struct
**region
, **lma_region
;
4614 const char *memspec
, *lma_memspec
;
4617 *lma_region
= lang_memory_region_lookup (lma_memspec
);
4619 /* If no runtime region has been given, but the load region has
4620 been, use the load region. */
4621 if (lma_memspec
!= 0 && strcmp (memspec
, "*default*") == 0)
4622 *region
= *lma_region
;
4624 *region
= lang_memory_region_lookup (memspec
);
4626 if (have_lma_p
&& lma_memspec
!= 0)
4627 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4631 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4633 const char *memspec
;
4634 struct lang_output_section_phdr_list
*phdrs
;
4635 const char *lma_memspec
;
4637 lang_get_regions (¤t_section
->region
,
4638 ¤t_section
->lma_region
,
4639 memspec
, lma_memspec
,
4640 current_section
->load_base
!= 0);
4641 current_section
->fill
= fill
;
4642 current_section
->phdrs
= phdrs
;
4643 stat_ptr
= &statement_list
;
4646 /* Create an absolute symbol with the given name with the value of the
4647 address of first byte of the section named.
4649 If the symbol already exists, then do nothing. */
4652 lang_abs_symbol_at_beginning_of (secname
, name
)
4653 const char *secname
;
4656 struct bfd_link_hash_entry
*h
;
4658 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
4659 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4660 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4662 if (h
->type
== bfd_link_hash_new
4663 || h
->type
== bfd_link_hash_undefined
)
4667 h
->type
= bfd_link_hash_defined
;
4669 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4670 if (sec
== (asection
*) NULL
)
4673 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4675 h
->u
.def
.section
= bfd_abs_section_ptr
;
4679 /* Create an absolute symbol with the given name with the value of the
4680 address of the first byte after the end of the section named.
4682 If the symbol already exists, then do nothing. */
4685 lang_abs_symbol_at_end_of (secname
, name
)
4686 const char *secname
;
4689 struct bfd_link_hash_entry
*h
;
4691 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
4692 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4693 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4695 if (h
->type
== bfd_link_hash_new
4696 || h
->type
== bfd_link_hash_undefined
)
4700 h
->type
= bfd_link_hash_defined
;
4702 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4703 if (sec
== (asection
*) NULL
)
4706 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4707 + bfd_section_size (output_bfd
, sec
) /
4708 bfd_octets_per_byte (output_bfd
));
4710 h
->u
.def
.section
= bfd_abs_section_ptr
;
4715 lang_statement_append (list
, element
, field
)
4716 lang_statement_list_type
*list
;
4717 lang_statement_union_type
*element
;
4718 lang_statement_union_type
**field
;
4720 *(list
->tail
) = element
;
4724 /* Set the output format type. -oformat overrides scripts. */
4727 lang_add_output_format (format
, big
, little
, from_script
)
4733 if (output_target
== NULL
|| !from_script
)
4735 if (command_line
.endian
== ENDIAN_BIG
4738 else if (command_line
.endian
== ENDIAN_LITTLE
4742 output_target
= format
;
4746 /* Enter a group. This creates a new lang_group_statement, and sets
4747 stat_ptr to build new statements within the group. */
4752 lang_group_statement_type
*g
;
4754 g
= new_stat (lang_group_statement
, stat_ptr
);
4755 lang_list_init (&g
->children
);
4756 stat_ptr
= &g
->children
;
4759 /* Leave a group. This just resets stat_ptr to start writing to the
4760 regular list of statements again. Note that this will not work if
4761 groups can occur inside anything else which can adjust stat_ptr,
4762 but currently they can't. */
4767 stat_ptr
= &statement_list
;
4770 /* Add a new program header. This is called for each entry in a PHDRS
4771 command in a linker script. */
4774 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4777 bfd_boolean filehdr
;
4782 struct lang_phdr
*n
, **pp
;
4784 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4787 n
->type
= exp_get_value_int (type
, 0, "program header type",
4788 lang_final_phase_enum
);
4789 n
->filehdr
= filehdr
;
4794 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4799 /* Record the program header information in the output BFD. FIXME: We
4800 should not be calling an ELF specific function here. */
4803 lang_record_phdrs ()
4807 struct lang_output_section_phdr_list
*last
;
4808 struct lang_phdr
*l
;
4809 lang_statement_union_type
*u
;
4812 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4814 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4821 for (u
= lang_output_section_statement
.head
;
4823 u
= u
->output_section_statement
.next
)
4825 lang_output_section_statement_type
*os
;
4826 struct lang_output_section_phdr_list
*pl
;
4828 os
= &u
->output_section_statement
;
4835 if (os
->sectype
== noload_section
4836 || os
->bfd_section
== NULL
4837 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4842 if (os
->bfd_section
== NULL
)
4845 for (; pl
!= NULL
; pl
= pl
->next
)
4847 if (strcmp (pl
->name
, l
->name
) == 0)
4852 secs
= ((asection
**)
4853 xrealloc (secs
, alc
* sizeof (asection
*)));
4855 secs
[c
] = os
->bfd_section
;
4862 if (l
->flags
== NULL
)
4865 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4866 lang_final_phase_enum
);
4871 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4872 lang_final_phase_enum
);
4874 if (! bfd_record_phdr (output_bfd
, l
->type
,
4875 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
4876 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4877 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4882 /* Make sure all the phdr assignments succeeded. */
4883 for (u
= lang_output_section_statement
.head
;
4885 u
= u
->output_section_statement
.next
)
4887 struct lang_output_section_phdr_list
*pl
;
4889 if (u
->output_section_statement
.bfd_section
== NULL
)
4892 for (pl
= u
->output_section_statement
.phdrs
;
4895 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4896 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4897 u
->output_section_statement
.name
, pl
->name
);
4901 /* Record a list of sections which may not be cross referenced. */
4904 lang_add_nocrossref (l
)
4905 struct lang_nocrossref
*l
;
4907 struct lang_nocrossrefs
*n
;
4909 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4910 n
->next
= nocrossref_list
;
4912 nocrossref_list
= n
;
4914 /* Set notice_all so that we get informed about all symbols. */
4915 link_info
.notice_all
= TRUE
;
4918 /* Overlay handling. We handle overlays with some static variables. */
4920 /* The overlay virtual address. */
4921 static etree_type
*overlay_vma
;
4923 /* An expression for the maximum section size seen so far. */
4924 static etree_type
*overlay_max
;
4926 /* A list of all the sections in this overlay. */
4928 struct overlay_list
{
4929 struct overlay_list
*next
;
4930 lang_output_section_statement_type
*os
;
4933 static struct overlay_list
*overlay_list
;
4935 /* Start handling an overlay. */
4938 lang_enter_overlay (vma_expr
)
4939 etree_type
*vma_expr
;
4941 /* The grammar should prevent nested overlays from occurring. */
4942 ASSERT (overlay_vma
== NULL
&& overlay_max
== NULL
);
4944 overlay_vma
= vma_expr
;
4947 /* Start a section in an overlay. We handle this by calling
4948 lang_enter_output_section_statement with the correct VMA.
4949 lang_leave_overlay sets up the LMA and memory regions. */
4952 lang_enter_overlay_section (name
)
4955 struct overlay_list
*n
;
4958 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4961 /* If this is the first section, then base the VMA of future
4962 sections on this one. This will work correctly even if `.' is
4963 used in the addresses. */
4964 if (overlay_list
== NULL
)
4965 overlay_vma
= exp_nameop (ADDR
, name
);
4967 /* Remember the section. */
4968 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4969 n
->os
= current_section
;
4970 n
->next
= overlay_list
;
4973 size
= exp_nameop (SIZEOF
, name
);
4975 /* Arrange to work out the maximum section end address. */
4976 if (overlay_max
== NULL
)
4979 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4982 /* Finish a section in an overlay. There isn't any special to do
4986 lang_leave_overlay_section (fill
, phdrs
)
4988 struct lang_output_section_phdr_list
*phdrs
;
4995 name
= current_section
->name
;
4997 /* For now, assume that "*default*" is the run-time memory region and
4998 that no load-time region has been specified. It doesn't really
4999 matter what we say here, since lang_leave_overlay will override it. */
5000 lang_leave_output_section_statement (fill
, "*default*", phdrs
, 0);
5002 /* Define the magic symbols. */
5004 clean
= xmalloc (strlen (name
) + 1);
5006 for (s1
= name
; *s1
!= '\0'; s1
++)
5007 if (ISALNUM (*s1
) || *s1
== '_')
5011 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
5012 sprintf (buf
, "__load_start_%s", clean
);
5013 lang_add_assignment (exp_assop ('=', buf
,
5014 exp_nameop (LOADADDR
, name
)));
5016 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
5017 sprintf (buf
, "__load_stop_%s", clean
);
5018 lang_add_assignment (exp_assop ('=', buf
,
5020 exp_nameop (LOADADDR
, name
),
5021 exp_nameop (SIZEOF
, name
))));
5026 /* Finish an overlay. If there are any overlay wide settings, this
5027 looks through all the sections in the overlay and sets them. */
5030 lang_leave_overlay (lma_expr
, nocrossrefs
, fill
, memspec
, phdrs
, lma_memspec
)
5031 etree_type
*lma_expr
;
5034 const char *memspec
;
5035 struct lang_output_section_phdr_list
*phdrs
;
5036 const char *lma_memspec
;
5038 lang_memory_region_type
*region
;
5039 lang_memory_region_type
*lma_region
;
5040 struct overlay_list
*l
;
5041 struct lang_nocrossref
*nocrossref
;
5043 lang_get_regions (®ion
, &lma_region
,
5044 memspec
, lma_memspec
,
5049 /* After setting the size of the last section, set '.' to end of the
5051 if (overlay_list
!= NULL
)
5052 overlay_list
->os
->update_dot_tree
5053 = exp_assop ('=', ".", exp_binop ('+', overlay_vma
, overlay_max
));
5058 struct overlay_list
*next
;
5060 if (fill
!= (fill_type
*) 0 && l
->os
->fill
== (fill_type
*) 0)
5063 l
->os
->region
= region
;
5064 l
->os
->lma_region
= lma_region
;
5066 /* The first section has the load address specified in the
5067 OVERLAY statement. The rest are worked out from that.
5068 The base address is not needed (and should be null) if
5069 an LMA region was specified. */
5071 l
->os
->load_base
= lma_expr
;
5072 else if (lma_region
== 0)
5073 l
->os
->load_base
= exp_binop ('+',
5074 exp_nameop (LOADADDR
, l
->next
->os
->name
),
5075 exp_nameop (SIZEOF
, l
->next
->os
->name
));
5077 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
5078 l
->os
->phdrs
= phdrs
;
5082 struct lang_nocrossref
*nc
;
5084 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
5085 nc
->name
= l
->os
->name
;
5086 nc
->next
= nocrossref
;
5095 if (nocrossref
!= NULL
)
5096 lang_add_nocrossref (nocrossref
);
5099 overlay_list
= NULL
;
5103 /* Version handling. This is only useful for ELF. */
5105 /* This global variable holds the version tree that we build. */
5107 struct bfd_elf_version_tree
*lang_elf_version_info
;
5110 lang_vers_match_lang_c (expr
, sym
)
5111 struct bfd_elf_version_expr
*expr
;
5114 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5116 return fnmatch (expr
->pattern
, sym
, 0) == 0;
5120 lang_vers_match_lang_cplusplus (expr
, sym
)
5121 struct bfd_elf_version_expr
*expr
;
5127 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5130 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
5133 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5134 Should we early out FALSE in this case? */
5135 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5139 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5147 lang_vers_match_lang_java (expr
, sym
)
5148 struct bfd_elf_version_expr
*expr
;
5154 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5157 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
5160 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5161 Should we early out FALSE in this case? */
5162 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5166 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5173 /* This is called for each variable name or match expression. */
5175 struct bfd_elf_version_expr
*
5176 lang_new_vers_pattern (orig
, new, lang
)
5177 struct bfd_elf_version_expr
*orig
;
5181 struct bfd_elf_version_expr
*ret
;
5183 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
5189 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
5190 ret
->match
= lang_vers_match_lang_c
;
5191 else if (strcasecmp (lang
, "C++") == 0)
5192 ret
->match
= lang_vers_match_lang_cplusplus
;
5193 else if (strcasecmp (lang
, "Java") == 0)
5194 ret
->match
= lang_vers_match_lang_java
;
5197 einfo (_("%X%P: unknown language `%s' in version information\n"),
5199 ret
->match
= lang_vers_match_lang_c
;
5202 return ldemul_new_vers_pattern (ret
);
5205 /* This is called for each set of variable names and match
5208 struct bfd_elf_version_tree
*
5209 lang_new_vers_node (globals
, locals
)
5210 struct bfd_elf_version_expr
*globals
;
5211 struct bfd_elf_version_expr
*locals
;
5213 struct bfd_elf_version_tree
*ret
;
5215 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
5219 ret
->globals
= globals
;
5220 ret
->locals
= locals
;
5222 ret
->name_indx
= (unsigned int) -1;
5227 /* This static variable keeps track of version indices. */
5229 static int version_index
;
5231 /* This is called when we know the name and dependencies of the
5235 lang_register_vers_node (name
, version
, deps
)
5237 struct bfd_elf_version_tree
*version
;
5238 struct bfd_elf_version_deps
*deps
;
5240 struct bfd_elf_version_tree
*t
, **pp
;
5241 struct bfd_elf_version_expr
*e1
;
5246 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
5247 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
5249 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5253 /* Make sure this node has a unique name. */
5254 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5255 if (strcmp (t
->name
, name
) == 0)
5256 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5258 /* Check the global and local match names, and make sure there
5259 aren't any duplicates. */
5261 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5263 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5265 struct bfd_elf_version_expr
*e2
;
5267 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5268 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5269 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5274 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
5276 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5278 struct bfd_elf_version_expr
*e2
;
5280 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
5281 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5282 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5287 version
->deps
= deps
;
5288 version
->name
= name
;
5289 if (name
[0] != '\0')
5292 version
->vernum
= version_index
;
5295 version
->vernum
= 0;
5297 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5302 /* This is called when we see a version dependency. */
5304 struct bfd_elf_version_deps
*
5305 lang_add_vers_depend (list
, name
)
5306 struct bfd_elf_version_deps
*list
;
5309 struct bfd_elf_version_deps
*ret
;
5310 struct bfd_elf_version_tree
*t
;
5312 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5315 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5317 if (strcmp (t
->name
, name
) == 0)
5319 ret
->version_needed
= t
;
5324 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5330 lang_do_version_exports_section ()
5332 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5334 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5336 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5343 len
= bfd_section_size (is
->the_bfd
, sec
);
5344 contents
= xmalloc (len
);
5345 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5346 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
5349 while (p
< contents
+ len
)
5351 greg
= lang_new_vers_pattern (greg
, p
, NULL
);
5352 p
= strchr (p
, '\0') + 1;
5355 /* Do not free the contents, as we used them creating the regex. */
5357 /* Do not include this section in the link. */
5358 bfd_set_section_flags (is
->the_bfd
, sec
,
5359 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5362 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
);
5363 lang_register_vers_node (command_line
.version_exports_section
,
5364 lang_new_vers_node (greg
, lreg
), NULL
);
5368 lang_add_unique (name
)
5371 struct unique_sections
*ent
;
5373 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5374 if (strcmp (ent
->name
, name
) == 0)
5377 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
5378 ent
->name
= xstrdup (name
);
5379 ent
->next
= unique_section_list
;
5380 unique_section_list
= ent
;