1 /* Linker command language support.
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
5 This file is part of GLD, the Gnu Linker.
7 GLD is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GLD is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GLD; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "libiberty.h"
43 static lang_statement_union_type
*new_statement
PARAMS ((enum statement_enum
,
45 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 lang_statement_list_type lang_output_section_statement
;
61 static CONST
char *current_target
;
62 static CONST
char *output_target
;
63 static lang_statement_list_type statement_list
;
64 static struct lang_phdr
*lang_phdr_list
;
66 static void lang_for_each_statement_worker
67 PARAMS ((void (*func
) (lang_statement_union_type
*),
68 lang_statement_union_type
*s
));
69 static lang_input_statement_type
*new_afile
70 PARAMS ((const char *name
, lang_input_file_enum_type file_type
,
71 const char *target
, boolean add_to_list
));
72 static void init_os
PARAMS ((lang_output_section_statement_type
*s
));
73 static void exp_init_os
PARAMS ((etree_type
*));
74 static void section_already_linked
PARAMS ((bfd
*, asection
*, PTR
));
75 static boolean wildcardp
PARAMS ((const char *));
76 static lang_statement_union_type
*wild_sort
77 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
79 static void wild_section
PARAMS ((lang_wild_statement_type
*ptr
,
81 lang_input_statement_type
*file
,
82 lang_output_section_statement_type
*output
));
83 static lang_input_statement_type
*lookup_name
PARAMS ((const char *name
));
84 static void load_symbols
PARAMS ((lang_input_statement_type
*entry
,
85 lang_statement_list_type
*));
86 static void wild_file
PARAMS ((lang_wild_statement_type
*, const char *,
87 lang_input_statement_type
*,
88 lang_output_section_statement_type
*));
89 static void wild
PARAMS ((lang_wild_statement_type
*s
,
90 const char *section
, const char *file
,
92 lang_output_section_statement_type
*output
));
93 static bfd
*open_output
PARAMS ((const char *name
));
94 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*statement
));
95 static void open_input_bfds
96 PARAMS ((lang_statement_union_type
*statement
, boolean
));
97 static void lang_reasonable_defaults
PARAMS ((void));
98 static void lang_place_undefineds
PARAMS ((void));
99 static void map_input_to_output_sections
100 PARAMS ((lang_statement_union_type
*s
,
102 lang_output_section_statement_type
*output_section_statement
));
103 static void print_output_section_statement
104 PARAMS ((lang_output_section_statement_type
*output_section_statement
));
105 static void print_assignment
106 PARAMS ((lang_assignment_statement_type
*assignment
,
107 lang_output_section_statement_type
*output_section
));
108 static void print_input_statement
PARAMS ((lang_input_statement_type
*statm
));
109 static boolean print_one_symbol
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
110 static void print_input_section
PARAMS ((lang_input_section_type
*in
));
111 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*fill
));
112 static void print_data_statement
PARAMS ((lang_data_statement_type
*data
));
113 static void print_address_statement
PARAMS ((lang_address_statement_type
*));
114 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*reloc
));
115 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*s
));
116 static void print_wild_statement
117 PARAMS ((lang_wild_statement_type
*w
,
118 lang_output_section_statement_type
*os
));
119 static void print_group
120 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
121 static void print_statement
PARAMS ((lang_statement_union_type
*s
,
122 lang_output_section_statement_type
*os
));
123 static void print_statement_list
PARAMS ((lang_statement_union_type
*s
,
124 lang_output_section_statement_type
*os
));
125 static void print_statements
PARAMS ((void));
126 static bfd_vma insert_pad
PARAMS ((lang_statement_union_type
**this_ptr
,
127 fill_type fill
, unsigned int power
,
128 asection
*output_section_statement
,
130 static bfd_vma size_input_section
131 PARAMS ((lang_statement_union_type
**this_ptr
,
132 lang_output_section_statement_type
*output_section_statement
,
133 fill_type fill
, bfd_vma dot
, boolean relax
));
134 static void lang_finish
PARAMS ((void));
135 static void ignore_bfd_errors
PARAMS ((const char *, ...));
136 static void lang_check
PARAMS ((void));
137 static void lang_common
PARAMS ((void));
138 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
139 static void lang_place_orphans
PARAMS ((void));
140 static int topower
PARAMS ((int));
141 static void lang_set_startof
PARAMS ((void));
142 static void reset_memory_regions
PARAMS ((void));
143 static void lang_record_phdrs
PARAMS ((void));
144 static void lang_gc_wild_section
145 PARAMS ((lang_wild_statement_type
*, const char *,
146 lang_input_statement_type
*));
147 static void lang_gc_wild_file
148 PARAMS ((lang_wild_statement_type
*, const char *,
149 lang_input_statement_type
*));
150 static void lang_gc_wild
151 PARAMS ((lang_wild_statement_type
*, const char *, const char *));
152 static void lang_gc_sections_1
PARAMS ((lang_statement_union_type
*));
153 static void lang_gc_sections
PARAMS ((void));
157 lang_output_section_statement_type
*abs_output_section
;
158 lang_statement_list_type
*stat_ptr
= &statement_list
;
159 lang_statement_list_type file_chain
= { 0 };
160 const char *entry_symbol
= NULL
;
161 boolean entry_from_cmdline
;
162 boolean lang_has_input_file
= false;
163 boolean had_output_filename
= false;
164 boolean lang_float_flag
= false;
165 boolean delete_output_file_on_failure
= false;
166 struct lang_nocrossrefs
*nocrossref_list
;
168 etree_type
*base
; /* Relocation base - or null */
171 #if defined(__STDC__) || defined(ALMOST_STDC)
172 #define cat(a,b) a##b
174 #define cat(a,b) a/**/b
177 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
179 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
181 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
183 #define SECTION_NAME_MAP_LENGTH (16)
189 return obstack_alloc (&stat_obstack
, size
);
192 /*----------------------------------------------------------------------
193 lang_for_each_statement walks the parse tree and calls the provided
194 function for each node
198 lang_for_each_statement_worker (func
, s
)
199 void (*func
) PARAMS ((lang_statement_union_type
*));
200 lang_statement_union_type
*s
;
202 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
206 switch (s
->header
.type
)
208 case lang_constructors_statement_enum
:
209 lang_for_each_statement_worker (func
, constructor_list
.head
);
211 case lang_output_section_statement_enum
:
212 lang_for_each_statement_worker
214 s
->output_section_statement
.children
.head
);
216 case lang_wild_statement_enum
:
217 lang_for_each_statement_worker
219 s
->wild_statement
.children
.head
);
221 case lang_group_statement_enum
:
222 lang_for_each_statement_worker (func
,
223 s
->group_statement
.children
.head
);
225 case lang_data_statement_enum
:
226 case lang_reloc_statement_enum
:
227 case lang_object_symbols_statement_enum
:
228 case lang_output_statement_enum
:
229 case lang_target_statement_enum
:
230 case lang_input_section_enum
:
231 case lang_input_statement_enum
:
232 case lang_assignment_statement_enum
:
233 case lang_padding_statement_enum
:
234 case lang_address_statement_enum
:
235 case lang_fill_statement_enum
:
245 lang_for_each_statement (func
)
246 void (*func
) PARAMS ((lang_statement_union_type
*));
248 lang_for_each_statement_worker (func
,
249 statement_list
.head
);
252 /*----------------------------------------------------------------------*/
254 lang_list_init (list
)
255 lang_statement_list_type
*list
;
257 list
->head
= (lang_statement_union_type
*) NULL
;
258 list
->tail
= &list
->head
;
261 /*----------------------------------------------------------------------
263 build a new statement node for the parse tree
268 lang_statement_union_type
*
269 new_statement (type
, size
, list
)
270 enum statement_enum type
;
272 lang_statement_list_type
* list
;
274 lang_statement_union_type
*new = (lang_statement_union_type
*)
277 new->header
.type
= type
;
278 new->header
.next
= (lang_statement_union_type
*) NULL
;
279 lang_statement_append (list
, new, &new->header
.next
);
284 Build a new input file node for the language. There are several ways
285 in which we treat an input file, eg, we only look at symbols, or
286 prefix it with a -l etc.
288 We can be supplied with requests for input files more than once;
289 they may, for example be split over serveral lines like foo.o(.text)
290 foo.o(.data) etc, so when asked for a file we check that we havn't
291 got it already so we don't duplicate the bfd.
294 static lang_input_statement_type
*
295 new_afile (name
, file_type
, target
, add_to_list
)
297 lang_input_file_enum_type file_type
;
301 lang_input_statement_type
*p
;
304 p
= new_stat (lang_input_statement
, stat_ptr
);
307 p
= ((lang_input_statement_type
*)
308 stat_alloc (sizeof (lang_input_statement_type
)));
309 p
->header
.next
= NULL
;
312 lang_has_input_file
= true;
316 case lang_input_file_is_symbols_only_enum
:
318 p
->is_archive
= false;
320 p
->local_sym_name
= name
;
321 p
->just_syms_flag
= true;
322 p
->search_dirs_flag
= false;
324 case lang_input_file_is_fake_enum
:
326 p
->is_archive
= false;
328 p
->local_sym_name
= name
;
329 p
->just_syms_flag
= false;
330 p
->search_dirs_flag
= false;
332 case lang_input_file_is_l_enum
:
333 p
->is_archive
= true;
336 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
337 p
->just_syms_flag
= false;
338 p
->search_dirs_flag
= true;
340 case lang_input_file_is_marker_enum
:
342 p
->is_archive
= false;
344 p
->local_sym_name
= name
;
345 p
->just_syms_flag
= false;
346 p
->search_dirs_flag
= true;
348 case lang_input_file_is_search_file_enum
:
350 p
->is_archive
= false;
352 p
->local_sym_name
= name
;
353 p
->just_syms_flag
= false;
354 p
->search_dirs_flag
= true;
356 case lang_input_file_is_file_enum
:
358 p
->is_archive
= false;
360 p
->local_sym_name
= name
;
361 p
->just_syms_flag
= false;
362 p
->search_dirs_flag
= false;
367 p
->the_bfd
= (bfd
*) NULL
;
368 p
->asymbols
= (asymbol
**) NULL
;
369 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
370 p
->next
= (lang_statement_union_type
*) NULL
;
372 p
->dynamic
= config
.dynamic_link
;
373 p
->whole_archive
= whole_archive
;
375 lang_statement_append (&input_file_chain
,
376 (lang_statement_union_type
*) p
,
381 lang_input_statement_type
*
382 lang_add_input_file (name
, file_type
, target
)
384 lang_input_file_enum_type file_type
;
387 lang_has_input_file
= true;
388 return new_afile (name
, file_type
, target
, true);
391 /* Build enough state so that the parser can build its tree */
395 obstack_begin (&stat_obstack
, 1000);
397 stat_ptr
= &statement_list
;
399 lang_list_init (stat_ptr
);
401 lang_list_init (&input_file_chain
);
402 lang_list_init (&lang_output_section_statement
);
403 lang_list_init (&file_chain
);
404 first_file
= lang_add_input_file ((char *) NULL
,
405 lang_input_file_is_marker_enum
,
407 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
409 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
413 /*----------------------------------------------------------------------
414 A region is an area of memory declared with the
415 MEMORY { name:org=exp, len=exp ... }
418 We maintain a list of all the regions here
420 If no regions are specified in the script, then the default is used
421 which is created when looked up to be the entire data space
424 static lang_memory_region_type
*lang_memory_region_list
;
425 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
427 lang_memory_region_type
*
428 lang_memory_region_lookup (name
)
429 CONST
char *CONST name
;
431 lang_memory_region_type
*p
;
433 for (p
= lang_memory_region_list
;
434 p
!= (lang_memory_region_type
*) NULL
;
437 if (strcmp (p
->name
, name
) == 0)
444 /* This code used to always use the first region in the list as the
445 default region. I changed it to instead use a region
446 encompassing all of memory as the default region. This permits
447 NOLOAD sections to work reasonably without requiring a region.
448 People should specify what region they mean, if they really want
450 if (strcmp (name
, "*default*") == 0)
452 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
454 return lang_memory_region_list
;
460 lang_memory_region_type
*new =
461 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
463 new->name
= buystring (name
);
464 new->next
= (lang_memory_region_type
*) NULL
;
466 *lang_memory_region_list_tail
= new;
467 lang_memory_region_list_tail
= &new->next
;
471 new->length
= ~(bfd_size_type
)0;
473 new->had_full_message
= false;
480 lang_memory_region_type
*
481 lang_memory_default (section
)
484 lang_memory_region_type
*p
;
486 flagword sec_flags
= section
->flags
;
488 /* Override SEC_DATA to mean a writable section. */
489 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
490 sec_flags
|= SEC_DATA
;
492 for (p
= lang_memory_region_list
;
493 p
!= (lang_memory_region_type
*) NULL
;
496 if ((p
->flags
& sec_flags
) != 0
497 && (p
->not_flags
& sec_flags
) == 0)
502 return lang_memory_region_lookup ("*default*");
505 lang_output_section_statement_type
*
506 lang_output_section_find (name
)
507 CONST
char *CONST name
;
509 lang_statement_union_type
*u
;
510 lang_output_section_statement_type
*lookup
;
512 for (u
= lang_output_section_statement
.head
;
513 u
!= (lang_statement_union_type
*) NULL
;
516 lookup
= &u
->output_section_statement
;
517 if (strcmp (name
, lookup
->name
) == 0)
522 return (lang_output_section_statement_type
*) NULL
;
525 lang_output_section_statement_type
*
526 lang_output_section_statement_lookup (name
)
527 CONST
char *CONST name
;
529 lang_output_section_statement_type
*lookup
;
531 lookup
= lang_output_section_find (name
);
532 if (lookup
== (lang_output_section_statement_type
*) NULL
)
535 lookup
= (lang_output_section_statement_type
*)
536 new_stat (lang_output_section_statement
, stat_ptr
);
537 lookup
->region
= (lang_memory_region_type
*) NULL
;
539 lookup
->block_value
= 1;
542 lookup
->next
= (lang_statement_union_type
*) NULL
;
543 lookup
->bfd_section
= (asection
*) NULL
;
544 lookup
->processed
= false;
545 lookup
->sectype
= normal_section
;
546 lookup
->addr_tree
= (etree_type
*) NULL
;
547 lang_list_init (&lookup
->children
);
549 lookup
->memspec
= (CONST
char *) NULL
;
551 lookup
->subsection_alignment
= -1;
552 lookup
->section_alignment
= -1;
553 lookup
->load_base
= (union etree_union
*) NULL
;
554 lookup
->phdrs
= NULL
;
556 lang_statement_append (&lang_output_section_statement
,
557 (lang_statement_union_type
*) lookup
,
564 lang_map_flags (flag
)
567 if (flag
& SEC_ALLOC
)
573 if (flag
& SEC_READONLY
)
586 lang_memory_region_type
*m
;
588 minfo (_("\nMemory Configuration\n\n"));
589 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
590 _("Name"), _("Origin"), _("Length"), _("Attributes"));
592 for (m
= lang_memory_region_list
;
593 m
!= (lang_memory_region_type
*) NULL
;
599 fprintf (config
.map_file
, "%-16s ", m
->name
);
601 sprintf_vma (buf
, m
->origin
);
602 minfo ("0x%s ", buf
);
610 minfo ("0x%V", m
->length
);
611 if (m
->flags
|| m
->not_flags
)
619 lang_map_flags (m
->flags
);
625 lang_map_flags (m
->not_flags
);
632 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
637 /* Initialize an output section. */
641 lang_output_section_statement_type
*s
;
643 section_userdata_type
*new;
645 if (s
->bfd_section
!= NULL
)
648 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
649 einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME
);
651 new = ((section_userdata_type
*)
652 stat_alloc (sizeof (section_userdata_type
)));
654 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
655 if (s
->bfd_section
== (asection
*) NULL
)
656 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
657 if (s
->bfd_section
== (asection
*) NULL
)
659 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
660 output_bfd
->xvec
->name
, s
->name
);
662 s
->bfd_section
->output_section
= s
->bfd_section
;
664 /* We initialize an output sections output offset to minus its own */
665 /* vma to allow us to output a section through itself */
666 s
->bfd_section
->output_offset
= 0;
667 get_userdata (s
->bfd_section
) = (PTR
) new;
669 /* If there is a base address, make sure that any sections it might
670 mention are initialized. */
671 if (s
->addr_tree
!= NULL
)
672 exp_init_os (s
->addr_tree
);
675 /* Make sure that all output sections mentioned in an expression are
682 switch (exp
->type
.node_class
)
685 exp_init_os (exp
->assign
.src
);
689 exp_init_os (exp
->binary
.lhs
);
690 exp_init_os (exp
->binary
.rhs
);
694 exp_init_os (exp
->trinary
.cond
);
695 exp_init_os (exp
->trinary
.lhs
);
696 exp_init_os (exp
->trinary
.rhs
);
700 exp_init_os (exp
->unary
.child
);
704 switch (exp
->type
.node_code
)
710 lang_output_section_statement_type
*os
;
712 os
= lang_output_section_find (exp
->name
.name
);
713 if (os
!= NULL
&& os
->bfd_section
== NULL
)
724 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
725 once into the output. This routine checks each sections, and
726 arranges to discard it if a section of the same name has already
727 been linked. This code assumes that all relevant sections have the
728 SEC_LINK_ONCE flag set; that is, it does not depend solely upon the
729 section name. This is called via bfd_map_over_sections. */
733 section_already_linked (abfd
, sec
, data
)
738 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
741 struct sec_link_once
*next
;
744 static struct sec_link_once
*sec_link_once_list
;
747 struct sec_link_once
*l
;
749 /* If we are only reading symbols from this object, then we want to
750 discard all sections. */
751 if (entry
->just_syms_flag
)
753 sec
->output_section
= bfd_abs_section_ptr
;
754 sec
->output_offset
= sec
->vma
;
758 flags
= bfd_get_section_flags (abfd
, sec
);
760 if ((flags
& SEC_LINK_ONCE
) == 0)
763 name
= bfd_get_section_name (abfd
, sec
);
765 for (l
= sec_link_once_list
; l
!= NULL
; l
= l
->next
)
767 if (strcmp (name
, bfd_get_section_name (l
->sec
->owner
, l
->sec
)) == 0)
769 /* The section has already been linked. See if we should
771 switch (flags
& SEC_LINK_DUPLICATES
)
776 case SEC_LINK_DUPLICATES_DISCARD
:
779 case SEC_LINK_DUPLICATES_ONE_ONLY
:
780 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
784 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
785 /* FIXME: We should really dig out the contents of both
786 sections and memcmp them. The COFF/PE spec says that
787 the Microsoft linker does not implement this
788 correctly, so I'm not going to bother doing it
791 case SEC_LINK_DUPLICATES_SAME_SIZE
:
792 if (bfd_section_size (abfd
, sec
)
793 != bfd_section_size (l
->sec
->owner
, l
->sec
))
794 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
799 /* Set the output_section field so that wild_doit does not
800 create a lang_input_section structure for this section. */
801 sec
->output_section
= bfd_abs_section_ptr
;
807 /* This is the first section with this name. Record it. */
809 l
= (struct sec_link_once
*) xmalloc (sizeof *l
);
811 l
->next
= sec_link_once_list
;
812 sec_link_once_list
= l
;
815 /* The wild routines.
817 These expand statements like *(.text) and foo.o to a list of
818 explicit actions, like foo.o(.text), bar.o(.text) and
819 foo.o(.text, .data). */
821 /* Return true if the PATTERN argument is a wildcard pattern.
822 Although backslashes are treated specially if a pattern contains
823 wildcards, we do not consider the mere presence of a backslash to
824 be enough to cause the the pattern to be treated as a wildcard.
825 That lets us handle DOS filenames more naturally. */
833 for (s
= pattern
; *s
!= '\0'; ++s
)
841 /* Add SECTION to the output section OUTPUT. Do this by creating a
842 lang_input_section statement which is placed at PTR. FILE is the
843 input file which holds SECTION. */
846 wild_doit (ptr
, section
, output
, file
)
847 lang_statement_list_type
*ptr
;
849 lang_output_section_statement_type
*output
;
850 lang_input_statement_type
*file
;
855 flags
= bfd_get_section_flags (section
->owner
, section
);
859 /* If we are doing a final link, discard sections marked with
861 if (! link_info
.relocateable
862 && (flags
& SEC_EXCLUDE
) != 0)
865 /* Discard input sections which are assigned to a section named
866 DISCARD_SECTION_NAME. */
867 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
870 /* Discard debugging sections if we are stripping debugging
872 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
873 && (flags
& SEC_DEBUGGING
) != 0)
878 if (section
->output_section
== NULL
)
880 /* This prevents future calls from assigning this section. */
881 section
->output_section
= bfd_abs_section_ptr
;
886 if (section
->output_section
== NULL
)
889 lang_input_section_type
*new;
892 if (output
->bfd_section
== NULL
)
900 /* Add a section reference to the list */
901 new = new_stat (lang_input_section
, ptr
);
903 new->section
= section
;
905 section
->output_section
= output
->bfd_section
;
907 flags
= section
->flags
;
909 /* We don't copy the SEC_NEVER_LOAD flag from an input section
910 to an output section, because we want to be able to include a
911 SEC_NEVER_LOAD section in the middle of an otherwise loaded
912 section (I don't know why we want to do this, but we do).
913 build_link_order in ldwrite.c handles this case by turning
914 the embedded SEC_NEVER_LOAD section into a fill. */
916 flags
&= ~ SEC_NEVER_LOAD
;
918 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
919 already been processed. One reason to do this is that on pe
920 format targets, .text$foo sections go into .text and it's odd
921 to see .text with SEC_LINK_ONCE set. */
923 if (! link_info
.relocateable
)
924 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
926 /* If this is not the first input section, and the SEC_READONLY
927 flag is not currently set, then don't set it just because the
928 input section has it set. */
930 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
931 flags
&= ~ SEC_READONLY
;
933 section
->output_section
->flags
|= flags
;
935 /* If SEC_READONLY is not set in the input section, then clear
936 it from the output section. */
937 if ((section
->flags
& SEC_READONLY
) == 0)
938 section
->output_section
->flags
&= ~SEC_READONLY
;
940 switch (output
->sectype
)
947 case overlay_section
:
948 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
951 output
->bfd_section
->flags
&= ~SEC_LOAD
;
952 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
956 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
957 output
->bfd_section
->alignment_power
= section
->alignment_power
;
959 /* If supplied an aligment, then force it. */
960 if (output
->section_alignment
!= -1)
961 output
->bfd_section
->alignment_power
= output
->section_alignment
;
965 /* Handle wildcard sorting. This returns the lang_input_section which
966 should follow the one we are going to create for SECTION and FILE,
967 based on the sorting requirements of WILD. It returns NULL if the
968 new section should just go at the end of the current list. */
970 static lang_statement_union_type
*
971 wild_sort (wild
, file
, section
)
972 lang_wild_statement_type
*wild
;
973 lang_input_statement_type
*file
;
976 const char *section_name
;
977 lang_statement_union_type
*l
;
979 if (! wild
->filenames_sorted
&& ! wild
->sections_sorted
)
982 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
983 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->next
)
985 lang_input_section_type
*ls
;
987 if (l
->header
.type
!= lang_input_section_enum
)
989 ls
= &l
->input_section
;
991 /* Sorting by filename takes precedence over sorting by section
994 if (wild
->filenames_sorted
)
1000 /* The PE support for the .idata section as generated by
1001 dlltool assumes that files will be sorted by the name of
1002 the archive and then the name of the file within the
1005 if (file
->the_bfd
!= NULL
1006 && bfd_my_archive (file
->the_bfd
) != NULL
)
1008 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1013 fn
= file
->filename
;
1017 if (ls
->ifile
->the_bfd
!= NULL
1018 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1020 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1025 ln
= ls
->ifile
->filename
;
1029 i
= strcmp (fn
, ln
);
1038 fn
= file
->filename
;
1040 ln
= ls
->ifile
->filename
;
1042 i
= strcmp (fn
, ln
);
1050 /* Here either the files are not sorted by name, or we are
1051 looking at the sections for this file. */
1053 if (wild
->sections_sorted
)
1055 if (strcmp (section_name
,
1056 bfd_get_section_name (ls
->ifile
->the_bfd
,
1066 /* Expand a wild statement for a particular FILE. SECTION may be
1067 NULL, in which case it is a wild card. */
1070 wild_section (ptr
, section
, file
, output
)
1071 lang_wild_statement_type
*ptr
;
1072 const char *section
;
1073 lang_input_statement_type
*file
;
1074 lang_output_section_statement_type
*output
;
1076 if (file
->just_syms_flag
== false)
1078 register asection
*s
;
1081 if (section
== NULL
)
1084 wildcard
= wildcardp (section
);
1086 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
1090 /* Attach all sections named SECTION. If SECTION is NULL,
1091 then attach all sections.
1093 Previously, if SECTION was NULL, this code did not call
1094 wild_doit if the SEC_IS_COMMON flag was set for the
1095 section. I did not understand that, and I took it out.
1096 --ian@cygnus.com. */
1098 if (section
== NULL
)
1104 name
= bfd_get_section_name (file
->the_bfd
, s
);
1106 match
= fnmatch (section
, name
, 0) == 0 ? true : false;
1108 match
= strcmp (section
, name
) == 0 ? true : false;
1113 lang_statement_union_type
*before
;
1115 /* If the wild pattern was marked KEEP, the member sections
1116 should be as well. */
1117 if (ptr
->keep_sections
)
1118 s
->flags
|= SEC_KEEP
;
1120 before
= wild_sort (ptr
, file
, s
);
1122 /* Here BEFORE points to the lang_input_section which
1123 should follow the one we are about to add. If BEFORE
1124 is NULL, then the section should just go at the end
1125 of the current list. */
1128 wild_doit (&ptr
->children
, s
, output
, file
);
1131 lang_statement_list_type list
;
1132 lang_statement_union_type
**pp
;
1134 lang_list_init (&list
);
1135 wild_doit (&list
, s
, output
, file
);
1137 /* If we are discarding the section, LIST.HEAD will
1139 if (list
.head
!= NULL
)
1141 ASSERT (list
.head
->next
== NULL
);
1143 for (pp
= &ptr
->children
.head
;
1146 ASSERT (*pp
!= NULL
);
1148 list
.head
->next
= *pp
;
1157 /* This is passed a file name which must have been seen already and
1158 added to the statement tree. We will see if it has been opened
1159 already and had its symbols read. If not then we'll read it. */
1161 static lang_input_statement_type
*
1165 lang_input_statement_type
*search
;
1167 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1168 search
!= (lang_input_statement_type
*) NULL
;
1169 search
= (lang_input_statement_type
*) search
->next_real_file
)
1171 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1173 if (search
->filename
!= (char *) NULL
1174 && name
!= (char *) NULL
1175 && strcmp (search
->filename
, name
) == 0)
1179 if (search
== (lang_input_statement_type
*) NULL
)
1180 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1183 /* If we have already added this file, or this file is not real
1184 (FIXME: can that ever actually happen?) or the name is NULL
1185 (FIXME: can that ever actually happen?) don't add this file. */
1188 || search
->filename
== (const char *) NULL
)
1191 load_symbols (search
, (lang_statement_list_type
*) NULL
);
1196 /* Get the symbols for an input file. */
1199 load_symbols (entry
, place
)
1200 lang_input_statement_type
*entry
;
1201 lang_statement_list_type
*place
;
1208 ldfile_open_file (entry
);
1210 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1211 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1214 lang_statement_list_type
*hold
;
1216 err
= bfd_get_error ();
1217 if (err
== bfd_error_file_ambiguously_recognized
)
1221 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1222 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1223 for (p
= matching
; *p
!= NULL
; p
++)
1227 else if (err
!= bfd_error_file_not_recognized
1229 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1231 bfd_close (entry
->the_bfd
);
1232 entry
->the_bfd
= NULL
;
1234 /* See if the emulation has some special knowledge. */
1236 if (ldemul_unrecognized_file (entry
))
1239 /* Try to interpret the file as a linker script. */
1241 ldfile_open_command_file (entry
->filename
);
1246 ldfile_assumed_script
= true;
1247 parser_input
= input_script
;
1249 ldfile_assumed_script
= false;
1256 /* We don't call ldlang_add_file for an archive. Instead, the
1257 add_symbols entry point will call ldlang_add_file, via the
1258 add_archive_element callback, for each element of the archive
1260 switch (bfd_get_format (entry
->the_bfd
))
1266 ldlang_add_file (entry
);
1267 if (trace_files
|| trace_file_tries
)
1268 info_msg ("%I\n", entry
);
1272 if (entry
->whole_archive
)
1274 bfd
*member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1276 while (member
!= NULL
)
1278 if (! bfd_check_format (member
, bfd_object
))
1279 einfo (_("%F%B: object %B in archive is not object\n"),
1280 entry
->the_bfd
, member
);
1281 if (! ((*link_info
.callbacks
->add_archive_element
)
1282 (&link_info
, member
, "--whole-archive")))
1284 if (! bfd_link_add_symbols (member
, &link_info
))
1285 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1286 member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1290 entry
->loaded
= true;
1296 if (! bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1297 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1299 entry
->loaded
= true;
1302 /* Handle a wild statement for a single file F. */
1305 wild_file (s
, section
, f
, output
)
1306 lang_wild_statement_type
*s
;
1307 const char *section
;
1308 lang_input_statement_type
*f
;
1309 lang_output_section_statement_type
*output
;
1311 if (f
->the_bfd
== NULL
1312 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
1313 wild_section (s
, section
, f
, output
);
1318 /* This is an archive file. We must map each member of the
1319 archive separately. */
1320 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
1321 while (member
!= NULL
)
1323 /* When lookup_name is called, it will call the add_symbols
1324 entry point for the archive. For each element of the
1325 archive which is included, BFD will call ldlang_add_file,
1326 which will set the usrdata field of the member to the
1327 lang_input_statement. */
1328 if (member
->usrdata
!= NULL
)
1330 wild_section (s
, section
,
1331 (lang_input_statement_type
*) member
->usrdata
,
1335 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
1340 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1341 indicating that it is a wildcard. Separate lang_input_section
1342 statements are created for each part of the expansion; they are
1343 added after the wild statement S. OUTPUT is the output section. */
1346 wild (s
, section
, file
, target
, output
)
1347 lang_wild_statement_type
*s
;
1348 const char *section
;
1351 lang_output_section_statement_type
*output
;
1353 lang_input_statement_type
*f
;
1355 if (file
== (char *) NULL
)
1357 /* Perform the iteration over all files in the list */
1358 for (f
= (lang_input_statement_type
*) file_chain
.head
;
1359 f
!= (lang_input_statement_type
*) NULL
;
1360 f
= (lang_input_statement_type
*) f
->next
)
1362 wild_file (s
, section
, f
, output
);
1365 else if (wildcardp (file
))
1367 for (f
= (lang_input_statement_type
*) file_chain
.head
;
1368 f
!= (lang_input_statement_type
*) NULL
;
1369 f
= (lang_input_statement_type
*) f
->next
)
1371 if (fnmatch (file
, f
->filename
, FNM_FILE_NAME
) == 0)
1372 wild_file (s
, section
, f
, output
);
1377 /* Perform the iteration over a single file */
1378 f
= lookup_name (file
);
1379 wild_file (s
, section
, f
, output
);
1382 if (section
!= (char *) NULL
1383 && strcmp (section
, "COMMON") == 0
1384 && default_common_section
== NULL
)
1386 /* Remember the section that common is going to in case we later
1387 get something which doesn't know where to put it. */
1388 default_common_section
= output
;
1392 /* Open the output file. */
1400 if (output_target
== (char *) NULL
)
1402 if (current_target
!= (char *) NULL
)
1403 output_target
= current_target
;
1405 output_target
= default_target
;
1407 output
= bfd_openw (name
, output_target
);
1409 if (output
== (bfd
*) NULL
)
1411 if (bfd_get_error () == bfd_error_invalid_target
)
1413 einfo (_("%P%F: target %s not found\n"), output_target
);
1415 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1418 delete_output_file_on_failure
= true;
1420 /* output->flags |= D_PAGED;*/
1422 if (! bfd_set_format (output
, bfd_object
))
1423 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1424 if (! bfd_set_arch_mach (output
,
1425 ldfile_output_architecture
,
1426 ldfile_output_machine
))
1427 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1429 link_info
.hash
= bfd_link_hash_table_create (output
);
1430 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1431 einfo (_("%P%F: can not create link hash table: %E\n"));
1433 bfd_set_gp_size (output
, g_switch_value
);
1441 ldlang_open_output (statement
)
1442 lang_statement_union_type
* statement
;
1444 switch (statement
->header
.type
)
1446 case lang_output_statement_enum
:
1447 ASSERT (output_bfd
== (bfd
*) NULL
);
1448 output_bfd
= open_output (statement
->output_statement
.name
);
1449 ldemul_set_output_arch ();
1450 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1451 output_bfd
->flags
|= D_PAGED
;
1453 output_bfd
->flags
&= ~D_PAGED
;
1454 if (config
.text_read_only
)
1455 output_bfd
->flags
|= WP_TEXT
;
1457 output_bfd
->flags
&= ~WP_TEXT
;
1458 if (link_info
.traditional_format
)
1459 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1461 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1464 case lang_target_statement_enum
:
1465 current_target
= statement
->target_statement
.target
;
1472 /* Open all the input files. */
1475 open_input_bfds (s
, force
)
1476 lang_statement_union_type
*s
;
1479 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1481 switch (s
->header
.type
)
1483 case lang_constructors_statement_enum
:
1484 open_input_bfds (constructor_list
.head
, force
);
1486 case lang_output_section_statement_enum
:
1487 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1489 case lang_wild_statement_enum
:
1490 /* Maybe we should load the file's symbols */
1491 if (s
->wild_statement
.filename
1492 && ! wildcardp (s
->wild_statement
.filename
))
1493 (void) lookup_name (s
->wild_statement
.filename
);
1494 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1496 case lang_group_statement_enum
:
1498 struct bfd_link_hash_entry
*undefs
;
1500 /* We must continually search the entries in the group
1501 until no new symbols are added to the list of undefined
1506 undefs
= link_info
.hash
->undefs_tail
;
1507 open_input_bfds (s
->group_statement
.children
.head
, true);
1509 while (undefs
!= link_info
.hash
->undefs_tail
);
1512 case lang_target_statement_enum
:
1513 current_target
= s
->target_statement
.target
;
1515 case lang_input_statement_enum
:
1516 if (s
->input_statement
.real
== true)
1518 lang_statement_list_type add
;
1520 s
->input_statement
.target
= current_target
;
1522 /* If we are being called from within a group, and this
1523 is an archive which has already been searched, then
1524 force it to be researched. */
1526 && s
->input_statement
.loaded
1527 && bfd_check_format (s
->input_statement
.the_bfd
,
1529 s
->input_statement
.loaded
= false;
1531 lang_list_init (&add
);
1533 load_symbols (&s
->input_statement
, &add
);
1535 if (add
.head
!= NULL
)
1537 *add
.tail
= s
->next
;
1548 /* If there are [COMMONS] statements, put a wild one into the bss section */
1551 lang_reasonable_defaults ()
1554 lang_output_section_statement_lookup (".text");
1555 lang_output_section_statement_lookup (".data");
1557 default_common_section
=
1558 lang_output_section_statement_lookup (".bss");
1561 if (placed_commons
== false)
1563 lang_wild_statement_type
*new =
1564 new_stat (lang_wild_statement
,
1565 &default_common_section
->children
);
1567 new->section_name
= "COMMON";
1568 new->filename
= (char *) NULL
;
1569 lang_list_init (&new->children
);
1576 Add the supplied name to the symbol table as an undefined reference.
1577 Remove items from the chain as we open input bfds
1579 typedef struct ldlang_undef_chain_list
1581 struct ldlang_undef_chain_list
*next
;
1583 } ldlang_undef_chain_list_type
;
1585 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
1588 ldlang_add_undef (name
)
1589 CONST
char *CONST name
;
1591 ldlang_undef_chain_list_type
*new =
1592 ((ldlang_undef_chain_list_type
*)
1593 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
1595 new->next
= ldlang_undef_chain_list_head
;
1596 ldlang_undef_chain_list_head
= new;
1598 new->name
= buystring (name
);
1601 /* Run through the list of undefineds created above and place them
1602 into the linker hash table as undefined symbols belonging to the
1606 lang_place_undefineds ()
1608 ldlang_undef_chain_list_type
*ptr
;
1610 for (ptr
= ldlang_undef_chain_list_head
;
1611 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
1614 struct bfd_link_hash_entry
*h
;
1616 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
1617 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1618 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1619 if (h
->type
== bfd_link_hash_new
)
1621 h
->type
= bfd_link_hash_undefined
;
1622 h
->u
.undef
.abfd
= NULL
;
1623 bfd_link_add_undef (link_info
.hash
, h
);
1628 /* Open input files and attatch to output sections */
1630 map_input_to_output_sections (s
, target
, output_section_statement
)
1631 lang_statement_union_type
* s
;
1633 lang_output_section_statement_type
* output_section_statement
;
1635 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1637 switch (s
->header
.type
)
1641 case lang_wild_statement_enum
:
1642 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1643 s
->wild_statement
.filename
, target
,
1644 output_section_statement
);
1647 case lang_constructors_statement_enum
:
1648 map_input_to_output_sections (constructor_list
.head
,
1650 output_section_statement
);
1652 case lang_output_section_statement_enum
:
1653 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1655 &s
->output_section_statement
);
1657 case lang_output_statement_enum
:
1659 case lang_target_statement_enum
:
1660 target
= s
->target_statement
.target
;
1662 case lang_group_statement_enum
:
1663 map_input_to_output_sections (s
->group_statement
.children
.head
,
1665 output_section_statement
);
1667 case lang_fill_statement_enum
:
1668 case lang_input_section_enum
:
1669 case lang_object_symbols_statement_enum
:
1670 case lang_data_statement_enum
:
1671 case lang_reloc_statement_enum
:
1672 case lang_padding_statement_enum
:
1673 case lang_input_statement_enum
:
1674 if (output_section_statement
!= NULL
1675 && output_section_statement
->bfd_section
== NULL
)
1676 init_os (output_section_statement
);
1678 case lang_assignment_statement_enum
:
1679 if (output_section_statement
!= NULL
1680 && output_section_statement
->bfd_section
== NULL
)
1681 init_os (output_section_statement
);
1683 /* Make sure that any sections mentioned in the assignment
1685 exp_init_os (s
->assignment_statement
.exp
);
1687 case lang_afile_asection_pair_statement_enum
:
1690 case lang_address_statement_enum
:
1691 /* Mark the specified section with the supplied address */
1693 lang_output_section_statement_type
*os
=
1694 lang_output_section_statement_lookup
1695 (s
->address_statement
.section_name
);
1697 if (os
->bfd_section
== NULL
)
1699 os
->addr_tree
= s
->address_statement
.address
;
1707 print_output_section_statement (output_section_statement
)
1708 lang_output_section_statement_type
* output_section_statement
;
1710 asection
*section
= output_section_statement
->bfd_section
;
1713 if (output_section_statement
!= abs_output_section
)
1715 minfo ("\n%s", output_section_statement
->name
);
1717 if (section
!= NULL
)
1719 print_dot
= section
->vma
;
1721 len
= strlen (output_section_statement
->name
);
1722 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
1727 while (len
< SECTION_NAME_MAP_LENGTH
)
1733 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
1735 if (output_section_statement
->load_base
!= NULL
)
1739 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
1740 "load base", lang_final_phase_enum
);
1741 minfo (_(" load address 0x%V"), addr
);
1748 print_statement_list (output_section_statement
->children
.head
,
1749 output_section_statement
);
1753 print_assignment (assignment
, output_section
)
1754 lang_assignment_statement_type
* assignment
;
1755 lang_output_section_statement_type
* output_section
;
1758 etree_value_type result
;
1760 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1763 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
1764 lang_final_phase_enum
, print_dot
, &print_dot
);
1766 minfo ("0x%V", result
.value
+ result
.section
->bfd_section
->vma
);
1777 exp_print_tree (assignment
->exp
);
1783 print_input_statement (statm
)
1784 lang_input_statement_type
* statm
;
1786 if (statm
->filename
!= (char *) NULL
)
1788 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1792 /* Print all symbols defined in a particular section. This is called
1793 via bfd_link_hash_traverse. */
1796 print_one_symbol (hash_entry
, ptr
)
1797 struct bfd_link_hash_entry
*hash_entry
;
1800 asection
*sec
= (asection
*) ptr
;
1802 if ((hash_entry
->type
== bfd_link_hash_defined
1803 || hash_entry
->type
== bfd_link_hash_defweak
)
1804 && sec
== hash_entry
->u
.def
.section
)
1808 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1811 (hash_entry
->u
.def
.value
1812 + hash_entry
->u
.def
.section
->output_offset
1813 + hash_entry
->u
.def
.section
->output_section
->vma
));
1815 minfo (" %T\n", hash_entry
->root
.string
);
1821 /* Print information about an input section to the map file. */
1824 print_input_section (in
)
1825 lang_input_section_type
* in
;
1827 asection
*i
= in
->section
;
1828 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
1834 minfo ("%s", i
->name
);
1836 if (i
->output_section
!= NULL
)
1840 len
= 1 + strlen (i
->name
);
1841 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
1846 while (len
< SECTION_NAME_MAP_LENGTH
)
1852 minfo ("0x%V %W %B\n",
1853 i
->output_section
->vma
+ i
->output_offset
, size
,
1856 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
1858 len
= SECTION_NAME_MAP_LENGTH
+ 3;
1870 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
1873 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
1875 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
;
1881 print_fill_statement (fill
)
1882 lang_fill_statement_type
* fill
;
1884 fprintf (config
.map_file
, " FILL mask 0x%x\n", fill
->fill
);
1888 print_data_statement (data
)
1889 lang_data_statement_type
* data
;
1896 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1899 addr
= data
->output_vma
;
1900 if (data
->output_section
!= NULL
)
1901 addr
+= data
->output_section
->vma
;
1929 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
1931 if (data
->exp
->type
.node_class
!= etree_value
)
1934 exp_print_tree (data
->exp
);
1939 print_dot
= addr
+ size
;
1942 /* Print an address statement. These are generated by options like
1946 print_address_statement (address
)
1947 lang_address_statement_type
*address
;
1949 minfo (_("Address of section %s set to "), address
->section_name
);
1950 exp_print_tree (address
->address
);
1954 /* Print a reloc statement. */
1957 print_reloc_statement (reloc
)
1958 lang_reloc_statement_type
*reloc
;
1964 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1967 addr
= reloc
->output_vma
;
1968 if (reloc
->output_section
!= NULL
)
1969 addr
+= reloc
->output_section
->vma
;
1971 size
= bfd_get_reloc_size (reloc
->howto
);
1973 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
1975 if (reloc
->name
!= NULL
)
1976 minfo ("%s+", reloc
->name
);
1978 minfo ("%s+", reloc
->section
->name
);
1980 exp_print_tree (reloc
->addend_exp
);
1984 print_dot
= addr
+ size
;
1988 print_padding_statement (s
)
1989 lang_padding_statement_type
*s
;
1996 len
= sizeof " *fill*" - 1;
1997 while (len
< SECTION_NAME_MAP_LENGTH
)
2003 addr
= s
->output_offset
;
2004 if (s
->output_section
!= NULL
)
2005 addr
+= s
->output_section
->vma
;
2006 minfo ("0x%V %W", addr
, s
->size
);
2009 minfo (" %u", s
->fill
);
2013 print_dot
= addr
+ s
->size
;
2017 print_wild_statement (w
, os
)
2018 lang_wild_statement_type
* w
;
2019 lang_output_section_statement_type
* os
;
2023 if (w
->filenames_sorted
)
2025 if (w
->filename
!= NULL
)
2026 minfo ("%s", w
->filename
);
2029 if (w
->filenames_sorted
)
2033 if (w
->sections_sorted
)
2035 if (w
->section_name
!= NULL
)
2036 minfo ("%s", w
->section_name
);
2039 if (w
->sections_sorted
)
2045 print_statement_list (w
->children
.head
, os
);
2048 /* Print a group statement. */
2052 lang_group_statement_type
*s
;
2053 lang_output_section_statement_type
*os
;
2055 fprintf (config
.map_file
, "START GROUP\n");
2056 print_statement_list (s
->children
.head
, os
);
2057 fprintf (config
.map_file
, "END GROUP\n");
2060 /* Print the list of statements in S.
2061 This can be called for any statement type. */
2064 print_statement_list (s
, os
)
2065 lang_statement_union_type
*s
;
2066 lang_output_section_statement_type
*os
;
2070 print_statement (s
, os
);
2075 /* Print the first statement in statement list S.
2076 This can be called for any statement type. */
2079 print_statement (s
, os
)
2080 lang_statement_union_type
*s
;
2081 lang_output_section_statement_type
*os
;
2083 switch (s
->header
.type
)
2086 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2089 case lang_constructors_statement_enum
:
2090 if (constructor_list
.head
!= NULL
)
2092 minfo (" CONSTRUCTORS\n");
2093 print_statement_list (constructor_list
.head
, os
);
2096 case lang_wild_statement_enum
:
2097 print_wild_statement (&s
->wild_statement
, os
);
2099 case lang_address_statement_enum
:
2100 print_address_statement (&s
->address_statement
);
2102 case lang_object_symbols_statement_enum
:
2103 minfo (" CREATE_OBJECT_SYMBOLS\n");
2105 case lang_fill_statement_enum
:
2106 print_fill_statement (&s
->fill_statement
);
2108 case lang_data_statement_enum
:
2109 print_data_statement (&s
->data_statement
);
2111 case lang_reloc_statement_enum
:
2112 print_reloc_statement (&s
->reloc_statement
);
2114 case lang_input_section_enum
:
2115 print_input_section (&s
->input_section
);
2117 case lang_padding_statement_enum
:
2118 print_padding_statement (&s
->padding_statement
);
2120 case lang_output_section_statement_enum
:
2121 print_output_section_statement (&s
->output_section_statement
);
2123 case lang_assignment_statement_enum
:
2124 print_assignment (&s
->assignment_statement
, os
);
2126 case lang_target_statement_enum
:
2127 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2129 case lang_output_statement_enum
:
2130 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2131 if (output_target
!= NULL
)
2132 minfo (" %s", output_target
);
2135 case lang_input_statement_enum
:
2136 print_input_statement (&s
->input_statement
);
2138 case lang_group_statement_enum
:
2139 print_group (&s
->group_statement
, os
);
2141 case lang_afile_asection_pair_statement_enum
:
2150 print_statement_list (statement_list
.head
, abs_output_section
);
2153 /* Print the first N statements in statement list S to STDERR.
2154 If N == 0, nothing is printed.
2155 If N < 0, the entire list is printed.
2156 Intended to be called from GDB. */
2159 dprint_statement (s
, n
)
2160 lang_statement_union_type
* s
;
2163 FILE *map_save
= config
.map_file
;
2165 config
.map_file
= stderr
;
2168 print_statement_list (s
, abs_output_section
);
2171 while (s
&& --n
>= 0)
2173 print_statement (s
, abs_output_section
);
2178 config
.map_file
= map_save
;
2182 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
2183 lang_statement_union_type
** this_ptr
;
2186 asection
* output_section_statement
;
2189 /* Align this section first to the
2190 input sections requirement, then
2191 to the output section's requirement.
2192 If this alignment is > than any seen before,
2193 then record it too. Perform the alignment by
2194 inserting a magic 'padding' statement.
2197 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
2199 if (alignment_needed
!= 0)
2201 lang_statement_union_type
*new =
2202 ((lang_statement_union_type
*)
2203 stat_alloc (sizeof (lang_padding_statement_type
)));
2205 /* Link into existing chain */
2206 new->header
.next
= *this_ptr
;
2208 new->header
.type
= lang_padding_statement_enum
;
2209 new->padding_statement
.output_section
= output_section_statement
;
2210 new->padding_statement
.output_offset
=
2211 dot
- output_section_statement
->vma
;
2212 new->padding_statement
.fill
= fill
;
2213 new->padding_statement
.size
= alignment_needed
;
2217 /* Remember the most restrictive alignment */
2218 if (power
> output_section_statement
->alignment_power
)
2220 output_section_statement
->alignment_power
= power
;
2222 output_section_statement
->_raw_size
+= alignment_needed
;
2223 return alignment_needed
+ dot
;
2227 /* Work out how much this section will move the dot point */
2229 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
2230 lang_statement_union_type
** this_ptr
;
2231 lang_output_section_statement_type
* output_section_statement
;
2236 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2237 asection
*i
= is
->section
;
2239 if (is
->ifile
->just_syms_flag
== false)
2241 if (output_section_statement
->subsection_alignment
!= -1)
2242 i
->alignment_power
=
2243 output_section_statement
->subsection_alignment
;
2245 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
2246 output_section_statement
->bfd_section
, dot
);
2248 /* Remember where in the output section this input section goes */
2250 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
2252 /* Mark how big the output section must be to contain this now
2254 if (i
->_cooked_size
!= 0)
2255 dot
+= i
->_cooked_size
;
2257 dot
+= i
->_raw_size
;
2258 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
2262 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2268 /* This variable indicates whether bfd_relax_section should be called
2271 static boolean relax_again
;
2273 /* Set the sizes for all the output sections. */
2276 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2277 lang_statement_union_type
* s
;
2278 lang_output_section_statement_type
* output_section_statement
;
2279 lang_statement_union_type
** prev
;
2284 /* Size up the sections from their constituent parts */
2285 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2287 switch (s
->header
.type
)
2290 case lang_output_section_statement_enum
:
2293 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
2295 if (os
->bfd_section
== NULL
)
2297 /* This section was never actually created. */
2301 /* If this is a COFF shared library section, use the size and
2302 address from the input section. FIXME: This is COFF
2303 specific; it would be cleaner if there were some other way
2304 to do this, but nothing simple comes to mind. */
2305 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2309 if (os
->children
.head
== NULL
2310 || os
->children
.head
->next
!= NULL
2311 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2312 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2315 input
= os
->children
.head
->input_section
.section
;
2316 bfd_set_section_vma (os
->bfd_section
->owner
,
2318 bfd_section_vma (input
->owner
, input
));
2319 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2323 if (bfd_is_abs_section (os
->bfd_section
))
2325 /* No matter what happens, an abs section starts at zero */
2326 ASSERT (os
->bfd_section
->vma
== 0);
2330 if (os
->addr_tree
== (etree_type
*) NULL
)
2332 /* No address specified for this section, get one
2333 from the region specification
2335 if (os
->region
== (lang_memory_region_type
*) NULL
2336 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2337 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2338 && os
->region
->name
[0] == '*'
2339 && strcmp (os
->region
->name
, "*default*") == 0))
2341 os
->region
= lang_memory_default (os
->bfd_section
);
2344 /* If a loadable section is using the default memory
2345 region, and some non default memory regions were
2346 defined, issue a warning. */
2347 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2348 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2349 && ! link_info
.relocateable
2350 && strcmp (os
->region
->name
, "*default*") == 0
2351 && lang_memory_region_list
!= NULL
2352 && (strcmp (lang_memory_region_list
->name
, "*default*") != 0
2353 || lang_memory_region_list
->next
!= NULL
))
2354 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2355 bfd_get_section_name (output_bfd
, os
->bfd_section
));
2357 dot
= os
->region
->current
;
2358 if (os
->section_alignment
== -1)
2363 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
2364 if (dot
!= olddot
&& config
.warn_section_align
)
2365 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2366 os
->name
, (unsigned int) (dot
- olddot
));
2373 r
= exp_fold_tree (os
->addr_tree
,
2375 lang_allocating_phase_enum
,
2377 if (r
.valid
== false)
2379 einfo (_("%F%S: non constant address expression for section %s\n"),
2382 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2384 /* The section starts here */
2385 /* First, align to what the section needs */
2387 if (os
->section_alignment
!= -1)
2388 dot
= align_power (dot
, os
->section_alignment
);
2390 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2392 os
->bfd_section
->output_offset
= 0;
2395 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
2396 os
->fill
, dot
, relax
);
2397 /* Ignore the size of the input sections, use the vma and size to */
2400 after
= ALIGN_N (os
->bfd_section
->vma
+
2401 os
->bfd_section
->_raw_size
,
2402 /* The coercion here is important, see ld.h. */
2403 (bfd_vma
) os
->block_value
);
2405 if (bfd_is_abs_section (os
->bfd_section
))
2406 ASSERT (after
== os
->bfd_section
->vma
);
2408 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
2409 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
2410 os
->processed
= true;
2412 /* Replace into region ? */
2413 if (os
->region
!= (lang_memory_region_type
*) NULL
)
2415 os
->region
->current
= dot
;
2416 /* Make sure this isn't silly. */
2417 if (os
->region
->current
< os
->region
->origin
2418 || (os
->region
->current
- os
->region
->origin
2419 > os
->region
->length
))
2421 if (os
->addr_tree
!= (etree_type
*) NULL
)
2423 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2424 os
->region
->current
,
2425 os
->bfd_section
->owner
,
2426 os
->bfd_section
->name
,
2431 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2433 os
->bfd_section
->owner
,
2434 os
->bfd_section
->name
);
2436 /* Reset the region pointer. */
2437 os
->region
->current
= os
->region
->origin
;
2443 case lang_constructors_statement_enum
:
2444 dot
= lang_size_sections (constructor_list
.head
,
2445 output_section_statement
,
2446 &s
->wild_statement
.children
.head
,
2451 case lang_data_statement_enum
:
2453 unsigned int size
= 0;
2455 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
2456 s
->data_statement
.output_section
=
2457 output_section_statement
->bfd_section
;
2459 switch (s
->data_statement
.type
)
2477 output_section_statement
->bfd_section
->_raw_size
+= size
;
2478 /* The output section gets contents, and then we inspect for
2479 any flags set in the input script which override any ALLOC */
2480 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
2481 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
)) {
2482 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
| SEC_LOAD
;
2487 case lang_reloc_statement_enum
:
2491 s
->reloc_statement
.output_vma
=
2492 dot
- output_section_statement
->bfd_section
->vma
;
2493 s
->reloc_statement
.output_section
=
2494 output_section_statement
->bfd_section
;
2495 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
2497 output_section_statement
->bfd_section
->_raw_size
+= size
;
2501 case lang_wild_statement_enum
:
2503 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
2504 output_section_statement
,
2505 &s
->wild_statement
.children
.head
,
2511 case lang_object_symbols_statement_enum
:
2512 link_info
.create_object_symbols_section
=
2513 output_section_statement
->bfd_section
;
2515 case lang_output_statement_enum
:
2516 case lang_target_statement_enum
:
2518 case lang_input_section_enum
:
2522 i
= (*prev
)->input_section
.section
;
2525 if (i
->_cooked_size
== 0)
2526 i
->_cooked_size
= i
->_raw_size
;
2532 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
2533 einfo (_("%P%F: can't relax section: %E\n"));
2537 dot
= size_input_section (prev
,
2538 output_section_statement
,
2539 output_section_statement
->fill
,
2543 case lang_input_statement_enum
:
2545 case lang_fill_statement_enum
:
2546 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
2548 fill
= s
->fill_statement
.fill
;
2550 case lang_assignment_statement_enum
:
2552 bfd_vma newdot
= dot
;
2554 exp_fold_tree (s
->assignment_statement
.exp
,
2555 output_section_statement
,
2556 lang_allocating_phase_enum
,
2562 /* The assignment changed dot. Insert a pad. */
2563 if (output_section_statement
== abs_output_section
)
2565 /* If we don't have an output section, then just adjust
2566 the default memory address. */
2567 lang_memory_region_lookup ("*default*")->current
= newdot
;
2571 lang_statement_union_type
*new =
2572 ((lang_statement_union_type
*)
2573 stat_alloc (sizeof (lang_padding_statement_type
)));
2575 /* Link into existing chain */
2576 new->header
.next
= *prev
;
2578 new->header
.type
= lang_padding_statement_enum
;
2579 new->padding_statement
.output_section
=
2580 output_section_statement
->bfd_section
;
2581 new->padding_statement
.output_offset
=
2582 dot
- output_section_statement
->bfd_section
->vma
;
2583 new->padding_statement
.fill
= fill
;
2584 new->padding_statement
.size
= newdot
- dot
;
2585 output_section_statement
->bfd_section
->_raw_size
+=
2586 new->padding_statement
.size
;
2594 case lang_padding_statement_enum
:
2595 /* If we are relaxing, and this is not the first pass, some
2596 padding statements may have been inserted during previous
2597 passes. We may have to move the padding statement to a new
2598 location if dot has a different value at this point in this
2599 pass than it did at this point in the previous pass. */
2600 s
->padding_statement
.output_offset
=
2601 dot
- output_section_statement
->bfd_section
->vma
;
2602 dot
+= s
->padding_statement
.size
;
2603 output_section_statement
->bfd_section
->_raw_size
+=
2604 s
->padding_statement
.size
;
2607 case lang_group_statement_enum
:
2608 dot
= lang_size_sections (s
->group_statement
.children
.head
,
2609 output_section_statement
,
2610 &s
->group_statement
.children
.head
,
2618 /* This can only get here when relaxing is turned on */
2620 case lang_address_statement_enum
:
2623 prev
= &s
->header
.next
;
2629 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
2630 lang_statement_union_type
* s
;
2631 lang_output_section_statement_type
* output_section_statement
;
2635 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2637 switch (s
->header
.type
)
2639 case lang_constructors_statement_enum
:
2640 dot
= lang_do_assignments (constructor_list
.head
,
2641 output_section_statement
,
2646 case lang_output_section_statement_enum
:
2648 lang_output_section_statement_type
*os
=
2649 &(s
->output_section_statement
);
2651 if (os
->bfd_section
!= NULL
)
2653 dot
= os
->bfd_section
->vma
;
2654 (void) lang_do_assignments (os
->children
.head
, os
,
2656 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
2660 /* If nothing has been placed into the output section then
2661 it won't have a bfd_section. */
2662 if (os
->bfd_section
)
2664 os
->bfd_section
->lma
2665 = exp_get_abs_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
2670 case lang_wild_statement_enum
:
2672 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
2673 output_section_statement
,
2678 case lang_object_symbols_statement_enum
:
2679 case lang_output_statement_enum
:
2680 case lang_target_statement_enum
:
2682 case lang_common_statement_enum
:
2685 case lang_data_statement_enum
:
2687 etree_value_type value
;
2689 value
= exp_fold_tree (s
->data_statement
.exp
,
2691 lang_final_phase_enum
, dot
, &dot
);
2692 s
->data_statement
.value
= value
.value
;
2693 if (value
.valid
== false)
2694 einfo (_("%F%P: invalid data statement\n"));
2696 switch (s
->data_statement
.type
)
2714 case lang_reloc_statement_enum
:
2716 etree_value_type value
;
2718 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
2720 lang_final_phase_enum
, dot
, &dot
);
2721 s
->reloc_statement
.addend_value
= value
.value
;
2722 if (value
.valid
== false)
2723 einfo (_("%F%P: invalid reloc statement\n"));
2725 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
);
2728 case lang_input_section_enum
:
2730 asection
*in
= s
->input_section
.section
;
2732 if (in
->_cooked_size
!= 0)
2733 dot
+= in
->_cooked_size
;
2735 dot
+= in
->_raw_size
;
2739 case lang_input_statement_enum
:
2741 case lang_fill_statement_enum
:
2742 fill
= s
->fill_statement
.fill
;
2744 case lang_assignment_statement_enum
:
2746 exp_fold_tree (s
->assignment_statement
.exp
,
2747 output_section_statement
,
2748 lang_final_phase_enum
,
2754 case lang_padding_statement_enum
:
2755 dot
+= s
->padding_statement
.size
;
2758 case lang_group_statement_enum
:
2759 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
2760 output_section_statement
,
2768 case lang_address_statement_enum
:
2776 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
2777 operator .startof. (section_name), it produces an undefined symbol
2778 .startof.section_name. Similarly, when it sees
2779 .sizeof. (section_name), it produces an undefined symbol
2780 .sizeof.section_name. For all the output sections, we look for
2781 such symbols, and set them to the correct value. */
2788 if (link_info
.relocateable
)
2791 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2793 const char *secname
;
2795 struct bfd_link_hash_entry
*h
;
2797 secname
= bfd_get_section_name (output_bfd
, s
);
2798 buf
= xmalloc (10 + strlen (secname
));
2800 sprintf (buf
, ".startof.%s", secname
);
2801 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
2802 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
2804 h
->type
= bfd_link_hash_defined
;
2805 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
2806 h
->u
.def
.section
= bfd_abs_section_ptr
;
2809 sprintf (buf
, ".sizeof.%s", secname
);
2810 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
2811 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
2813 h
->type
= bfd_link_hash_defined
;
2814 if (s
->_cooked_size
!= 0)
2815 h
->u
.def
.value
= s
->_cooked_size
;
2817 h
->u
.def
.value
= s
->_raw_size
;
2818 h
->u
.def
.section
= bfd_abs_section_ptr
;
2828 struct bfd_link_hash_entry
*h
;
2831 if (link_info
.relocateable
|| link_info
.shared
)
2836 if (entry_symbol
== (char *) NULL
)
2838 /* No entry has been specified. Look for start, but don't warn
2839 if we don't find it. */
2840 entry_symbol
= "start";
2844 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
2845 if (h
!= (struct bfd_link_hash_entry
*) NULL
2846 && (h
->type
== bfd_link_hash_defined
2847 || h
->type
== bfd_link_hash_defweak
)
2848 && h
->u
.def
.section
->output_section
!= NULL
)
2852 val
= (h
->u
.def
.value
2853 + bfd_get_section_vma (output_bfd
,
2854 h
->u
.def
.section
->output_section
)
2855 + h
->u
.def
.section
->output_offset
);
2856 if (! bfd_set_start_address (output_bfd
, val
))
2857 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
);
2864 /* We couldn't find the entry symbol. Try parsing it as a
2866 val
= bfd_scan_vma (entry_symbol
, &send
, 0);
2869 if (! bfd_set_start_address (output_bfd
, val
))
2870 einfo (_("%P%F: can't set start address\n"));
2876 /* Can't find the entry symbol, and it's not a number. Use
2877 the first address in the text section. */
2878 ts
= bfd_get_section_by_name (output_bfd
, ".text");
2879 if (ts
!= (asection
*) NULL
)
2882 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
2883 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
2884 if (! bfd_set_start_address (output_bfd
,
2885 bfd_get_section_vma (output_bfd
,
2887 einfo (_("%P%F: can't set start address\n"));
2892 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
2899 /* This is a small function used when we want to ignore errors from
2903 #ifdef ANSI_PROTOTYPES
2904 ignore_bfd_errors (const char *s
, ...)
2906 ignore_bfd_errors (s
)
2910 /* Don't do anything. */
2913 /* Check that the architecture of all the input files is compatible
2914 with the output file. Also call the backend to let it do any
2915 other checking that is needed. */
2920 lang_statement_union_type
*file
;
2922 CONST bfd_arch_info_type
*compatible
;
2924 for (file
= file_chain
.head
;
2925 file
!= (lang_statement_union_type
*) NULL
;
2926 file
= file
->input_statement
.next
)
2928 input_bfd
= file
->input_statement
.the_bfd
;
2929 compatible
= bfd_arch_get_compatible (input_bfd
,
2931 if (compatible
== NULL
)
2933 if (command_line
.warn_mismatch
)
2934 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
2935 bfd_printable_name (input_bfd
), input_bfd
,
2936 bfd_printable_name (output_bfd
));
2940 bfd_error_handler_type pfn
= NULL
;
2942 /* If we aren't supposed to warn about mismatched input
2943 files, temporarily set the BFD error handler to a
2944 function which will do nothing. We still want to call
2945 bfd_merge_private_bfd_data, since it may set up
2946 information which is needed in the output file. */
2947 if (! command_line
.warn_mismatch
)
2948 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
2949 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
2951 if (command_line
.warn_mismatch
)
2952 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
2955 if (! command_line
.warn_mismatch
)
2956 bfd_set_error_handler (pfn
);
2961 /* Look through all the global common symbols and attach them to the
2962 correct section. The -sort-common command line switch may be used
2963 to roughly sort the entries by size. */
2968 if (link_info
.relocateable
2969 && ! command_line
.force_common_definition
)
2972 if (! config
.sort_common
)
2973 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
2978 for (power
= 4; power
>= 0; power
--)
2979 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
2984 /* Place one common symbol in the correct section. */
2987 lang_one_common (h
, info
)
2988 struct bfd_link_hash_entry
*h
;
2991 unsigned int power_of_two
;
2995 if (h
->type
!= bfd_link_hash_common
)
2999 power_of_two
= h
->u
.c
.p
->alignment_power
;
3001 if (config
.sort_common
3002 && power_of_two
< (unsigned int) *(int *) info
)
3005 section
= h
->u
.c
.p
->section
;
3007 /* Increase the size of the section. */
3008 section
->_cooked_size
= ALIGN_N (section
->_cooked_size
,
3009 (bfd_size_type
) (1 << power_of_two
));
3011 /* Adjust the alignment if necessary. */
3012 if (power_of_two
> section
->alignment_power
)
3013 section
->alignment_power
= power_of_two
;
3015 /* Change the symbol from common to defined. */
3016 h
->type
= bfd_link_hash_defined
;
3017 h
->u
.def
.section
= section
;
3018 h
->u
.def
.value
= section
->_cooked_size
;
3020 /* Increase the size of the section. */
3021 section
->_cooked_size
+= size
;
3023 /* Make sure the section is allocated in memory, and make sure that
3024 it is no longer a common section. */
3025 section
->flags
|= SEC_ALLOC
;
3026 section
->flags
&= ~ SEC_IS_COMMON
;
3028 if (config
.map_file
!= NULL
)
3030 static boolean header_printed
;
3035 if (! header_printed
)
3037 minfo (_("\nAllocating common symbols\n"));
3038 minfo (_("Common symbol size file\n\n"));
3039 header_printed
= true;
3042 name
= demangle (h
->root
.string
);
3044 len
= strlen (name
);
3059 if (size
<= 0xffffffff)
3060 sprintf (buf
, "%lx", (unsigned long) size
);
3062 sprintf_vma (buf
, size
);
3072 minfo ("%B\n", section
->owner
);
3079 run through the input files and ensure that every input
3080 section has somewhere to go. If one is found without
3081 a destination then create an input request and place it
3082 into the statement tree.
3086 lang_place_orphans ()
3088 lang_input_statement_type
*file
;
3090 for (file
= (lang_input_statement_type
*) file_chain
.head
;
3091 file
!= (lang_input_statement_type
*) NULL
;
3092 file
= (lang_input_statement_type
*) file
->next
)
3096 for (s
= file
->the_bfd
->sections
;
3097 s
!= (asection
*) NULL
;
3100 if (s
->output_section
== (asection
*) NULL
)
3102 /* This section of the file is not attatched, root
3103 around for a sensible place for it to go */
3105 if (file
->just_syms_flag
)
3107 /* We are only retrieving symbol values from this
3108 file. We want the symbols to act as though the
3109 values in the file are absolute. */
3110 s
->output_section
= bfd_abs_section_ptr
;
3111 s
->output_offset
= s
->vma
;
3113 else if (strcmp (s
->name
, "COMMON") == 0)
3115 /* This is a lonely common section which must have
3116 come from an archive. We attach to the section
3117 with the wildcard. */
3118 if (! link_info
.relocateable
3119 || command_line
.force_common_definition
)
3121 if (default_common_section
== NULL
)
3124 /* This message happens when using the
3125 svr3.ifile linker script, so I have
3127 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3129 default_common_section
=
3130 lang_output_section_statement_lookup (".bss");
3133 wild_doit (&default_common_section
->children
, s
,
3134 default_common_section
, file
);
3137 else if (ldemul_place_orphan (file
, s
))
3141 lang_output_section_statement_type
*os
=
3142 lang_output_section_statement_lookup (s
->name
);
3144 wild_doit (&os
->children
, s
, os
, file
);
3153 lang_set_flags (ptr
, flags
)
3154 lang_memory_region_type
*ptr
;
3157 flagword
*ptr_flags
= &ptr
->flags
;
3159 ptr
->flags
= ptr
->not_flags
= 0;
3165 ptr_flags
= (ptr_flags
== &ptr
->flags
) ? &ptr
->not_flags
: &ptr
->flags
;
3169 *ptr_flags
|= SEC_ALLOC
;
3173 *ptr_flags
|= SEC_READONLY
;
3177 *ptr_flags
|= SEC_DATA
;
3181 *ptr_flags
|= SEC_CODE
;
3186 *ptr_flags
|= SEC_LOAD
;
3190 einfo (_("%P%F: invalid syntax in flags\n"));
3197 /* Call a function on each input file. This function will be called
3198 on an archive, but not on the elements. */
3201 lang_for_each_input_file (func
)
3202 void (*func
) PARAMS ((lang_input_statement_type
*));
3204 lang_input_statement_type
*f
;
3206 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3208 f
= (lang_input_statement_type
*) f
->next_real_file
)
3212 /* Call a function on each file. The function will be called on all
3213 the elements of an archive which are included in the link, but will
3214 not be called on the archive file itself. */
3217 lang_for_each_file (func
)
3218 void (*func
) PARAMS ((lang_input_statement_type
*));
3220 lang_input_statement_type
*f
;
3222 for (f
= (lang_input_statement_type
*) file_chain
.head
;
3223 f
!= (lang_input_statement_type
*) NULL
;
3224 f
= (lang_input_statement_type
*) f
->next
)
3235 lang_for_each_input_section (func
)
3236 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
3238 lang_input_statement_type
*f
;
3240 for (f
= (lang_input_statement_type
*) file_chain
.head
;
3241 f
!= (lang_input_statement_type
*) NULL
;
3242 f
= (lang_input_statement_type
*) f
->next
)
3246 for (s
= f
->the_bfd
->sections
;
3247 s
!= (asection
*) NULL
;
3250 func (f
->the_bfd
, s
);
3258 ldlang_add_file (entry
)
3259 lang_input_statement_type
* entry
;
3263 lang_statement_append (&file_chain
,
3264 (lang_statement_union_type
*) entry
,
3267 /* The BFD linker needs to have a list of all input BFDs involved in
3269 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3270 ASSERT (entry
->the_bfd
!= output_bfd
);
3271 for (pp
= &link_info
.input_bfds
;
3272 *pp
!= (bfd
*) NULL
;
3273 pp
= &(*pp
)->link_next
)
3275 *pp
= entry
->the_bfd
;
3276 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3277 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3279 /* Look through the sections and check for any which should not be
3280 included in the link. We need to do this now, so that we can
3281 notice when the backend linker tries to report multiple
3282 definition errors for symbols which are in sections we aren't
3283 going to link. FIXME: It might be better to entirely ignore
3284 symbols which are defined in sections which are going to be
3285 discarded. This would require modifying the backend linker for
3286 each backend which might set the SEC_LINK_ONCE flag. If we do
3287 this, we should probably handle SEC_EXCLUDE in the same way. */
3289 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
3293 lang_add_output (name
, from_script
)
3297 /* Make -o on command line override OUTPUT in script. */
3298 if (had_output_filename
== false || !from_script
)
3300 output_filename
= name
;
3301 had_output_filename
= true;
3306 static lang_output_section_statement_type
*current_section
;
3318 for (l
= 0; l
< 32; l
++)
3320 if (i
>= (unsigned int) x
)
3329 lang_enter_output_section_statement (output_section_statement_name
,
3330 address_exp
, sectype
, block_value
,
3331 align
, subalign
, ebase
)
3332 const char *output_section_statement_name
;
3333 etree_type
* address_exp
;
3334 enum section_type sectype
;
3335 bfd_vma block_value
;
3337 etree_type
*subalign
;
3340 lang_output_section_statement_type
*os
;
3344 lang_output_section_statement_lookup (output_section_statement_name
);
3348 /* Add this statement to tree */
3349 /* add_statement(lang_output_section_statement_enum,
3350 output_section_statement);*/
3351 /* Make next things chain into subchain of this */
3353 if (os
->addr_tree
==
3354 (etree_type
*) NULL
)
3359 os
->sectype
= sectype
;
3360 if (sectype
!= noload_section
)
3361 os
->flags
= SEC_NO_FLAGS
;
3363 os
->flags
= SEC_NEVER_LOAD
;
3364 os
->block_value
= block_value
? block_value
: 1;
3365 stat_ptr
= &os
->children
;
3367 os
->subsection_alignment
= topower(
3368 exp_get_value_int(subalign
, -1,
3369 "subsection alignment",
3371 os
->section_alignment
= topower(
3372 exp_get_value_int(align
, -1,
3373 "section alignment", 0));
3375 os
->load_base
= ebase
;
3382 lang_output_statement_type
*new =
3383 new_stat (lang_output_statement
, stat_ptr
);
3385 new->name
= output_filename
;
3388 /* Reset the current counters in the regions */
3390 reset_memory_regions ()
3392 lang_memory_region_type
*p
= lang_memory_region_list
;
3394 for (p
= lang_memory_region_list
;
3395 p
!= (lang_memory_region_type
*) NULL
;
3398 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
3399 p
->current
= p
->origin
;
3403 /* ??? At some point this traversal for GC should share code with the
3404 traversal for manipulating the output file. */
3406 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3407 as needed. SECTION may be NULL, in which case it is a wild card. */
3410 lang_gc_wild_section (ptr
, section
, file
)
3411 lang_wild_statement_type
*ptr
;
3412 const char *section
;
3413 lang_input_statement_type
*file
;
3415 if (file
->just_syms_flag
== false)
3417 register asection
*s
;
3420 if (section
== NULL
)
3423 wildcard
= wildcardp (section
);
3425 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3429 if (section
== NULL
)
3435 name
= bfd_get_section_name (file
->the_bfd
, s
);
3437 match
= fnmatch (section
, name
, 0) == 0 ? true : false;
3439 match
= strcmp (section
, name
) == 0 ? true : false;
3444 /* If the wild pattern was marked KEEP, the member sections
3445 should be as well. */
3446 if (ptr
->keep_sections
)
3447 s
->flags
|= SEC_KEEP
;
3453 /* Handle a wild statement for a single file F. */
3456 lang_gc_wild_file (s
, section
, f
)
3457 lang_wild_statement_type
*s
;
3458 const char *section
;
3459 lang_input_statement_type
*f
;
3461 if (f
->the_bfd
== NULL
3462 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
3463 lang_gc_wild_section (s
, section
, f
);
3468 /* This is an archive file. We must map each member of the
3469 archive separately. */
3470 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
3471 while (member
!= NULL
)
3473 /* When lookup_name is called, it will call the add_symbols
3474 entry point for the archive. For each element of the
3475 archive which is included, BFD will call ldlang_add_file,
3476 which will set the usrdata field of the member to the
3477 lang_input_statement. */
3478 if (member
->usrdata
!= NULL
)
3480 lang_gc_wild_section (s
, section
,
3481 (lang_input_statement_type
*) member
->usrdata
);
3484 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
3489 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
3490 may be NULL, indicating that it is a wildcard. */
3493 lang_gc_wild (s
, section
, file
)
3494 lang_wild_statement_type
*s
;
3495 const char *section
;
3498 lang_input_statement_type
*f
;
3500 if (file
== (char *) NULL
)
3502 /* Perform the iteration over all files in the list */
3503 for (f
= (lang_input_statement_type
*) file_chain
.head
;
3504 f
!= (lang_input_statement_type
*) NULL
;
3505 f
= (lang_input_statement_type
*) f
->next
)
3507 lang_gc_wild_file (s
, section
, f
);
3510 else if (wildcardp (file
))
3512 for (f
= (lang_input_statement_type
*) file_chain
.head
;
3513 f
!= (lang_input_statement_type
*) NULL
;
3514 f
= (lang_input_statement_type
*) f
->next
)
3516 if (fnmatch (file
, f
->filename
, FNM_FILE_NAME
) == 0)
3517 lang_gc_wild_file (s
, section
, f
);
3522 /* Perform the iteration over a single file */
3523 f
= lookup_name (file
);
3524 lang_gc_wild_file (s
, section
, f
);
3528 /* Iterate over sections marking them against GC. */
3531 lang_gc_sections_1 (s
)
3532 lang_statement_union_type
* s
;
3534 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
3536 switch (s
->header
.type
)
3538 case lang_wild_statement_enum
:
3539 lang_gc_wild (&s
->wild_statement
,
3540 s
->wild_statement
.section_name
,
3541 s
->wild_statement
.filename
);
3543 case lang_constructors_statement_enum
:
3544 lang_gc_sections_1 (constructor_list
.head
);
3546 case lang_output_section_statement_enum
:
3547 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
3549 case lang_group_statement_enum
:
3550 lang_gc_sections_1 (s
->group_statement
.children
.head
);
3559 struct bfd_link_hash_entry
*h
;
3560 ldlang_undef_chain_list_type
*ulist
, fake_list_start
;
3562 /* Keep all sections so marked in the link script. */
3564 lang_gc_sections_1 (statement_list
.head
);
3566 /* Keep all sections containing symbols undefined on the command-line.
3567 Handle the entry symbol at the same time. */
3569 fake_list_start
.next
= ldlang_undef_chain_list_head
;
3570 fake_list_start
.name
= entry_symbol
;
3572 for (ulist
= &fake_list_start
; ulist
; ulist
= ulist
->next
)
3574 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
3575 false, false, false);
3577 if (h
!= (struct bfd_link_hash_entry
*) NULL
3578 && (h
->type
== bfd_link_hash_defined
3579 || h
->type
== bfd_link_hash_defweak
)
3580 && ! bfd_is_abs_section (h
->u
.def
.section
))
3582 h
->u
.def
.section
->flags
|= SEC_KEEP
;
3586 bfd_gc_sections (output_bfd
, &link_info
);
3592 lang_reasonable_defaults ();
3593 current_target
= default_target
;
3595 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
3597 ldemul_create_output_section_statements ();
3599 /* Add to the hash table all undefineds on the command line */
3600 lang_place_undefineds ();
3602 /* Create a bfd for each input file */
3603 current_target
= default_target
;
3604 open_input_bfds (statement_list
.head
, false);
3606 ldemul_after_open ();
3608 /* Make sure that we're not mixing architectures. We call this
3609 after all the input files have been opened, but before we do any
3610 other processing, so that any operations merge_private_bfd_data
3611 does on the output file will be known during the rest of the
3615 /* Build all sets based on the information gathered from the input
3617 ldctor_build_sets ();
3619 /* Remove unreferenced sections if asked to. */
3620 if (command_line
.gc_sections
)
3621 lang_gc_sections ();
3623 /* Size up the common data */
3626 /* Run through the contours of the script and attach input sections
3627 to the correct output sections
3629 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
3630 (lang_output_section_statement_type
*) NULL
);
3633 /* Find any sections not attached explicitly and handle them */
3634 lang_place_orphans ();
3636 ldemul_before_allocation ();
3638 /* We must record the program headers before we try to fix the
3639 section positions, since they will affect SIZEOF_HEADERS. */
3640 lang_record_phdrs ();
3642 /* Now run around and relax if we can */
3643 if (command_line
.relax
)
3645 /* First time round is a trial run to get the 'worst case'
3646 addresses of the objects if there was no relaxing. */
3647 lang_size_sections (statement_list
.head
,
3649 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
3651 /* Keep relaxing until bfd_relax_section gives up. */
3654 reset_memory_regions ();
3656 relax_again
= false;
3658 /* Do all the assignments with our current guesses as to
3660 lang_do_assignments (statement_list
.head
,
3662 (fill_type
) 0, (bfd_vma
) 0);
3664 /* Perform another relax pass - this time we know where the
3665 globals are, so can make better guess. */
3666 lang_size_sections (statement_list
.head
,
3668 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
3670 while (relax_again
);
3674 /* Size up the sections. */
3675 lang_size_sections (statement_list
.head
,
3677 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
3680 /* See if anything special should be done now we know how big
3682 ldemul_after_allocation ();
3684 /* Fix any .startof. or .sizeof. symbols. */
3685 lang_set_startof ();
3687 /* Do all the assignments, now that we know the final restingplaces
3688 of all the symbols */
3690 lang_do_assignments (statement_list
.head
,
3692 (fill_type
) 0, (bfd_vma
) 0);
3700 /* EXPORTED TO YACC */
3703 lang_add_wild (section_name
, sections_sorted
, filename
, filenames_sorted
,
3705 const char *const section_name
;
3706 boolean sections_sorted
;
3707 const char *const filename
;
3708 boolean filenames_sorted
;
3709 boolean keep_sections
;
3711 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
3714 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
3716 placed_commons
= true;
3718 if (filename
!= (char *) NULL
)
3720 lang_has_input_file
= true;
3722 new->section_name
= section_name
;
3723 new->sections_sorted
= sections_sorted
;
3724 new->filename
= filename
;
3725 new->filenames_sorted
= filenames_sorted
;
3726 new->keep_sections
= keep_sections
;
3727 lang_list_init (&new->children
);
3731 lang_section_start (name
, address
)
3733 etree_type
* address
;
3735 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
3737 ad
->section_name
= name
;
3738 ad
->address
= address
;
3741 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
3742 because of a -e argument on the command line, or zero if this is
3743 called by ENTRY in a linker script. Command line arguments take
3747 lang_add_entry (name
, cmdline
)
3751 if (entry_symbol
== NULL
3753 || ! entry_from_cmdline
)
3755 entry_symbol
= name
;
3756 entry_from_cmdline
= cmdline
;
3761 lang_add_target (name
)
3764 lang_target_statement_type
*new = new_stat (lang_target_statement
,
3780 map_option_f
= true;
3791 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
3798 lang_add_data (type
, exp
)
3800 union etree_union
*exp
;
3803 lang_data_statement_type
*new = new_stat (lang_data_statement
,
3811 /* Create a new reloc statement. RELOC is the BFD relocation type to
3812 generate. HOWTO is the corresponding howto structure (we could
3813 look this up, but the caller has already done so). SECTION is the
3814 section to generate a reloc against, or NAME is the name of the
3815 symbol to generate a reloc against. Exactly one of SECTION and
3816 NAME must be NULL. ADDEND is an expression for the addend. */
3819 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
3820 bfd_reloc_code_real_type reloc
;
3821 reloc_howto_type
*howto
;
3824 union etree_union
*addend
;
3826 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
3830 p
->section
= section
;
3832 p
->addend_exp
= addend
;
3834 p
->addend_value
= 0;
3835 p
->output_section
= NULL
;
3840 lang_add_assignment (exp
)
3843 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
3850 lang_add_attribute (attribute
)
3851 enum statement_enum attribute
;
3853 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
3860 if (startup_file
!= (char *) NULL
)
3862 einfo (_("%P%Fmultiple STARTUP files\n"));
3864 first_file
->filename
= name
;
3865 first_file
->local_sym_name
= name
;
3866 first_file
->real
= true;
3868 startup_file
= name
;
3875 lang_float_flag
= maybe
;
3879 lang_leave_output_section_statement (fill
, memspec
, phdrs
)
3881 const char *memspec
;
3882 struct lang_output_section_phdr_list
*phdrs
;
3884 current_section
->fill
= fill
;
3885 current_section
->region
= lang_memory_region_lookup (memspec
);
3886 current_section
->phdrs
= phdrs
;
3887 stat_ptr
= &statement_list
;
3891 Create an absolute symbol with the given name with the value of the
3892 address of first byte of the section named.
3894 If the symbol already exists, then do nothing.
3897 lang_abs_symbol_at_beginning_of (secname
, name
)
3898 const char *secname
;
3901 struct bfd_link_hash_entry
*h
;
3903 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
3904 if (h
== (struct bfd_link_hash_entry
*) NULL
)
3905 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3907 if (h
->type
== bfd_link_hash_new
3908 || h
->type
== bfd_link_hash_undefined
)
3912 h
->type
= bfd_link_hash_defined
;
3914 sec
= bfd_get_section_by_name (output_bfd
, secname
);
3915 if (sec
== (asection
*) NULL
)
3918 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
3920 h
->u
.def
.section
= bfd_abs_section_ptr
;
3925 Create an absolute symbol with the given name with the value of the
3926 address of the first byte after the end of the section named.
3928 If the symbol already exists, then do nothing.
3931 lang_abs_symbol_at_end_of (secname
, name
)
3932 const char *secname
;
3935 struct bfd_link_hash_entry
*h
;
3937 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
3938 if (h
== (struct bfd_link_hash_entry
*) NULL
)
3939 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3941 if (h
->type
== bfd_link_hash_new
3942 || h
->type
== bfd_link_hash_undefined
)
3946 h
->type
= bfd_link_hash_defined
;
3948 sec
= bfd_get_section_by_name (output_bfd
, secname
);
3949 if (sec
== (asection
*) NULL
)
3952 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
3953 + bfd_section_size (output_bfd
, sec
));
3955 h
->u
.def
.section
= bfd_abs_section_ptr
;
3960 lang_statement_append (list
, element
, field
)
3961 lang_statement_list_type
* list
;
3962 lang_statement_union_type
* element
;
3963 lang_statement_union_type
** field
;
3965 *(list
->tail
) = element
;
3969 /* Set the output format type. -oformat overrides scripts. */
3972 lang_add_output_format (format
, big
, little
, from_script
)
3978 if (output_target
== NULL
|| !from_script
)
3980 if (command_line
.endian
== ENDIAN_BIG
3983 else if (command_line
.endian
== ENDIAN_LITTLE
3987 output_target
= format
;
3991 /* Enter a group. This creates a new lang_group_statement, and sets
3992 stat_ptr to build new statements within the group. */
3997 lang_group_statement_type
*g
;
3999 g
= new_stat (lang_group_statement
, stat_ptr
);
4000 lang_list_init (&g
->children
);
4001 stat_ptr
= &g
->children
;
4004 /* Leave a group. This just resets stat_ptr to start writing to the
4005 regular list of statements again. Note that this will not work if
4006 groups can occur inside anything else which can adjust stat_ptr,
4007 but currently they can't. */
4012 stat_ptr
= &statement_list
;
4015 /* Add a new program header. This is called for each entry in a PHDRS
4016 command in a linker script. */
4019 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4027 struct lang_phdr
*n
, **pp
;
4029 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4032 n
->type
= exp_get_value_int (type
, 0, "program header type",
4033 lang_final_phase_enum
);
4034 n
->filehdr
= filehdr
;
4039 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4044 /* Record the program header information in the output BFD. FIXME: We
4045 should not be calling an ELF specific function here. */
4048 lang_record_phdrs ()
4052 struct lang_output_section_phdr_list
*last
;
4053 struct lang_phdr
*l
;
4054 lang_statement_union_type
*u
;
4057 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4059 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4066 for (u
= lang_output_section_statement
.head
;
4068 u
= u
->output_section_statement
.next
)
4070 lang_output_section_statement_type
*os
;
4071 struct lang_output_section_phdr_list
*pl
;
4073 os
= &u
->output_section_statement
;
4080 if (os
->sectype
== noload_section
4081 || os
->bfd_section
== NULL
4082 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4087 if (os
->bfd_section
== NULL
)
4090 for (; pl
!= NULL
; pl
= pl
->next
)
4092 if (strcmp (pl
->name
, l
->name
) == 0)
4097 secs
= ((asection
**)
4098 xrealloc (secs
, alc
* sizeof (asection
*)));
4100 secs
[c
] = os
->bfd_section
;
4107 if (l
->flags
== NULL
)
4110 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4111 lang_final_phase_enum
);
4116 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4117 lang_final_phase_enum
);
4119 if (! bfd_record_phdr (output_bfd
, l
->type
,
4120 l
->flags
== NULL
? false : true,
4122 l
->at
== NULL
? false : true,
4123 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4124 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4129 /* Make sure all the phdr assignments succeeded. */
4130 for (u
= lang_output_section_statement
.head
;
4132 u
= u
->output_section_statement
.next
)
4134 struct lang_output_section_phdr_list
*pl
;
4136 if (u
->output_section_statement
.bfd_section
== NULL
)
4139 for (pl
= u
->output_section_statement
.phdrs
;
4142 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4143 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4144 u
->output_section_statement
.name
, pl
->name
);
4148 /* Record a list of sections which may not be cross referenced. */
4151 lang_add_nocrossref (l
)
4152 struct lang_nocrossref
*l
;
4154 struct lang_nocrossrefs
*n
;
4156 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4157 n
->next
= nocrossref_list
;
4159 nocrossref_list
= n
;
4161 /* Set notice_all so that we get informed about all symbols. */
4162 link_info
.notice_all
= true;
4165 /* Overlay handling. We handle overlays with some static variables. */
4167 /* The overlay virtual address. */
4168 static etree_type
*overlay_vma
;
4170 /* The overlay load address. */
4171 static etree_type
*overlay_lma
;
4173 /* Whether nocrossrefs is set for this overlay. */
4174 static int overlay_nocrossrefs
;
4176 /* An expression for the maximum section size seen so far. */
4177 static etree_type
*overlay_max
;
4179 /* A list of all the sections in this overlay. */
4183 struct overlay_list
*next
;
4184 lang_output_section_statement_type
*os
;
4187 static struct overlay_list
*overlay_list
;
4189 /* Start handling an overlay. */
4192 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
4193 etree_type
*vma_expr
;
4194 etree_type
*lma_expr
;
4197 /* The grammar should prevent nested overlays from occurring. */
4198 ASSERT (overlay_vma
== NULL
4199 && overlay_lma
== NULL
4200 && overlay_list
== NULL
4201 && overlay_max
== NULL
);
4203 overlay_vma
= vma_expr
;
4204 overlay_lma
= lma_expr
;
4205 overlay_nocrossrefs
= nocrossrefs
;
4208 /* Start a section in an overlay. We handle this by calling
4209 lang_enter_output_section_statement with the correct VMA and LMA. */
4212 lang_enter_overlay_section (name
)
4215 struct overlay_list
*n
;
4218 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4219 0, 0, 0, overlay_lma
);
4221 /* If this is the first section, then base the VMA and LMA of future
4222 sections on this one. This will work correctly even if `.' is
4223 used in the addresses. */
4224 if (overlay_list
== NULL
)
4226 overlay_vma
= exp_nameop (ADDR
, name
);
4227 overlay_lma
= exp_nameop (LOADADDR
, name
);
4230 /* Remember the section. */
4231 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4232 n
->os
= current_section
;
4233 n
->next
= overlay_list
;
4236 size
= exp_nameop (SIZEOF
, name
);
4238 /* Adjust the LMA for the next section. */
4239 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
4241 /* Arrange to work out the maximum section end address. */
4242 if (overlay_max
== NULL
)
4245 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4248 /* Finish a section in an overlay. There isn't any special to do
4252 lang_leave_overlay_section (fill
, phdrs
)
4254 struct lang_output_section_phdr_list
*phdrs
;
4261 name
= current_section
->name
;
4263 lang_leave_output_section_statement (fill
, "*default*", phdrs
);
4265 /* Define the magic symbols. */
4267 clean
= xmalloc (strlen (name
) + 1);
4269 for (s1
= name
; *s1
!= '\0'; s1
++)
4270 if (isalnum ((unsigned char) *s1
) || *s1
== '_')
4274 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4275 sprintf (buf
, "__load_start_%s", clean
);
4276 lang_add_assignment (exp_assop ('=', buf
,
4277 exp_nameop (LOADADDR
, name
)));
4279 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4280 sprintf (buf
, "__load_stop_%s", clean
);
4281 lang_add_assignment (exp_assop ('=', buf
,
4283 exp_nameop (LOADADDR
, name
),
4284 exp_nameop (SIZEOF
, name
))));
4289 /* Finish an overlay. If there are any overlay wide settings, this
4290 looks through all the sections in the overlay and sets them. */
4293 lang_leave_overlay (fill
, memspec
, phdrs
)
4295 const char *memspec
;
4296 struct lang_output_section_phdr_list
*phdrs
;
4298 lang_memory_region_type
*region
;
4299 struct overlay_list
*l
;
4300 struct lang_nocrossref
*nocrossref
;
4302 if (memspec
== NULL
)
4305 region
= lang_memory_region_lookup (memspec
);
4312 struct overlay_list
*next
;
4314 if (fill
!= 0 && l
->os
->fill
== 0)
4316 if (region
!= NULL
&& l
->os
->region
== NULL
)
4317 l
->os
->region
= region
;
4318 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4319 l
->os
->phdrs
= phdrs
;
4321 if (overlay_nocrossrefs
)
4323 struct lang_nocrossref
*nc
;
4325 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
4326 nc
->name
= l
->os
->name
;
4327 nc
->next
= nocrossref
;
4336 if (nocrossref
!= NULL
)
4337 lang_add_nocrossref (nocrossref
);
4339 /* Update . for the end of the overlay. */
4340 lang_add_assignment (exp_assop ('=', ".",
4341 exp_binop ('+', overlay_vma
, overlay_max
)));
4345 overlay_nocrossrefs
= 0;
4346 overlay_list
= NULL
;
4350 /* Version handling. This is only useful for ELF. */
4352 /* This global variable holds the version tree that we build. */
4354 struct bfd_elf_version_tree
*lang_elf_version_info
;
4356 /* This is called for each variable name or match expression. */
4358 struct bfd_elf_version_expr
*
4359 lang_new_vers_regex (orig
, new)
4360 struct bfd_elf_version_expr
*orig
;
4363 struct bfd_elf_version_expr
*ret
;
4365 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
4371 /* This is called for each set of variable names and match
4374 struct bfd_elf_version_tree
*
4375 lang_new_vers_node (globals
, locals
)
4376 struct bfd_elf_version_expr
*globals
;
4377 struct bfd_elf_version_expr
*locals
;
4379 struct bfd_elf_version_tree
*ret
;
4381 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
4385 ret
->globals
= globals
;
4386 ret
->locals
= locals
;
4388 ret
->name_indx
= (unsigned int) -1;
4393 /* This static variable keeps track of version indices. */
4395 static int version_index
;
4397 /* This is called when we know the name and dependencies of the
4401 lang_register_vers_node (name
, version
, deps
)
4403 struct bfd_elf_version_tree
*version
;
4404 struct bfd_elf_version_deps
*deps
;
4406 struct bfd_elf_version_tree
*t
, **pp
;
4407 struct bfd_elf_version_expr
*e1
;
4409 /* Make sure this node has a unique name. */
4410 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4411 if (strcmp (t
->name
, name
) == 0)
4412 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
4414 /* Check the global and local match names, and make sure there
4415 aren't any duplicates. */
4417 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
4419 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4421 struct bfd_elf_version_expr
*e2
;
4423 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
4424 if (strcmp (e1
->match
, e2
->match
) == 0)
4425 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4430 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
4432 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4434 struct bfd_elf_version_expr
*e2
;
4436 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
4437 if (strcmp (e1
->match
, e2
->match
) == 0)
4438 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4443 version
->deps
= deps
;
4444 version
->name
= name
;
4446 version
->vernum
= version_index
;
4448 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4453 /* This is called when we see a version dependency. */
4455 struct bfd_elf_version_deps
*
4456 lang_add_vers_depend (list
, name
)
4457 struct bfd_elf_version_deps
*list
;
4460 struct bfd_elf_version_deps
*ret
;
4461 struct bfd_elf_version_tree
*t
;
4463 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
4466 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4468 if (strcmp (t
->name
, name
) == 0)
4470 ret
->version_needed
= t
;
4475 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);