1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
6 This file is part of GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
26 #include "safe-ctype.h"
44 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
47 /* Locals variables. */
48 static struct obstack stat_obstack
;
50 #define obstack_chunk_alloc xmalloc
51 #define obstack_chunk_free free
52 static const char *startup_file
;
53 static lang_statement_list_type input_file_chain
;
54 static bfd_boolean placed_commons
= FALSE
;
55 static lang_output_section_statement_type
*default_common_section
;
56 static bfd_boolean map_option_f
;
57 static bfd_vma print_dot
;
58 static lang_input_statement_type
*first_file
;
59 static const char *current_target
;
60 static const char *output_target
;
61 static lang_statement_list_type statement_list
;
62 static struct lang_phdr
*lang_phdr_list
;
64 /* Forward declarations. */
65 static lang_statement_union_type
*new_statement
66 PARAMS ((enum statement_enum
, size_t, lang_statement_list_type
*));
67 static void lang_for_each_statement_worker
68 PARAMS ((void (*) (lang_statement_union_type
*),
69 lang_statement_union_type
*));
70 static lang_input_statement_type
*new_afile
71 PARAMS ((const char *, lang_input_file_enum_type
, const char *,
73 static lang_memory_region_type
*lang_memory_default
74 PARAMS ((asection
*));
75 static void lang_map_flags
78 PARAMS ((lang_output_section_statement_type
*));
79 static void exp_init_os
80 PARAMS ((etree_type
*));
81 static void section_already_linked
82 PARAMS ((bfd
*, asection
*, PTR
));
83 static struct bfd_hash_entry
*already_linked_newfunc
84 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
85 static void already_linked_table_init
87 static void already_linked_table_free
89 static bfd_boolean wildcardp
90 PARAMS ((const char *));
91 static lang_statement_union_type
*wild_sort
92 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*,
93 lang_input_statement_type
*, asection
*));
94 static void output_section_callback
95 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
96 lang_input_statement_type
*, PTR
));
97 static lang_input_statement_type
*lookup_name
98 PARAMS ((const char *));
99 static bfd_boolean load_symbols
100 PARAMS ((lang_input_statement_type
*, lang_statement_list_type
*));
102 PARAMS ((lang_wild_statement_type
*,
103 const char *, lang_output_section_statement_type
*));
104 static bfd
*open_output
105 PARAMS ((const char *));
106 static void ldlang_open_output
107 PARAMS ((lang_statement_union_type
*));
108 static void open_input_bfds
109 PARAMS ((lang_statement_union_type
*, bfd_boolean
));
110 static void lang_reasonable_defaults
112 static void insert_undefined
113 PARAMS ((const char *));
114 static void lang_place_undefineds
116 static void map_input_to_output_sections
117 PARAMS ((lang_statement_union_type
*, const char *,
118 lang_output_section_statement_type
*));
119 static void strip_excluded_output_sections
121 static void print_output_section_statement
122 PARAMS ((lang_output_section_statement_type
*));
123 static void print_assignment
124 PARAMS ((lang_assignment_statement_type
*,
125 lang_output_section_statement_type
*));
126 static void print_input_statement
127 PARAMS ((lang_input_statement_type
*));
128 static bfd_boolean print_one_symbol
129 PARAMS ((struct bfd_link_hash_entry
*, PTR
));
130 static void print_input_section
131 PARAMS ((lang_input_section_type
*));
132 static void print_fill_statement
133 PARAMS ((lang_fill_statement_type
*));
134 static void print_data_statement
135 PARAMS ((lang_data_statement_type
*));
136 static void print_address_statement
137 PARAMS ((lang_address_statement_type
*));
138 static void print_reloc_statement
139 PARAMS ((lang_reloc_statement_type
*));
140 static void print_padding_statement
141 PARAMS ((lang_padding_statement_type
*));
142 static void print_wild_statement
143 PARAMS ((lang_wild_statement_type
*, lang_output_section_statement_type
*));
144 static void print_group
145 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
146 static void print_statement
147 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
148 static void print_statement_list
149 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
150 static void print_statements
152 static void insert_pad
153 PARAMS ((lang_statement_union_type
**, fill_type
*,
154 unsigned int, asection
*, bfd_vma
));
155 static bfd_vma size_input_section
156 PARAMS ((lang_statement_union_type
**, lang_output_section_statement_type
*,
157 fill_type
*, bfd_vma
));
158 static void lang_finish
160 static void ignore_bfd_errors
161 PARAMS ((const char *, ...));
162 static void lang_check
164 static void lang_common
166 static bfd_boolean lang_one_common
167 PARAMS ((struct bfd_link_hash_entry
*, PTR
));
168 static void lang_place_orphans
172 static void lang_set_startof
174 static void gc_section_callback
175 PARAMS ((lang_wild_statement_type
*, struct wildcard_list
*, asection
*,
176 lang_input_statement_type
*, PTR
));
177 static void lang_get_regions
178 PARAMS ((struct memory_region_struct
**, struct memory_region_struct
**,
179 const char *, const char *, int));
180 static void lang_record_phdrs
182 static void lang_gc_wild
183 PARAMS ((lang_wild_statement_type
*));
184 static void lang_gc_sections_1
185 PARAMS ((lang_statement_union_type
*));
186 static void lang_gc_sections
188 static int lang_vers_match_lang_c
189 PARAMS ((struct bfd_elf_version_expr
*, const char *));
190 static int lang_vers_match_lang_cplusplus
191 PARAMS ((struct bfd_elf_version_expr
*, const char *));
192 static int lang_vers_match_lang_java
193 PARAMS ((struct bfd_elf_version_expr
*, const char *));
194 static void lang_do_version_exports_section
196 static void lang_check_section_addresses
198 static void os_region_check
199 PARAMS ((lang_output_section_statement_type
*,
200 struct memory_region_struct
*, etree_type
*, bfd_vma
));
201 static bfd_vma lang_size_sections_1
202 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*,
203 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
229 /* Exported variables. */
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 several 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
);
916 if (s
->load_base
!= NULL
)
917 exp_init_os (s
->load_base
);
920 /* Make sure that all output sections mentioned in an expression are
927 switch (exp
->type
.node_class
)
930 exp_init_os (exp
->assign
.src
);
934 exp_init_os (exp
->binary
.lhs
);
935 exp_init_os (exp
->binary
.rhs
);
939 exp_init_os (exp
->trinary
.cond
);
940 exp_init_os (exp
->trinary
.lhs
);
941 exp_init_os (exp
->trinary
.rhs
);
945 exp_init_os (exp
->unary
.child
);
949 switch (exp
->type
.node_code
)
955 lang_output_section_statement_type
*os
;
957 os
= lang_output_section_find (exp
->name
.name
);
958 if (os
!= NULL
&& os
->bfd_section
== NULL
)
969 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
970 once into the output. This routine checks each section, and
971 arrange to discard it if a section of the same name has already
972 been linked. If the section has COMDAT information, then it uses
973 that to decide whether the section should be included. This code
974 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
975 that is, it does not depend solely upon the section name.
976 section_already_linked is called via bfd_map_over_sections. */
978 /* This is the shape of the elements inside the already_linked hash
979 table. It maps a name onto a list of already_linked elements with
980 the same name. It's possible to get more than one element in a
981 list if the COMDAT sections have different names. */
983 struct already_linked_hash_entry
985 struct bfd_hash_entry root
;
986 struct already_linked
*entry
;
989 struct already_linked
991 struct already_linked
*next
;
995 /* The hash table. */
997 static struct bfd_hash_table already_linked_table
;
1000 section_already_linked (abfd
, sec
, data
)
1005 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
1008 struct already_linked
*l
;
1009 struct already_linked_hash_entry
*already_linked_list
;
1011 /* If we are only reading symbols from this object, then we want to
1012 discard all sections. */
1013 if (entry
->just_syms_flag
)
1015 bfd_link_just_syms (sec
, &link_info
);
1019 flags
= bfd_get_section_flags (abfd
, sec
);
1021 if ((flags
& SEC_LINK_ONCE
) == 0)
1024 /* FIXME: When doing a relocatable link, we may have trouble
1025 copying relocations in other sections that refer to local symbols
1026 in the section being discarded. Those relocations will have to
1027 be converted somehow; as of this writing I'm not sure that any of
1028 the backends handle that correctly.
1030 It is tempting to instead not discard link once sections when
1031 doing a relocatable link (technically, they should be discarded
1032 whenever we are building constructors). However, that fails,
1033 because the linker winds up combining all the link once sections
1034 into a single large link once section, which defeats the purpose
1035 of having link once sections in the first place.
1037 Also, not merging link once sections in a relocatable link
1038 causes trouble for MIPS ELF, which relies on link once semantics
1039 to handle the .reginfo section correctly. */
1041 name
= bfd_get_section_name (abfd
, sec
);
1043 already_linked_list
=
1044 ((struct already_linked_hash_entry
*)
1045 bfd_hash_lookup (&already_linked_table
, name
, TRUE
, FALSE
));
1047 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
1049 if (sec
->comdat
== NULL
1050 || l
->sec
->comdat
== NULL
1051 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
1053 /* The section has already been linked. See if we should
1055 switch (flags
& SEC_LINK_DUPLICATES
)
1060 case SEC_LINK_DUPLICATES_DISCARD
:
1063 case SEC_LINK_DUPLICATES_ONE_ONLY
:
1064 if (sec
->comdat
== NULL
)
1065 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
1068 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
1069 abfd
, name
, sec
->comdat
->name
);
1072 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
1073 /* FIXME: We should really dig out the contents of both
1074 sections and memcmp them. The COFF/PE spec says that
1075 the Microsoft linker does not implement this
1076 correctly, so I'm not going to bother doing it
1079 case SEC_LINK_DUPLICATES_SAME_SIZE
:
1080 if (bfd_section_size (abfd
, sec
)
1081 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1082 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1087 /* Set the output_section field so that lang_add_section
1088 does not create a lang_input_section structure for this
1090 sec
->output_section
= bfd_abs_section_ptr
;
1092 if (flags
& SEC_GROUP
)
1093 bfd_discard_group (abfd
, sec
);
1099 /* This is the first section with this name. Record it. Allocate
1100 the memory from the same obstack as the hash table is kept in. */
1102 l
= ((struct already_linked
*)
1103 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1106 l
->next
= already_linked_list
->entry
;
1107 already_linked_list
->entry
= l
;
1110 /* Support routines for the hash table used by section_already_linked,
1111 initialize the table, fill in an entry and remove the table. */
1113 static struct bfd_hash_entry
*
1114 already_linked_newfunc (entry
, table
, string
)
1115 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1116 struct bfd_hash_table
*table
;
1117 const char *string ATTRIBUTE_UNUSED
;
1119 struct already_linked_hash_entry
*ret
=
1120 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1124 return (struct bfd_hash_entry
*) ret
;
1128 already_linked_table_init ()
1130 if (! bfd_hash_table_init_n (&already_linked_table
,
1131 already_linked_newfunc
,
1133 einfo (_("%P%F: Failed to create hash table\n"));
1137 already_linked_table_free ()
1139 bfd_hash_table_free (&already_linked_table
);
1142 /* The wild routines.
1144 These expand statements like *(.text) and foo.o to a list of
1145 explicit actions, like foo.o(.text), bar.o(.text) and
1146 foo.o(.text, .data). */
1148 /* Return TRUE if the PATTERN argument is a wildcard pattern.
1149 Although backslashes are treated specially if a pattern contains
1150 wildcards, we do not consider the mere presence of a backslash to
1151 be enough to cause the pattern to be treated as a wildcard.
1152 That lets us handle DOS filenames more naturally. */
1156 const char *pattern
;
1160 for (s
= pattern
; *s
!= '\0'; ++s
)
1168 /* Add SECTION to the output section OUTPUT. Do this by creating a
1169 lang_input_section statement which is placed at PTR. FILE is the
1170 input file which holds SECTION. */
1173 lang_add_section (ptr
, section
, output
, file
)
1174 lang_statement_list_type
*ptr
;
1176 lang_output_section_statement_type
*output
;
1177 lang_input_statement_type
*file
;
1180 bfd_boolean discard
;
1182 flags
= bfd_get_section_flags (section
->owner
, section
);
1186 /* Discard sections marked with SEC_EXCLUDE if we are doing a final
1187 link. Discard debugging sections marked with SEC_EXCLUDE on a
1188 relocatable link too. */
1189 if ((flags
& SEC_EXCLUDE
) != 0
1190 && ((flags
& SEC_DEBUGGING
) != 0 || !link_info
.relocateable
))
1193 /* Discard input sections which are assigned to a section named
1194 DISCARD_SECTION_NAME. */
1195 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1198 /* Discard debugging sections if we are stripping debugging
1200 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1201 && (flags
& SEC_DEBUGGING
) != 0)
1206 if (section
->output_section
== NULL
)
1208 /* This prevents future calls from assigning this section. */
1209 section
->output_section
= bfd_abs_section_ptr
;
1214 if (section
->output_section
== NULL
)
1217 lang_input_section_type
*new;
1220 if (output
->bfd_section
== NULL
)
1223 first
= ! output
->bfd_section
->linker_has_input
;
1224 output
->bfd_section
->linker_has_input
= 1;
1226 /* Add a section reference to the list. */
1227 new = new_stat (lang_input_section
, ptr
);
1229 new->section
= section
;
1231 section
->output_section
= output
->bfd_section
;
1233 flags
= section
->flags
;
1235 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1236 to an output section, because we want to be able to include a
1237 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1238 section (I don't know why we want to do this, but we do).
1239 build_link_order in ldwrite.c handles this case by turning
1240 the embedded SEC_NEVER_LOAD section into a fill. */
1242 flags
&= ~ SEC_NEVER_LOAD
;
1244 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1245 already been processed. One reason to do this is that on pe
1246 format targets, .text$foo sections go into .text and it's odd
1247 to see .text with SEC_LINK_ONCE set. */
1249 if (! link_info
.relocateable
)
1250 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1252 /* If this is not the first input section, and the SEC_READONLY
1253 flag is not currently set, then don't set it just because the
1254 input section has it set. */
1256 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1257 flags
&= ~ SEC_READONLY
;
1259 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1261 && ((section
->output_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1262 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1263 || ((flags
& SEC_MERGE
)
1264 && section
->output_section
->entsize
!= section
->entsize
)))
1266 section
->output_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1267 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1270 /* For now make .tbss normal section. */
1271 if ((flags
& SEC_THREAD_LOCAL
) && ! link_info
.relocateable
)
1274 section
->output_section
->flags
|= flags
;
1276 if (flags
& SEC_MERGE
)
1277 section
->output_section
->entsize
= section
->entsize
;
1279 /* If SEC_READONLY is not set in the input section, then clear
1280 it from the output section. */
1281 if ((section
->flags
& SEC_READONLY
) == 0)
1282 section
->output_section
->flags
&= ~SEC_READONLY
;
1284 switch (output
->sectype
)
1286 case normal_section
:
1291 case overlay_section
:
1292 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1294 case noload_section
:
1295 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1296 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1300 /* Copy over SEC_SMALL_DATA. */
1301 if (section
->flags
& SEC_SMALL_DATA
)
1302 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1304 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1305 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1307 /* If supplied an alignment, then force it. */
1308 if (output
->section_alignment
!= -1)
1309 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1311 if (section
->flags
& SEC_BLOCK
)
1313 section
->output_section
->flags
|= SEC_BLOCK
;
1314 /* FIXME: This value should really be obtained from the bfd... */
1315 output
->block_value
= 128;
1320 /* Handle wildcard sorting. This returns the lang_input_section which
1321 should follow the one we are going to create for SECTION and FILE,
1322 based on the sorting requirements of WILD. It returns NULL if the
1323 new section should just go at the end of the current list. */
1325 static lang_statement_union_type
*
1326 wild_sort (wild
, sec
, file
, section
)
1327 lang_wild_statement_type
*wild
;
1328 struct wildcard_list
*sec
;
1329 lang_input_statement_type
*file
;
1332 const char *section_name
;
1333 lang_statement_union_type
*l
;
1335 if (!wild
->filenames_sorted
&& (sec
== NULL
|| !sec
->spec
.sorted
))
1338 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1339 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
1341 lang_input_section_type
*ls
;
1343 if (l
->header
.type
!= lang_input_section_enum
)
1345 ls
= &l
->input_section
;
1347 /* Sorting by filename takes precedence over sorting by section
1350 if (wild
->filenames_sorted
)
1352 const char *fn
, *ln
;
1356 /* The PE support for the .idata section as generated by
1357 dlltool assumes that files will be sorted by the name of
1358 the archive and then the name of the file within the
1361 if (file
->the_bfd
!= NULL
1362 && bfd_my_archive (file
->the_bfd
) != NULL
)
1364 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1369 fn
= file
->filename
;
1373 if (ls
->ifile
->the_bfd
!= NULL
1374 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1376 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1381 ln
= ls
->ifile
->filename
;
1385 i
= strcmp (fn
, ln
);
1394 fn
= file
->filename
;
1396 ln
= ls
->ifile
->filename
;
1398 i
= strcmp (fn
, ln
);
1406 /* Here either the files are not sorted by name, or we are
1407 looking at the sections for this file. */
1409 if (sec
!= NULL
&& sec
->spec
.sorted
)
1411 if (strcmp (section_name
,
1412 bfd_get_section_name (ls
->ifile
->the_bfd
,
1422 /* Expand a wild statement for a particular FILE. SECTION may be
1423 NULL, in which case it is a wild card. */
1426 output_section_callback (ptr
, sec
, section
, file
, output
)
1427 lang_wild_statement_type
*ptr
;
1428 struct wildcard_list
*sec
;
1430 lang_input_statement_type
*file
;
1433 lang_statement_union_type
*before
;
1435 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1436 if (unique_section_p (bfd_get_section_name (file
->the_bfd
, section
)))
1439 /* If the wild pattern was marked KEEP, the member sections
1440 should be as well. */
1441 if (ptr
->keep_sections
)
1442 section
->flags
|= SEC_KEEP
;
1444 before
= wild_sort (ptr
, sec
, file
, section
);
1446 /* Here BEFORE points to the lang_input_section which
1447 should follow the one we are about to add. If BEFORE
1448 is NULL, then the section should just go at the end
1449 of the current list. */
1452 lang_add_section (&ptr
->children
, section
,
1453 (lang_output_section_statement_type
*) output
,
1457 lang_statement_list_type list
;
1458 lang_statement_union_type
**pp
;
1460 lang_list_init (&list
);
1461 lang_add_section (&list
, section
,
1462 (lang_output_section_statement_type
*) output
,
1465 /* If we are discarding the section, LIST.HEAD will
1467 if (list
.head
!= NULL
)
1469 ASSERT (list
.head
->header
.next
== NULL
);
1471 for (pp
= &ptr
->children
.head
;
1473 pp
= &(*pp
)->header
.next
)
1474 ASSERT (*pp
!= NULL
);
1476 list
.head
->header
.next
= *pp
;
1482 /* This is passed a file name which must have been seen already and
1483 added to the statement tree. We will see if it has been opened
1484 already and had its symbols read. If not then we'll read it. */
1486 static lang_input_statement_type
*
1490 lang_input_statement_type
*search
;
1492 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1493 search
!= (lang_input_statement_type
*) NULL
;
1494 search
= (lang_input_statement_type
*) search
->next_real_file
)
1496 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1498 if (search
->filename
!= (char *) NULL
1499 && name
!= (char *) NULL
1500 && strcmp (search
->filename
, name
) == 0)
1504 if (search
== (lang_input_statement_type
*) NULL
)
1505 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1508 /* If we have already added this file, or this file is not real
1509 (FIXME: can that ever actually happen?) or the name is NULL
1510 (FIXME: can that ever actually happen?) don't add this file. */
1513 || search
->filename
== (const char *) NULL
)
1516 if (! load_symbols (search
, (lang_statement_list_type
*) NULL
))
1522 /* Get the symbols for an input file. */
1525 load_symbols (entry
, place
)
1526 lang_input_statement_type
*entry
;
1527 lang_statement_list_type
*place
;
1534 ldfile_open_file (entry
);
1536 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1537 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1540 lang_statement_list_type
*hold
;
1541 bfd_boolean bad_load
= TRUE
;
1543 err
= bfd_get_error ();
1545 /* See if the emulation has some special knowledge. */
1546 if (ldemul_unrecognized_file (entry
))
1549 if (err
== bfd_error_file_ambiguously_recognized
)
1553 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1554 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1555 for (p
= matching
; *p
!= NULL
; p
++)
1559 else if (err
!= bfd_error_file_not_recognized
1561 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1565 bfd_close (entry
->the_bfd
);
1566 entry
->the_bfd
= NULL
;
1568 /* Try to interpret the file as a linker script. */
1569 ldfile_open_command_file (entry
->filename
);
1574 ldfile_assumed_script
= TRUE
;
1575 parser_input
= input_script
;
1577 ldfile_assumed_script
= FALSE
;
1584 if (ldemul_recognized_file (entry
))
1587 /* We don't call ldlang_add_file for an archive. Instead, the
1588 add_symbols entry point will call ldlang_add_file, via the
1589 add_archive_element callback, for each element of the archive
1591 switch (bfd_get_format (entry
->the_bfd
))
1597 ldlang_add_file (entry
);
1598 if (trace_files
|| trace_file_tries
)
1599 info_msg ("%I\n", entry
);
1603 if (entry
->whole_archive
)
1606 bfd_boolean loaded
= TRUE
;
1610 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
1615 if (! bfd_check_format (member
, bfd_object
))
1617 einfo (_("%F%B: member %B in archive is not an object\n"),
1618 entry
->the_bfd
, member
);
1622 if (! ((*link_info
.callbacks
->add_archive_element
)
1623 (&link_info
, member
, "--whole-archive")))
1626 if (! bfd_link_add_symbols (member
, &link_info
))
1628 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1633 entry
->loaded
= loaded
;
1639 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1640 entry
->loaded
= TRUE
;
1642 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1644 return entry
->loaded
;
1647 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1648 may be NULL, indicating that it is a wildcard. Separate
1649 lang_input_section statements are created for each part of the
1650 expansion; they are added after the wild statement S. OUTPUT is
1651 the output section. */
1654 wild (s
, target
, output
)
1655 lang_wild_statement_type
*s
;
1656 const char *target ATTRIBUTE_UNUSED
;
1657 lang_output_section_statement_type
*output
;
1659 struct wildcard_list
*sec
;
1661 walk_wild (s
, output_section_callback
, (PTR
) output
);
1663 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
1665 if (default_common_section
!= NULL
)
1667 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
1669 /* Remember the section that common is going to in case we
1670 later get something which doesn't know where to put it. */
1671 default_common_section
= output
;
1676 /* Return TRUE iff target is the sought target. */
1679 get_target (target
, data
)
1680 const bfd_target
*target
;
1683 const char *sought
= (const char *) data
;
1685 return strcmp (target
->name
, sought
) == 0;
1688 /* Like strcpy() but convert to lower case as well. */
1697 while ((c
= *src
++) != 0)
1698 *dest
++ = TOLOWER (c
);
1703 /* Remove the first occurrence of needle (if any) in haystack
1707 strcut (haystack
, needle
)
1711 haystack
= strstr (haystack
, needle
);
1717 for (src
= haystack
+ strlen (needle
); *src
;)
1718 *haystack
++ = *src
++;
1724 /* Compare two target format name strings.
1725 Return a value indicating how "similar" they are. */
1728 name_compare (first
, second
)
1736 copy1
= xmalloc (strlen (first
) + 1);
1737 copy2
= xmalloc (strlen (second
) + 1);
1739 /* Convert the names to lower case. */
1740 stricpy (copy1
, first
);
1741 stricpy (copy2
, second
);
1743 /* Remove and endian strings from the name. */
1744 strcut (copy1
, "big");
1745 strcut (copy1
, "little");
1746 strcut (copy2
, "big");
1747 strcut (copy2
, "little");
1749 /* Return a value based on how many characters match,
1750 starting from the beginning. If both strings are
1751 the same then return 10 * their length. */
1752 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1753 if (copy1
[result
] == 0)
1765 /* Set by closest_target_match() below. */
1766 static const bfd_target
*winner
;
1768 /* Scan all the valid bfd targets looking for one that has the endianness
1769 requirement that was specified on the command line, and is the nearest
1770 match to the original output target. */
1773 closest_target_match (target
, data
)
1774 const bfd_target
*target
;
1777 const bfd_target
*original
= (const bfd_target
*) data
;
1779 if (command_line
.endian
== ENDIAN_BIG
1780 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1783 if (command_line
.endian
== ENDIAN_LITTLE
1784 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1787 /* Must be the same flavour. */
1788 if (target
->flavour
!= original
->flavour
)
1791 /* If we have not found a potential winner yet, then record this one. */
1798 /* Oh dear, we now have two potential candidates for a successful match.
1799 Compare their names and choose the better one. */
1800 if (name_compare (target
->name
, original
->name
)
1801 > name_compare (winner
->name
, original
->name
))
1804 /* Keep on searching until wqe have checked them all. */
1808 /* Return the BFD target format of the first input file. */
1811 get_first_input_target ()
1813 char *target
= NULL
;
1815 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1817 if (s
->header
.type
== lang_input_statement_enum
1820 ldfile_open_file (s
);
1822 if (s
->the_bfd
!= NULL
1823 && bfd_check_format (s
->the_bfd
, bfd_object
))
1825 target
= bfd_get_target (s
->the_bfd
);
1837 lang_get_output_target ()
1841 /* Has the user told us which output format to use? */
1842 if (output_target
!= (char *) NULL
)
1843 return output_target
;
1845 /* No - has the current target been set to something other than
1847 if (current_target
!= default_target
)
1848 return current_target
;
1850 /* No - can we determine the format of the first input file? */
1851 target
= get_first_input_target ();
1855 /* Failed - use the default output target. */
1856 return default_target
;
1859 /* Open the output file. */
1867 output_target
= lang_get_output_target ();
1869 /* Has the user requested a particular endianness on the command
1871 if (command_line
.endian
!= ENDIAN_UNSET
)
1873 const bfd_target
*target
;
1874 enum bfd_endian desired_endian
;
1876 /* Get the chosen target. */
1877 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1879 /* If the target is not supported, we cannot do anything. */
1882 if (command_line
.endian
== ENDIAN_BIG
)
1883 desired_endian
= BFD_ENDIAN_BIG
;
1885 desired_endian
= BFD_ENDIAN_LITTLE
;
1887 /* See if the target has the wrong endianness. This should
1888 not happen if the linker script has provided big and
1889 little endian alternatives, but some scrips don't do
1891 if (target
->byteorder
!= desired_endian
)
1893 /* If it does, then see if the target provides
1894 an alternative with the correct endianness. */
1895 if (target
->alternative_target
!= NULL
1896 && (target
->alternative_target
->byteorder
== desired_endian
))
1897 output_target
= target
->alternative_target
->name
;
1900 /* Try to find a target as similar as possible to
1901 the default target, but which has the desired
1902 endian characteristic. */
1903 (void) bfd_search_for_target (closest_target_match
,
1906 /* Oh dear - we could not find any targets that
1907 satisfy our requirements. */
1909 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1911 output_target
= winner
->name
;
1917 output
= bfd_openw (name
, output_target
);
1919 if (output
== (bfd
*) NULL
)
1921 if (bfd_get_error () == bfd_error_invalid_target
)
1922 einfo (_("%P%F: target %s not found\n"), output_target
);
1924 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1927 delete_output_file_on_failure
= TRUE
;
1930 output
->flags
|= D_PAGED
;
1933 if (! bfd_set_format (output
, bfd_object
))
1934 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1935 if (! bfd_set_arch_mach (output
,
1936 ldfile_output_architecture
,
1937 ldfile_output_machine
))
1938 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1940 link_info
.hash
= bfd_link_hash_table_create (output
);
1941 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1942 einfo (_("%P%F: can not create link hash table: %E\n"));
1944 bfd_set_gp_size (output
, g_switch_value
);
1949 ldlang_open_output (statement
)
1950 lang_statement_union_type
*statement
;
1952 switch (statement
->header
.type
)
1954 case lang_output_statement_enum
:
1955 ASSERT (output_bfd
== (bfd
*) NULL
);
1956 output_bfd
= open_output (statement
->output_statement
.name
);
1957 ldemul_set_output_arch ();
1958 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1959 output_bfd
->flags
|= D_PAGED
;
1961 output_bfd
->flags
&= ~D_PAGED
;
1962 if (config
.text_read_only
)
1963 output_bfd
->flags
|= WP_TEXT
;
1965 output_bfd
->flags
&= ~WP_TEXT
;
1966 if (link_info
.traditional_format
)
1967 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1969 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1972 case lang_target_statement_enum
:
1973 current_target
= statement
->target_statement
.target
;
1980 /* Open all the input files. */
1983 open_input_bfds (s
, force
)
1984 lang_statement_union_type
*s
;
1987 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
1989 switch (s
->header
.type
)
1991 case lang_constructors_statement_enum
:
1992 open_input_bfds (constructor_list
.head
, force
);
1994 case lang_output_section_statement_enum
:
1995 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1997 case lang_wild_statement_enum
:
1998 /* Maybe we should load the file's symbols. */
1999 if (s
->wild_statement
.filename
2000 && ! wildcardp (s
->wild_statement
.filename
))
2001 (void) lookup_name (s
->wild_statement
.filename
);
2002 open_input_bfds (s
->wild_statement
.children
.head
, force
);
2004 case lang_group_statement_enum
:
2006 struct bfd_link_hash_entry
*undefs
;
2008 /* We must continually search the entries in the group
2009 until no new symbols are added to the list of undefined
2014 undefs
= link_info
.hash
->undefs_tail
;
2015 open_input_bfds (s
->group_statement
.children
.head
, TRUE
);
2017 while (undefs
!= link_info
.hash
->undefs_tail
);
2020 case lang_target_statement_enum
:
2021 current_target
= s
->target_statement
.target
;
2023 case lang_input_statement_enum
:
2024 if (s
->input_statement
.real
)
2026 lang_statement_list_type add
;
2028 s
->input_statement
.target
= current_target
;
2030 /* If we are being called from within a group, and this
2031 is an archive which has already been searched, then
2032 force it to be researched unless the whole archive
2033 has been loaded already. */
2035 && !s
->input_statement
.whole_archive
2036 && s
->input_statement
.loaded
2037 && bfd_check_format (s
->input_statement
.the_bfd
,
2039 s
->input_statement
.loaded
= FALSE
;
2041 lang_list_init (&add
);
2043 if (! load_symbols (&s
->input_statement
, &add
))
2044 config
.make_executable
= FALSE
;
2046 if (add
.head
!= NULL
)
2048 *add
.tail
= s
->header
.next
;
2049 s
->header
.next
= add
.head
;
2059 /* If there are [COMMONS] statements, put a wild one into the bss
2063 lang_reasonable_defaults ()
2066 lang_output_section_statement_lookup (".text");
2067 lang_output_section_statement_lookup (".data");
2069 default_common_section
= lang_output_section_statement_lookup (".bss");
2071 if (!placed_commons
)
2073 lang_wild_statement_type
*new =
2074 new_stat (lang_wild_statement
,
2075 &default_common_section
->children
);
2077 new->section_name
= "COMMON";
2078 new->filename
= (char *) NULL
;
2079 lang_list_init (&new->children
);
2084 /* Add the supplied name to the symbol table as an undefined reference.
2085 This is a two step process as the symbol table doesn't even exist at
2086 the time the ld command line is processed. First we put the name
2087 on a list, then, once the output file has been opened, transfer the
2088 name to the symbol table. */
2090 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
2092 #define ldlang_undef_chain_list_head entry_symbol.next
2095 ldlang_add_undef (name
)
2096 const char *const name
;
2098 ldlang_undef_chain_list_type
*new =
2099 ((ldlang_undef_chain_list_type
*)
2100 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
2102 new->next
= ldlang_undef_chain_list_head
;
2103 ldlang_undef_chain_list_head
= new;
2105 new->name
= xstrdup (name
);
2107 if (output_bfd
!= NULL
)
2108 insert_undefined (new->name
);
2111 /* Insert NAME as undefined in the symbol table. */
2114 insert_undefined (name
)
2117 struct bfd_link_hash_entry
*h
;
2119 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
2120 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2121 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2122 if (h
->type
== bfd_link_hash_new
)
2124 h
->type
= bfd_link_hash_undefined
;
2125 h
->u
.undef
.abfd
= NULL
;
2126 bfd_link_add_undef (link_info
.hash
, h
);
2130 /* Run through the list of undefineds created above and place them
2131 into the linker hash table as undefined symbols belonging to the
2135 lang_place_undefineds ()
2137 ldlang_undef_chain_list_type
*ptr
;
2139 for (ptr
= ldlang_undef_chain_list_head
;
2140 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
2143 insert_undefined (ptr
->name
);
2147 /* Open input files and attach to output sections. */
2150 map_input_to_output_sections (s
, target
, output_section_statement
)
2151 lang_statement_union_type
*s
;
2153 lang_output_section_statement_type
*output_section_statement
;
2155 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2157 switch (s
->header
.type
)
2159 case lang_wild_statement_enum
:
2160 wild (&s
->wild_statement
, target
, output_section_statement
);
2162 case lang_constructors_statement_enum
:
2163 map_input_to_output_sections (constructor_list
.head
,
2165 output_section_statement
);
2167 case lang_output_section_statement_enum
:
2168 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2170 &s
->output_section_statement
);
2172 case lang_output_statement_enum
:
2174 case lang_target_statement_enum
:
2175 target
= s
->target_statement
.target
;
2177 case lang_group_statement_enum
:
2178 map_input_to_output_sections (s
->group_statement
.children
.head
,
2180 output_section_statement
);
2182 case lang_fill_statement_enum
:
2183 case lang_input_section_enum
:
2184 case lang_object_symbols_statement_enum
:
2185 case lang_data_statement_enum
:
2186 case lang_reloc_statement_enum
:
2187 case lang_padding_statement_enum
:
2188 case lang_input_statement_enum
:
2189 if (output_section_statement
!= NULL
2190 && output_section_statement
->bfd_section
== NULL
)
2191 init_os (output_section_statement
);
2193 case lang_assignment_statement_enum
:
2194 if (output_section_statement
!= NULL
2195 && output_section_statement
->bfd_section
== NULL
)
2196 init_os (output_section_statement
);
2198 /* Make sure that any sections mentioned in the assignment
2200 exp_init_os (s
->assignment_statement
.exp
);
2202 case lang_afile_asection_pair_statement_enum
:
2205 case lang_address_statement_enum
:
2206 /* Mark the specified section with the supplied address. */
2208 lang_output_section_statement_type
*os
=
2209 lang_output_section_statement_lookup
2210 (s
->address_statement
.section_name
);
2212 if (os
->bfd_section
== NULL
)
2214 os
->addr_tree
= s
->address_statement
.address
;
2221 /* An output section might have been removed after its statement was
2222 added. For example, ldemul_before_allocation can remove dynamic
2223 sections if they turn out to be not needed. Clean them up here. */
2226 strip_excluded_output_sections ()
2228 lang_statement_union_type
*u
;
2230 for (u
= lang_output_section_statement
.head
;
2232 u
= u
->output_section_statement
.next
)
2234 lang_output_section_statement_type
*os
;
2237 os
= &u
->output_section_statement
;
2238 s
= os
->bfd_section
;
2239 if (s
!= NULL
&& (s
->flags
& SEC_EXCLUDE
) != 0)
2243 os
->bfd_section
= NULL
;
2245 for (p
= &output_bfd
->sections
; *p
; p
= &(*p
)->next
)
2248 bfd_section_list_remove (output_bfd
, p
);
2249 output_bfd
->section_count
--;
2257 print_output_section_statement (output_section_statement
)
2258 lang_output_section_statement_type
*output_section_statement
;
2260 asection
*section
= output_section_statement
->bfd_section
;
2263 if (output_section_statement
!= abs_output_section
)
2265 minfo ("\n%s", output_section_statement
->name
);
2267 if (section
!= NULL
)
2269 print_dot
= section
->vma
;
2271 len
= strlen (output_section_statement
->name
);
2272 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2277 while (len
< SECTION_NAME_MAP_LENGTH
)
2283 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2285 if (output_section_statement
->load_base
!= NULL
)
2289 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2290 "load base", lang_final_phase_enum
);
2291 minfo (_(" load address 0x%V"), addr
);
2298 print_statement_list (output_section_statement
->children
.head
,
2299 output_section_statement
);
2303 print_assignment (assignment
, output_section
)
2304 lang_assignment_statement_type
*assignment
;
2305 lang_output_section_statement_type
*output_section
;
2308 etree_value_type result
;
2310 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2313 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2314 lang_final_phase_enum
, print_dot
, &print_dot
);
2320 value
= result
.value
+ result
.section
->bfd_section
->vma
;
2321 dst
= assignment
->exp
->assign
.dst
;
2323 minfo ("0x%V", value
);
2324 if (dst
[0] == '.' && dst
[1] == 0)
2337 exp_print_tree (assignment
->exp
);
2343 print_input_statement (statm
)
2344 lang_input_statement_type
*statm
;
2346 if (statm
->filename
!= (char *) NULL
)
2348 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2352 /* Print all symbols defined in a particular section. This is called
2353 via bfd_link_hash_traverse. */
2356 print_one_symbol (hash_entry
, ptr
)
2357 struct bfd_link_hash_entry
*hash_entry
;
2360 asection
*sec
= (asection
*) ptr
;
2362 if ((hash_entry
->type
== bfd_link_hash_defined
2363 || hash_entry
->type
== bfd_link_hash_defweak
)
2364 && sec
== hash_entry
->u
.def
.section
)
2368 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2371 (hash_entry
->u
.def
.value
2372 + hash_entry
->u
.def
.section
->output_offset
2373 + hash_entry
->u
.def
.section
->output_section
->vma
));
2375 minfo (" %T\n", hash_entry
->root
.string
);
2381 /* Print information about an input section to the map file. */
2384 print_input_section (in
)
2385 lang_input_section_type
*in
;
2387 asection
*i
= in
->section
;
2388 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2389 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2390 ldfile_output_machine
);
2395 minfo ("%s", i
->name
);
2397 if (i
->output_section
!= NULL
)
2401 len
= 1 + strlen (i
->name
);
2402 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2407 while (len
< SECTION_NAME_MAP_LENGTH
)
2413 minfo ("0x%V %W %B\n",
2414 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2417 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2419 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2431 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2434 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2436 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2442 print_fill_statement (fill
)
2443 lang_fill_statement_type
*fill
;
2447 fputs (" FILL mask 0x", config
.map_file
);
2448 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
2449 fprintf (config
.map_file
, "%02x", *p
);
2450 fputs ("\n", config
.map_file
);
2454 print_data_statement (data
)
2455 lang_data_statement_type
*data
;
2461 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2462 ldfile_output_machine
);
2464 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2467 addr
= data
->output_vma
;
2468 if (data
->output_section
!= NULL
)
2469 addr
+= data
->output_section
->vma
;
2497 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2499 if (data
->exp
->type
.node_class
!= etree_value
)
2502 exp_print_tree (data
->exp
);
2507 print_dot
= addr
+ size
/ opb
;
2511 /* Print an address statement. These are generated by options like
2515 print_address_statement (address
)
2516 lang_address_statement_type
*address
;
2518 minfo (_("Address of section %s set to "), address
->section_name
);
2519 exp_print_tree (address
->address
);
2523 /* Print a reloc statement. */
2526 print_reloc_statement (reloc
)
2527 lang_reloc_statement_type
*reloc
;
2532 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2533 ldfile_output_machine
);
2535 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2538 addr
= reloc
->output_vma
;
2539 if (reloc
->output_section
!= NULL
)
2540 addr
+= reloc
->output_section
->vma
;
2542 size
= bfd_get_reloc_size (reloc
->howto
);
2544 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2546 if (reloc
->name
!= NULL
)
2547 minfo ("%s+", reloc
->name
);
2549 minfo ("%s+", reloc
->section
->name
);
2551 exp_print_tree (reloc
->addend_exp
);
2555 print_dot
= addr
+ size
/ opb
;
2559 print_padding_statement (s
)
2560 lang_padding_statement_type
*s
;
2564 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2565 ldfile_output_machine
);
2569 len
= sizeof " *fill*" - 1;
2570 while (len
< SECTION_NAME_MAP_LENGTH
)
2576 addr
= s
->output_offset
;
2577 if (s
->output_section
!= NULL
)
2578 addr
+= s
->output_section
->vma
;
2579 minfo ("0x%V %W ", addr
, s
->size
);
2581 if (s
->fill
->size
!= 0)
2585 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
2586 fprintf (config
.map_file
, "%02x", *p
);
2591 print_dot
= addr
+ s
->size
/ opb
;
2595 print_wild_statement (w
, os
)
2596 lang_wild_statement_type
*w
;
2597 lang_output_section_statement_type
*os
;
2599 struct wildcard_list
*sec
;
2603 if (w
->filenames_sorted
)
2605 if (w
->filename
!= NULL
)
2606 minfo ("%s", w
->filename
);
2609 if (w
->filenames_sorted
)
2613 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
2615 if (sec
->spec
.sorted
)
2617 if (sec
->spec
.exclude_name_list
!= NULL
)
2620 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
2621 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
2622 minfo (" %s", tmp
->name
);
2625 if (sec
->spec
.name
!= NULL
)
2626 minfo ("%s", sec
->spec
.name
);
2629 if (sec
->spec
.sorted
)
2638 print_statement_list (w
->children
.head
, os
);
2641 /* Print a group statement. */
2645 lang_group_statement_type
*s
;
2646 lang_output_section_statement_type
*os
;
2648 fprintf (config
.map_file
, "START GROUP\n");
2649 print_statement_list (s
->children
.head
, os
);
2650 fprintf (config
.map_file
, "END GROUP\n");
2653 /* Print the list of statements in S.
2654 This can be called for any statement type. */
2657 print_statement_list (s
, os
)
2658 lang_statement_union_type
*s
;
2659 lang_output_section_statement_type
*os
;
2663 print_statement (s
, os
);
2668 /* Print the first statement in statement list S.
2669 This can be called for any statement type. */
2672 print_statement (s
, os
)
2673 lang_statement_union_type
*s
;
2674 lang_output_section_statement_type
*os
;
2676 switch (s
->header
.type
)
2679 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2682 case lang_constructors_statement_enum
:
2683 if (constructor_list
.head
!= NULL
)
2685 if (constructors_sorted
)
2686 minfo (" SORT (CONSTRUCTORS)\n");
2688 minfo (" CONSTRUCTORS\n");
2689 print_statement_list (constructor_list
.head
, os
);
2692 case lang_wild_statement_enum
:
2693 print_wild_statement (&s
->wild_statement
, os
);
2695 case lang_address_statement_enum
:
2696 print_address_statement (&s
->address_statement
);
2698 case lang_object_symbols_statement_enum
:
2699 minfo (" CREATE_OBJECT_SYMBOLS\n");
2701 case lang_fill_statement_enum
:
2702 print_fill_statement (&s
->fill_statement
);
2704 case lang_data_statement_enum
:
2705 print_data_statement (&s
->data_statement
);
2707 case lang_reloc_statement_enum
:
2708 print_reloc_statement (&s
->reloc_statement
);
2710 case lang_input_section_enum
:
2711 print_input_section (&s
->input_section
);
2713 case lang_padding_statement_enum
:
2714 print_padding_statement (&s
->padding_statement
);
2716 case lang_output_section_statement_enum
:
2717 print_output_section_statement (&s
->output_section_statement
);
2719 case lang_assignment_statement_enum
:
2720 print_assignment (&s
->assignment_statement
, os
);
2722 case lang_target_statement_enum
:
2723 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2725 case lang_output_statement_enum
:
2726 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2727 if (output_target
!= NULL
)
2728 minfo (" %s", output_target
);
2731 case lang_input_statement_enum
:
2732 print_input_statement (&s
->input_statement
);
2734 case lang_group_statement_enum
:
2735 print_group (&s
->group_statement
, os
);
2737 case lang_afile_asection_pair_statement_enum
:
2746 print_statement_list (statement_list
.head
, abs_output_section
);
2749 /* Print the first N statements in statement list S to STDERR.
2750 If N == 0, nothing is printed.
2751 If N < 0, the entire list is printed.
2752 Intended to be called from GDB. */
2755 dprint_statement (s
, n
)
2756 lang_statement_union_type
*s
;
2759 FILE *map_save
= config
.map_file
;
2761 config
.map_file
= stderr
;
2764 print_statement_list (s
, abs_output_section
);
2767 while (s
&& --n
>= 0)
2769 print_statement (s
, abs_output_section
);
2774 config
.map_file
= map_save
;
2778 insert_pad (ptr
, fill
, alignment_needed
, output_section
, dot
)
2779 lang_statement_union_type
**ptr
;
2781 unsigned int alignment_needed
;
2782 asection
*output_section
;
2785 static fill_type zero_fill
= { 1, { 0 } };
2786 lang_statement_union_type
*pad
;
2788 pad
= ((lang_statement_union_type
*)
2789 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
2790 if (ptr
!= &statement_list
.head
2791 && pad
->header
.type
== lang_padding_statement_enum
2792 && pad
->padding_statement
.output_section
== output_section
)
2794 /* Use the existing pad statement. The above test on output
2795 section is probably redundant, but it doesn't hurt to check. */
2799 /* Make a new padding statement, linked into existing chain. */
2800 pad
= ((lang_statement_union_type
*)
2801 stat_alloc (sizeof (lang_padding_statement_type
)));
2802 pad
->header
.next
= *ptr
;
2804 pad
->header
.type
= lang_padding_statement_enum
;
2805 pad
->padding_statement
.output_section
= output_section
;
2806 if (fill
== (fill_type
*) 0)
2808 pad
->padding_statement
.fill
= fill
;
2810 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
2811 pad
->padding_statement
.size
= alignment_needed
;
2812 output_section
->_raw_size
+= alignment_needed
;
2815 /* Work out how much this section will move the dot point. */
2818 size_input_section (this_ptr
, output_section_statement
, fill
, dot
)
2819 lang_statement_union_type
**this_ptr
;
2820 lang_output_section_statement_type
*output_section_statement
;
2824 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2825 asection
*i
= is
->section
;
2827 if (!is
->ifile
->just_syms_flag
)
2829 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2830 ldfile_output_machine
);
2831 unsigned int alignment_needed
;
2834 /* Align this section first to the input sections requirement,
2835 then to the output section's requirement. If this alignment
2836 is greater than any seen before, then record it too. Perform
2837 the alignment by inserting a magic 'padding' statement. */
2839 if (output_section_statement
->subsection_alignment
!= -1)
2840 i
->alignment_power
= output_section_statement
->subsection_alignment
;
2842 o
= output_section_statement
->bfd_section
;
2843 if (o
->alignment_power
< i
->alignment_power
)
2844 o
->alignment_power
= i
->alignment_power
;
2846 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
2848 if (alignment_needed
!= 0)
2850 insert_pad (this_ptr
, fill
, alignment_needed
* opb
, o
, dot
);
2851 dot
+= alignment_needed
;
2854 /* Remember where in the output section this input section goes. */
2856 i
->output_offset
= dot
- o
->vma
;
2858 /* Mark how big the output section must be to contain this now. */
2859 if (i
->_cooked_size
!= 0)
2860 dot
+= i
->_cooked_size
/ opb
;
2862 dot
+= i
->_raw_size
/ opb
;
2863 o
->_raw_size
= (dot
- o
->vma
) * opb
;
2867 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2873 #define IGNORE_SECTION(bfd, s) \
2874 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2875 != (SEC_ALLOC | SEC_LOAD)) \
2876 || bfd_section_size (bfd, s) == 0)
2878 /* Check to see if any allocated sections overlap with other allocated
2879 sections. This can happen when the linker script specifically specifies
2880 the output section addresses of the two sections. */
2883 lang_check_section_addresses ()
2886 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2888 /* Scan all sections in the output list. */
2889 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2893 /* Ignore sections which are not loaded or which have no contents. */
2894 if (IGNORE_SECTION (output_bfd
, s
))
2897 /* Once we reach section 's' stop our seach. This prevents two
2898 warning messages from being produced, one for 'section A overlaps
2899 section B' and one for 'section B overlaps section A'. */
2900 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2907 /* Only consider loadable sections with real contents. */
2908 if (IGNORE_SECTION (output_bfd
, os
))
2911 /* We must check the sections' LMA addresses not their
2912 VMA addresses because overlay sections can have
2913 overlapping VMAs but they must have distinct LMAs. */
2914 s_start
= bfd_section_lma (output_bfd
, s
);
2915 os_start
= bfd_section_lma (output_bfd
, os
);
2916 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2917 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2919 /* Look for an overlap. */
2920 if ((s_end
< os_start
) || (s_start
> os_end
))
2924 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2925 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2927 /* Once we have found one overlap for this section,
2928 stop looking for others. */
2934 /* Make sure the new address is within the region. We explicitly permit the
2935 current address to be at the exact end of the region when the address is
2936 non-zero, in case the region is at the end of addressable memory and the
2937 calculation wraps around. */
2940 os_region_check (os
, region
, tree
, base
)
2941 lang_output_section_statement_type
*os
;
2942 struct memory_region_struct
*region
;
2946 if ((region
->current
< region
->origin
2947 || (region
->current
- region
->origin
> region
->length
))
2948 && ((region
->current
!= region
->origin
+ region
->length
)
2951 if (tree
!= (etree_type
*) NULL
)
2953 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2955 os
->bfd_section
->owner
,
2956 os
->bfd_section
->name
,
2961 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2963 os
->bfd_section
->owner
,
2964 os
->bfd_section
->name
);
2966 /* Reset the region pointer. */
2967 region
->current
= region
->origin
;
2971 /* Set the sizes for all the output sections. */
2974 lang_size_sections_1 (s
, output_section_statement
, prev
, fill
, dot
, relax
,
2976 lang_statement_union_type
*s
;
2977 lang_output_section_statement_type
*output_section_statement
;
2978 lang_statement_union_type
**prev
;
2982 bfd_boolean check_regions
;
2984 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2985 ldfile_output_machine
);
2987 /* Size up the sections from their constituent parts. */
2988 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2990 switch (s
->header
.type
)
2992 case lang_output_section_statement_enum
:
2995 lang_output_section_statement_type
*os
;
2997 os
= &s
->output_section_statement
;
2998 if (os
->bfd_section
== NULL
)
2999 /* This section was never actually created. */
3002 /* If this is a COFF shared library section, use the size and
3003 address from the input section. FIXME: This is COFF
3004 specific; it would be cleaner if there were some other way
3005 to do this, but nothing simple comes to mind. */
3006 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
3010 if (os
->children
.head
== NULL
3011 || os
->children
.head
->header
.next
!= NULL
3012 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
3013 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
3016 input
= os
->children
.head
->input_section
.section
;
3017 bfd_set_section_vma (os
->bfd_section
->owner
,
3019 bfd_section_vma (input
->owner
, input
));
3020 os
->bfd_section
->_raw_size
= input
->_raw_size
;
3024 if (bfd_is_abs_section (os
->bfd_section
))
3026 /* No matter what happens, an abs section starts at zero. */
3027 ASSERT (os
->bfd_section
->vma
== 0);
3031 if (os
->addr_tree
== (etree_type
*) NULL
)
3033 /* No address specified for this section, get one
3034 from the region specification. */
3035 if (os
->region
== (lang_memory_region_type
*) NULL
3036 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3037 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
3038 && os
->region
->name
[0] == '*'
3039 && strcmp (os
->region
->name
, "*default*") == 0))
3041 os
->region
= lang_memory_default (os
->bfd_section
);
3044 /* If a loadable section is using the default memory
3045 region, and some non default memory regions were
3046 defined, issue a warning. */
3047 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3048 & (SEC_ALLOC
| SEC_LOAD
)) != 0
3049 && (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3050 & SEC_NEVER_LOAD
) == 0
3051 && ! link_info
.relocateable
3053 && strcmp (os
->region
->name
, "*default*") == 0
3054 && lang_memory_region_list
!= NULL
3055 && (strcmp (lang_memory_region_list
->name
,
3057 || lang_memory_region_list
->next
!= NULL
))
3058 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
3059 bfd_get_section_name (output_bfd
,
3062 dot
= os
->region
->current
;
3064 if (os
->section_alignment
== -1)
3069 dot
= align_power (dot
,
3070 os
->bfd_section
->alignment_power
);
3072 if (dot
!= olddot
&& config
.warn_section_align
)
3073 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
3074 os
->name
, (unsigned int) (dot
- olddot
));
3081 r
= exp_fold_tree (os
->addr_tree
,
3083 lang_allocating_phase_enum
,
3086 einfo (_("%F%S: non constant address expression for section %s\n"),
3089 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
3092 /* The section starts here.
3093 First, align to what the section needs. */
3095 if (os
->section_alignment
!= -1)
3096 dot
= align_power (dot
, os
->section_alignment
);
3098 bfd_set_section_vma (0, os
->bfd_section
, dot
);
3100 os
->bfd_section
->output_offset
= 0;
3103 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
3104 os
->fill
, dot
, relax
, check_regions
);
3106 /* Put the section within the requested block size, or
3107 align at the block boundary. */
3108 after
= align_n (os
->bfd_section
->vma
3109 + os
->bfd_section
->_raw_size
/ opb
,
3110 (bfd_vma
) os
->block_value
);
3112 if (bfd_is_abs_section (os
->bfd_section
))
3113 ASSERT (after
== os
->bfd_section
->vma
);
3114 else if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) == 0
3115 && (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
)
3116 && ! link_info
.relocateable
)
3117 os
->bfd_section
->_raw_size
= 0;
3119 os
->bfd_section
->_raw_size
=
3120 (after
- os
->bfd_section
->vma
) * opb
;
3122 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3123 os
->processed
= TRUE
;
3125 if (os
->update_dot_tree
!= 0)
3126 exp_fold_tree (os
->update_dot_tree
, abs_output_section
,
3127 lang_allocating_phase_enum
, dot
, &dot
);
3129 /* Update dot in the region ?
3130 We only do this if the section is going to be allocated,
3131 since unallocated sections do not contribute to the region's
3132 overall size in memory.
3134 If the SEC_NEVER_LOAD bit is not set, it will affect the
3135 addresses of sections after it. We have to update
3137 if (os
->region
!= (lang_memory_region_type
*) NULL
3138 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3139 & SEC_NEVER_LOAD
) == 0
3140 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
3141 & (SEC_ALLOC
| SEC_LOAD
))))
3143 os
->region
->current
= dot
;
3146 /* Make sure the new address is within the region. */
3147 os_region_check (os
, os
->region
, os
->addr_tree
,
3148 os
->bfd_section
->vma
);
3150 /* If there's no load address specified, use the run
3151 region as the load region. */
3152 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
3153 os
->lma_region
= os
->region
;
3155 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
)
3157 /* Set load_base, which will be handled later. */
3158 os
->load_base
= exp_intop (os
->lma_region
->current
);
3159 os
->lma_region
->current
+=
3160 os
->bfd_section
->_raw_size
/ opb
;
3162 os_region_check (os
, os
->lma_region
, NULL
,
3163 os
->bfd_section
->lma
);
3169 case lang_constructors_statement_enum
:
3170 dot
= lang_size_sections_1 (constructor_list
.head
,
3171 output_section_statement
,
3172 &s
->wild_statement
.children
.head
,
3173 fill
, dot
, relax
, check_regions
);
3176 case lang_data_statement_enum
:
3178 unsigned int size
= 0;
3180 s
->data_statement
.output_vma
=
3181 dot
- output_section_statement
->bfd_section
->vma
;
3182 s
->data_statement
.output_section
=
3183 output_section_statement
->bfd_section
;
3185 switch (s
->data_statement
.type
)
3206 output_section_statement
->bfd_section
->_raw_size
+= size
;
3207 /* The output section gets contents, and then we inspect for
3208 any flags set in the input script which override any ALLOC. */
3209 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3210 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3212 output_section_statement
->bfd_section
->flags
|=
3213 SEC_ALLOC
| SEC_LOAD
;
3218 case lang_reloc_statement_enum
:
3222 s
->reloc_statement
.output_vma
=
3223 dot
- output_section_statement
->bfd_section
->vma
;
3224 s
->reloc_statement
.output_section
=
3225 output_section_statement
->bfd_section
;
3226 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3228 output_section_statement
->bfd_section
->_raw_size
+= size
;
3232 case lang_wild_statement_enum
:
3234 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
3235 output_section_statement
,
3236 &s
->wild_statement
.children
.head
,
3237 fill
, dot
, relax
, check_regions
);
3241 case lang_object_symbols_statement_enum
:
3242 link_info
.create_object_symbols_section
=
3243 output_section_statement
->bfd_section
;
3245 case lang_output_statement_enum
:
3246 case lang_target_statement_enum
:
3248 case lang_input_section_enum
:
3252 i
= (*prev
)->input_section
.section
;
3255 if (i
->_cooked_size
== 0)
3256 i
->_cooked_size
= i
->_raw_size
;
3262 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3263 einfo (_("%P%F: can't relax section: %E\n"));
3267 dot
= size_input_section (prev
, output_section_statement
,
3268 output_section_statement
->fill
, dot
);
3271 case lang_input_statement_enum
:
3273 case lang_fill_statement_enum
:
3274 s
->fill_statement
.output_section
=
3275 output_section_statement
->bfd_section
;
3277 fill
= s
->fill_statement
.fill
;
3279 case lang_assignment_statement_enum
:
3281 bfd_vma newdot
= dot
;
3283 exp_fold_tree (s
->assignment_statement
.exp
,
3284 output_section_statement
,
3285 lang_allocating_phase_enum
,
3291 if (output_section_statement
== abs_output_section
)
3293 /* If we don't have an output section, then just adjust
3294 the default memory address. */
3295 lang_memory_region_lookup ("*default*")->current
= newdot
;
3299 /* Insert a pad after this statement. We can't
3300 put the pad before when relaxing, in case the
3301 assignment references dot. */
3302 insert_pad (&s
->header
.next
, fill
, (newdot
- dot
) * opb
,
3303 output_section_statement
->bfd_section
, dot
);
3305 /* Don't neuter the pad below when relaxing. */
3314 case lang_padding_statement_enum
:
3315 /* If this is the first time lang_size_sections is called,
3316 we won't have any padding statements. If this is the
3317 second or later passes when relaxing, we should allow
3318 padding to shrink. If padding is needed on this pass, it
3319 will be added back in. */
3320 s
->padding_statement
.size
= 0;
3322 /* Make sure output_offset is valid. If relaxation shrinks
3323 the section and this pad isn't needed, it's possible to
3324 have output_offset larger than the final size of the
3325 section. bfd_set_section_contents will complain even for
3326 a pad size of zero. */
3327 s
->padding_statement
.output_offset
3328 = dot
- output_section_statement
->bfd_section
->vma
;
3331 case lang_group_statement_enum
:
3332 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
3333 output_section_statement
,
3334 &s
->group_statement
.children
.head
,
3335 fill
, dot
, relax
, check_regions
);
3342 /* We can only get here when relaxing is turned on. */
3343 case lang_address_statement_enum
:
3346 prev
= &s
->header
.next
;
3352 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
,
3354 lang_statement_union_type
*s
;
3355 lang_output_section_statement_type
*output_section_statement
;
3356 lang_statement_union_type
**prev
;
3360 bfd_boolean check_regions
;
3364 exp_data_seg
.phase
= exp_dataseg_none
;
3365 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
3366 dot
, relax
, check_regions
);
3367 if (exp_data_seg
.phase
== exp_dataseg_end_seen
)
3369 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3370 a page could be saved in the data segment. */
3371 bfd_vma first
, last
;
3373 first
= -exp_data_seg
.base
& (exp_data_seg
.pagesize
- 1);
3374 last
= exp_data_seg
.end
& (exp_data_seg
.pagesize
- 1);
3376 && ((exp_data_seg
.base
& ~(exp_data_seg
.pagesize
- 1))
3377 != (exp_data_seg
.end
& ~(exp_data_seg
.pagesize
- 1)))
3378 && first
+ last
<= exp_data_seg
.pagesize
)
3380 exp_data_seg
.phase
= exp_dataseg_adjust
;
3381 result
= lang_size_sections_1 (s
, output_section_statement
, prev
,
3382 fill
, dot
, relax
, check_regions
);
3390 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3391 lang_statement_union_type
*s
;
3392 lang_output_section_statement_type
*output_section_statement
;
3396 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3397 ldfile_output_machine
);
3399 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
3401 switch (s
->header
.type
)
3403 case lang_constructors_statement_enum
:
3404 dot
= lang_do_assignments (constructor_list
.head
,
3405 output_section_statement
,
3410 case lang_output_section_statement_enum
:
3412 lang_output_section_statement_type
*os
;
3414 os
= &(s
->output_section_statement
);
3415 if (os
->bfd_section
!= NULL
)
3417 dot
= os
->bfd_section
->vma
;
3418 (void) lang_do_assignments (os
->children
.head
, os
,
3420 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3425 /* If nothing has been placed into the output section then
3426 it won't have a bfd_section. */
3427 if (os
->bfd_section
)
3429 os
->bfd_section
->lma
3430 = exp_get_abs_int (os
->load_base
, 0, "load base",
3431 lang_final_phase_enum
);
3436 case lang_wild_statement_enum
:
3438 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3439 output_section_statement
,
3444 case lang_object_symbols_statement_enum
:
3445 case lang_output_statement_enum
:
3446 case lang_target_statement_enum
:
3448 case lang_common_statement_enum
:
3451 case lang_data_statement_enum
:
3453 etree_value_type value
;
3455 value
= exp_fold_tree (s
->data_statement
.exp
,
3457 lang_final_phase_enum
, dot
, &dot
);
3458 s
->data_statement
.value
= value
.value
;
3460 einfo (_("%F%P: invalid data statement\n"));
3464 switch (s
->data_statement
.type
)
3488 case lang_reloc_statement_enum
:
3490 etree_value_type value
;
3492 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3494 lang_final_phase_enum
, dot
, &dot
);
3495 s
->reloc_statement
.addend_value
= value
.value
;
3497 einfo (_("%F%P: invalid reloc statement\n"));
3499 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3502 case lang_input_section_enum
:
3504 asection
*in
= s
->input_section
.section
;
3506 if (in
->_cooked_size
!= 0)
3507 dot
+= in
->_cooked_size
/ opb
;
3509 dot
+= in
->_raw_size
/ opb
;
3513 case lang_input_statement_enum
:
3515 case lang_fill_statement_enum
:
3516 fill
= s
->fill_statement
.fill
;
3518 case lang_assignment_statement_enum
:
3520 exp_fold_tree (s
->assignment_statement
.exp
,
3521 output_section_statement
,
3522 lang_final_phase_enum
,
3528 case lang_padding_statement_enum
:
3529 dot
+= s
->padding_statement
.size
/ opb
;
3532 case lang_group_statement_enum
:
3533 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3534 output_section_statement
,
3542 case lang_address_statement_enum
:
3550 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3551 operator .startof. (section_name), it produces an undefined symbol
3552 .startof.section_name. Similarly, when it sees
3553 .sizeof. (section_name), it produces an undefined symbol
3554 .sizeof.section_name. For all the output sections, we look for
3555 such symbols, and set them to the correct value. */
3562 if (link_info
.relocateable
)
3565 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3567 const char *secname
;
3569 struct bfd_link_hash_entry
*h
;
3571 secname
= bfd_get_section_name (output_bfd
, s
);
3572 buf
= xmalloc (10 + strlen (secname
));
3574 sprintf (buf
, ".startof.%s", secname
);
3575 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
3576 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3578 h
->type
= bfd_link_hash_defined
;
3579 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3580 h
->u
.def
.section
= bfd_abs_section_ptr
;
3583 sprintf (buf
, ".sizeof.%s", secname
);
3584 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
3585 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3589 opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3590 ldfile_output_machine
);
3591 h
->type
= bfd_link_hash_defined
;
3592 if (s
->_cooked_size
!= 0)
3593 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3595 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3596 h
->u
.def
.section
= bfd_abs_section_ptr
;
3606 struct bfd_link_hash_entry
*h
;
3609 if (link_info
.relocateable
|| link_info
.shared
)
3614 if (entry_symbol
.name
== (const char *) NULL
)
3616 /* No entry has been specified. Look for start, but don't warn
3617 if we don't find it. */
3618 entry_symbol
.name
= "start";
3622 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
3623 FALSE
, FALSE
, TRUE
);
3624 if (h
!= (struct bfd_link_hash_entry
*) NULL
3625 && (h
->type
== bfd_link_hash_defined
3626 || h
->type
== bfd_link_hash_defweak
)
3627 && h
->u
.def
.section
->output_section
!= NULL
)
3631 val
= (h
->u
.def
.value
3632 + bfd_get_section_vma (output_bfd
,
3633 h
->u
.def
.section
->output_section
)
3634 + h
->u
.def
.section
->output_offset
);
3635 if (! bfd_set_start_address (output_bfd
, val
))
3636 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
3643 /* We couldn't find the entry symbol. Try parsing it as a
3645 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
3648 if (! bfd_set_start_address (output_bfd
, val
))
3649 einfo (_("%P%F: can't set start address\n"));
3655 /* Can't find the entry symbol, and it's not a number. Use
3656 the first address in the text section. */
3657 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
3658 if (ts
!= (asection
*) NULL
)
3661 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3663 bfd_get_section_vma (output_bfd
, ts
));
3664 if (! bfd_set_start_address (output_bfd
,
3665 bfd_get_section_vma (output_bfd
,
3667 einfo (_("%P%F: can't set start address\n"));
3672 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3679 /* This is a small function used when we want to ignore errors from
3683 #ifdef ANSI_PROTOTYPES
3684 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3686 ignore_bfd_errors (s
)
3687 const char *s ATTRIBUTE_UNUSED
;
3690 /* Don't do anything. */
3693 /* Check that the architecture of all the input files is compatible
3694 with the output file. Also call the backend to let it do any
3695 other checking that is needed. */
3700 lang_statement_union_type
*file
;
3702 const bfd_arch_info_type
*compatible
;
3704 for (file
= file_chain
.head
;
3705 file
!= (lang_statement_union_type
*) NULL
;
3706 file
= file
->input_statement
.next
)
3708 input_bfd
= file
->input_statement
.the_bfd
;
3709 compatible
= bfd_arch_get_compatible (input_bfd
, output_bfd
,
3710 command_line
.accept_unknown_input_arch
);
3712 /* In general it is not possible to perform a relocatable
3713 link between differing object formats when the input
3714 file has relocations, because the relocations in the
3715 input format may not have equivalent representations in
3716 the output format (and besides BFD does not translate
3717 relocs for other link purposes than a final link). */
3718 if ((link_info
.relocateable
|| link_info
.emitrelocations
)
3719 && (compatible
== NULL
3720 || bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
3721 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
3723 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3724 bfd_get_target (input_bfd
), input_bfd
,
3725 bfd_get_target (output_bfd
), output_bfd
);
3726 /* einfo with %F exits. */
3729 if (compatible
== NULL
)
3731 if (command_line
.warn_mismatch
)
3732 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3733 bfd_printable_name (input_bfd
), input_bfd
,
3734 bfd_printable_name (output_bfd
));
3736 else if (bfd_count_sections (input_bfd
))
3738 /* If the input bfd has no contents, it shouldn't set the
3739 private data of the output bfd. */
3741 bfd_error_handler_type pfn
= NULL
;
3743 /* If we aren't supposed to warn about mismatched input
3744 files, temporarily set the BFD error handler to a
3745 function which will do nothing. We still want to call
3746 bfd_merge_private_bfd_data, since it may set up
3747 information which is needed in the output file. */
3748 if (! command_line
.warn_mismatch
)
3749 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3750 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3752 if (command_line
.warn_mismatch
)
3753 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3756 if (! command_line
.warn_mismatch
)
3757 bfd_set_error_handler (pfn
);
3762 /* Look through all the global common symbols and attach them to the
3763 correct section. The -sort-common command line switch may be used
3764 to roughly sort the entries by size. */
3769 if (command_line
.inhibit_common_definition
)
3771 if (link_info
.relocateable
3772 && ! command_line
.force_common_definition
)
3775 if (! config
.sort_common
)
3776 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3781 for (power
= 4; power
>= 0; power
--)
3782 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3787 /* Place one common symbol in the correct section. */
3790 lang_one_common (h
, info
)
3791 struct bfd_link_hash_entry
*h
;
3794 unsigned int power_of_two
;
3797 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3798 ldfile_output_machine
);
3800 if (h
->type
!= bfd_link_hash_common
)
3804 power_of_two
= h
->u
.c
.p
->alignment_power
;
3806 if (config
.sort_common
3807 && power_of_two
< (unsigned int) *(int *) info
)
3810 section
= h
->u
.c
.p
->section
;
3812 /* Increase the size of the section. */
3813 section
->_cooked_size
= align_n ((section
->_cooked_size
+ opb
- 1) / opb
,
3814 (bfd_vma
) 1 << power_of_two
) * opb
;
3816 /* Adjust the alignment if necessary. */
3817 if (power_of_two
> section
->alignment_power
)
3818 section
->alignment_power
= power_of_two
;
3820 /* Change the symbol from common to defined. */
3821 h
->type
= bfd_link_hash_defined
;
3822 h
->u
.def
.section
= section
;
3823 h
->u
.def
.value
= section
->_cooked_size
;
3825 /* Increase the size of the section. */
3826 section
->_cooked_size
+= size
;
3828 /* Make sure the section is allocated in memory, and make sure that
3829 it is no longer a common section. */
3830 section
->flags
|= SEC_ALLOC
;
3831 section
->flags
&= ~SEC_IS_COMMON
;
3833 if (config
.map_file
!= NULL
)
3835 static bfd_boolean header_printed
;
3840 if (! header_printed
)
3842 minfo (_("\nAllocating common symbols\n"));
3843 minfo (_("Common symbol size file\n\n"));
3844 header_printed
= TRUE
;
3847 name
= demangle (h
->root
.string
);
3849 len
= strlen (name
);
3864 if (size
<= 0xffffffff)
3865 sprintf (buf
, "%lx", (unsigned long) size
);
3867 sprintf_vma (buf
, size
);
3877 minfo ("%B\n", section
->owner
);
3883 /* Run through the input files and ensure that every input section has
3884 somewhere to go. If one is found without a destination then create
3885 an input request and place it into the statement tree. */
3888 lang_place_orphans ()
3890 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3894 for (s
= file
->the_bfd
->sections
;
3895 s
!= (asection
*) NULL
;
3898 if (s
->output_section
== (asection
*) NULL
)
3900 /* This section of the file is not attached, root
3901 around for a sensible place for it to go. */
3903 if (file
->just_syms_flag
)
3907 else if (strcmp (s
->name
, "COMMON") == 0)
3909 /* This is a lonely common section which must have
3910 come from an archive. We attach to the section
3911 with the wildcard. */
3912 if (! link_info
.relocateable
3913 || command_line
.force_common_definition
)
3915 if (default_common_section
== NULL
)
3918 /* This message happens when using the
3919 svr3.ifile linker script, so I have
3921 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3923 default_common_section
=
3924 lang_output_section_statement_lookup (".bss");
3927 lang_add_section (&default_common_section
->children
, s
,
3928 default_common_section
, file
);
3931 else if (ldemul_place_orphan (file
, s
))
3935 lang_output_section_statement_type
*os
;
3937 os
= lang_output_section_statement_lookup (s
->name
);
3938 lang_add_section (&os
->children
, s
, os
, file
);
3946 lang_set_flags (ptr
, flags
, invert
)
3947 lang_memory_region_type
*ptr
;
3951 flagword
*ptr_flags
;
3953 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3959 *ptr_flags
|= SEC_ALLOC
;
3963 *ptr_flags
|= SEC_READONLY
;
3967 *ptr_flags
|= SEC_DATA
;
3971 *ptr_flags
|= SEC_CODE
;
3976 *ptr_flags
|= SEC_LOAD
;
3980 einfo (_("%P%F: invalid syntax in flags\n"));
3987 /* Call a function on each input file. This function will be called
3988 on an archive, but not on the elements. */
3991 lang_for_each_input_file (func
)
3992 void (*func
) PARAMS ((lang_input_statement_type
*));
3994 lang_input_statement_type
*f
;
3996 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3998 f
= (lang_input_statement_type
*) f
->next_real_file
)
4002 /* Call a function on each file. The function will be called on all
4003 the elements of an archive which are included in the link, but will
4004 not be called on the archive file itself. */
4007 lang_for_each_file (func
)
4008 void (*func
) PARAMS ((lang_input_statement_type
*));
4010 LANG_FOR_EACH_INPUT_STATEMENT (f
)
4021 lang_for_each_input_section (func
)
4022 void (*func
) PARAMS ((bfd
*ab
, asection
*as
));
4024 LANG_FOR_EACH_INPUT_STATEMENT (f
)
4028 for (s
= f
->the_bfd
->sections
;
4029 s
!= (asection
*) NULL
;
4032 func (f
->the_bfd
, s
);
4040 ldlang_add_file (entry
)
4041 lang_input_statement_type
*entry
;
4045 lang_statement_append (&file_chain
,
4046 (lang_statement_union_type
*) entry
,
4049 /* The BFD linker needs to have a list of all input BFDs involved in
4051 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
4052 ASSERT (entry
->the_bfd
!= output_bfd
);
4053 for (pp
= &link_info
.input_bfds
;
4054 *pp
!= (bfd
*) NULL
;
4055 pp
= &(*pp
)->link_next
)
4057 *pp
= entry
->the_bfd
;
4058 entry
->the_bfd
->usrdata
= (PTR
) entry
;
4059 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
4061 /* Look through the sections and check for any which should not be
4062 included in the link. We need to do this now, so that we can
4063 notice when the backend linker tries to report multiple
4064 definition errors for symbols which are in sections we aren't
4065 going to link. FIXME: It might be better to entirely ignore
4066 symbols which are defined in sections which are going to be
4067 discarded. This would require modifying the backend linker for
4068 each backend which might set the SEC_LINK_ONCE flag. If we do
4069 this, we should probably handle SEC_EXCLUDE in the same way. */
4071 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
4075 lang_add_output (name
, from_script
)
4079 /* Make -o on command line override OUTPUT in script. */
4080 if (!had_output_filename
|| !from_script
)
4082 output_filename
= name
;
4083 had_output_filename
= TRUE
;
4087 static lang_output_section_statement_type
*current_section
;
4099 for (l
= 0; l
< 32; l
++)
4101 if (i
>= (unsigned int) x
)
4109 lang_output_section_statement_type
*
4110 lang_enter_output_section_statement (output_section_statement_name
,
4111 address_exp
, sectype
, block_value
,
4112 align
, subalign
, ebase
)
4113 const char *output_section_statement_name
;
4114 etree_type
*address_exp
;
4115 enum section_type sectype
;
4116 bfd_vma block_value
;
4118 etree_type
*subalign
;
4121 lang_output_section_statement_type
*os
;
4125 lang_output_section_statement_lookup (output_section_statement_name
);
4127 /* Add this statement to tree. */
4129 add_statement (lang_output_section_statement_enum
,
4130 output_section_statement
);
4132 /* Make next things chain into subchain of this. */
4134 if (os
->addr_tree
== (etree_type
*) NULL
)
4136 os
->addr_tree
= address_exp
;
4138 os
->sectype
= sectype
;
4139 if (sectype
!= noload_section
)
4140 os
->flags
= SEC_NO_FLAGS
;
4142 os
->flags
= SEC_NEVER_LOAD
;
4143 os
->block_value
= block_value
? block_value
: 1;
4144 stat_ptr
= &os
->children
;
4146 os
->subsection_alignment
=
4147 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
4148 os
->section_alignment
=
4149 topower (exp_get_value_int (align
, -1, "section alignment", 0));
4151 os
->load_base
= ebase
;
4158 lang_output_statement_type
*new =
4159 new_stat (lang_output_statement
, stat_ptr
);
4161 new->name
= output_filename
;
4164 /* Reset the current counters in the regions. */
4167 lang_reset_memory_regions ()
4169 lang_memory_region_type
*p
= lang_memory_region_list
;
4172 for (p
= lang_memory_region_list
;
4173 p
!= (lang_memory_region_type
*) NULL
;
4176 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
4177 p
->current
= p
->origin
;
4180 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4184 /* If the wild pattern was marked KEEP, the member sections
4185 should be as well. */
4188 gc_section_callback (ptr
, sec
, section
, file
, data
)
4189 lang_wild_statement_type
*ptr
;
4190 struct wildcard_list
*sec ATTRIBUTE_UNUSED
;
4192 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
4193 PTR data ATTRIBUTE_UNUSED
;
4195 if (ptr
->keep_sections
)
4196 section
->flags
|= SEC_KEEP
;
4199 /* Handle a wild statement, marking it against GC. */
4203 lang_wild_statement_type
*s
;
4205 walk_wild (s
, gc_section_callback
, NULL
);
4208 /* Iterate over sections marking them against GC. */
4211 lang_gc_sections_1 (s
)
4212 lang_statement_union_type
*s
;
4214 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
4216 switch (s
->header
.type
)
4218 case lang_wild_statement_enum
:
4219 lang_gc_wild (&s
->wild_statement
);
4221 case lang_constructors_statement_enum
:
4222 lang_gc_sections_1 (constructor_list
.head
);
4224 case lang_output_section_statement_enum
:
4225 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4227 case lang_group_statement_enum
:
4228 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4239 struct bfd_link_hash_entry
*h
;
4240 ldlang_undef_chain_list_type
*ulist
;
4242 /* Keep all sections so marked in the link script. */
4244 lang_gc_sections_1 (statement_list
.head
);
4246 /* Keep all sections containing symbols undefined on the command-line,
4247 and the section containing the entry symbol. */
4249 for (ulist
= link_info
.gc_sym_list
; ulist
; ulist
= ulist
->next
)
4251 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4252 FALSE
, FALSE
, FALSE
);
4254 if (h
!= (struct bfd_link_hash_entry
*) NULL
4255 && (h
->type
== bfd_link_hash_defined
4256 || h
->type
== bfd_link_hash_defweak
)
4257 && ! bfd_is_abs_section (h
->u
.def
.section
))
4259 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4263 bfd_gc_sections (output_bfd
, &link_info
);
4269 lang_reasonable_defaults ();
4270 current_target
= default_target
;
4272 /* Open the output file. */
4273 lang_for_each_statement (ldlang_open_output
);
4275 ldemul_create_output_section_statements ();
4277 /* Add to the hash table all undefineds on the command line. */
4278 lang_place_undefineds ();
4280 already_linked_table_init ();
4282 /* Create a bfd for each input file. */
4283 current_target
= default_target
;
4284 open_input_bfds (statement_list
.head
, FALSE
);
4286 link_info
.gc_sym_list
= &entry_symbol
;
4287 if (entry_symbol
.name
== NULL
)
4288 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
4290 ldemul_after_open ();
4292 already_linked_table_free ();
4294 /* Make sure that we're not mixing architectures. We call this
4295 after all the input files have been opened, but before we do any
4296 other processing, so that any operations merge_private_bfd_data
4297 does on the output file will be known during the rest of the
4301 /* Handle .exports instead of a version script if we're told to do so. */
4302 if (command_line
.version_exports_section
)
4303 lang_do_version_exports_section ();
4305 /* Build all sets based on the information gathered from the input
4307 ldctor_build_sets ();
4309 /* Remove unreferenced sections if asked to. */
4310 if (command_line
.gc_sections
)
4311 lang_gc_sections ();
4313 /* If there were any SEC_MERGE sections, finish their merging, so that
4314 section sizes can be computed. This has to be done after GC of sections,
4315 so that GCed sections are not merged, but before assigning output
4316 sections, since removing whole input sections is hard then. */
4317 bfd_merge_sections (output_bfd
, &link_info
);
4319 /* Size up the common data. */
4322 /* Run through the contours of the script and attach input sections
4323 to the correct output sections. */
4324 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4325 (lang_output_section_statement_type
*) NULL
);
4327 /* Find any sections not attached explicitly and handle them. */
4328 lang_place_orphans ();
4330 if (! link_info
.relocateable
)
4332 /* Look for a text section and set the readonly attribute in it. */
4333 asection
*found
= bfd_get_section_by_name (output_bfd
, ".text");
4335 if (found
!= (asection
*) NULL
)
4337 if (config
.text_read_only
)
4338 found
->flags
|= SEC_READONLY
;
4340 found
->flags
&= ~SEC_READONLY
;
4344 /* Do anything special before sizing sections. This is where ELF
4345 and other back-ends size dynamic sections. */
4346 ldemul_before_allocation ();
4348 if (!link_info
.relocateable
)
4349 strip_excluded_output_sections ();
4351 /* We must record the program headers before we try to fix the
4352 section positions, since they will affect SIZEOF_HEADERS. */
4353 lang_record_phdrs ();
4355 /* Size up the sections. */
4356 lang_size_sections (statement_list
.head
,
4358 &statement_list
.head
, 0, (bfd_vma
) 0, NULL
,
4359 command_line
.relax
? FALSE
: TRUE
);
4361 /* Now run around and relax if we can. */
4362 if (command_line
.relax
)
4364 /* Keep relaxing until bfd_relax_section gives up. */
4365 bfd_boolean relax_again
;
4369 lang_reset_memory_regions ();
4371 relax_again
= FALSE
;
4373 /* Note: pe-dll.c does something like this also. If you find
4374 you need to change this code, you probably need to change
4375 pe-dll.c also. DJ */
4377 /* Do all the assignments with our current guesses as to
4379 lang_do_assignments (statement_list
.head
,
4381 (fill_type
*) 0, (bfd_vma
) 0);
4383 /* Perform another relax pass - this time we know where the
4384 globals are, so can make a better guess. */
4385 lang_size_sections (statement_list
.head
,
4387 &statement_list
.head
, 0, (bfd_vma
) 0,
4388 &relax_again
, FALSE
);
4390 while (relax_again
);
4392 /* Final extra sizing to report errors. */
4393 lang_reset_memory_regions ();
4394 lang_do_assignments (statement_list
.head
,
4396 (fill_type
*) 0, (bfd_vma
) 0);
4397 lang_size_sections (statement_list
.head
,
4399 & statement_list
.head
, 0, (bfd_vma
) 0,
4403 /* See if anything special should be done now we know how big
4405 ldemul_after_allocation ();
4407 /* Fix any .startof. or .sizeof. symbols. */
4408 lang_set_startof ();
4410 /* Do all the assignments, now that we know the final resting places
4411 of all the symbols. */
4413 lang_do_assignments (statement_list
.head
,
4415 (fill_type
*) 0, (bfd_vma
) 0);
4417 /* Make sure that the section addresses make sense. */
4418 if (! link_info
.relocateable
4419 && command_line
.check_section_addresses
)
4420 lang_check_section_addresses ();
4428 /* EXPORTED TO YACC */
4431 lang_add_wild (filespec
, section_list
, keep_sections
)
4432 struct wildcard_spec
*filespec
;
4433 struct wildcard_list
*section_list
;
4434 bfd_boolean keep_sections
;
4436 struct wildcard_list
*curr
, *next
;
4437 lang_wild_statement_type
*new;
4439 /* Reverse the list as the parser puts it back to front. */
4440 for (curr
= section_list
, section_list
= NULL
;
4442 section_list
= curr
, curr
= next
)
4444 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
4445 placed_commons
= TRUE
;
4448 curr
->next
= section_list
;
4451 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
4453 if (strcmp (filespec
->name
, "*") == 0)
4454 filespec
->name
= NULL
;
4455 else if (! wildcardp (filespec
->name
))
4456 lang_has_input_file
= TRUE
;
4459 new = new_stat (lang_wild_statement
, stat_ptr
);
4460 new->filename
= NULL
;
4461 new->filenames_sorted
= FALSE
;
4462 if (filespec
!= NULL
)
4464 new->filename
= filespec
->name
;
4465 new->filenames_sorted
= filespec
->sorted
;
4467 new->section_list
= section_list
;
4468 new->keep_sections
= keep_sections
;
4469 lang_list_init (&new->children
);
4473 lang_section_start (name
, address
)
4475 etree_type
*address
;
4477 lang_address_statement_type
*ad
;
4479 ad
= new_stat (lang_address_statement
, stat_ptr
);
4480 ad
->section_name
= name
;
4481 ad
->address
= address
;
4484 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4485 because of a -e argument on the command line, or zero if this is
4486 called by ENTRY in a linker script. Command line arguments take
4490 lang_add_entry (name
, cmdline
)
4492 bfd_boolean cmdline
;
4494 if (entry_symbol
.name
== NULL
4496 || ! entry_from_cmdline
)
4498 entry_symbol
.name
= name
;
4499 entry_from_cmdline
= cmdline
;
4504 lang_add_target (name
)
4507 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4523 map_option_f
= TRUE
;
4531 lang_add_fill (fill
)
4534 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4541 lang_add_data (type
, exp
)
4543 union etree_union
*exp
;
4546 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4554 /* Create a new reloc statement. RELOC is the BFD relocation type to
4555 generate. HOWTO is the corresponding howto structure (we could
4556 look this up, but the caller has already done so). SECTION is the
4557 section to generate a reloc against, or NAME is the name of the
4558 symbol to generate a reloc against. Exactly one of SECTION and
4559 NAME must be NULL. ADDEND is an expression for the addend. */
4562 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4563 bfd_reloc_code_real_type reloc
;
4564 reloc_howto_type
*howto
;
4567 union etree_union
*addend
;
4569 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4573 p
->section
= section
;
4575 p
->addend_exp
= addend
;
4577 p
->addend_value
= 0;
4578 p
->output_section
= NULL
;
4582 lang_assignment_statement_type
*
4583 lang_add_assignment (exp
)
4586 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4594 lang_add_attribute (attribute
)
4595 enum statement_enum attribute
;
4597 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4604 if (startup_file
!= (char *) NULL
)
4606 einfo (_("%P%Fmultiple STARTUP files\n"));
4608 first_file
->filename
= name
;
4609 first_file
->local_sym_name
= name
;
4610 first_file
->real
= TRUE
;
4612 startup_file
= name
;
4619 lang_float_flag
= maybe
;
4623 /* Work out the load- and run-time regions from a script statement, and
4624 store them in *LMA_REGION and *REGION respectively.
4626 MEMSPEC is the name of the run-time region, or "*default*" if the
4627 statement didn't specify one. LMA_MEMSPEC is the name of the
4628 load-time region, or null if the statement didn't specify one.
4629 HAVE_LMA_P is TRUE if the statement had an explicit load address.
4631 It is an error to specify both a load region and a load address. */
4634 lang_get_regions (region
, lma_region
, memspec
, lma_memspec
, have_lma_p
)
4635 struct memory_region_struct
**region
, **lma_region
;
4636 const char *memspec
, *lma_memspec
;
4639 *lma_region
= lang_memory_region_lookup (lma_memspec
);
4641 /* If no runtime region has been given, but the load region has
4642 been, use the load region. */
4643 if (lma_memspec
!= 0 && strcmp (memspec
, "*default*") == 0)
4644 *region
= *lma_region
;
4646 *region
= lang_memory_region_lookup (memspec
);
4648 if (have_lma_p
&& lma_memspec
!= 0)
4649 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4653 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4655 const char *memspec
;
4656 struct lang_output_section_phdr_list
*phdrs
;
4657 const char *lma_memspec
;
4659 lang_get_regions (¤t_section
->region
,
4660 ¤t_section
->lma_region
,
4661 memspec
, lma_memspec
,
4662 current_section
->load_base
!= 0);
4663 current_section
->fill
= fill
;
4664 current_section
->phdrs
= phdrs
;
4665 stat_ptr
= &statement_list
;
4668 /* Create an absolute symbol with the given name with the value of the
4669 address of first byte of the section named.
4671 If the symbol already exists, then do nothing. */
4674 lang_abs_symbol_at_beginning_of (secname
, name
)
4675 const char *secname
;
4678 struct bfd_link_hash_entry
*h
;
4680 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
4681 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4682 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4684 if (h
->type
== bfd_link_hash_new
4685 || h
->type
== bfd_link_hash_undefined
)
4689 h
->type
= bfd_link_hash_defined
;
4691 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4692 if (sec
== (asection
*) NULL
)
4695 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4697 h
->u
.def
.section
= bfd_abs_section_ptr
;
4701 /* Create an absolute symbol with the given name with the value of the
4702 address of the first byte after the end of the section named.
4704 If the symbol already exists, then do nothing. */
4707 lang_abs_symbol_at_end_of (secname
, name
)
4708 const char *secname
;
4711 struct bfd_link_hash_entry
*h
;
4713 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
4714 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4715 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4717 if (h
->type
== bfd_link_hash_new
4718 || h
->type
== bfd_link_hash_undefined
)
4722 h
->type
= bfd_link_hash_defined
;
4724 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4725 if (sec
== (asection
*) NULL
)
4728 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4729 + bfd_section_size (output_bfd
, sec
) /
4730 bfd_octets_per_byte (output_bfd
));
4732 h
->u
.def
.section
= bfd_abs_section_ptr
;
4737 lang_statement_append (list
, element
, field
)
4738 lang_statement_list_type
*list
;
4739 lang_statement_union_type
*element
;
4740 lang_statement_union_type
**field
;
4742 *(list
->tail
) = element
;
4746 /* Set the output format type. -oformat overrides scripts. */
4749 lang_add_output_format (format
, big
, little
, from_script
)
4755 if (output_target
== NULL
|| !from_script
)
4757 if (command_line
.endian
== ENDIAN_BIG
4760 else if (command_line
.endian
== ENDIAN_LITTLE
4764 output_target
= format
;
4768 /* Enter a group. This creates a new lang_group_statement, and sets
4769 stat_ptr to build new statements within the group. */
4774 lang_group_statement_type
*g
;
4776 g
= new_stat (lang_group_statement
, stat_ptr
);
4777 lang_list_init (&g
->children
);
4778 stat_ptr
= &g
->children
;
4781 /* Leave a group. This just resets stat_ptr to start writing to the
4782 regular list of statements again. Note that this will not work if
4783 groups can occur inside anything else which can adjust stat_ptr,
4784 but currently they can't. */
4789 stat_ptr
= &statement_list
;
4792 /* Add a new program header. This is called for each entry in a PHDRS
4793 command in a linker script. */
4796 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4799 bfd_boolean filehdr
;
4804 struct lang_phdr
*n
, **pp
;
4806 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4809 n
->type
= exp_get_value_int (type
, 0, "program header type",
4810 lang_final_phase_enum
);
4811 n
->filehdr
= filehdr
;
4816 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4821 /* Record the program header information in the output BFD. FIXME: We
4822 should not be calling an ELF specific function here. */
4825 lang_record_phdrs ()
4829 struct lang_output_section_phdr_list
*last
;
4830 struct lang_phdr
*l
;
4831 lang_statement_union_type
*u
;
4834 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4836 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4843 for (u
= lang_output_section_statement
.head
;
4845 u
= u
->output_section_statement
.next
)
4847 lang_output_section_statement_type
*os
;
4848 struct lang_output_section_phdr_list
*pl
;
4850 os
= &u
->output_section_statement
;
4857 if (os
->sectype
== noload_section
4858 || os
->bfd_section
== NULL
4859 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4864 if (os
->bfd_section
== NULL
)
4867 for (; pl
!= NULL
; pl
= pl
->next
)
4869 if (strcmp (pl
->name
, l
->name
) == 0)
4874 secs
= ((asection
**)
4875 xrealloc (secs
, alc
* sizeof (asection
*)));
4877 secs
[c
] = os
->bfd_section
;
4884 if (l
->flags
== NULL
)
4887 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4888 lang_final_phase_enum
);
4893 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4894 lang_final_phase_enum
);
4896 if (! bfd_record_phdr (output_bfd
, l
->type
,
4897 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
4898 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4899 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4904 /* Make sure all the phdr assignments succeeded. */
4905 for (u
= lang_output_section_statement
.head
;
4907 u
= u
->output_section_statement
.next
)
4909 struct lang_output_section_phdr_list
*pl
;
4911 if (u
->output_section_statement
.bfd_section
== NULL
)
4914 for (pl
= u
->output_section_statement
.phdrs
;
4917 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4918 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4919 u
->output_section_statement
.name
, pl
->name
);
4923 /* Record a list of sections which may not be cross referenced. */
4926 lang_add_nocrossref (l
)
4927 struct lang_nocrossref
*l
;
4929 struct lang_nocrossrefs
*n
;
4931 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4932 n
->next
= nocrossref_list
;
4934 nocrossref_list
= n
;
4936 /* Set notice_all so that we get informed about all symbols. */
4937 link_info
.notice_all
= TRUE
;
4940 /* Overlay handling. We handle overlays with some static variables. */
4942 /* The overlay virtual address. */
4943 static etree_type
*overlay_vma
;
4945 /* An expression for the maximum section size seen so far. */
4946 static etree_type
*overlay_max
;
4948 /* A list of all the sections in this overlay. */
4950 struct overlay_list
{
4951 struct overlay_list
*next
;
4952 lang_output_section_statement_type
*os
;
4955 static struct overlay_list
*overlay_list
;
4957 /* Start handling an overlay. */
4960 lang_enter_overlay (vma_expr
)
4961 etree_type
*vma_expr
;
4963 /* The grammar should prevent nested overlays from occurring. */
4964 ASSERT (overlay_vma
== NULL
&& overlay_max
== NULL
);
4966 overlay_vma
= vma_expr
;
4969 /* Start a section in an overlay. We handle this by calling
4970 lang_enter_output_section_statement with the correct VMA.
4971 lang_leave_overlay sets up the LMA and memory regions. */
4974 lang_enter_overlay_section (name
)
4977 struct overlay_list
*n
;
4980 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4983 /* If this is the first section, then base the VMA of future
4984 sections on this one. This will work correctly even if `.' is
4985 used in the addresses. */
4986 if (overlay_list
== NULL
)
4987 overlay_vma
= exp_nameop (ADDR
, name
);
4989 /* Remember the section. */
4990 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4991 n
->os
= current_section
;
4992 n
->next
= overlay_list
;
4995 size
= exp_nameop (SIZEOF
, name
);
4997 /* Arrange to work out the maximum section end address. */
4998 if (overlay_max
== NULL
)
5001 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
5004 /* Finish a section in an overlay. There isn't any special to do
5008 lang_leave_overlay_section (fill
, phdrs
)
5010 struct lang_output_section_phdr_list
*phdrs
;
5017 name
= current_section
->name
;
5019 /* For now, assume that "*default*" is the run-time memory region and
5020 that no load-time region has been specified. It doesn't really
5021 matter what we say here, since lang_leave_overlay will override it. */
5022 lang_leave_output_section_statement (fill
, "*default*", phdrs
, 0);
5024 /* Define the magic symbols. */
5026 clean
= xmalloc (strlen (name
) + 1);
5028 for (s1
= name
; *s1
!= '\0'; s1
++)
5029 if (ISALNUM (*s1
) || *s1
== '_')
5033 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
5034 sprintf (buf
, "__load_start_%s", clean
);
5035 lang_add_assignment (exp_assop ('=', buf
,
5036 exp_nameop (LOADADDR
, name
)));
5038 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
5039 sprintf (buf
, "__load_stop_%s", clean
);
5040 lang_add_assignment (exp_assop ('=', buf
,
5042 exp_nameop (LOADADDR
, name
),
5043 exp_nameop (SIZEOF
, name
))));
5048 /* Finish an overlay. If there are any overlay wide settings, this
5049 looks through all the sections in the overlay and sets them. */
5052 lang_leave_overlay (lma_expr
, nocrossrefs
, fill
, memspec
, phdrs
, lma_memspec
)
5053 etree_type
*lma_expr
;
5056 const char *memspec
;
5057 struct lang_output_section_phdr_list
*phdrs
;
5058 const char *lma_memspec
;
5060 lang_memory_region_type
*region
;
5061 lang_memory_region_type
*lma_region
;
5062 struct overlay_list
*l
;
5063 struct lang_nocrossref
*nocrossref
;
5065 lang_get_regions (®ion
, &lma_region
,
5066 memspec
, lma_memspec
,
5071 /* After setting the size of the last section, set '.' to end of the
5073 if (overlay_list
!= NULL
)
5074 overlay_list
->os
->update_dot_tree
5075 = exp_assop ('=', ".", exp_binop ('+', overlay_vma
, overlay_max
));
5080 struct overlay_list
*next
;
5082 if (fill
!= (fill_type
*) 0 && l
->os
->fill
== (fill_type
*) 0)
5085 l
->os
->region
= region
;
5086 l
->os
->lma_region
= lma_region
;
5088 /* The first section has the load address specified in the
5089 OVERLAY statement. The rest are worked out from that.
5090 The base address is not needed (and should be null) if
5091 an LMA region was specified. */
5093 l
->os
->load_base
= lma_expr
;
5094 else if (lma_region
== 0)
5095 l
->os
->load_base
= exp_binop ('+',
5096 exp_nameop (LOADADDR
, l
->next
->os
->name
),
5097 exp_nameop (SIZEOF
, l
->next
->os
->name
));
5099 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
5100 l
->os
->phdrs
= phdrs
;
5104 struct lang_nocrossref
*nc
;
5106 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
5107 nc
->name
= l
->os
->name
;
5108 nc
->next
= nocrossref
;
5117 if (nocrossref
!= NULL
)
5118 lang_add_nocrossref (nocrossref
);
5121 overlay_list
= NULL
;
5125 /* Version handling. This is only useful for ELF. */
5127 /* This global variable holds the version tree that we build. */
5129 struct bfd_elf_version_tree
*lang_elf_version_info
;
5132 lang_vers_match_lang_c (expr
, sym
)
5133 struct bfd_elf_version_expr
*expr
;
5136 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5138 return fnmatch (expr
->pattern
, sym
, 0) == 0;
5142 lang_vers_match_lang_cplusplus (expr
, sym
)
5143 struct bfd_elf_version_expr
*expr
;
5149 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5152 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
5155 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5156 Should we early out FALSE in this case? */
5157 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5161 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5169 lang_vers_match_lang_java (expr
, sym
)
5170 struct bfd_elf_version_expr
*expr
;
5176 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5179 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
5182 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5183 Should we early out FALSE in this case? */
5184 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
5188 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
5195 /* This is called for each variable name or match expression. */
5197 struct bfd_elf_version_expr
*
5198 lang_new_vers_pattern (orig
, new, lang
)
5199 struct bfd_elf_version_expr
*orig
;
5203 struct bfd_elf_version_expr
*ret
;
5205 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
5211 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
5212 ret
->match
= lang_vers_match_lang_c
;
5213 else if (strcasecmp (lang
, "C++") == 0)
5214 ret
->match
= lang_vers_match_lang_cplusplus
;
5215 else if (strcasecmp (lang
, "Java") == 0)
5216 ret
->match
= lang_vers_match_lang_java
;
5219 einfo (_("%X%P: unknown language `%s' in version information\n"),
5221 ret
->match
= lang_vers_match_lang_c
;
5224 return ldemul_new_vers_pattern (ret
);
5227 /* This is called for each set of variable names and match
5230 struct bfd_elf_version_tree
*
5231 lang_new_vers_node (globals
, locals
)
5232 struct bfd_elf_version_expr
*globals
;
5233 struct bfd_elf_version_expr
*locals
;
5235 struct bfd_elf_version_tree
*ret
;
5237 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
5241 ret
->globals
= globals
;
5242 ret
->locals
= locals
;
5244 ret
->name_indx
= (unsigned int) -1;
5249 /* This static variable keeps track of version indices. */
5251 static int version_index
;
5253 /* This is called when we know the name and dependencies of the
5257 lang_register_vers_node (name
, version
, deps
)
5259 struct bfd_elf_version_tree
*version
;
5260 struct bfd_elf_version_deps
*deps
;
5262 struct bfd_elf_version_tree
*t
, **pp
;
5263 struct bfd_elf_version_expr
*e1
;
5268 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
5269 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
5271 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5275 /* Make sure this node has a unique name. */
5276 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5277 if (strcmp (t
->name
, name
) == 0)
5278 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5280 /* Check the global and local match names, and make sure there
5281 aren't any duplicates. */
5283 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5285 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5287 struct bfd_elf_version_expr
*e2
;
5289 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5290 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5291 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5296 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
5298 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5300 struct bfd_elf_version_expr
*e2
;
5302 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
5303 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5304 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5309 version
->deps
= deps
;
5310 version
->name
= name
;
5311 if (name
[0] != '\0')
5314 version
->vernum
= version_index
;
5317 version
->vernum
= 0;
5319 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5324 /* This is called when we see a version dependency. */
5326 struct bfd_elf_version_deps
*
5327 lang_add_vers_depend (list
, name
)
5328 struct bfd_elf_version_deps
*list
;
5331 struct bfd_elf_version_deps
*ret
;
5332 struct bfd_elf_version_tree
*t
;
5334 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5337 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5339 if (strcmp (t
->name
, name
) == 0)
5341 ret
->version_needed
= t
;
5346 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5352 lang_do_version_exports_section ()
5354 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5356 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5358 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5365 len
= bfd_section_size (is
->the_bfd
, sec
);
5366 contents
= xmalloc (len
);
5367 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5368 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
5371 while (p
< contents
+ len
)
5373 greg
= lang_new_vers_pattern (greg
, p
, NULL
);
5374 p
= strchr (p
, '\0') + 1;
5377 /* Do not free the contents, as we used them creating the regex. */
5379 /* Do not include this section in the link. */
5380 bfd_set_section_flags (is
->the_bfd
, sec
,
5381 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5384 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
);
5385 lang_register_vers_node (command_line
.version_exports_section
,
5386 lang_new_vers_node (greg
, lreg
), NULL
);
5390 lang_add_unique (name
)
5393 struct unique_sections
*ent
;
5395 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5396 if (strcmp (ent
->name
, name
) == 0)
5399 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
5400 ent
->name
= xstrdup (name
);
5401 ent
->next
= unique_section_list
;
5402 unique_section_list
= ent
;