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"
45 static lang_statement_union_type
*new_statement
46 PARAMS ((enum statement_enum
, size_t, lang_statement_list_type
*));
49 static struct obstack stat_obstack
;
51 #define obstack_chunk_alloc xmalloc
52 #define obstack_chunk_free free
53 static const char *startup_file
;
54 static lang_statement_list_type input_file_chain
;
55 static boolean placed_commons
= false;
56 static lang_output_section_statement_type
*default_common_section
;
57 static boolean map_option_f
;
58 static bfd_vma print_dot
;
59 static lang_input_statement_type
*first_file
;
60 static const char *current_target
;
61 static const char *output_target
;
62 static lang_statement_list_type statement_list
;
63 static struct lang_phdr
*lang_phdr_list
;
65 static void lang_for_each_statement_worker
66 PARAMS ((void (*) (lang_statement_union_type
*),
67 lang_statement_union_type
*));
68 static lang_input_statement_type
*new_afile
69 PARAMS ((const char *, lang_input_file_enum_type
, const char *, boolean
));
70 static lang_memory_region_type
*lang_memory_default
PARAMS ((asection
*));
71 static void lang_map_flags
PARAMS ((flagword
));
72 static void init_os
PARAMS ((lang_output_section_statement_type
*));
73 static void exp_init_os
PARAMS ((etree_type
*));
74 static void section_already_linked
PARAMS ((bfd
*, asection
*, PTR
));
75 static struct bfd_hash_entry
*already_linked_newfunc
76 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
77 static void already_linked_table_init
PARAMS ((void));
78 static void already_linked_table_free
PARAMS ((void));
79 static boolean wildcardp
PARAMS ((const char *));
80 static lang_statement_union_type
*wild_sort
81 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
83 static void output_section_callback
84 PARAMS ((lang_wild_statement_type
*, asection
*,
85 lang_input_statement_type
*, PTR
));
86 static lang_input_statement_type
*lookup_name
PARAMS ((const char *));
87 static void load_symbols
88 PARAMS ((lang_input_statement_type
*, lang_statement_list_type
*));
90 PARAMS ((lang_wild_statement_type
*, const char *, const char *,
91 const char *, lang_output_section_statement_type
*));
92 static bfd
*open_output
PARAMS ((const char *));
93 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*));
94 static void open_input_bfds
PARAMS ((lang_statement_union_type
*, boolean
));
95 static void lang_reasonable_defaults
PARAMS ((void));
96 static void lang_place_undefineds
PARAMS ((void));
97 static void map_input_to_output_sections
98 PARAMS ((lang_statement_union_type
*, const char *,
99 lang_output_section_statement_type
*));
100 static void print_output_section_statement
101 PARAMS ((lang_output_section_statement_type
*));
102 static void print_assignment
103 PARAMS ((lang_assignment_statement_type
*,
104 lang_output_section_statement_type
*));
105 static void print_input_statement
PARAMS ((lang_input_statement_type
*));
106 static boolean print_one_symbol
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
107 static void print_input_section
PARAMS ((lang_input_section_type
*));
108 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*));
109 static void print_data_statement
PARAMS ((lang_data_statement_type
*));
110 static void print_address_statement
PARAMS ((lang_address_statement_type
*));
111 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*));
112 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*));
113 static void print_wild_statement
114 PARAMS ((lang_wild_statement_type
*, lang_output_section_statement_type
*));
115 static void print_group
116 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
117 static void print_statement
118 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
119 static void print_statement_list
120 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
121 static void print_statements
PARAMS ((void));
122 static bfd_vma insert_pad
123 PARAMS ((lang_statement_union_type
**, fill_type
,
124 unsigned int, asection
*, bfd_vma
));
125 static bfd_vma size_input_section
126 PARAMS ((lang_statement_union_type
**, lang_output_section_statement_type
*,
127 fill_type
, bfd_vma
, boolean
));
128 static void lang_finish
PARAMS ((void));
129 static void ignore_bfd_errors
PARAMS ((const char *, ...));
130 static void record_bfd_errors
PARAMS ((const char *, ...));
131 static void lang_check
PARAMS ((void));
132 static void lang_common
PARAMS ((void));
133 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
134 static void lang_place_orphans
PARAMS ((void));
135 static int topower
PARAMS ((int));
136 static void lang_set_startof
PARAMS ((void));
137 static void reset_memory_regions
PARAMS ((void));
138 static void gc_section_callback
139 PARAMS ((lang_wild_statement_type
*, asection
*,
140 lang_input_statement_type
*, PTR
));
141 static void lang_record_phdrs
PARAMS ((void));
142 static void lang_gc_wild
143 PARAMS ((lang_wild_statement_type
*, const char *, const char *));
144 static void lang_gc_sections_1
PARAMS ((lang_statement_union_type
*));
145 static void lang_gc_sections
PARAMS ((void));
146 static int lang_vers_match_lang_c
147 PARAMS ((struct bfd_elf_version_expr
*, const char *));
148 static int lang_vers_match_lang_cplusplus
149 PARAMS ((struct bfd_elf_version_expr
*, const char *));
150 static int lang_vers_match_lang_java
151 PARAMS ((struct bfd_elf_version_expr
*, const char *));
152 static void lang_do_version_exports_section
PARAMS ((void));
153 static void lang_check_section_addresses
PARAMS ((void));
154 static void os_region_check
155 PARAMS ((lang_output_section_statement_type
*,
156 struct memory_region_struct
*, etree_type
*, bfd_vma
));
158 typedef void (*callback_t
) PARAMS ((lang_wild_statement_type
*,
159 asection
*, lang_input_statement_type
*,
161 static void walk_wild
162 PARAMS ((lang_wild_statement_type
*, const char *, const char *,
164 static void walk_wild_section
165 PARAMS ((lang_wild_statement_type
*, const char *,
166 lang_input_statement_type
*, callback_t
, PTR
));
167 static void walk_wild_file
168 PARAMS ((lang_wild_statement_type
*, const char *,
169 lang_input_statement_type
*, callback_t
, PTR
));
171 static int get_target
PARAMS ((const bfd_target
*, PTR
));
172 static void stricpy
PARAMS ((char *, char *));
173 static void strcut
PARAMS ((char *, char *));
174 static int name_compare
PARAMS ((char *, char *));
175 static int closest_target_match
PARAMS ((const bfd_target
*, PTR
));
176 static char * get_first_input_target
PARAMS ((void));
179 lang_output_section_statement_type
*abs_output_section
;
180 lang_statement_list_type lang_output_section_statement
;
181 lang_statement_list_type
*stat_ptr
= &statement_list
;
182 lang_statement_list_type file_chain
= { NULL
, NULL
};
183 const char *entry_symbol
= NULL
;
184 boolean entry_from_cmdline
;
185 boolean lang_has_input_file
= false;
186 boolean had_output_filename
= false;
187 boolean lang_float_flag
= false;
188 boolean delete_output_file_on_failure
= false;
189 struct lang_nocrossrefs
*nocrossref_list
;
190 struct unique_sections
*unique_section_list
;
192 etree_type
*base
; /* Relocation base - or null */
194 #if defined (__STDC__) || defined (ALMOST_STDC)
195 #define cat(a,b) a##b
197 #define cat(a,b) a/**/b
200 /* Don't beautify the line below with "innocent" whitespace, it breaks
201 the K&R C preprocessor! */
202 #define new_stat(x, y) \
203 (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
205 #define outside_section_address(q) \
206 ((q)->output_offset + (q)->output_section->vma)
208 #define outside_symbol_address(q) \
209 ((q)->value + outside_section_address (q->section))
211 #define SECTION_NAME_MAP_LENGTH (16)
217 return obstack_alloc (&stat_obstack
, size
);
221 unique_section_p (secnam
)
224 struct unique_sections
*unam
;
226 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
227 if (wildcardp (unam
->name
)
228 ? fnmatch (unam
->name
, secnam
, 0) == 0
229 : strcmp (unam
->name
, secnam
) == 0)
237 /* Generic traversal routines for finding matching sections. */
240 walk_wild_section (ptr
, section
, file
, callback
, data
)
241 lang_wild_statement_type
*ptr
;
243 lang_input_statement_type
*file
;
247 /* Don't process sections from files which were excluded. */
248 if (ptr
->exclude_filename_list
!= NULL
)
250 struct name_list
*list_tmp
;
251 for (list_tmp
= ptr
->exclude_filename_list
;
253 list_tmp
= list_tmp
->next
)
257 if (wildcardp (list_tmp
->name
))
258 match
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
260 match
= strcmp (list_tmp
->name
, file
->filename
) == 0;
267 if (file
->just_syms_flag
== false)
269 register asection
*s
;
270 boolean wildcard
= false;
273 wildcard
= wildcardp (section
);
275 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
278 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
283 match
= fnmatch (section
, sname
, 0) == 0;
285 match
= strcmp (section
, sname
) == 0;
287 /* If this is a wild-card output section statement, exclude
288 sections that match UNIQUE_SECTION_LIST. */
289 if (match
&& (data
== NULL
|| !unique_section_p (sname
)))
290 (*callback
) (ptr
, s
, file
, data
);
295 /* Handle a wild statement for a single file F. */
298 walk_wild_file (s
, section
, f
, callback
, data
)
299 lang_wild_statement_type
*s
;
301 lang_input_statement_type
*f
;
305 if (f
->the_bfd
== NULL
306 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
307 walk_wild_section (s
, section
, f
, callback
, data
);
312 /* This is an archive file. We must map each member of the
313 archive separately. */
314 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
315 while (member
!= NULL
)
317 /* When lookup_name is called, it will call the add_symbols
318 entry point for the archive. For each element of the
319 archive which is included, BFD will call ldlang_add_file,
320 which will set the usrdata field of the member to the
321 lang_input_statement. */
322 if (member
->usrdata
!= NULL
)
324 walk_wild_section (s
, section
,
325 (lang_input_statement_type
*) member
->usrdata
,
329 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
335 walk_wild (s
, section
, file
, callback
, data
)
336 lang_wild_statement_type
*s
;
342 if (file
== (char *) NULL
)
344 /* Perform the iteration over all files in the list. */
345 LANG_FOR_EACH_INPUT_STATEMENT (f
)
347 walk_wild_file (s
, section
, f
, callback
, data
);
350 else if (wildcardp (file
))
352 LANG_FOR_EACH_INPUT_STATEMENT (f
)
354 if (fnmatch (file
, f
->filename
, FNM_FILE_NAME
) == 0)
355 walk_wild_file (s
, section
, f
, callback
, data
);
360 lang_input_statement_type
*f
;
362 /* Perform the iteration over a single file. */
363 f
= lookup_name (file
);
364 walk_wild_file (s
, section
, f
, callback
, data
);
368 /* lang_for_each_statement walks the parse tree and calls the provided
369 function for each node. */
372 lang_for_each_statement_worker (func
, s
)
373 void (*func
) PARAMS ((lang_statement_union_type
*));
374 lang_statement_union_type
*s
;
376 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
380 switch (s
->header
.type
)
382 case lang_constructors_statement_enum
:
383 lang_for_each_statement_worker (func
, constructor_list
.head
);
385 case lang_output_section_statement_enum
:
386 lang_for_each_statement_worker
388 s
->output_section_statement
.children
.head
);
390 case lang_wild_statement_enum
:
391 lang_for_each_statement_worker
393 s
->wild_statement
.children
.head
);
395 case lang_group_statement_enum
:
396 lang_for_each_statement_worker (func
,
397 s
->group_statement
.children
.head
);
399 case lang_data_statement_enum
:
400 case lang_reloc_statement_enum
:
401 case lang_object_symbols_statement_enum
:
402 case lang_output_statement_enum
:
403 case lang_target_statement_enum
:
404 case lang_input_section_enum
:
405 case lang_input_statement_enum
:
406 case lang_assignment_statement_enum
:
407 case lang_padding_statement_enum
:
408 case lang_address_statement_enum
:
409 case lang_fill_statement_enum
:
419 lang_for_each_statement (func
)
420 void (*func
) PARAMS ((lang_statement_union_type
*));
422 lang_for_each_statement_worker (func
, statement_list
.head
);
425 /*----------------------------------------------------------------------*/
428 lang_list_init (list
)
429 lang_statement_list_type
*list
;
431 list
->head
= (lang_statement_union_type
*) NULL
;
432 list
->tail
= &list
->head
;
435 /* Build a new statement node for the parse tree. */
437 static lang_statement_union_type
*
438 new_statement (type
, size
, list
)
439 enum statement_enum type
;
441 lang_statement_list_type
*list
;
443 lang_statement_union_type
*new = (lang_statement_union_type
*)
446 new->header
.type
= type
;
447 new->header
.next
= (lang_statement_union_type
*) NULL
;
448 lang_statement_append (list
, new, &new->header
.next
);
452 /* Build a new input file node for the language. There are several
453 ways in which we treat an input file, eg, we only look at symbols,
454 or prefix it with a -l etc.
456 We can be supplied with requests for input files more than once;
457 they may, for example be split over serveral lines like foo.o(.text)
458 foo.o(.data) etc, so when asked for a file we check that we haven't
459 got it already so we don't duplicate the bfd. */
461 static lang_input_statement_type
*
462 new_afile (name
, file_type
, target
, add_to_list
)
464 lang_input_file_enum_type file_type
;
468 lang_input_statement_type
*p
;
471 p
= new_stat (lang_input_statement
, stat_ptr
);
474 p
= ((lang_input_statement_type
*)
475 stat_alloc (sizeof (lang_input_statement_type
)));
476 p
->header
.next
= NULL
;
479 lang_has_input_file
= true;
483 case lang_input_file_is_symbols_only_enum
:
485 p
->is_archive
= false;
487 p
->local_sym_name
= name
;
488 p
->just_syms_flag
= true;
489 p
->search_dirs_flag
= false;
491 case lang_input_file_is_fake_enum
:
493 p
->is_archive
= false;
495 p
->local_sym_name
= name
;
496 p
->just_syms_flag
= false;
497 p
->search_dirs_flag
= false;
499 case lang_input_file_is_l_enum
:
500 p
->is_archive
= true;
503 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
504 p
->just_syms_flag
= false;
505 p
->search_dirs_flag
= true;
507 case lang_input_file_is_marker_enum
:
509 p
->is_archive
= false;
511 p
->local_sym_name
= name
;
512 p
->just_syms_flag
= false;
513 p
->search_dirs_flag
= true;
515 case lang_input_file_is_search_file_enum
:
517 p
->is_archive
= false;
519 p
->local_sym_name
= name
;
520 p
->just_syms_flag
= false;
521 p
->search_dirs_flag
= true;
523 case lang_input_file_is_file_enum
:
525 p
->is_archive
= false;
527 p
->local_sym_name
= name
;
528 p
->just_syms_flag
= false;
529 p
->search_dirs_flag
= false;
534 p
->the_bfd
= (bfd
*) NULL
;
535 p
->asymbols
= (asymbol
**) NULL
;
536 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
537 p
->next
= (lang_statement_union_type
*) NULL
;
539 p
->dynamic
= config
.dynamic_link
;
540 p
->whole_archive
= whole_archive
;
542 lang_statement_append (&input_file_chain
,
543 (lang_statement_union_type
*) p
,
548 lang_input_statement_type
*
549 lang_add_input_file (name
, file_type
, target
)
551 lang_input_file_enum_type file_type
;
554 lang_has_input_file
= true;
555 return new_afile (name
, file_type
, target
, true);
558 /* Build enough state so that the parser can build its tree. */
563 obstack_begin (&stat_obstack
, 1000);
565 stat_ptr
= &statement_list
;
567 lang_list_init (stat_ptr
);
569 lang_list_init (&input_file_chain
);
570 lang_list_init (&lang_output_section_statement
);
571 lang_list_init (&file_chain
);
572 first_file
= lang_add_input_file ((char *) NULL
,
573 lang_input_file_is_marker_enum
,
576 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
578 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
582 /*----------------------------------------------------------------------
583 A region is an area of memory declared with the
584 MEMORY { name:org=exp, len=exp ... }
587 We maintain a list of all the regions here.
589 If no regions are specified in the script, then the default is used
590 which is created when looked up to be the entire data space. */
592 static lang_memory_region_type
*lang_memory_region_list
;
593 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
595 lang_memory_region_type
*
596 lang_memory_region_lookup (name
)
597 const char *const name
;
599 lang_memory_region_type
*p
;
601 for (p
= lang_memory_region_list
;
602 p
!= (lang_memory_region_type
*) NULL
;
605 if (strcmp (p
->name
, name
) == 0)
612 /* This code used to always use the first region in the list as the
613 default region. I changed it to instead use a region
614 encompassing all of memory as the default region. This permits
615 NOLOAD sections to work reasonably without requiring a region.
616 People should specify what region they mean, if they really want
618 if (strcmp (name
, "*default*") == 0)
620 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
622 return lang_memory_region_list
;
628 lang_memory_region_type
*new =
629 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
631 new->name
= xstrdup (name
);
632 new->next
= (lang_memory_region_type
*) NULL
;
634 *lang_memory_region_list_tail
= new;
635 lang_memory_region_list_tail
= &new->next
;
639 new->length
= ~(bfd_size_type
) 0;
641 new->had_full_message
= false;
647 static lang_memory_region_type
*
648 lang_memory_default (section
)
651 lang_memory_region_type
*p
;
653 flagword sec_flags
= section
->flags
;
655 /* Override SEC_DATA to mean a writable section. */
656 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
657 sec_flags
|= SEC_DATA
;
659 for (p
= lang_memory_region_list
;
660 p
!= (lang_memory_region_type
*) NULL
;
663 if ((p
->flags
& sec_flags
) != 0
664 && (p
->not_flags
& sec_flags
) == 0)
669 return lang_memory_region_lookup ("*default*");
672 lang_output_section_statement_type
*
673 lang_output_section_find (name
)
674 const char *const name
;
676 lang_statement_union_type
*u
;
677 lang_output_section_statement_type
*lookup
;
679 for (u
= lang_output_section_statement
.head
;
680 u
!= (lang_statement_union_type
*) NULL
;
683 lookup
= &u
->output_section_statement
;
684 if (strcmp (name
, lookup
->name
) == 0)
689 return (lang_output_section_statement_type
*) NULL
;
692 lang_output_section_statement_type
*
693 lang_output_section_statement_lookup (name
)
694 const char *const name
;
696 lang_output_section_statement_type
*lookup
;
698 lookup
= lang_output_section_find (name
);
699 if (lookup
== (lang_output_section_statement_type
*) NULL
)
702 lookup
= (lang_output_section_statement_type
*)
703 new_stat (lang_output_section_statement
, stat_ptr
);
704 lookup
->region
= (lang_memory_region_type
*) NULL
;
705 lookup
->lma_region
= (lang_memory_region_type
*) NULL
;
707 lookup
->block_value
= 1;
710 lookup
->next
= (lang_statement_union_type
*) NULL
;
711 lookup
->bfd_section
= (asection
*) NULL
;
712 lookup
->processed
= false;
713 lookup
->sectype
= normal_section
;
714 lookup
->addr_tree
= (etree_type
*) NULL
;
715 lang_list_init (&lookup
->children
);
717 lookup
->memspec
= (const char *) NULL
;
719 lookup
->subsection_alignment
= -1;
720 lookup
->section_alignment
= -1;
721 lookup
->load_base
= (union etree_union
*) NULL
;
722 lookup
->phdrs
= NULL
;
724 lang_statement_append (&lang_output_section_statement
,
725 (lang_statement_union_type
*) lookup
,
732 lang_map_flags (flag
)
735 if (flag
& SEC_ALLOC
)
741 if (flag
& SEC_READONLY
)
754 lang_memory_region_type
*m
;
756 minfo (_("\nMemory Configuration\n\n"));
757 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
758 _("Name"), _("Origin"), _("Length"), _("Attributes"));
760 for (m
= lang_memory_region_list
;
761 m
!= (lang_memory_region_type
*) NULL
;
767 fprintf (config
.map_file
, "%-16s ", m
->name
);
769 sprintf_vma (buf
, m
->origin
);
770 minfo ("0x%s ", buf
);
778 minfo ("0x%V", m
->length
);
779 if (m
->flags
|| m
->not_flags
)
787 lang_map_flags (m
->flags
);
793 lang_map_flags (m
->not_flags
);
800 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
805 /* Initialize an output section. */
809 lang_output_section_statement_type
*s
;
811 section_userdata_type
*new;
813 if (s
->bfd_section
!= NULL
)
816 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
817 einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME
);
819 new = ((section_userdata_type
*)
820 stat_alloc (sizeof (section_userdata_type
)));
822 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
823 if (s
->bfd_section
== (asection
*) NULL
)
824 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
825 if (s
->bfd_section
== (asection
*) NULL
)
827 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
828 output_bfd
->xvec
->name
, s
->name
);
830 s
->bfd_section
->output_section
= s
->bfd_section
;
832 /* We initialize an output sections output offset to minus its own
833 vma to allow us to output a section through itself. */
834 s
->bfd_section
->output_offset
= 0;
835 get_userdata (s
->bfd_section
) = (PTR
) new;
837 /* If there is a base address, make sure that any sections it might
838 mention are initialized. */
839 if (s
->addr_tree
!= NULL
)
840 exp_init_os (s
->addr_tree
);
843 /* Make sure that all output sections mentioned in an expression are
850 switch (exp
->type
.node_class
)
853 exp_init_os (exp
->assign
.src
);
857 exp_init_os (exp
->binary
.lhs
);
858 exp_init_os (exp
->binary
.rhs
);
862 exp_init_os (exp
->trinary
.cond
);
863 exp_init_os (exp
->trinary
.lhs
);
864 exp_init_os (exp
->trinary
.rhs
);
868 exp_init_os (exp
->unary
.child
);
872 switch (exp
->type
.node_code
)
878 lang_output_section_statement_type
*os
;
880 os
= lang_output_section_find (exp
->name
.name
);
881 if (os
!= NULL
&& os
->bfd_section
== NULL
)
892 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
893 once into the output. This routine checks each section, and
894 arrange to discard it if a section of the same name has already
895 been linked. If the section has COMDAT information, then it uses
896 that to decide whether the section should be included. This code
897 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
898 that is, it does not depend solely upon the section name.
899 section_already_linked is called via bfd_map_over_sections. */
901 /* This is the shape of the elements inside the already_linked hash
902 table. It maps a name onto a list of already_linked elements with
903 the same name. It's possible to get more than one element in a
904 list if the COMDAT sections have different names. */
906 struct already_linked_hash_entry
908 struct bfd_hash_entry root
;
909 struct already_linked
*entry
;
912 struct already_linked
914 struct already_linked
*next
;
918 /* The hash table. */
920 static struct bfd_hash_table already_linked_table
;
923 section_already_linked (abfd
, sec
, data
)
928 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
931 struct already_linked
*l
;
932 struct already_linked_hash_entry
*already_linked_list
;
934 /* If we are only reading symbols from this object, then we want to
935 discard all sections. */
936 if (entry
->just_syms_flag
)
938 sec
->output_section
= bfd_abs_section_ptr
;
939 sec
->output_offset
= sec
->vma
;
943 flags
= bfd_get_section_flags (abfd
, sec
);
945 if ((flags
& SEC_LINK_ONCE
) == 0)
948 /* FIXME: When doing a relocatable link, we may have trouble
949 copying relocations in other sections that refer to local symbols
950 in the section being discarded. Those relocations will have to
951 be converted somehow; as of this writing I'm not sure that any of
952 the backends handle that correctly.
954 It is tempting to instead not discard link once sections when
955 doing a relocatable link (technically, they should be discarded
956 whenever we are building constructors). However, that fails,
957 because the linker winds up combining all the link once sections
958 into a single large link once section, which defeats the purpose
959 of having link once sections in the first place.
961 Also, not merging link once sections in a relocatable link
962 causes trouble for MIPS ELF, which relies in link once semantics
963 to handle the .reginfo section correctly. */
965 name
= bfd_get_section_name (abfd
, sec
);
967 already_linked_list
=
968 ((struct already_linked_hash_entry
*)
969 bfd_hash_lookup (&already_linked_table
, name
, true, false));
971 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
973 if (sec
->comdat
== NULL
974 || l
->sec
->comdat
== NULL
975 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
977 /* The section has already been linked. See if we should
979 switch (flags
& SEC_LINK_DUPLICATES
)
984 case SEC_LINK_DUPLICATES_DISCARD
:
987 case SEC_LINK_DUPLICATES_ONE_ONLY
:
988 if (sec
->comdat
== NULL
)
989 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
992 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
993 abfd
, name
, sec
->comdat
->name
);
996 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
997 /* FIXME: We should really dig out the contents of both
998 sections and memcmp them. The COFF/PE spec says that
999 the Microsoft linker does not implement this
1000 correctly, so I'm not going to bother doing it
1003 case SEC_LINK_DUPLICATES_SAME_SIZE
:
1004 if (bfd_section_size (abfd
, sec
)
1005 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1006 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1011 /* Set the output_section field so that wild_doit does not
1012 create a lang_input_section structure for this section.
1013 Since there might be a symbol in the section being
1014 discarded, we must retain a pointer to the section which
1015 we are really going to use. */
1016 sec
->output_section
= bfd_abs_section_ptr
;
1017 sec
->kept_section
= l
->sec
;
1023 /* This is the first section with this name. Record it. Allocate
1024 the memory from the same obstack as the hash table is kept in. */
1026 l
= ((struct already_linked
*)
1027 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1030 l
->next
= already_linked_list
->entry
;
1031 already_linked_list
->entry
= l
;
1034 /* Support routines for the hash table used by section_already_linked,
1035 initialize the table, fill in an entry and remove the table. */
1037 static struct bfd_hash_entry
*
1038 already_linked_newfunc (entry
, table
, string
)
1039 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1040 struct bfd_hash_table
*table
;
1041 const char *string ATTRIBUTE_UNUSED
;
1043 struct already_linked_hash_entry
*ret
=
1044 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1048 return (struct bfd_hash_entry
*) ret
;
1052 already_linked_table_init ()
1054 if (! bfd_hash_table_init_n (&already_linked_table
,
1055 already_linked_newfunc
,
1057 einfo (_("%P%F: Failed to create hash table\n"));
1061 already_linked_table_free ()
1063 bfd_hash_table_free (&already_linked_table
);
1066 /* The wild routines.
1068 These expand statements like *(.text) and foo.o to a list of
1069 explicit actions, like foo.o(.text), bar.o(.text) and
1070 foo.o(.text, .data). */
1072 /* Return true if the PATTERN argument is a wildcard pattern.
1073 Although backslashes are treated specially if a pattern contains
1074 wildcards, we do not consider the mere presence of a backslash to
1075 be enough to cause the the pattern to be treated as a wildcard.
1076 That lets us handle DOS filenames more naturally. */
1080 const char *pattern
;
1084 for (s
= pattern
; *s
!= '\0'; ++s
)
1092 /* Add SECTION to the output section OUTPUT. Do this by creating a
1093 lang_input_section statement which is placed at PTR. FILE is the
1094 input file which holds SECTION. */
1097 wild_doit (ptr
, section
, output
, file
)
1098 lang_statement_list_type
*ptr
;
1100 lang_output_section_statement_type
*output
;
1101 lang_input_statement_type
*file
;
1106 flags
= bfd_get_section_flags (section
->owner
, section
);
1110 /* If we are doing a final link, discard sections marked with
1112 if (! link_info
.relocateable
1113 && (flags
& SEC_EXCLUDE
) != 0)
1116 /* Discard input sections which are assigned to a section named
1117 DISCARD_SECTION_NAME. */
1118 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1121 /* Discard debugging sections if we are stripping debugging
1123 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1124 && (flags
& SEC_DEBUGGING
) != 0)
1129 if (section
->output_section
== NULL
)
1131 /* This prevents future calls from assigning this section. */
1132 section
->output_section
= bfd_abs_section_ptr
;
1137 if (section
->output_section
== NULL
)
1140 lang_input_section_type
*new;
1143 if (output
->bfd_section
== NULL
)
1146 first
= ! output
->bfd_section
->linker_has_input
;
1147 output
->bfd_section
->linker_has_input
= 1;
1149 /* Add a section reference to the list. */
1150 new = new_stat (lang_input_section
, ptr
);
1152 new->section
= section
;
1154 section
->output_section
= output
->bfd_section
;
1156 flags
= section
->flags
;
1158 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1159 to an output section, because we want to be able to include a
1160 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1161 section (I don't know why we want to do this, but we do).
1162 build_link_order in ldwrite.c handles this case by turning
1163 the embedded SEC_NEVER_LOAD section into a fill. */
1165 flags
&= ~ SEC_NEVER_LOAD
;
1167 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1168 already been processed. One reason to do this is that on pe
1169 format targets, .text$foo sections go into .text and it's odd
1170 to see .text with SEC_LINK_ONCE set. */
1172 if (! link_info
.relocateable
)
1173 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1175 /* If this is not the first input section, and the SEC_READONLY
1176 flag is not currently set, then don't set it just because the
1177 input section has it set. */
1179 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1180 flags
&= ~ SEC_READONLY
;
1182 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1184 && ((section
->output_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1185 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1186 || ((flags
& SEC_MERGE
)
1187 && section
->output_section
->entsize
!= section
->entsize
)))
1189 section
->output_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1190 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1193 section
->output_section
->flags
|= flags
;
1195 if (flags
& SEC_MERGE
)
1196 section
->output_section
->entsize
= section
->entsize
;
1198 /* If SEC_READONLY is not set in the input section, then clear
1199 it from the output section. */
1200 if ((section
->flags
& SEC_READONLY
) == 0)
1201 section
->output_section
->flags
&= ~SEC_READONLY
;
1203 switch (output
->sectype
)
1205 case normal_section
:
1210 case overlay_section
:
1211 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1213 case noload_section
:
1214 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1215 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1219 /* Copy over SEC_SMALL_DATA. */
1220 if (section
->flags
& SEC_SMALL_DATA
)
1221 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1223 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1224 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1226 /* If supplied an aligment, then force it. */
1227 if (output
->section_alignment
!= -1)
1228 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1230 if (section
->flags
& SEC_BLOCK
)
1232 section
->output_section
->flags
|= SEC_BLOCK
;
1233 /* FIXME: This value should really be obtained from the bfd... */
1234 output
->block_value
= 128;
1239 /* Handle wildcard sorting. This returns the lang_input_section which
1240 should follow the one we are going to create for SECTION and FILE,
1241 based on the sorting requirements of WILD. It returns NULL if the
1242 new section should just go at the end of the current list. */
1244 static lang_statement_union_type
*
1245 wild_sort (wild
, file
, section
)
1246 lang_wild_statement_type
*wild
;
1247 lang_input_statement_type
*file
;
1250 const char *section_name
;
1251 lang_statement_union_type
*l
;
1253 if (! wild
->filenames_sorted
&& ! wild
->sections_sorted
)
1256 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1257 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->next
)
1259 lang_input_section_type
*ls
;
1261 if (l
->header
.type
!= lang_input_section_enum
)
1263 ls
= &l
->input_section
;
1265 /* Sorting by filename takes precedence over sorting by section
1268 if (wild
->filenames_sorted
)
1270 const char *fn
, *ln
;
1274 /* The PE support for the .idata section as generated by
1275 dlltool assumes that files will be sorted by the name of
1276 the archive and then the name of the file within the
1279 if (file
->the_bfd
!= NULL
1280 && bfd_my_archive (file
->the_bfd
) != NULL
)
1282 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1287 fn
= file
->filename
;
1291 if (ls
->ifile
->the_bfd
!= NULL
1292 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1294 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1299 ln
= ls
->ifile
->filename
;
1303 i
= strcmp (fn
, ln
);
1312 fn
= file
->filename
;
1314 ln
= ls
->ifile
->filename
;
1316 i
= strcmp (fn
, ln
);
1324 /* Here either the files are not sorted by name, or we are
1325 looking at the sections for this file. */
1327 if (wild
->sections_sorted
)
1329 if (strcmp (section_name
,
1330 bfd_get_section_name (ls
->ifile
->the_bfd
,
1340 /* Expand a wild statement for a particular FILE. SECTION may be
1341 NULL, in which case it is a wild card. */
1344 output_section_callback (ptr
, section
, file
, output
)
1345 lang_wild_statement_type
*ptr
;
1347 lang_input_statement_type
*file
;
1350 lang_statement_union_type
*before
;
1352 /* If the wild pattern was marked KEEP, the member sections
1353 should be as well. */
1354 if (ptr
->keep_sections
)
1355 section
->flags
|= SEC_KEEP
;
1357 before
= wild_sort (ptr
, file
, section
);
1359 /* Here BEFORE points to the lang_input_section which
1360 should follow the one we are about to add. If BEFORE
1361 is NULL, then the section should just go at the end
1362 of the current list. */
1365 wild_doit (&ptr
->children
, section
,
1366 (lang_output_section_statement_type
*) output
,
1370 lang_statement_list_type list
;
1371 lang_statement_union_type
**pp
;
1373 lang_list_init (&list
);
1374 wild_doit (&list
, section
,
1375 (lang_output_section_statement_type
*) output
,
1378 /* If we are discarding the section, LIST.HEAD will
1380 if (list
.head
!= NULL
)
1382 ASSERT (list
.head
->next
== NULL
);
1384 for (pp
= &ptr
->children
.head
;
1387 ASSERT (*pp
!= NULL
);
1389 list
.head
->next
= *pp
;
1395 /* This is passed a file name which must have been seen already and
1396 added to the statement tree. We will see if it has been opened
1397 already and had its symbols read. If not then we'll read it. */
1399 static lang_input_statement_type
*
1403 lang_input_statement_type
*search
;
1405 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1406 search
!= (lang_input_statement_type
*) NULL
;
1407 search
= (lang_input_statement_type
*) search
->next_real_file
)
1409 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1411 if (search
->filename
!= (char *) NULL
1412 && name
!= (char *) NULL
1413 && strcmp (search
->filename
, name
) == 0)
1417 if (search
== (lang_input_statement_type
*) NULL
)
1418 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1421 /* If we have already added this file, or this file is not real
1422 (FIXME: can that ever actually happen?) or the name is NULL
1423 (FIXME: can that ever actually happen?) don't add this file. */
1426 || search
->filename
== (const char *) NULL
)
1429 load_symbols (search
, (lang_statement_list_type
*) NULL
);
1434 /* Get the symbols for an input file. */
1437 load_symbols (entry
, place
)
1438 lang_input_statement_type
*entry
;
1439 lang_statement_list_type
*place
;
1446 ldfile_open_file (entry
);
1448 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1449 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1452 lang_statement_list_type
*hold
;
1454 err
= bfd_get_error ();
1456 /* See if the emulation has some special knowledge. */
1457 if (ldemul_unrecognized_file (entry
))
1460 if (err
== bfd_error_file_ambiguously_recognized
)
1464 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1465 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1466 for (p
= matching
; *p
!= NULL
; p
++)
1470 else if (err
!= bfd_error_file_not_recognized
1472 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1474 bfd_close (entry
->the_bfd
);
1475 entry
->the_bfd
= NULL
;
1477 /* Try to interpret the file as a linker script. */
1478 ldfile_open_command_file (entry
->filename
);
1483 ldfile_assumed_script
= true;
1484 parser_input
= input_script
;
1486 ldfile_assumed_script
= false;
1493 if (ldemul_recognized_file (entry
))
1496 /* We don't call ldlang_add_file for an archive. Instead, the
1497 add_symbols entry point will call ldlang_add_file, via the
1498 add_archive_element callback, for each element of the archive
1500 switch (bfd_get_format (entry
->the_bfd
))
1506 ldlang_add_file (entry
);
1507 if (trace_files
|| trace_file_tries
)
1508 info_msg ("%I\n", entry
);
1512 if (entry
->whole_archive
)
1514 bfd
*member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1516 while (member
!= NULL
)
1518 if (! bfd_check_format (member
, bfd_object
))
1519 einfo (_("%F%B: object %B in archive is not object\n"),
1520 entry
->the_bfd
, member
);
1521 if (! ((*link_info
.callbacks
->add_archive_element
)
1522 (&link_info
, member
, "--whole-archive")))
1524 if (! bfd_link_add_symbols (member
, &link_info
))
1525 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1526 member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1530 entry
->loaded
= true;
1536 if (! bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1537 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1539 entry
->loaded
= true;
1542 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1543 indicating that it is a wildcard. Separate lang_input_section
1544 statements are created for each part of the expansion; they are
1545 added after the wild statement S. OUTPUT is the output section. */
1548 wild (s
, section
, file
, target
, output
)
1549 lang_wild_statement_type
*s
;
1550 const char *section
;
1552 const char *target ATTRIBUTE_UNUSED
;
1553 lang_output_section_statement_type
*output
;
1555 walk_wild (s
, section
, file
, output_section_callback
, (PTR
) output
);
1557 if (section
!= (char *) NULL
1558 && strcmp (section
, "COMMON") == 0
1559 && default_common_section
== NULL
)
1561 /* Remember the section that common is going to in case we later
1562 get something which doesn't know where to put it. */
1563 default_common_section
= output
;
1567 /* Return true iff target is the sought target. */
1570 get_target (target
, data
)
1571 const bfd_target
*target
;
1574 const char *sought
= (const char *) data
;
1576 return strcmp (target
->name
, sought
) == 0;
1579 /* Like strcpy() but convert to lower case as well. */
1588 while ((c
= *src
++) != 0)
1590 if (isupper ((unsigned char) c
))
1599 /* Remove the first occurance of needle (if any) in haystack
1603 strcut (haystack
, needle
)
1607 haystack
= strstr (haystack
, needle
);
1613 for (src
= haystack
+ strlen (needle
); *src
;)
1614 *haystack
++ = *src
++;
1620 /* Compare two target format name strings.
1621 Return a value indicating how "similar" they are. */
1624 name_compare (first
, second
)
1632 copy1
= xmalloc (strlen (first
) + 1);
1633 copy2
= xmalloc (strlen (second
) + 1);
1635 /* Convert the names to lower case. */
1636 stricpy (copy1
, first
);
1637 stricpy (copy2
, second
);
1639 /* Remove and endian strings from the name. */
1640 strcut (copy1
, "big");
1641 strcut (copy1
, "little");
1642 strcut (copy2
, "big");
1643 strcut (copy2
, "little");
1645 /* Return a value based on how many characters match,
1646 starting from the beginning. If both strings are
1647 the same then return 10 * their length. */
1648 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1649 if (copy1
[result
] == 0)
1661 /* Set by closest_target_match() below. */
1662 static const bfd_target
*winner
;
1664 /* Scan all the valid bfd targets looking for one that has the endianness
1665 requirement that was specified on the command line, and is the nearest
1666 match to the original output target. */
1669 closest_target_match (target
, data
)
1670 const bfd_target
*target
;
1673 const bfd_target
*original
= (const bfd_target
*) data
;
1675 if (command_line
.endian
== ENDIAN_BIG
1676 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1679 if (command_line
.endian
== ENDIAN_LITTLE
1680 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1683 /* Must be the same flavour. */
1684 if (target
->flavour
!= original
->flavour
)
1687 /* If we have not found a potential winner yet, then record this one. */
1694 /* Oh dear, we now have two potential candidates for a successful match.
1695 Compare their names and choose the better one. */
1696 if (name_compare (target
->name
, original
->name
)
1697 > name_compare (winner
->name
, original
->name
))
1700 /* Keep on searching until wqe have checked them all. */
1704 /* Return the BFD target format of the first input file. */
1707 get_first_input_target ()
1709 char *target
= NULL
;
1711 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1713 if (s
->header
.type
== lang_input_statement_enum
1716 ldfile_open_file (s
);
1718 if (s
->the_bfd
!= NULL
1719 && bfd_check_format (s
->the_bfd
, bfd_object
))
1721 target
= bfd_get_target (s
->the_bfd
);
1732 /* Open the output file. */
1740 /* Has the user told us which output format to use? */
1741 if (output_target
== (char *) NULL
)
1743 /* No - has the current target been set to something other than
1745 if (current_target
!= default_target
)
1746 output_target
= current_target
;
1748 /* No - can we determine the format of the first input file? */
1751 output_target
= get_first_input_target ();
1753 /* Failed - use the default output target. */
1754 if (output_target
== NULL
)
1755 output_target
= default_target
;
1759 /* Has the user requested a particular endianness on the command
1761 if (command_line
.endian
!= ENDIAN_UNSET
)
1763 const bfd_target
*target
;
1764 enum bfd_endian desired_endian
;
1766 /* Get the chosen target. */
1767 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1769 /* If the target is not supported, we cannot do anything. */
1772 if (command_line
.endian
== ENDIAN_BIG
)
1773 desired_endian
= BFD_ENDIAN_BIG
;
1775 desired_endian
= BFD_ENDIAN_LITTLE
;
1777 /* See if the target has the wrong endianness. This should
1778 not happen if the linker script has provided big and
1779 little endian alternatives, but some scrips don't do
1781 if (target
->byteorder
!= desired_endian
)
1783 /* If it does, then see if the target provides
1784 an alternative with the correct endianness. */
1785 if (target
->alternative_target
!= NULL
1786 && (target
->alternative_target
->byteorder
== desired_endian
))
1787 output_target
= target
->alternative_target
->name
;
1790 /* Try to find a target as similar as possible to
1791 the default target, but which has the desired
1792 endian characteristic. */
1793 (void) bfd_search_for_target (closest_target_match
,
1796 /* Oh dear - we could not find any targets that
1797 satisfy our requirements. */
1799 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1801 output_target
= winner
->name
;
1807 output
= bfd_openw (name
, output_target
);
1809 if (output
== (bfd
*) NULL
)
1811 if (bfd_get_error () == bfd_error_invalid_target
)
1812 einfo (_("%P%F: target %s not found\n"), output_target
);
1814 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1817 delete_output_file_on_failure
= true;
1820 output
->flags
|= D_PAGED
;
1823 if (! bfd_set_format (output
, bfd_object
))
1824 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1825 if (! bfd_set_arch_mach (output
,
1826 ldfile_output_architecture
,
1827 ldfile_output_machine
))
1828 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1830 link_info
.hash
= bfd_link_hash_table_create (output
);
1831 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1832 einfo (_("%P%F: can not create link hash table: %E\n"));
1834 bfd_set_gp_size (output
, g_switch_value
);
1839 ldlang_open_output (statement
)
1840 lang_statement_union_type
*statement
;
1842 switch (statement
->header
.type
)
1844 case lang_output_statement_enum
:
1845 ASSERT (output_bfd
== (bfd
*) NULL
);
1846 output_bfd
= open_output (statement
->output_statement
.name
);
1847 ldemul_set_output_arch ();
1848 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1849 output_bfd
->flags
|= D_PAGED
;
1851 output_bfd
->flags
&= ~D_PAGED
;
1852 if (config
.text_read_only
)
1853 output_bfd
->flags
|= WP_TEXT
;
1855 output_bfd
->flags
&= ~WP_TEXT
;
1856 if (link_info
.traditional_format
)
1857 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1859 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1862 case lang_target_statement_enum
:
1863 current_target
= statement
->target_statement
.target
;
1870 /* Open all the input files. */
1873 open_input_bfds (s
, force
)
1874 lang_statement_union_type
*s
;
1877 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1879 switch (s
->header
.type
)
1881 case lang_constructors_statement_enum
:
1882 open_input_bfds (constructor_list
.head
, force
);
1884 case lang_output_section_statement_enum
:
1885 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1887 case lang_wild_statement_enum
:
1888 /* Maybe we should load the file's symbols. */
1889 if (s
->wild_statement
.filename
1890 && ! wildcardp (s
->wild_statement
.filename
))
1891 (void) lookup_name (s
->wild_statement
.filename
);
1892 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1894 case lang_group_statement_enum
:
1896 struct bfd_link_hash_entry
*undefs
;
1898 /* We must continually search the entries in the group
1899 until no new symbols are added to the list of undefined
1904 undefs
= link_info
.hash
->undefs_tail
;
1905 open_input_bfds (s
->group_statement
.children
.head
, true);
1907 while (undefs
!= link_info
.hash
->undefs_tail
);
1910 case lang_target_statement_enum
:
1911 current_target
= s
->target_statement
.target
;
1913 case lang_input_statement_enum
:
1914 if (s
->input_statement
.real
)
1916 lang_statement_list_type add
;
1918 s
->input_statement
.target
= current_target
;
1920 /* If we are being called from within a group, and this
1921 is an archive which has already been searched, then
1922 force it to be researched unless the whole archive
1923 has been loaded already. */
1925 && !s
->input_statement
.whole_archive
1926 && s
->input_statement
.loaded
1927 && bfd_check_format (s
->input_statement
.the_bfd
,
1929 s
->input_statement
.loaded
= false;
1931 lang_list_init (&add
);
1933 load_symbols (&s
->input_statement
, &add
);
1935 if (add
.head
!= NULL
)
1937 *add
.tail
= s
->next
;
1948 /* If there are [COMMONS] statements, put a wild one into the bss
1952 lang_reasonable_defaults ()
1955 lang_output_section_statement_lookup (".text");
1956 lang_output_section_statement_lookup (".data");
1958 default_common_section
= lang_output_section_statement_lookup (".bss");
1960 if (placed_commons
== false)
1962 lang_wild_statement_type
*new =
1963 new_stat (lang_wild_statement
,
1964 &default_common_section
->children
);
1966 new->section_name
= "COMMON";
1967 new->filename
= (char *) NULL
;
1968 lang_list_init (&new->children
);
1973 /* Add the supplied name to the symbol table as an undefined reference.
1974 Remove items from the chain as we open input bfds. */
1975 typedef struct ldlang_undef_chain_list
1977 struct ldlang_undef_chain_list
*next
;
1979 } ldlang_undef_chain_list_type
;
1981 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
1984 ldlang_add_undef (name
)
1985 const char *const name
;
1987 ldlang_undef_chain_list_type
*new =
1988 ((ldlang_undef_chain_list_type
*)
1989 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
1991 new->next
= ldlang_undef_chain_list_head
;
1992 ldlang_undef_chain_list_head
= new;
1994 new->name
= xstrdup (name
);
1997 /* Run through the list of undefineds created above and place them
1998 into the linker hash table as undefined symbols belonging to the
2002 lang_place_undefineds ()
2004 ldlang_undef_chain_list_type
*ptr
;
2006 for (ptr
= ldlang_undef_chain_list_head
;
2007 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
2010 struct bfd_link_hash_entry
*h
;
2012 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
2013 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2014 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2015 if (h
->type
== bfd_link_hash_new
)
2017 h
->type
= bfd_link_hash_undefined
;
2018 h
->u
.undef
.abfd
= NULL
;
2019 bfd_link_add_undef (link_info
.hash
, h
);
2024 /* Open input files and attatch to output sections. */
2027 map_input_to_output_sections (s
, target
, output_section_statement
)
2028 lang_statement_union_type
*s
;
2030 lang_output_section_statement_type
*output_section_statement
;
2032 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2034 switch (s
->header
.type
)
2037 case lang_wild_statement_enum
:
2038 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
2039 s
->wild_statement
.filename
, target
,
2040 output_section_statement
);
2043 case lang_constructors_statement_enum
:
2044 map_input_to_output_sections (constructor_list
.head
,
2046 output_section_statement
);
2048 case lang_output_section_statement_enum
:
2049 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2051 &s
->output_section_statement
);
2053 case lang_output_statement_enum
:
2055 case lang_target_statement_enum
:
2056 target
= s
->target_statement
.target
;
2058 case lang_group_statement_enum
:
2059 map_input_to_output_sections (s
->group_statement
.children
.head
,
2061 output_section_statement
);
2063 case lang_fill_statement_enum
:
2064 case lang_input_section_enum
:
2065 case lang_object_symbols_statement_enum
:
2066 case lang_data_statement_enum
:
2067 case lang_reloc_statement_enum
:
2068 case lang_padding_statement_enum
:
2069 case lang_input_statement_enum
:
2070 if (output_section_statement
!= NULL
2071 && output_section_statement
->bfd_section
== NULL
)
2072 init_os (output_section_statement
);
2074 case lang_assignment_statement_enum
:
2075 if (output_section_statement
!= NULL
2076 && output_section_statement
->bfd_section
== NULL
)
2077 init_os (output_section_statement
);
2079 /* Make sure that any sections mentioned in the assignment
2081 exp_init_os (s
->assignment_statement
.exp
);
2083 case lang_afile_asection_pair_statement_enum
:
2086 case lang_address_statement_enum
:
2087 /* Mark the specified section with the supplied address. */
2089 lang_output_section_statement_type
*os
=
2090 lang_output_section_statement_lookup
2091 (s
->address_statement
.section_name
);
2093 if (os
->bfd_section
== NULL
)
2095 os
->addr_tree
= s
->address_statement
.address
;
2103 print_output_section_statement (output_section_statement
)
2104 lang_output_section_statement_type
*output_section_statement
;
2106 asection
*section
= output_section_statement
->bfd_section
;
2109 if (output_section_statement
!= abs_output_section
)
2111 minfo ("\n%s", output_section_statement
->name
);
2113 if (section
!= NULL
)
2115 print_dot
= section
->vma
;
2117 len
= strlen (output_section_statement
->name
);
2118 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2123 while (len
< SECTION_NAME_MAP_LENGTH
)
2129 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2131 if (output_section_statement
->load_base
!= NULL
)
2135 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2136 "load base", lang_final_phase_enum
);
2137 minfo (_(" load address 0x%V"), addr
);
2144 print_statement_list (output_section_statement
->children
.head
,
2145 output_section_statement
);
2149 print_assignment (assignment
, output_section
)
2150 lang_assignment_statement_type
*assignment
;
2151 lang_output_section_statement_type
*output_section
;
2154 etree_value_type result
;
2156 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2159 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2160 lang_final_phase_enum
, print_dot
, &print_dot
);
2162 minfo ("0x%V", result
.value
+ result
.section
->bfd_section
->vma
);
2173 exp_print_tree (assignment
->exp
);
2179 print_input_statement (statm
)
2180 lang_input_statement_type
*statm
;
2182 if (statm
->filename
!= (char *) NULL
)
2184 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2188 /* Print all symbols defined in a particular section. This is called
2189 via bfd_link_hash_traverse. */
2192 print_one_symbol (hash_entry
, ptr
)
2193 struct bfd_link_hash_entry
*hash_entry
;
2196 asection
*sec
= (asection
*) ptr
;
2198 if ((hash_entry
->type
== bfd_link_hash_defined
2199 || hash_entry
->type
== bfd_link_hash_defweak
)
2200 && sec
== hash_entry
->u
.def
.section
)
2204 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2207 (hash_entry
->u
.def
.value
2208 + hash_entry
->u
.def
.section
->output_offset
2209 + hash_entry
->u
.def
.section
->output_section
->vma
));
2211 minfo (" %T\n", hash_entry
->root
.string
);
2217 /* Print information about an input section to the map file. */
2220 print_input_section (in
)
2221 lang_input_section_type
*in
;
2223 asection
*i
= in
->section
;
2224 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2225 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2226 ldfile_output_machine
);
2231 minfo ("%s", i
->name
);
2233 if (i
->output_section
!= NULL
)
2237 len
= 1 + strlen (i
->name
);
2238 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2243 while (len
< SECTION_NAME_MAP_LENGTH
)
2249 minfo ("0x%V %W %B\n",
2250 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2253 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2255 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2267 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2270 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2272 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2278 print_fill_statement (fill
)
2279 lang_fill_statement_type
*fill
;
2281 fprintf (config
.map_file
, " FILL mask 0x%x\n", fill
->fill
);
2285 print_data_statement (data
)
2286 lang_data_statement_type
*data
;
2292 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2293 ldfile_output_machine
);
2295 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2298 addr
= data
->output_vma
;
2299 if (data
->output_section
!= NULL
)
2300 addr
+= data
->output_section
->vma
;
2328 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2330 if (data
->exp
->type
.node_class
!= etree_value
)
2333 exp_print_tree (data
->exp
);
2338 print_dot
= addr
+ size
/ opb
;
2342 /* Print an address statement. These are generated by options like
2346 print_address_statement (address
)
2347 lang_address_statement_type
*address
;
2349 minfo (_("Address of section %s set to "), address
->section_name
);
2350 exp_print_tree (address
->address
);
2354 /* Print a reloc statement. */
2357 print_reloc_statement (reloc
)
2358 lang_reloc_statement_type
*reloc
;
2363 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2364 ldfile_output_machine
);
2366 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2369 addr
= reloc
->output_vma
;
2370 if (reloc
->output_section
!= NULL
)
2371 addr
+= reloc
->output_section
->vma
;
2373 size
= bfd_get_reloc_size (reloc
->howto
);
2375 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2377 if (reloc
->name
!= NULL
)
2378 minfo ("%s+", reloc
->name
);
2380 minfo ("%s+", reloc
->section
->name
);
2382 exp_print_tree (reloc
->addend_exp
);
2386 print_dot
= addr
+ size
/ opb
;
2390 print_padding_statement (s
)
2391 lang_padding_statement_type
*s
;
2395 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2396 ldfile_output_machine
);
2400 len
= sizeof " *fill*" - 1;
2401 while (len
< SECTION_NAME_MAP_LENGTH
)
2407 addr
= s
->output_offset
;
2408 if (s
->output_section
!= NULL
)
2409 addr
+= s
->output_section
->vma
;
2410 minfo ("0x%V %W", addr
, s
->size
);
2413 minfo (" %u", s
->fill
);
2417 print_dot
= addr
+ s
->size
/ opb
;
2421 print_wild_statement (w
, os
)
2422 lang_wild_statement_type
*w
;
2423 lang_output_section_statement_type
*os
;
2427 if (w
->filenames_sorted
)
2429 if (w
->exclude_filename_list
!= NULL
)
2432 minfo ("EXCLUDE_FILE ( %s", w
->exclude_filename_list
->name
);
2433 for (tmp
= w
->exclude_filename_list
->next
; tmp
; tmp
= tmp
->next
)
2434 minfo (", %s", tmp
->name
);
2437 if (w
->filename
!= NULL
)
2438 minfo ("%s", w
->filename
);
2441 if (w
->filenames_sorted
)
2445 if (w
->sections_sorted
)
2447 if (w
->section_name
!= NULL
)
2448 minfo ("%s", w
->section_name
);
2451 if (w
->sections_sorted
)
2457 print_statement_list (w
->children
.head
, os
);
2460 /* Print a group statement. */
2464 lang_group_statement_type
*s
;
2465 lang_output_section_statement_type
*os
;
2467 fprintf (config
.map_file
, "START GROUP\n");
2468 print_statement_list (s
->children
.head
, os
);
2469 fprintf (config
.map_file
, "END GROUP\n");
2472 /* Print the list of statements in S.
2473 This can be called for any statement type. */
2476 print_statement_list (s
, os
)
2477 lang_statement_union_type
*s
;
2478 lang_output_section_statement_type
*os
;
2482 print_statement (s
, os
);
2487 /* Print the first statement in statement list S.
2488 This can be called for any statement type. */
2491 print_statement (s
, os
)
2492 lang_statement_union_type
*s
;
2493 lang_output_section_statement_type
*os
;
2495 switch (s
->header
.type
)
2498 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2501 case lang_constructors_statement_enum
:
2502 if (constructor_list
.head
!= NULL
)
2504 if (constructors_sorted
)
2505 minfo (" SORT (CONSTRUCTORS)\n");
2507 minfo (" CONSTRUCTORS\n");
2508 print_statement_list (constructor_list
.head
, os
);
2511 case lang_wild_statement_enum
:
2512 print_wild_statement (&s
->wild_statement
, os
);
2514 case lang_address_statement_enum
:
2515 print_address_statement (&s
->address_statement
);
2517 case lang_object_symbols_statement_enum
:
2518 minfo (" CREATE_OBJECT_SYMBOLS\n");
2520 case lang_fill_statement_enum
:
2521 print_fill_statement (&s
->fill_statement
);
2523 case lang_data_statement_enum
:
2524 print_data_statement (&s
->data_statement
);
2526 case lang_reloc_statement_enum
:
2527 print_reloc_statement (&s
->reloc_statement
);
2529 case lang_input_section_enum
:
2530 print_input_section (&s
->input_section
);
2532 case lang_padding_statement_enum
:
2533 print_padding_statement (&s
->padding_statement
);
2535 case lang_output_section_statement_enum
:
2536 print_output_section_statement (&s
->output_section_statement
);
2538 case lang_assignment_statement_enum
:
2539 print_assignment (&s
->assignment_statement
, os
);
2541 case lang_target_statement_enum
:
2542 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2544 case lang_output_statement_enum
:
2545 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2546 if (output_target
!= NULL
)
2547 minfo (" %s", output_target
);
2550 case lang_input_statement_enum
:
2551 print_input_statement (&s
->input_statement
);
2553 case lang_group_statement_enum
:
2554 print_group (&s
->group_statement
, os
);
2556 case lang_afile_asection_pair_statement_enum
:
2565 print_statement_list (statement_list
.head
, abs_output_section
);
2568 /* Print the first N statements in statement list S to STDERR.
2569 If N == 0, nothing is printed.
2570 If N < 0, the entire list is printed.
2571 Intended to be called from GDB. */
2574 dprint_statement (s
, n
)
2575 lang_statement_union_type
*s
;
2578 FILE *map_save
= config
.map_file
;
2580 config
.map_file
= stderr
;
2583 print_statement_list (s
, abs_output_section
);
2586 while (s
&& --n
>= 0)
2588 print_statement (s
, abs_output_section
);
2593 config
.map_file
= map_save
;
2597 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
2598 lang_statement_union_type
**this_ptr
;
2601 asection
*output_section_statement
;
2604 /* Align this section first to the
2605 input sections requirement, then
2606 to the output section's requirement.
2607 If this alignment is > than any seen before,
2608 then record it too. Perform the alignment by
2609 inserting a magic 'padding' statement. */
2611 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2612 ldfile_output_machine
);
2613 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
2615 if (alignment_needed
!= 0)
2617 lang_statement_union_type
*new =
2618 ((lang_statement_union_type
*)
2619 stat_alloc (sizeof (lang_padding_statement_type
)));
2621 /* Link into existing chain. */
2622 new->header
.next
= *this_ptr
;
2624 new->header
.type
= lang_padding_statement_enum
;
2625 new->padding_statement
.output_section
= output_section_statement
;
2626 new->padding_statement
.output_offset
=
2627 dot
- output_section_statement
->vma
;
2628 new->padding_statement
.fill
= fill
;
2629 new->padding_statement
.size
= alignment_needed
* opb
;
2632 /* Remember the most restrictive alignment. */
2633 if (power
> output_section_statement
->alignment_power
)
2635 output_section_statement
->alignment_power
= power
;
2637 output_section_statement
->_raw_size
+= alignment_needed
* opb
;
2639 return dot
+ alignment_needed
;
2642 /* Work out how much this section will move the dot point. */
2645 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
2646 lang_statement_union_type
**this_ptr
;
2647 lang_output_section_statement_type
*output_section_statement
;
2650 boolean relax ATTRIBUTE_UNUSED
;
2652 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2653 asection
*i
= is
->section
;
2654 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2655 ldfile_output_machine
);
2657 if (is
->ifile
->just_syms_flag
== false)
2659 if (output_section_statement
->subsection_alignment
!= -1)
2660 i
->alignment_power
=
2661 output_section_statement
->subsection_alignment
;
2663 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
2664 output_section_statement
->bfd_section
, dot
);
2666 /* Remember where in the output section this input section goes. */
2668 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
2670 /* Mark how big the output section must be to contain this now. */
2671 if (i
->_cooked_size
!= 0)
2672 dot
+= i
->_cooked_size
/ opb
;
2674 dot
+= i
->_raw_size
/ opb
;
2675 output_section_statement
->bfd_section
->_raw_size
=
2676 (dot
- output_section_statement
->bfd_section
->vma
) * opb
;
2680 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2686 #define IGNORE_SECTION(bfd, s) \
2687 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2688 != (SEC_ALLOC | SEC_LOAD)) \
2689 || bfd_section_size (bfd, s) == 0)
2691 /* Check to see if any allocated sections overlap with other allocated
2692 sections. This can happen when the linker script specifically specifies
2693 the output section addresses of the two sections. */
2696 lang_check_section_addresses ()
2699 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2701 /* Scan all sections in the output list. */
2702 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2706 /* Ignore sections which are not loaded or which have no contents. */
2707 if (IGNORE_SECTION (output_bfd
, s
))
2710 /* Once we reach section 's' stop our seach. This prevents two
2711 warning messages from being produced, one for 'section A overlaps
2712 section B' and one for 'section B overlaps section A'. */
2713 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2720 /* Only consider loadable sections with real contents. */
2721 if (IGNORE_SECTION (output_bfd
, os
))
2724 /* We must check the sections' LMA addresses not their
2725 VMA addresses because overlay sections can have
2726 overlapping VMAs but they must have distinct LMAs. */
2727 s_start
= bfd_section_lma (output_bfd
, s
);
2728 os_start
= bfd_section_lma (output_bfd
, os
);
2729 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2730 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2732 /* Look for an overlap. */
2733 if ((s_end
< os_start
) || (s_start
> os_end
))
2737 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2738 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2740 /* Once we have found one overlap for this section,
2741 stop looking for others. */
2747 /* This variable indicates whether bfd_relax_section should be called
2750 static boolean relax_again
;
2752 /* Make sure the new address is within the region. We explicitly permit the
2753 current address to be at the exact end of the region when the address is
2754 non-zero, in case the region is at the end of addressable memory and the
2755 calculation wraps around. */
2758 os_region_check (os
, region
, tree
, base
)
2759 lang_output_section_statement_type
*os
;
2760 struct memory_region_struct
*region
;
2764 if ((region
->current
< region
->origin
2765 || (region
->current
- region
->origin
> region
->length
))
2766 && ((region
->current
!= region
->origin
+ region
->length
)
2769 if (tree
!= (etree_type
*) NULL
)
2771 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2773 os
->bfd_section
->owner
,
2774 os
->bfd_section
->name
,
2779 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2781 os
->bfd_section
->owner
,
2782 os
->bfd_section
->name
);
2784 /* Reset the region pointer. */
2785 region
->current
= region
->origin
;
2789 /* Set the sizes for all the output sections. */
2792 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2793 lang_statement_union_type
*s
;
2794 lang_output_section_statement_type
*output_section_statement
;
2795 lang_statement_union_type
**prev
;
2800 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2801 ldfile_output_machine
);
2803 /* Size up the sections from their constituent parts. */
2804 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2806 switch (s
->header
.type
)
2808 case lang_output_section_statement_enum
:
2811 lang_output_section_statement_type
*os
;
2813 os
= &s
->output_section_statement
;
2814 if (os
->bfd_section
== NULL
)
2815 /* This section was never actually created. */
2818 /* If this is a COFF shared library section, use the size and
2819 address from the input section. FIXME: This is COFF
2820 specific; it would be cleaner if there were some other way
2821 to do this, but nothing simple comes to mind. */
2822 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2826 if (os
->children
.head
== NULL
2827 || os
->children
.head
->next
!= NULL
2828 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2829 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2832 input
= os
->children
.head
->input_section
.section
;
2833 bfd_set_section_vma (os
->bfd_section
->owner
,
2835 bfd_section_vma (input
->owner
, input
));
2836 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2840 if (bfd_is_abs_section (os
->bfd_section
))
2842 /* No matter what happens, an abs section starts at zero. */
2843 ASSERT (os
->bfd_section
->vma
== 0);
2847 if (os
->addr_tree
== (etree_type
*) NULL
)
2849 /* No address specified for this section, get one
2850 from the region specification. */
2851 if (os
->region
== (lang_memory_region_type
*) NULL
2852 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2853 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2854 && os
->region
->name
[0] == '*'
2855 && strcmp (os
->region
->name
, "*default*") == 0))
2857 os
->region
= lang_memory_default (os
->bfd_section
);
2860 /* If a loadable section is using the default memory
2861 region, and some non default memory regions were
2862 defined, issue a warning. */
2863 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2864 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2865 && ! link_info
.relocateable
2866 && strcmp (os
->region
->name
, "*default*") == 0
2867 && lang_memory_region_list
!= NULL
2868 && (strcmp (lang_memory_region_list
->name
,
2870 || lang_memory_region_list
->next
!= NULL
))
2871 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2872 bfd_get_section_name (output_bfd
,
2875 dot
= os
->region
->current
;
2877 if (os
->section_alignment
== -1)
2882 dot
= align_power (dot
,
2883 os
->bfd_section
->alignment_power
);
2885 if (dot
!= olddot
&& config
.warn_section_align
)
2886 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2887 os
->name
, (unsigned int) (dot
- olddot
));
2894 r
= exp_fold_tree (os
->addr_tree
,
2896 lang_allocating_phase_enum
,
2898 if (r
.valid_p
== false)
2900 einfo (_("%F%S: non constant address expression for section %s\n"),
2903 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2906 /* The section starts here.
2907 First, align to what the section needs. */
2909 if (os
->section_alignment
!= -1)
2910 dot
= align_power (dot
, os
->section_alignment
);
2912 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2914 os
->bfd_section
->output_offset
= 0;
2917 (void) lang_size_sections (os
->children
.head
, os
,
2919 os
->fill
, dot
, relax
);
2921 /* Put the section within the requested block size, or
2922 align at the block boundary. */
2923 after
= ALIGN_N (os
->bfd_section
->vma
2924 + os
->bfd_section
->_raw_size
/ opb
,
2925 /* The coercion here is important, see ld.h. */
2926 (bfd_vma
) os
->block_value
);
2928 if (bfd_is_abs_section (os
->bfd_section
))
2929 ASSERT (after
== os
->bfd_section
->vma
);
2931 os
->bfd_section
->_raw_size
=
2932 (after
- os
->bfd_section
->vma
) * opb
;
2933 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
2934 os
->processed
= true;
2936 /* Update dot in the region ?
2937 We only do this if the section is going to be allocated,
2938 since unallocated sections do not contribute to the region's
2939 overall size in memory.
2941 If the SEC_NEVER_LOAD bit is not set, it will affect the
2942 addresses of sections after it. We have to update
2944 if (os
->region
!= (lang_memory_region_type
*) NULL
2945 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2946 & SEC_NEVER_LOAD
) == 0
2947 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2948 & (SEC_ALLOC
| SEC_LOAD
))))
2950 os
->region
->current
= dot
;
2952 /* Make sure the new address is within the region. */
2953 os_region_check (os
, os
->region
, os
->addr_tree
,
2954 os
->bfd_section
->vma
);
2956 /* If there's no load address specified, use the run
2957 region as the load region. */
2958 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
2959 os
->lma_region
= os
->region
;
2961 if (os
->lma_region
!= NULL
)
2963 if (os
->load_base
!= NULL
)
2965 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
2969 /* Don't allocate twice. */
2970 if (os
->lma_region
!= os
->region
)
2972 /* Set load_base, which will be handled later. */
2974 exp_intop (os
->lma_region
->current
);
2975 os
->lma_region
->current
+=
2976 os
->bfd_section
->_raw_size
/ opb
;
2977 os_region_check (os
, os
->lma_region
, NULL
,
2978 os
->bfd_section
->lma
);
2986 case lang_constructors_statement_enum
:
2987 dot
= lang_size_sections (constructor_list
.head
,
2988 output_section_statement
,
2989 &s
->wild_statement
.children
.head
,
2994 case lang_data_statement_enum
:
2996 unsigned int size
= 0;
2998 s
->data_statement
.output_vma
=
2999 dot
- output_section_statement
->bfd_section
->vma
;
3000 s
->data_statement
.output_section
=
3001 output_section_statement
->bfd_section
;
3003 switch (s
->data_statement
.type
)
3024 output_section_statement
->bfd_section
->_raw_size
+= size
;
3025 /* The output section gets contents, and then we inspect for
3026 any flags set in the input script which override any ALLOC. */
3027 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3028 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3030 output_section_statement
->bfd_section
->flags
|=
3031 SEC_ALLOC
| SEC_LOAD
;
3036 case lang_reloc_statement_enum
:
3040 s
->reloc_statement
.output_vma
=
3041 dot
- output_section_statement
->bfd_section
->vma
;
3042 s
->reloc_statement
.output_section
=
3043 output_section_statement
->bfd_section
;
3044 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3046 output_section_statement
->bfd_section
->_raw_size
+= size
;
3050 case lang_wild_statement_enum
:
3052 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
3053 output_section_statement
,
3054 &s
->wild_statement
.children
.head
,
3059 case lang_object_symbols_statement_enum
:
3060 link_info
.create_object_symbols_section
=
3061 output_section_statement
->bfd_section
;
3063 case lang_output_statement_enum
:
3064 case lang_target_statement_enum
:
3066 case lang_input_section_enum
:
3070 i
= (*prev
)->input_section
.section
;
3073 if (i
->_cooked_size
== 0)
3074 i
->_cooked_size
= i
->_raw_size
;
3080 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3081 einfo (_("%P%F: can't relax section: %E\n"));
3085 dot
= size_input_section (prev
,
3086 output_section_statement
,
3087 output_section_statement
->fill
,
3091 case lang_input_statement_enum
:
3093 case lang_fill_statement_enum
:
3094 s
->fill_statement
.output_section
=
3095 output_section_statement
->bfd_section
;
3097 fill
= s
->fill_statement
.fill
;
3099 case lang_assignment_statement_enum
:
3101 bfd_vma newdot
= dot
;
3103 exp_fold_tree (s
->assignment_statement
.exp
,
3104 output_section_statement
,
3105 lang_allocating_phase_enum
,
3111 /* The assignment changed dot. Insert a pad. */
3112 if (output_section_statement
== abs_output_section
)
3114 /* If we don't have an output section, then just adjust
3115 the default memory address. */
3116 lang_memory_region_lookup ("*default*")->current
= newdot
;
3120 lang_statement_union_type
*new =
3121 ((lang_statement_union_type
*)
3122 stat_alloc (sizeof (lang_padding_statement_type
)));
3124 /* Link into existing chain. */
3125 new->header
.next
= *prev
;
3127 new->header
.type
= lang_padding_statement_enum
;
3128 new->padding_statement
.output_section
=
3129 output_section_statement
->bfd_section
;
3130 new->padding_statement
.output_offset
=
3131 dot
- output_section_statement
->bfd_section
->vma
;
3132 new->padding_statement
.fill
= fill
;
3133 new->padding_statement
.size
= (newdot
- dot
) * opb
;
3134 output_section_statement
->bfd_section
->_raw_size
+=
3135 new->padding_statement
.size
;
3143 case lang_padding_statement_enum
:
3144 /* If we are relaxing, and this is not the first pass, some
3145 padding statements may have been inserted during previous
3146 passes. We may have to move the padding statement to a new
3147 location if dot has a different value at this point in this
3148 pass than it did at this point in the previous pass. */
3149 s
->padding_statement
.output_offset
=
3150 dot
- output_section_statement
->bfd_section
->vma
;
3151 dot
+= s
->padding_statement
.size
/ opb
;
3152 output_section_statement
->bfd_section
->_raw_size
+=
3153 s
->padding_statement
.size
;
3156 case lang_group_statement_enum
:
3157 dot
= lang_size_sections (s
->group_statement
.children
.head
,
3158 output_section_statement
,
3159 &s
->group_statement
.children
.head
,
3167 /* This can only get here when relaxing is turned on. */
3169 case lang_address_statement_enum
:
3172 prev
= &s
->header
.next
;
3178 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3179 lang_statement_union_type
*s
;
3180 lang_output_section_statement_type
*output_section_statement
;
3184 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3185 ldfile_output_machine
);
3187 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
3189 switch (s
->header
.type
)
3191 case lang_constructors_statement_enum
:
3192 dot
= lang_do_assignments (constructor_list
.head
,
3193 output_section_statement
,
3198 case lang_output_section_statement_enum
:
3200 lang_output_section_statement_type
*os
;
3202 os
= &(s
->output_section_statement
);
3203 if (os
->bfd_section
!= NULL
)
3205 dot
= os
->bfd_section
->vma
;
3206 (void) lang_do_assignments (os
->children
.head
, os
,
3208 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3213 /* If nothing has been placed into the output section then
3214 it won't have a bfd_section. */
3215 if (os
->bfd_section
)
3217 os
->bfd_section
->lma
3218 = exp_get_abs_int (os
->load_base
, 0, "load base",
3219 lang_final_phase_enum
);
3224 case lang_wild_statement_enum
:
3226 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3227 output_section_statement
,
3232 case lang_object_symbols_statement_enum
:
3233 case lang_output_statement_enum
:
3234 case lang_target_statement_enum
:
3236 case lang_common_statement_enum
:
3239 case lang_data_statement_enum
:
3241 etree_value_type value
;
3243 value
= exp_fold_tree (s
->data_statement
.exp
,
3245 lang_final_phase_enum
, dot
, &dot
);
3246 s
->data_statement
.value
= value
.value
;
3247 if (value
.valid_p
== false)
3248 einfo (_("%F%P: invalid data statement\n"));
3252 switch (s
->data_statement
.type
)
3276 case lang_reloc_statement_enum
:
3278 etree_value_type value
;
3280 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3282 lang_final_phase_enum
, dot
, &dot
);
3283 s
->reloc_statement
.addend_value
= value
.value
;
3284 if (value
.valid_p
== false)
3285 einfo (_("%F%P: invalid reloc statement\n"));
3287 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3290 case lang_input_section_enum
:
3292 asection
*in
= s
->input_section
.section
;
3294 if (in
->_cooked_size
!= 0)
3295 dot
+= in
->_cooked_size
/ opb
;
3297 dot
+= in
->_raw_size
/ opb
;
3301 case lang_input_statement_enum
:
3303 case lang_fill_statement_enum
:
3304 fill
= s
->fill_statement
.fill
;
3306 case lang_assignment_statement_enum
:
3308 exp_fold_tree (s
->assignment_statement
.exp
,
3309 output_section_statement
,
3310 lang_final_phase_enum
,
3316 case lang_padding_statement_enum
:
3317 dot
+= s
->padding_statement
.size
/ opb
;
3320 case lang_group_statement_enum
:
3321 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3322 output_section_statement
,
3330 case lang_address_statement_enum
:
3338 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3339 operator .startof. (section_name), it produces an undefined symbol
3340 .startof.section_name. Similarly, when it sees
3341 .sizeof. (section_name), it produces an undefined symbol
3342 .sizeof.section_name. For all the output sections, we look for
3343 such symbols, and set them to the correct value. */
3350 if (link_info
.relocateable
)
3353 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3355 const char *secname
;
3357 struct bfd_link_hash_entry
*h
;
3359 secname
= bfd_get_section_name (output_bfd
, s
);
3360 buf
= xmalloc (10 + strlen (secname
));
3362 sprintf (buf
, ".startof.%s", secname
);
3363 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3364 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3366 h
->type
= bfd_link_hash_defined
;
3367 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3368 h
->u
.def
.section
= bfd_abs_section_ptr
;
3371 sprintf (buf
, ".sizeof.%s", secname
);
3372 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3373 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3377 opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3378 ldfile_output_machine
);
3379 h
->type
= bfd_link_hash_defined
;
3380 if (s
->_cooked_size
!= 0)
3381 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3383 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3384 h
->u
.def
.section
= bfd_abs_section_ptr
;
3394 struct bfd_link_hash_entry
*h
;
3397 if (link_info
.relocateable
|| link_info
.shared
)
3402 if (entry_symbol
== (char *) NULL
)
3404 /* No entry has been specified. Look for start, but don't warn
3405 if we don't find it. */
3406 entry_symbol
= "start";
3410 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
3411 if (h
!= (struct bfd_link_hash_entry
*) NULL
3412 && (h
->type
== bfd_link_hash_defined
3413 || h
->type
== bfd_link_hash_defweak
)
3414 && h
->u
.def
.section
->output_section
!= NULL
)
3418 val
= (h
->u
.def
.value
3419 + bfd_get_section_vma (output_bfd
,
3420 h
->u
.def
.section
->output_section
)
3421 + h
->u
.def
.section
->output_offset
);
3422 if (! bfd_set_start_address (output_bfd
, val
))
3423 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
);
3430 /* We couldn't find the entry symbol. Try parsing it as a
3432 val
= bfd_scan_vma (entry_symbol
, &send
, 0);
3435 if (! bfd_set_start_address (output_bfd
, val
))
3436 einfo (_("%P%F: can't set start address\n"));
3442 /* Can't find the entry symbol, and it's not a number. Use
3443 the first address in the text section. */
3444 ts
= bfd_get_section_by_name (output_bfd
, ".text");
3445 if (ts
!= (asection
*) NULL
)
3448 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3449 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
3450 if (! bfd_set_start_address (output_bfd
,
3451 bfd_get_section_vma (output_bfd
,
3453 einfo (_("%P%F: can't set start address\n"));
3458 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3465 /* This is the routine to handle BFD error messages. */
3467 #ifdef ANSI_PROTOTYPES
3470 record_bfd_errors (const char *s
, ...)
3478 vfprintf (stderr
, s
, p
);
3482 fprintf (stderr
, "\n");
3487 #else /* ! defined (ANSI_PROTOTYPES) */
3490 record_bfd_errors (va_alist
)
3500 s
= va_arg (p
, const char *);
3501 vfprintf (stderr
, s
, p
);
3505 fprintf (stderr
, "\n");
3510 #endif /* ! defined (ANSI_PROTOTYPES) */
3512 /* This is a small function used when we want to ignore errors from
3516 #ifdef ANSI_PROTOTYPES
3517 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3519 ignore_bfd_errors (s
)
3520 const char *s ATTRIBUTE_UNUSED
;
3523 /* Don't do anything. */
3526 /* Check that the architecture of all the input files is compatible
3527 with the output file. Also call the backend to let it do any
3528 other checking that is needed. */
3533 lang_statement_union_type
*file
;
3535 const bfd_arch_info_type
*compatible
;
3537 for (file
= file_chain
.head
;
3538 file
!= (lang_statement_union_type
*) NULL
;
3539 file
= file
->input_statement
.next
)
3541 input_bfd
= file
->input_statement
.the_bfd
;
3542 compatible
= bfd_arch_get_compatible (input_bfd
,
3544 if (compatible
== NULL
)
3546 if (command_line
.warn_mismatch
)
3547 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3548 bfd_printable_name (input_bfd
), input_bfd
,
3549 bfd_printable_name (output_bfd
));
3551 else if (bfd_count_sections (input_bfd
))
3553 /* If the input bfd has no contents, it shouldn't set the
3554 private data of the output bfd. */
3556 bfd_error_handler_type pfn
= NULL
;
3558 /* If we aren't supposed to warn about mismatched input
3559 files, temporarily set the BFD error handler to a
3560 function which will do nothing. We still want to call
3561 bfd_merge_private_bfd_data, since it may set up
3562 information which is needed in the output file. */
3563 if (! command_line
.warn_mismatch
)
3564 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3565 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3567 if (command_line
.warn_mismatch
)
3568 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3571 if (! command_line
.warn_mismatch
)
3572 bfd_set_error_handler (pfn
);
3577 /* Look through all the global common symbols and attach them to the
3578 correct section. The -sort-common command line switch may be used
3579 to roughly sort the entries by size. */
3584 if (link_info
.relocateable
3585 && ! command_line
.force_common_definition
)
3588 if (! config
.sort_common
)
3589 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3594 for (power
= 4; power
>= 0; power
--)
3595 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3600 /* Place one common symbol in the correct section. */
3603 lang_one_common (h
, info
)
3604 struct bfd_link_hash_entry
*h
;
3607 unsigned int power_of_two
;
3610 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3611 ldfile_output_machine
);
3613 if (h
->type
!= bfd_link_hash_common
)
3617 power_of_two
= h
->u
.c
.p
->alignment_power
;
3619 if (config
.sort_common
3620 && power_of_two
< (unsigned int) *(int *) info
)
3623 section
= h
->u
.c
.p
->section
;
3625 /* Increase the size of the section. */
3626 section
->_cooked_size
= ALIGN_N ((section
->_cooked_size
+ opb
- 1) / opb
,
3627 (bfd_size_type
) (1 << power_of_two
)) * opb
;
3629 /* Adjust the alignment if necessary. */
3630 if (power_of_two
> section
->alignment_power
)
3631 section
->alignment_power
= power_of_two
;
3633 /* Change the symbol from common to defined. */
3634 h
->type
= bfd_link_hash_defined
;
3635 h
->u
.def
.section
= section
;
3636 h
->u
.def
.value
= section
->_cooked_size
;
3638 /* Increase the size of the section. */
3639 section
->_cooked_size
+= size
;
3641 /* Make sure the section is allocated in memory, and make sure that
3642 it is no longer a common section. */
3643 section
->flags
|= SEC_ALLOC
;
3644 section
->flags
&= ~SEC_IS_COMMON
;
3646 if (config
.map_file
!= NULL
)
3648 static boolean header_printed
;
3653 if (! header_printed
)
3655 minfo (_("\nAllocating common symbols\n"));
3656 minfo (_("Common symbol size file\n\n"));
3657 header_printed
= true;
3660 name
= demangle (h
->root
.string
);
3662 len
= strlen (name
);
3677 if (size
<= 0xffffffff)
3678 sprintf (buf
, "%lx", (unsigned long) size
);
3680 sprintf_vma (buf
, size
);
3690 minfo ("%B\n", section
->owner
);
3696 /* Run through the input files and ensure that every input section has
3697 somewhere to go. If one is found without a destination then create
3698 an input request and place it into the statement tree. */
3701 lang_place_orphans ()
3703 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3707 for (s
= file
->the_bfd
->sections
;
3708 s
!= (asection
*) NULL
;
3711 if (s
->output_section
== (asection
*) NULL
)
3713 /* This section of the file is not attatched, root
3714 around for a sensible place for it to go. */
3716 if (file
->just_syms_flag
)
3718 /* We are only retrieving symbol values from this
3719 file. We want the symbols to act as though the
3720 values in the file are absolute. */
3721 s
->output_section
= bfd_abs_section_ptr
;
3722 s
->output_offset
= s
->vma
;
3724 else if (strcmp (s
->name
, "COMMON") == 0)
3726 /* This is a lonely common section which must have
3727 come from an archive. We attach to the section
3728 with the wildcard. */
3729 if (! link_info
.relocateable
3730 || command_line
.force_common_definition
)
3732 if (default_common_section
== NULL
)
3735 /* This message happens when using the
3736 svr3.ifile linker script, so I have
3738 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3740 default_common_section
=
3741 lang_output_section_statement_lookup (".bss");
3744 wild_doit (&default_common_section
->children
, s
,
3745 default_common_section
, file
);
3748 else if (ldemul_place_orphan (file
, s
))
3752 lang_output_section_statement_type
*os
=
3753 lang_output_section_statement_lookup (s
->name
);
3755 wild_doit (&os
->children
, s
, os
, file
);
3763 lang_set_flags (ptr
, flags
, invert
)
3764 lang_memory_region_type
*ptr
;
3768 flagword
*ptr_flags
;
3770 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3776 *ptr_flags
|= SEC_ALLOC
;
3780 *ptr_flags
|= SEC_READONLY
;
3784 *ptr_flags
|= SEC_DATA
;
3788 *ptr_flags
|= SEC_CODE
;
3793 *ptr_flags
|= SEC_LOAD
;
3797 einfo (_("%P%F: invalid syntax in flags\n"));
3804 /* Call a function on each input file. This function will be called
3805 on an archive, but not on the elements. */
3808 lang_for_each_input_file (func
)
3809 void (*func
) PARAMS ((lang_input_statement_type
*));
3811 lang_input_statement_type
*f
;
3813 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3815 f
= (lang_input_statement_type
*) f
->next_real_file
)
3819 /* Call a function on each file. The function will be called on all
3820 the elements of an archive which are included in the link, but will
3821 not be called on the archive file itself. */
3824 lang_for_each_file (func
)
3825 void (*func
) PARAMS ((lang_input_statement_type
*));
3827 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3838 lang_for_each_input_section (func
)
3839 void (*func
) PARAMS ((bfd
*ab
, asection
*as
));
3841 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3845 for (s
= f
->the_bfd
->sections
;
3846 s
!= (asection
*) NULL
;
3849 func (f
->the_bfd
, s
);
3857 ldlang_add_file (entry
)
3858 lang_input_statement_type
*entry
;
3862 lang_statement_append (&file_chain
,
3863 (lang_statement_union_type
*) entry
,
3866 /* The BFD linker needs to have a list of all input BFDs involved in
3868 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3869 ASSERT (entry
->the_bfd
!= output_bfd
);
3870 for (pp
= &link_info
.input_bfds
;
3871 *pp
!= (bfd
*) NULL
;
3872 pp
= &(*pp
)->link_next
)
3874 *pp
= entry
->the_bfd
;
3875 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3876 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3878 /* Look through the sections and check for any which should not be
3879 included in the link. We need to do this now, so that we can
3880 notice when the backend linker tries to report multiple
3881 definition errors for symbols which are in sections we aren't
3882 going to link. FIXME: It might be better to entirely ignore
3883 symbols which are defined in sections which are going to be
3884 discarded. This would require modifying the backend linker for
3885 each backend which might set the SEC_LINK_ONCE flag. If we do
3886 this, we should probably handle SEC_EXCLUDE in the same way. */
3888 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
3892 lang_add_output (name
, from_script
)
3896 /* Make -o on command line override OUTPUT in script. */
3897 if (had_output_filename
== false || !from_script
)
3899 output_filename
= name
;
3900 had_output_filename
= true;
3904 static lang_output_section_statement_type
*current_section
;
3916 for (l
= 0; l
< 32; l
++)
3918 if (i
>= (unsigned int) x
)
3926 lang_output_section_statement_type
*
3927 lang_enter_output_section_statement (output_section_statement_name
,
3928 address_exp
, sectype
, block_value
,
3929 align
, subalign
, ebase
)
3930 const char *output_section_statement_name
;
3931 etree_type
*address_exp
;
3932 enum section_type sectype
;
3933 bfd_vma block_value
;
3935 etree_type
*subalign
;
3938 lang_output_section_statement_type
*os
;
3942 lang_output_section_statement_lookup (output_section_statement_name
);
3944 /* Add this statement to tree. */
3946 add_statement (lang_output_section_statement_enum
,
3947 output_section_statement
);
3949 /* Make next things chain into subchain of this. */
3951 if (os
->addr_tree
== (etree_type
*) NULL
)
3953 os
->addr_tree
= address_exp
;
3955 os
->sectype
= sectype
;
3956 if (sectype
!= noload_section
)
3957 os
->flags
= SEC_NO_FLAGS
;
3959 os
->flags
= SEC_NEVER_LOAD
;
3960 os
->block_value
= block_value
? block_value
: 1;
3961 stat_ptr
= &os
->children
;
3963 os
->subsection_alignment
=
3964 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
3965 os
->section_alignment
=
3966 topower (exp_get_value_int (align
, -1, "section alignment", 0));
3968 os
->load_base
= ebase
;
3975 lang_output_statement_type
*new =
3976 new_stat (lang_output_statement
, stat_ptr
);
3978 new->name
= output_filename
;
3981 /* Reset the current counters in the regions. */
3984 reset_memory_regions ()
3986 lang_memory_region_type
*p
= lang_memory_region_list
;
3988 for (p
= lang_memory_region_list
;
3989 p
!= (lang_memory_region_type
*) NULL
;
3992 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
3993 p
->current
= p
->origin
;
3997 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3998 as needed. SECTION may be NULL, in which case it is a wild card. */
4001 gc_section_callback (ptr
, section
, file
, data
)
4002 lang_wild_statement_type
*ptr
;
4004 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
4005 PTR data ATTRIBUTE_UNUSED
;
4007 /* If the wild pattern was marked KEEP, the member sections
4008 should be as well. */
4009 if (ptr
->keep_sections
)
4010 section
->flags
|= SEC_KEEP
;
4013 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
4014 may be NULL, indicating that it is a wildcard. */
4017 lang_gc_wild (s
, section
, file
)
4018 lang_wild_statement_type
*s
;
4019 const char *section
;
4022 walk_wild (s
, section
, file
, gc_section_callback
, NULL
);
4025 /* Iterate over sections marking them against GC. */
4028 lang_gc_sections_1 (s
)
4029 lang_statement_union_type
*s
;
4031 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
4033 switch (s
->header
.type
)
4035 case lang_wild_statement_enum
:
4036 lang_gc_wild (&s
->wild_statement
,
4037 s
->wild_statement
.section_name
,
4038 s
->wild_statement
.filename
);
4040 case lang_constructors_statement_enum
:
4041 lang_gc_sections_1 (constructor_list
.head
);
4043 case lang_output_section_statement_enum
:
4044 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4046 case lang_group_statement_enum
:
4047 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4058 struct bfd_link_hash_entry
*h
;
4059 ldlang_undef_chain_list_type
*ulist
, fake_list_start
;
4061 /* Keep all sections so marked in the link script. */
4063 lang_gc_sections_1 (statement_list
.head
);
4065 /* Keep all sections containing symbols undefined on the command-line.
4066 Handle the entry symbol at the same time. */
4068 if (entry_symbol
!= NULL
)
4070 fake_list_start
.next
= ldlang_undef_chain_list_head
;
4071 fake_list_start
.name
= (char *) entry_symbol
;
4072 ulist
= &fake_list_start
;
4075 ulist
= ldlang_undef_chain_list_head
;
4077 for (; ulist
; ulist
= ulist
->next
)
4079 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4080 false, false, false);
4082 if (h
!= (struct bfd_link_hash_entry
*) NULL
4083 && (h
->type
== bfd_link_hash_defined
4084 || h
->type
== bfd_link_hash_defweak
)
4085 && ! bfd_is_abs_section (h
->u
.def
.section
))
4087 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4091 bfd_gc_sections (output_bfd
, &link_info
);
4097 lang_reasonable_defaults ();
4098 current_target
= default_target
;
4100 /* Open the output file. */
4101 lang_for_each_statement (ldlang_open_output
);
4103 ldemul_create_output_section_statements ();
4105 /* Add to the hash table all undefineds on the command line. */
4106 lang_place_undefineds ();
4108 already_linked_table_init ();
4110 /* Create a bfd for each input file. */
4111 current_target
= default_target
;
4112 open_input_bfds (statement_list
.head
, false);
4114 ldemul_after_open ();
4116 already_linked_table_free ();
4118 /* Make sure that we're not mixing architectures. We call this
4119 after all the input files have been opened, but before we do any
4120 other processing, so that any operations merge_private_bfd_data
4121 does on the output file will be known during the rest of the
4125 /* Handle .exports instead of a version script if we're told to do so. */
4126 if (command_line
.version_exports_section
)
4127 lang_do_version_exports_section ();
4129 /* Build all sets based on the information gathered from the input
4131 ldctor_build_sets ();
4133 /* Remove unreferenced sections if asked to. */
4134 if (command_line
.gc_sections
)
4135 lang_gc_sections ();
4137 /* If there were any SEC_MERGE sections, finish their merging, so that
4138 section sizes can be computed. This has to be done after GC of sections,
4139 so that GCed sections are not merged, but before assigning output
4140 sections, since removing whole input sections is hard then. */
4141 bfd_merge_sections (output_bfd
, &link_info
);
4143 /* Size up the common data. */
4146 /* Run through the contours of the script and attach input sections
4147 to the correct output sections. */
4148 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4149 (lang_output_section_statement_type
*) NULL
);
4151 /* Find any sections not attached explicitly and handle them. */
4152 lang_place_orphans ();
4154 ldemul_before_allocation ();
4156 /* We must record the program headers before we try to fix the
4157 section positions, since they will affect SIZEOF_HEADERS. */
4158 lang_record_phdrs ();
4160 /* Now run around and relax if we can. */
4161 if (command_line
.relax
)
4163 /* First time round is a trial run to get the 'worst case'
4164 addresses of the objects if there was no relaxing. */
4165 lang_size_sections (statement_list
.head
,
4167 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
4169 /* Keep relaxing until bfd_relax_section gives up. */
4172 reset_memory_regions ();
4174 relax_again
= false;
4176 /* Note: pe-dll.c does something like this also. If you find
4177 you need to change this code, you probably need to change
4178 pe-dll.c also. DJ */
4180 /* Do all the assignments with our current guesses as to
4182 lang_do_assignments (statement_list
.head
,
4184 (fill_type
) 0, (bfd_vma
) 0);
4186 /* Perform another relax pass - this time we know where the
4187 globals are, so can make better guess. */
4188 lang_size_sections (statement_list
.head
,
4190 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
4192 while (relax_again
);
4196 /* Size up the sections. */
4197 lang_size_sections (statement_list
.head
,
4199 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
4202 /* See if anything special should be done now we know how big
4204 ldemul_after_allocation ();
4206 /* Fix any .startof. or .sizeof. symbols. */
4207 lang_set_startof ();
4209 /* Do all the assignments, now that we know the final resting places
4210 of all the symbols. */
4212 lang_do_assignments (statement_list
.head
,
4214 (fill_type
) 0, (bfd_vma
) 0);
4216 /* Make sure that the section addresses make sense. */
4217 if (! link_info
.relocateable
4218 && command_line
.check_section_addresses
)
4219 lang_check_section_addresses ();
4227 /* EXPORTED TO YACC */
4230 lang_add_wild (section_name
, sections_sorted
, filename
, filenames_sorted
,
4231 keep_sections
, exclude_filename_list
)
4232 const char *const section_name
;
4233 boolean sections_sorted
;
4234 const char *const filename
;
4235 boolean filenames_sorted
;
4236 boolean keep_sections
;
4237 struct name_list
*exclude_filename_list
;
4239 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
4242 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
4244 placed_commons
= true;
4246 if (filename
!= NULL
&& ! wildcardp (filename
))
4248 lang_has_input_file
= true;
4250 new->section_name
= section_name
;
4251 new->sections_sorted
= sections_sorted
;
4252 new->filename
= filename
;
4253 new->filenames_sorted
= filenames_sorted
;
4254 new->keep_sections
= keep_sections
;
4255 new->exclude_filename_list
= exclude_filename_list
;
4256 lang_list_init (&new->children
);
4260 lang_section_start (name
, address
)
4262 etree_type
*address
;
4264 lang_address_statement_type
*ad
;
4266 ad
= new_stat (lang_address_statement
, stat_ptr
);
4267 ad
->section_name
= name
;
4268 ad
->address
= address
;
4271 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4272 because of a -e argument on the command line, or zero if this is
4273 called by ENTRY in a linker script. Command line arguments take
4277 lang_add_entry (name
, cmdline
)
4281 if (entry_symbol
== NULL
4283 || ! entry_from_cmdline
)
4285 entry_symbol
= name
;
4286 entry_from_cmdline
= cmdline
;
4291 lang_add_target (name
)
4294 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4310 map_option_f
= true;
4321 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4328 lang_add_data (type
, exp
)
4330 union etree_union
*exp
;
4333 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4341 /* Create a new reloc statement. RELOC is the BFD relocation type to
4342 generate. HOWTO is the corresponding howto structure (we could
4343 look this up, but the caller has already done so). SECTION is the
4344 section to generate a reloc against, or NAME is the name of the
4345 symbol to generate a reloc against. Exactly one of SECTION and
4346 NAME must be NULL. ADDEND is an expression for the addend. */
4349 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4350 bfd_reloc_code_real_type reloc
;
4351 reloc_howto_type
*howto
;
4354 union etree_union
*addend
;
4356 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4360 p
->section
= section
;
4362 p
->addend_exp
= addend
;
4364 p
->addend_value
= 0;
4365 p
->output_section
= NULL
;
4369 lang_assignment_statement_type
*
4370 lang_add_assignment (exp
)
4373 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4381 lang_add_attribute (attribute
)
4382 enum statement_enum attribute
;
4384 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4391 if (startup_file
!= (char *) NULL
)
4393 einfo (_("%P%Fmultiple STARTUP files\n"));
4395 first_file
->filename
= name
;
4396 first_file
->local_sym_name
= name
;
4397 first_file
->real
= true;
4399 startup_file
= name
;
4406 lang_float_flag
= maybe
;
4410 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4412 const char *memspec
;
4413 struct lang_output_section_phdr_list
*phdrs
;
4414 const char *lma_memspec
;
4416 current_section
->fill
= fill
;
4417 current_section
->region
= lang_memory_region_lookup (memspec
);
4418 if (strcmp (lma_memspec
, "*default*") != 0)
4420 current_section
->lma_region
= lang_memory_region_lookup (lma_memspec
);
4421 /* If no runtime region has been given, but the load region has
4422 been, use the load region. */
4423 if (strcmp (memspec
, "*default*") == 0)
4424 current_section
->region
= lang_memory_region_lookup (lma_memspec
);
4426 current_section
->phdrs
= phdrs
;
4427 stat_ptr
= &statement_list
;
4430 /* Create an absolute symbol with the given name with the value of the
4431 address of first byte of the section named.
4433 If the symbol already exists, then do nothing. */
4436 lang_abs_symbol_at_beginning_of (secname
, name
)
4437 const char *secname
;
4440 struct bfd_link_hash_entry
*h
;
4442 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4443 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4444 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4446 if (h
->type
== bfd_link_hash_new
4447 || h
->type
== bfd_link_hash_undefined
)
4451 h
->type
= bfd_link_hash_defined
;
4453 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4454 if (sec
== (asection
*) NULL
)
4457 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4459 h
->u
.def
.section
= bfd_abs_section_ptr
;
4463 /* Create an absolute symbol with the given name with the value of the
4464 address of the first byte after the end of the section named.
4466 If the symbol already exists, then do nothing. */
4469 lang_abs_symbol_at_end_of (secname
, name
)
4470 const char *secname
;
4473 struct bfd_link_hash_entry
*h
;
4475 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4476 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4477 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4479 if (h
->type
== bfd_link_hash_new
4480 || h
->type
== bfd_link_hash_undefined
)
4484 h
->type
= bfd_link_hash_defined
;
4486 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4487 if (sec
== (asection
*) NULL
)
4490 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4491 + bfd_section_size (output_bfd
, sec
) /
4492 bfd_octets_per_byte (output_bfd
));
4494 h
->u
.def
.section
= bfd_abs_section_ptr
;
4499 lang_statement_append (list
, element
, field
)
4500 lang_statement_list_type
*list
;
4501 lang_statement_union_type
*element
;
4502 lang_statement_union_type
**field
;
4504 *(list
->tail
) = element
;
4508 /* Set the output format type. -oformat overrides scripts. */
4511 lang_add_output_format (format
, big
, little
, from_script
)
4517 if (output_target
== NULL
|| !from_script
)
4519 if (command_line
.endian
== ENDIAN_BIG
4522 else if (command_line
.endian
== ENDIAN_LITTLE
4526 output_target
= format
;
4530 /* Enter a group. This creates a new lang_group_statement, and sets
4531 stat_ptr to build new statements within the group. */
4536 lang_group_statement_type
*g
;
4538 g
= new_stat (lang_group_statement
, stat_ptr
);
4539 lang_list_init (&g
->children
);
4540 stat_ptr
= &g
->children
;
4543 /* Leave a group. This just resets stat_ptr to start writing to the
4544 regular list of statements again. Note that this will not work if
4545 groups can occur inside anything else which can adjust stat_ptr,
4546 but currently they can't. */
4551 stat_ptr
= &statement_list
;
4554 /* Add a new program header. This is called for each entry in a PHDRS
4555 command in a linker script. */
4558 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4566 struct lang_phdr
*n
, **pp
;
4568 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4571 n
->type
= exp_get_value_int (type
, 0, "program header type",
4572 lang_final_phase_enum
);
4573 n
->filehdr
= filehdr
;
4578 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4583 /* Record the program header information in the output BFD. FIXME: We
4584 should not be calling an ELF specific function here. */
4587 lang_record_phdrs ()
4591 struct lang_output_section_phdr_list
*last
;
4592 struct lang_phdr
*l
;
4593 lang_statement_union_type
*u
;
4596 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4598 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4605 for (u
= lang_output_section_statement
.head
;
4607 u
= u
->output_section_statement
.next
)
4609 lang_output_section_statement_type
*os
;
4610 struct lang_output_section_phdr_list
*pl
;
4612 os
= &u
->output_section_statement
;
4619 if (os
->sectype
== noload_section
4620 || os
->bfd_section
== NULL
4621 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4626 if (os
->bfd_section
== NULL
)
4629 for (; pl
!= NULL
; pl
= pl
->next
)
4631 if (strcmp (pl
->name
, l
->name
) == 0)
4636 secs
= ((asection
**)
4637 xrealloc (secs
, alc
* sizeof (asection
*)));
4639 secs
[c
] = os
->bfd_section
;
4646 if (l
->flags
== NULL
)
4649 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4650 lang_final_phase_enum
);
4655 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4656 lang_final_phase_enum
);
4658 if (! bfd_record_phdr (output_bfd
, l
->type
,
4659 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
4660 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4661 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4666 /* Make sure all the phdr assignments succeeded. */
4667 for (u
= lang_output_section_statement
.head
;
4669 u
= u
->output_section_statement
.next
)
4671 struct lang_output_section_phdr_list
*pl
;
4673 if (u
->output_section_statement
.bfd_section
== NULL
)
4676 for (pl
= u
->output_section_statement
.phdrs
;
4679 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4680 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4681 u
->output_section_statement
.name
, pl
->name
);
4685 /* Record a list of sections which may not be cross referenced. */
4688 lang_add_nocrossref (l
)
4689 struct lang_nocrossref
*l
;
4691 struct lang_nocrossrefs
*n
;
4693 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4694 n
->next
= nocrossref_list
;
4696 nocrossref_list
= n
;
4698 /* Set notice_all so that we get informed about all symbols. */
4699 link_info
.notice_all
= true;
4702 /* Overlay handling. We handle overlays with some static variables. */
4704 /* The overlay virtual address. */
4705 static etree_type
*overlay_vma
;
4707 /* The overlay load address. */
4708 static etree_type
*overlay_lma
;
4710 /* Whether nocrossrefs is set for this overlay. */
4711 static int overlay_nocrossrefs
;
4713 /* An expression for the maximum section size seen so far. */
4714 static etree_type
*overlay_max
;
4716 /* A list of all the sections in this overlay. */
4718 struct overlay_list
{
4719 struct overlay_list
*next
;
4720 lang_output_section_statement_type
*os
;
4723 static struct overlay_list
*overlay_list
;
4725 /* Start handling an overlay. */
4728 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
4729 etree_type
*vma_expr
;
4730 etree_type
*lma_expr
;
4733 /* The grammar should prevent nested overlays from occurring. */
4734 ASSERT (overlay_vma
== NULL
4735 && overlay_lma
== NULL
4736 && overlay_list
== NULL
4737 && overlay_max
== NULL
);
4739 overlay_vma
= vma_expr
;
4740 overlay_lma
= lma_expr
;
4741 overlay_nocrossrefs
= nocrossrefs
;
4744 /* Start a section in an overlay. We handle this by calling
4745 lang_enter_output_section_statement with the correct VMA and LMA. */
4748 lang_enter_overlay_section (name
)
4751 struct overlay_list
*n
;
4754 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4755 0, 0, 0, overlay_lma
);
4757 /* If this is the first section, then base the VMA and LMA of future
4758 sections on this one. This will work correctly even if `.' is
4759 used in the addresses. */
4760 if (overlay_list
== NULL
)
4762 overlay_vma
= exp_nameop (ADDR
, name
);
4763 overlay_lma
= exp_nameop (LOADADDR
, name
);
4766 /* Remember the section. */
4767 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4768 n
->os
= current_section
;
4769 n
->next
= overlay_list
;
4772 size
= exp_nameop (SIZEOF
, name
);
4774 /* Adjust the LMA for the next section. */
4775 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
4777 /* Arrange to work out the maximum section end address. */
4778 if (overlay_max
== NULL
)
4781 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4784 /* Finish a section in an overlay. There isn't any special to do
4788 lang_leave_overlay_section (fill
, phdrs
)
4790 struct lang_output_section_phdr_list
*phdrs
;
4797 name
= current_section
->name
;
4799 lang_leave_output_section_statement (fill
, "*default*",
4800 phdrs
, "*default*");
4802 /* Define the magic symbols. */
4804 clean
= xmalloc (strlen (name
) + 1);
4806 for (s1
= name
; *s1
!= '\0'; s1
++)
4807 if (isalnum ((unsigned char) *s1
) || *s1
== '_')
4811 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4812 sprintf (buf
, "__load_start_%s", clean
);
4813 lang_add_assignment (exp_assop ('=', buf
,
4814 exp_nameop (LOADADDR
, name
)));
4816 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4817 sprintf (buf
, "__load_stop_%s", clean
);
4818 lang_add_assignment (exp_assop ('=', buf
,
4820 exp_nameop (LOADADDR
, name
),
4821 exp_nameop (SIZEOF
, name
))));
4826 /* Finish an overlay. If there are any overlay wide settings, this
4827 looks through all the sections in the overlay and sets them. */
4830 lang_leave_overlay (fill
, memspec
, phdrs
, lma_memspec
)
4832 const char *memspec
;
4833 struct lang_output_section_phdr_list
*phdrs
;
4834 const char *lma_memspec
;
4836 lang_memory_region_type
*region
;
4837 lang_memory_region_type
*lma_region
;
4838 struct overlay_list
*l
;
4839 struct lang_nocrossref
*nocrossref
;
4841 if (memspec
== NULL
)
4844 region
= lang_memory_region_lookup (memspec
);
4846 if (lma_memspec
== NULL
)
4849 lma_region
= lang_memory_region_lookup (lma_memspec
);
4856 struct overlay_list
*next
;
4858 if (fill
!= 0 && l
->os
->fill
== 0)
4860 if (region
!= NULL
&& l
->os
->region
== NULL
)
4861 l
->os
->region
= region
;
4862 /* We only set lma_region for the first overlay section, as
4863 subsequent overlay sections will have load_base set relative
4864 to the first section. Also, don't set lma_region if
4865 load_base is specified. FIXME: There should really be a test
4866 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4867 rather than letting LDADDR simply override LMA_REGION. */
4868 if (lma_region
!= NULL
&& l
->os
->lma_region
== NULL
4869 && l
->next
== NULL
&& l
->os
->load_base
== NULL
)
4870 l
->os
->lma_region
= lma_region
;
4871 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4872 l
->os
->phdrs
= phdrs
;
4874 if (overlay_nocrossrefs
)
4876 struct lang_nocrossref
*nc
;
4878 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
4879 nc
->name
= l
->os
->name
;
4880 nc
->next
= nocrossref
;
4889 if (nocrossref
!= NULL
)
4890 lang_add_nocrossref (nocrossref
);
4892 /* Update . for the end of the overlay. */
4893 lang_add_assignment (exp_assop ('=', ".",
4894 exp_binop ('+', overlay_vma
, overlay_max
)));
4898 overlay_nocrossrefs
= 0;
4899 overlay_list
= NULL
;
4903 /* Version handling. This is only useful for ELF. */
4905 /* This global variable holds the version tree that we build. */
4907 struct bfd_elf_version_tree
*lang_elf_version_info
;
4910 lang_vers_match_lang_c (expr
, sym
)
4911 struct bfd_elf_version_expr
*expr
;
4914 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4916 return fnmatch (expr
->pattern
, sym
, 0) == 0;
4920 lang_vers_match_lang_cplusplus (expr
, sym
)
4921 struct bfd_elf_version_expr
*expr
;
4927 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4930 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
4933 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4934 Should we early out false in this case? */
4935 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4939 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4947 lang_vers_match_lang_java (expr
, sym
)
4948 struct bfd_elf_version_expr
*expr
;
4954 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4957 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
4960 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4961 Should we early out false in this case? */
4962 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4966 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4973 /* This is called for each variable name or match expression. */
4975 struct bfd_elf_version_expr
*
4976 lang_new_vers_regex (orig
, new, lang
)
4977 struct bfd_elf_version_expr
*orig
;
4981 struct bfd_elf_version_expr
*ret
;
4983 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
4987 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
4988 ret
->match
= lang_vers_match_lang_c
;
4989 else if (strcasecmp (lang
, "C++") == 0)
4990 ret
->match
= lang_vers_match_lang_cplusplus
;
4991 else if (strcasecmp (lang
, "Java") == 0)
4992 ret
->match
= lang_vers_match_lang_java
;
4995 einfo (_("%X%P: unknown language `%s' in version information\n"),
4997 ret
->match
= lang_vers_match_lang_c
;
5003 /* This is called for each set of variable names and match
5006 struct bfd_elf_version_tree
*
5007 lang_new_vers_node (globals
, locals
)
5008 struct bfd_elf_version_expr
*globals
;
5009 struct bfd_elf_version_expr
*locals
;
5011 struct bfd_elf_version_tree
*ret
;
5013 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
5017 ret
->globals
= globals
;
5018 ret
->locals
= locals
;
5020 ret
->name_indx
= (unsigned int) -1;
5025 /* This static variable keeps track of version indices. */
5027 static int version_index
;
5029 /* This is called when we know the name and dependencies of the
5033 lang_register_vers_node (name
, version
, deps
)
5035 struct bfd_elf_version_tree
*version
;
5036 struct bfd_elf_version_deps
*deps
;
5038 struct bfd_elf_version_tree
*t
, **pp
;
5039 struct bfd_elf_version_expr
*e1
;
5041 /* Make sure this node has a unique name. */
5042 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5043 if (strcmp (t
->name
, name
) == 0)
5044 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5046 /* Check the global and local match names, and make sure there
5047 aren't any duplicates. */
5049 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5051 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5053 struct bfd_elf_version_expr
*e2
;
5055 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5056 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5057 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5062 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
5064 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5066 struct bfd_elf_version_expr
*e2
;
5068 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
5069 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5070 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5075 version
->deps
= deps
;
5076 version
->name
= name
;
5078 version
->vernum
= version_index
;
5080 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5085 /* This is called when we see a version dependency. */
5087 struct bfd_elf_version_deps
*
5088 lang_add_vers_depend (list
, name
)
5089 struct bfd_elf_version_deps
*list
;
5092 struct bfd_elf_version_deps
*ret
;
5093 struct bfd_elf_version_tree
*t
;
5095 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5098 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5100 if (strcmp (t
->name
, name
) == 0)
5102 ret
->version_needed
= t
;
5107 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5113 lang_do_version_exports_section ()
5115 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5117 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5119 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5126 len
= bfd_section_size (is
->the_bfd
, sec
);
5127 contents
= xmalloc (len
);
5128 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5129 einfo (_("%X%P: unable to read .exports section contents"), sec
);
5132 while (p
< contents
+ len
)
5134 greg
= lang_new_vers_regex (greg
, p
, NULL
);
5135 p
= strchr (p
, '\0') + 1;
5138 /* Do not free the contents, as we used them creating the regex. */
5140 /* Do not include this section in the link. */
5141 bfd_set_section_flags (is
->the_bfd
, sec
,
5142 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5145 lreg
= lang_new_vers_regex (NULL
, "*", NULL
);
5146 lang_register_vers_node (command_line
.version_exports_section
,
5147 lang_new_vers_node (greg
, lreg
), NULL
);
5151 lang_add_unique (name
)
5154 struct unique_sections
*ent
;
5156 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5157 if (strcmp (ent
->name
, name
) == 0)
5160 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
5161 ent
->name
= xstrdup (name
);
5162 ent
->next
= unique_section_list
;
5163 unique_section_list
= ent
;