1 /* Linker command language support.
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 1999
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"
44 static lang_statement_union_type
*new_statement
PARAMS ((enum statement_enum
,
46 lang_statement_list_type
*));
50 static struct obstack stat_obstack
;
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
54 static CONST
char *startup_file
;
55 static lang_statement_list_type input_file_chain
;
56 static boolean placed_commons
= false;
57 static lang_output_section_statement_type
*default_common_section
;
58 static boolean map_option_f
;
59 static bfd_vma print_dot
;
60 static lang_input_statement_type
*first_file
;
61 static lang_statement_list_type lang_output_section_statement
;
62 static CONST
char *current_target
;
63 static CONST
char *output_target
;
64 static lang_statement_list_type statement_list
;
65 static struct lang_phdr
*lang_phdr_list
;
67 static void lang_for_each_statement_worker
68 PARAMS ((void (*func
) (lang_statement_union_type
*),
69 lang_statement_union_type
*s
));
70 static lang_input_statement_type
*new_afile
71 PARAMS ((const char *name
, lang_input_file_enum_type file_type
,
72 const char *target
, boolean add_to_list
));
73 static void init_os
PARAMS ((lang_output_section_statement_type
*s
));
74 static void exp_init_os
PARAMS ((etree_type
*));
75 static void section_already_linked
PARAMS ((bfd
*, asection
*, PTR
));
76 static boolean wildcardp
PARAMS ((const char *));
77 static lang_statement_union_type
*wild_sort
78 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
80 static lang_input_statement_type
*lookup_name
PARAMS ((const char *name
));
81 static void load_symbols
PARAMS ((lang_input_statement_type
*entry
,
82 lang_statement_list_type
*));
83 static void wild
PARAMS ((lang_wild_statement_type
*s
,
84 const char *section
, const char *file
,
86 lang_output_section_statement_type
*output
));
87 static bfd
*open_output
PARAMS ((const char *name
));
88 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*statement
));
89 static void open_input_bfds
90 PARAMS ((lang_statement_union_type
*statement
, boolean
));
91 static void lang_reasonable_defaults
PARAMS ((void));
92 static void lang_place_undefineds
PARAMS ((void));
93 static void map_input_to_output_sections
94 PARAMS ((lang_statement_union_type
*s
,
96 lang_output_section_statement_type
*output_section_statement
));
97 static void print_output_section_statement
98 PARAMS ((lang_output_section_statement_type
*output_section_statement
));
99 static void print_assignment
100 PARAMS ((lang_assignment_statement_type
*assignment
,
101 lang_output_section_statement_type
*output_section
));
102 static void print_input_statement
PARAMS ((lang_input_statement_type
*statm
));
103 static boolean print_one_symbol
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
104 static void print_input_section
PARAMS ((lang_input_section_type
*in
));
105 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*fill
));
106 static void print_data_statement
PARAMS ((lang_data_statement_type
*data
));
107 static void print_address_statement
PARAMS ((lang_address_statement_type
*));
108 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*reloc
));
109 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*s
));
110 static void print_wild_statement
111 PARAMS ((lang_wild_statement_type
*w
,
112 lang_output_section_statement_type
*os
));
113 static void print_group
114 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
115 static void print_statement
PARAMS ((lang_statement_union_type
*s
,
116 lang_output_section_statement_type
*os
));
117 static void print_statement_list
PARAMS ((lang_statement_union_type
*s
,
118 lang_output_section_statement_type
*os
));
119 static void print_statements
PARAMS ((void));
120 static bfd_vma insert_pad
PARAMS ((lang_statement_union_type
**this_ptr
,
121 fill_type fill
, unsigned int power
,
122 asection
*output_section_statement
,
124 static bfd_vma size_input_section
125 PARAMS ((lang_statement_union_type
**this_ptr
,
126 lang_output_section_statement_type
*output_section_statement
,
127 fill_type fill
, bfd_vma dot
, boolean relax
));
128 static void lang_finish
PARAMS ((void));
129 static void ignore_bfd_errors
PARAMS ((const char *, ...));
130 static void lang_check
PARAMS ((void));
131 static void lang_common
PARAMS ((void));
132 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
133 static void lang_place_orphans
PARAMS ((void));
134 static int topower
PARAMS ((int));
135 static void lang_set_startof
PARAMS ((void));
136 static void reset_memory_regions
PARAMS ((void));
137 static void lang_record_phdrs
PARAMS ((void));
138 static void lang_gc_wild
139 PARAMS ((lang_wild_statement_type
*, const char *, const char *));
140 static void lang_gc_sections_1
PARAMS ((lang_statement_union_type
*));
141 static void lang_gc_sections
PARAMS ((void));
142 static void lang_do_version_exports_section
PARAMS ((void));
143 static void lang_check_section_addresses
PARAMS ((void));
145 typedef void (*callback_t
) PARAMS ((lang_wild_statement_type
*,
146 asection
*, lang_input_statement_type
*,
148 static void walk_wild_section
149 PARAMS ((lang_wild_statement_type
*, const char *,
150 lang_input_statement_type
*, callback_t
, void *));
151 static void walk_wild_file
152 PARAMS ((lang_wild_statement_type
*, const char *,
153 lang_input_statement_type
*, callback_t
, void *));
156 lang_output_section_statement_type
*abs_output_section
;
157 lang_statement_list_type
*stat_ptr
= &statement_list
;
158 lang_statement_list_type file_chain
= { 0 };
159 const char *entry_symbol
= NULL
;
160 boolean entry_from_cmdline
;
161 boolean lang_has_input_file
= false;
162 boolean had_output_filename
= false;
163 boolean lang_float_flag
= false;
164 boolean delete_output_file_on_failure
= false;
165 struct lang_nocrossrefs
*nocrossref_list
;
167 etree_type
*base
; /* Relocation base - or null */
170 #if defined(__STDC__) || defined(ALMOST_STDC)
171 #define cat(a,b) a##b
173 #define cat(a,b) a/**/b
176 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
178 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
180 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
182 #define SECTION_NAME_MAP_LENGTH (16)
188 return obstack_alloc (&stat_obstack
, size
);
191 /*----------------------------------------------------------------------
192 Generic traversal routines for finding matching sections.
196 walk_wild_section (ptr
, section
, file
, callback
, data
)
197 lang_wild_statement_type
*ptr
;
199 lang_input_statement_type
*file
;
203 /* Don't process sections from files which were excluded. */
204 if (ptr
->exclude_filename
!= NULL
)
208 if (wildcardp (ptr
->exclude_filename
))
209 match
= fnmatch (ptr
->exclude_filename
, file
->filename
, 0) == 0 ? true : false;
211 match
= strcmp (ptr
->exclude_filename
, file
->filename
) == 0 ? true : false;
217 if (file
->just_syms_flag
== false)
219 register asection
*s
;
225 wildcard
= wildcardp (section
);
227 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
237 name
= bfd_get_section_name (file
->the_bfd
, s
);
239 match
= fnmatch (section
, name
, 0) == 0 ? true : false;
241 match
= strcmp (section
, name
) == 0 ? true : false;
245 (*callback
) (ptr
, s
, file
, data
);
250 /* Handle a wild statement for a single file F. */
253 walk_wild_file (s
, section
, f
, callback
, data
)
254 lang_wild_statement_type
*s
;
256 lang_input_statement_type
*f
;
260 if (f
->the_bfd
== NULL
261 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
262 walk_wild_section (s
, section
, f
, callback
, data
);
267 /* This is an archive file. We must map each member of the
268 archive separately. */
269 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
270 while (member
!= NULL
)
272 /* When lookup_name is called, it will call the add_symbols
273 entry point for the archive. For each element of the
274 archive which is included, BFD will call ldlang_add_file,
275 which will set the usrdata field of the member to the
276 lang_input_statement. */
277 if (member
->usrdata
!= NULL
)
279 walk_wild_section (s
, section
,
280 (lang_input_statement_type
*) member
->usrdata
,
284 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
290 walk_wild (s
, section
, file
, callback
, data
)
291 lang_wild_statement_type
*s
;
297 lang_input_statement_type
*f
;
299 if (file
== (char *) NULL
)
301 /* Perform the iteration over all files in the list. */
302 for (f
= (lang_input_statement_type
*) file_chain
.head
;
303 f
!= (lang_input_statement_type
*) NULL
;
304 f
= (lang_input_statement_type
*) f
->next
)
306 walk_wild_file (s
, section
, f
, callback
, data
);
309 else if (wildcardp (file
))
311 for (f
= (lang_input_statement_type
*) file_chain
.head
;
312 f
!= (lang_input_statement_type
*) NULL
;
313 f
= (lang_input_statement_type
*) f
->next
)
315 if (fnmatch (file
, f
->filename
, FNM_FILE_NAME
) == 0)
316 walk_wild_file (s
, section
, f
, callback
, data
);
321 /* Perform the iteration over a single file. */
322 f
= lookup_name (file
);
323 walk_wild_file (s
, section
, f
, callback
, data
);
327 /*----------------------------------------------------------------------
328 lang_for_each_statement walks the parse tree and calls the provided
329 function for each node
333 lang_for_each_statement_worker (func
, s
)
334 void (*func
) PARAMS ((lang_statement_union_type
*));
335 lang_statement_union_type
*s
;
337 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
341 switch (s
->header
.type
)
343 case lang_constructors_statement_enum
:
344 lang_for_each_statement_worker (func
, constructor_list
.head
);
346 case lang_output_section_statement_enum
:
347 lang_for_each_statement_worker
349 s
->output_section_statement
.children
.head
);
351 case lang_wild_statement_enum
:
352 lang_for_each_statement_worker
354 s
->wild_statement
.children
.head
);
356 case lang_group_statement_enum
:
357 lang_for_each_statement_worker (func
,
358 s
->group_statement
.children
.head
);
360 case lang_data_statement_enum
:
361 case lang_reloc_statement_enum
:
362 case lang_object_symbols_statement_enum
:
363 case lang_output_statement_enum
:
364 case lang_target_statement_enum
:
365 case lang_input_section_enum
:
366 case lang_input_statement_enum
:
367 case lang_assignment_statement_enum
:
368 case lang_padding_statement_enum
:
369 case lang_address_statement_enum
:
370 case lang_fill_statement_enum
:
380 lang_for_each_statement (func
)
381 void (*func
) PARAMS ((lang_statement_union_type
*));
383 lang_for_each_statement_worker (func
,
384 statement_list
.head
);
387 /*----------------------------------------------------------------------*/
389 lang_list_init (list
)
390 lang_statement_list_type
*list
;
392 list
->head
= (lang_statement_union_type
*) NULL
;
393 list
->tail
= &list
->head
;
396 /*----------------------------------------------------------------------
398 build a new statement node for the parse tree
403 lang_statement_union_type
*
404 new_statement (type
, size
, list
)
405 enum statement_enum type
;
407 lang_statement_list_type
* list
;
409 lang_statement_union_type
*new = (lang_statement_union_type
*)
412 new->header
.type
= type
;
413 new->header
.next
= (lang_statement_union_type
*) NULL
;
414 lang_statement_append (list
, new, &new->header
.next
);
419 Build a new input file node for the language. There are several ways
420 in which we treat an input file, eg, we only look at symbols, or
421 prefix it with a -l etc.
423 We can be supplied with requests for input files more than once;
424 they may, for example be split over serveral lines like foo.o(.text)
425 foo.o(.data) etc, so when asked for a file we check that we havn't
426 got it already so we don't duplicate the bfd.
429 static lang_input_statement_type
*
430 new_afile (name
, file_type
, target
, add_to_list
)
432 lang_input_file_enum_type file_type
;
436 lang_input_statement_type
*p
;
439 p
= new_stat (lang_input_statement
, stat_ptr
);
442 p
= ((lang_input_statement_type
*)
443 stat_alloc (sizeof (lang_input_statement_type
)));
444 p
->header
.next
= NULL
;
447 lang_has_input_file
= true;
451 case lang_input_file_is_symbols_only_enum
:
453 p
->is_archive
= false;
455 p
->local_sym_name
= name
;
456 p
->just_syms_flag
= true;
457 p
->search_dirs_flag
= false;
459 case lang_input_file_is_fake_enum
:
461 p
->is_archive
= false;
463 p
->local_sym_name
= name
;
464 p
->just_syms_flag
= false;
465 p
->search_dirs_flag
= false;
467 case lang_input_file_is_l_enum
:
468 p
->is_archive
= true;
471 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
472 p
->just_syms_flag
= false;
473 p
->search_dirs_flag
= true;
475 case lang_input_file_is_marker_enum
:
477 p
->is_archive
= false;
479 p
->local_sym_name
= name
;
480 p
->just_syms_flag
= false;
481 p
->search_dirs_flag
= true;
483 case lang_input_file_is_search_file_enum
:
485 p
->is_archive
= false;
487 p
->local_sym_name
= name
;
488 p
->just_syms_flag
= false;
489 p
->search_dirs_flag
= true;
491 case lang_input_file_is_file_enum
:
493 p
->is_archive
= false;
495 p
->local_sym_name
= name
;
496 p
->just_syms_flag
= false;
497 p
->search_dirs_flag
= false;
502 p
->the_bfd
= (bfd
*) NULL
;
503 p
->asymbols
= (asymbol
**) NULL
;
504 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
505 p
->next
= (lang_statement_union_type
*) NULL
;
507 p
->dynamic
= config
.dynamic_link
;
508 p
->whole_archive
= whole_archive
;
510 lang_statement_append (&input_file_chain
,
511 (lang_statement_union_type
*) p
,
516 lang_input_statement_type
*
517 lang_add_input_file (name
, file_type
, target
)
519 lang_input_file_enum_type file_type
;
522 lang_has_input_file
= true;
523 return new_afile (name
, file_type
, target
, true);
526 /* Build enough state so that the parser can build its tree */
530 obstack_begin (&stat_obstack
, 1000);
532 stat_ptr
= &statement_list
;
534 lang_list_init (stat_ptr
);
536 lang_list_init (&input_file_chain
);
537 lang_list_init (&lang_output_section_statement
);
538 lang_list_init (&file_chain
);
539 first_file
= lang_add_input_file ((char *) NULL
,
540 lang_input_file_is_marker_enum
,
542 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
544 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
548 /*----------------------------------------------------------------------
549 A region is an area of memory declared with the
550 MEMORY { name:org=exp, len=exp ... }
553 We maintain a list of all the regions here
555 If no regions are specified in the script, then the default is used
556 which is created when looked up to be the entire data space
559 static lang_memory_region_type
*lang_memory_region_list
;
560 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
562 lang_memory_region_type
*
563 lang_memory_region_lookup (name
)
564 CONST
char *CONST name
;
566 lang_memory_region_type
*p
;
568 for (p
= lang_memory_region_list
;
569 p
!= (lang_memory_region_type
*) NULL
;
572 if (strcmp (p
->name
, name
) == 0)
579 /* This code used to always use the first region in the list as the
580 default region. I changed it to instead use a region
581 encompassing all of memory as the default region. This permits
582 NOLOAD sections to work reasonably without requiring a region.
583 People should specify what region they mean, if they really want
585 if (strcmp (name
, "*default*") == 0)
587 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
589 return lang_memory_region_list
;
595 lang_memory_region_type
*new =
596 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
598 new->name
= buystring (name
);
599 new->next
= (lang_memory_region_type
*) NULL
;
601 *lang_memory_region_list_tail
= new;
602 lang_memory_region_list_tail
= &new->next
;
606 new->length
= ~(bfd_size_type
)0;
608 new->had_full_message
= false;
615 lang_memory_region_type
*
616 lang_memory_default (section
)
619 lang_memory_region_type
*p
;
621 flagword sec_flags
= section
->flags
;
623 /* Override SEC_DATA to mean a writable section. */
624 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
625 sec_flags
|= SEC_DATA
;
627 for (p
= lang_memory_region_list
;
628 p
!= (lang_memory_region_type
*) NULL
;
631 if ((p
->flags
& sec_flags
) != 0
632 && (p
->not_flags
& sec_flags
) == 0)
637 return lang_memory_region_lookup ("*default*");
640 lang_output_section_statement_type
*
641 lang_output_section_find (name
)
642 CONST
char *CONST name
;
644 lang_statement_union_type
*u
;
645 lang_output_section_statement_type
*lookup
;
647 for (u
= lang_output_section_statement
.head
;
648 u
!= (lang_statement_union_type
*) NULL
;
651 lookup
= &u
->output_section_statement
;
652 if (strcmp (name
, lookup
->name
) == 0)
657 return (lang_output_section_statement_type
*) NULL
;
660 lang_output_section_statement_type
*
661 lang_output_section_statement_lookup (name
)
662 CONST
char *CONST name
;
664 lang_output_section_statement_type
*lookup
;
666 lookup
= lang_output_section_find (name
);
667 if (lookup
== (lang_output_section_statement_type
*) NULL
)
670 lookup
= (lang_output_section_statement_type
*)
671 new_stat (lang_output_section_statement
, stat_ptr
);
672 lookup
->region
= (lang_memory_region_type
*) NULL
;
674 lookup
->block_value
= 1;
677 lookup
->next
= (lang_statement_union_type
*) NULL
;
678 lookup
->bfd_section
= (asection
*) NULL
;
679 lookup
->processed
= false;
680 lookup
->sectype
= normal_section
;
681 lookup
->addr_tree
= (etree_type
*) NULL
;
682 lang_list_init (&lookup
->children
);
684 lookup
->memspec
= (CONST
char *) NULL
;
686 lookup
->subsection_alignment
= -1;
687 lookup
->section_alignment
= -1;
688 lookup
->load_base
= (union etree_union
*) NULL
;
689 lookup
->phdrs
= NULL
;
691 lang_statement_append (&lang_output_section_statement
,
692 (lang_statement_union_type
*) lookup
,
699 lang_map_flags (flag
)
702 if (flag
& SEC_ALLOC
)
708 if (flag
& SEC_READONLY
)
721 lang_memory_region_type
*m
;
723 minfo (_("\nMemory Configuration\n\n"));
724 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
725 _("Name"), _("Origin"), _("Length"), _("Attributes"));
727 for (m
= lang_memory_region_list
;
728 m
!= (lang_memory_region_type
*) NULL
;
734 fprintf (config
.map_file
, "%-16s ", m
->name
);
736 sprintf_vma (buf
, m
->origin
);
737 minfo ("0x%s ", buf
);
745 minfo ("0x%V", m
->length
);
746 if (m
->flags
|| m
->not_flags
)
754 lang_map_flags (m
->flags
);
760 lang_map_flags (m
->not_flags
);
767 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
772 /* Initialize an output section. */
776 lang_output_section_statement_type
*s
;
778 section_userdata_type
*new;
780 if (s
->bfd_section
!= NULL
)
783 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
784 einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME
);
786 new = ((section_userdata_type
*)
787 stat_alloc (sizeof (section_userdata_type
)));
789 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
790 if (s
->bfd_section
== (asection
*) NULL
)
791 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
792 if (s
->bfd_section
== (asection
*) NULL
)
794 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
795 output_bfd
->xvec
->name
, s
->name
);
797 s
->bfd_section
->output_section
= s
->bfd_section
;
799 /* We initialize an output sections output offset to minus its own */
800 /* vma to allow us to output a section through itself */
801 s
->bfd_section
->output_offset
= 0;
802 get_userdata (s
->bfd_section
) = (PTR
) new;
804 /* If there is a base address, make sure that any sections it might
805 mention are initialized. */
806 if (s
->addr_tree
!= NULL
)
807 exp_init_os (s
->addr_tree
);
810 /* Make sure that all output sections mentioned in an expression are
817 switch (exp
->type
.node_class
)
820 exp_init_os (exp
->assign
.src
);
824 exp_init_os (exp
->binary
.lhs
);
825 exp_init_os (exp
->binary
.rhs
);
829 exp_init_os (exp
->trinary
.cond
);
830 exp_init_os (exp
->trinary
.lhs
);
831 exp_init_os (exp
->trinary
.rhs
);
835 exp_init_os (exp
->unary
.child
);
839 switch (exp
->type
.node_code
)
845 lang_output_section_statement_type
*os
;
847 os
= lang_output_section_find (exp
->name
.name
);
848 if (os
!= NULL
&& os
->bfd_section
== NULL
)
859 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
860 once into the output. This routine checks each sections, and
861 arranges to discard it if a section of the same name has already
862 been linked. This code assumes that all relevant sections have the
863 SEC_LINK_ONCE flag set; that is, it does not depend solely upon the
864 section name. This is called via bfd_map_over_sections. */
868 section_already_linked (abfd
, sec
, data
)
873 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
876 struct sec_link_once
*next
;
879 static struct sec_link_once
*sec_link_once_list
;
882 struct sec_link_once
*l
;
884 /* If we are only reading symbols from this object, then we want to
885 discard all sections. */
886 if (entry
->just_syms_flag
)
888 sec
->output_section
= bfd_abs_section_ptr
;
889 sec
->output_offset
= sec
->vma
;
893 flags
= bfd_get_section_flags (abfd
, sec
);
895 if ((flags
& SEC_LINK_ONCE
) == 0)
898 name
= bfd_get_section_name (abfd
, sec
);
900 for (l
= sec_link_once_list
; l
!= NULL
; l
= l
->next
)
902 if (strcmp (name
, bfd_get_section_name (l
->sec
->owner
, l
->sec
)) == 0)
904 /* The section has already been linked. See if we should
906 switch (flags
& SEC_LINK_DUPLICATES
)
911 case SEC_LINK_DUPLICATES_DISCARD
:
914 case SEC_LINK_DUPLICATES_ONE_ONLY
:
915 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
919 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
920 /* FIXME: We should really dig out the contents of both
921 sections and memcmp them. The COFF/PE spec says that
922 the Microsoft linker does not implement this
923 correctly, so I'm not going to bother doing it
926 case SEC_LINK_DUPLICATES_SAME_SIZE
:
927 if (bfd_section_size (abfd
, sec
)
928 != bfd_section_size (l
->sec
->owner
, l
->sec
))
929 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
934 /* Set the output_section field so that wild_doit does not
935 create a lang_input_section structure for this section. */
936 sec
->output_section
= bfd_abs_section_ptr
;
942 /* This is the first section with this name. Record it. */
944 l
= (struct sec_link_once
*) xmalloc (sizeof *l
);
946 l
->next
= sec_link_once_list
;
947 sec_link_once_list
= l
;
950 /* The wild routines.
952 These expand statements like *(.text) and foo.o to a list of
953 explicit actions, like foo.o(.text), bar.o(.text) and
954 foo.o(.text, .data). */
956 /* Return true if the PATTERN argument is a wildcard pattern.
957 Although backslashes are treated specially if a pattern contains
958 wildcards, we do not consider the mere presence of a backslash to
959 be enough to cause the the pattern to be treated as a wildcard.
960 That lets us handle DOS filenames more naturally. */
968 for (s
= pattern
; *s
!= '\0'; ++s
)
976 /* Add SECTION to the output section OUTPUT. Do this by creating a
977 lang_input_section statement which is placed at PTR. FILE is the
978 input file which holds SECTION. */
981 wild_doit (ptr
, section
, output
, file
)
982 lang_statement_list_type
*ptr
;
984 lang_output_section_statement_type
*output
;
985 lang_input_statement_type
*file
;
990 flags
= bfd_get_section_flags (section
->owner
, section
);
994 /* If we are doing a final link, discard sections marked with
996 if (! link_info
.relocateable
997 && (flags
& SEC_EXCLUDE
) != 0)
1000 /* Discard input sections which are assigned to a section named
1001 DISCARD_SECTION_NAME. */
1002 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1005 /* Discard debugging sections if we are stripping debugging
1007 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1008 && (flags
& SEC_DEBUGGING
) != 0)
1013 if (section
->output_section
== NULL
)
1015 /* This prevents future calls from assigning this section. */
1016 section
->output_section
= bfd_abs_section_ptr
;
1021 if (section
->output_section
== NULL
)
1024 lang_input_section_type
*new;
1027 if (output
->bfd_section
== NULL
)
1035 /* Add a section reference to the list */
1036 new = new_stat (lang_input_section
, ptr
);
1038 new->section
= section
;
1040 section
->output_section
= output
->bfd_section
;
1042 flags
= section
->flags
;
1044 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1045 to an output section, because we want to be able to include a
1046 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1047 section (I don't know why we want to do this, but we do).
1048 build_link_order in ldwrite.c handles this case by turning
1049 the embedded SEC_NEVER_LOAD section into a fill. */
1051 flags
&= ~ SEC_NEVER_LOAD
;
1053 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1054 already been processed. One reason to do this is that on pe
1055 format targets, .text$foo sections go into .text and it's odd
1056 to see .text with SEC_LINK_ONCE set. */
1058 if (! link_info
.relocateable
)
1059 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1061 /* If this is not the first input section, and the SEC_READONLY
1062 flag is not currently set, then don't set it just because the
1063 input section has it set. */
1065 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1066 flags
&= ~ SEC_READONLY
;
1068 section
->output_section
->flags
|= flags
;
1070 /* If SEC_READONLY is not set in the input section, then clear
1071 it from the output section. */
1072 if ((section
->flags
& SEC_READONLY
) == 0)
1073 section
->output_section
->flags
&= ~SEC_READONLY
;
1075 switch (output
->sectype
)
1077 case normal_section
:
1082 case overlay_section
:
1083 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1085 case noload_section
:
1086 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1087 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1091 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1092 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1094 /* If supplied an aligment, then force it. */
1095 if (output
->section_alignment
!= -1)
1096 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1100 /* Handle wildcard sorting. This returns the lang_input_section which
1101 should follow the one we are going to create for SECTION and FILE,
1102 based on the sorting requirements of WILD. It returns NULL if the
1103 new section should just go at the end of the current list. */
1105 static lang_statement_union_type
*
1106 wild_sort (wild
, file
, section
)
1107 lang_wild_statement_type
*wild
;
1108 lang_input_statement_type
*file
;
1111 const char *section_name
;
1112 lang_statement_union_type
*l
;
1114 if (! wild
->filenames_sorted
&& ! wild
->sections_sorted
)
1117 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1118 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->next
)
1120 lang_input_section_type
*ls
;
1122 if (l
->header
.type
!= lang_input_section_enum
)
1124 ls
= &l
->input_section
;
1126 /* Sorting by filename takes precedence over sorting by section
1129 if (wild
->filenames_sorted
)
1131 const char *fn
, *ln
;
1135 /* The PE support for the .idata section as generated by
1136 dlltool assumes that files will be sorted by the name of
1137 the archive and then the name of the file within the
1140 if (file
->the_bfd
!= NULL
1141 && bfd_my_archive (file
->the_bfd
) != NULL
)
1143 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1148 fn
= file
->filename
;
1152 if (ls
->ifile
->the_bfd
!= NULL
1153 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1155 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1160 ln
= ls
->ifile
->filename
;
1164 i
= strcmp (fn
, ln
);
1173 fn
= file
->filename
;
1175 ln
= ls
->ifile
->filename
;
1177 i
= strcmp (fn
, ln
);
1185 /* Here either the files are not sorted by name, or we are
1186 looking at the sections for this file. */
1188 if (wild
->sections_sorted
)
1190 if (strcmp (section_name
,
1191 bfd_get_section_name (ls
->ifile
->the_bfd
,
1201 /* Expand a wild statement for a particular FILE. SECTION may be
1202 NULL, in which case it is a wild card. */
1205 output_section_callback (ptr
, section
, file
, output
)
1206 lang_wild_statement_type
*ptr
;
1208 lang_input_statement_type
*file
;
1211 lang_statement_union_type
*before
;
1213 /* If the wild pattern was marked KEEP, the member sections
1214 should be as well. */
1215 if (ptr
->keep_sections
)
1216 section
->flags
|= SEC_KEEP
;
1218 before
= wild_sort (ptr
, file
, section
);
1220 /* Here BEFORE points to the lang_input_section which
1221 should follow the one we are about to add. If BEFORE
1222 is NULL, then the section should just go at the end
1223 of the current list. */
1226 wild_doit (&ptr
->children
, section
,
1227 (lang_output_section_statement_type
*) output
,
1231 lang_statement_list_type list
;
1232 lang_statement_union_type
**pp
;
1234 lang_list_init (&list
);
1235 wild_doit (&list
, section
,
1236 (lang_output_section_statement_type
*) output
,
1239 /* If we are discarding the section, LIST.HEAD will
1241 if (list
.head
!= NULL
)
1243 ASSERT (list
.head
->next
== NULL
);
1245 for (pp
= &ptr
->children
.head
;
1248 ASSERT (*pp
!= NULL
);
1250 list
.head
->next
= *pp
;
1256 /* This is passed a file name which must have been seen already and
1257 added to the statement tree. We will see if it has been opened
1258 already and had its symbols read. If not then we'll read it. */
1260 static lang_input_statement_type
*
1264 lang_input_statement_type
*search
;
1266 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1267 search
!= (lang_input_statement_type
*) NULL
;
1268 search
= (lang_input_statement_type
*) search
->next_real_file
)
1270 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1272 if (search
->filename
!= (char *) NULL
1273 && name
!= (char *) NULL
1274 && strcmp (search
->filename
, name
) == 0)
1278 if (search
== (lang_input_statement_type
*) NULL
)
1279 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1282 /* If we have already added this file, or this file is not real
1283 (FIXME: can that ever actually happen?) or the name is NULL
1284 (FIXME: can that ever actually happen?) don't add this file. */
1287 || search
->filename
== (const char *) NULL
)
1290 load_symbols (search
, (lang_statement_list_type
*) NULL
);
1295 /* Get the symbols for an input file. */
1298 load_symbols (entry
, place
)
1299 lang_input_statement_type
*entry
;
1300 lang_statement_list_type
*place
;
1307 ldfile_open_file (entry
);
1309 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1310 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1313 lang_statement_list_type
*hold
;
1315 err
= bfd_get_error ();
1316 if (err
== bfd_error_file_ambiguously_recognized
)
1320 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1321 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1322 for (p
= matching
; *p
!= NULL
; p
++)
1326 else if (err
!= bfd_error_file_not_recognized
1328 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1330 bfd_close (entry
->the_bfd
);
1331 entry
->the_bfd
= NULL
;
1333 /* See if the emulation has some special knowledge. */
1335 if (ldemul_unrecognized_file (entry
))
1338 /* Try to interpret the file as a linker script. */
1340 ldfile_open_command_file (entry
->filename
);
1345 ldfile_assumed_script
= true;
1346 parser_input
= input_script
;
1348 ldfile_assumed_script
= false;
1355 if (ldemul_recognized_file (entry
))
1358 /* We don't call ldlang_add_file for an archive. Instead, the
1359 add_symbols entry point will call ldlang_add_file, via the
1360 add_archive_element callback, for each element of the archive
1362 switch (bfd_get_format (entry
->the_bfd
))
1368 ldlang_add_file (entry
);
1369 if (trace_files
|| trace_file_tries
)
1370 info_msg ("%I\n", entry
);
1374 if (entry
->whole_archive
)
1376 bfd
*member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1378 while (member
!= NULL
)
1380 if (! bfd_check_format (member
, bfd_object
))
1381 einfo (_("%F%B: object %B in archive is not object\n"),
1382 entry
->the_bfd
, member
);
1383 if (! ((*link_info
.callbacks
->add_archive_element
)
1384 (&link_info
, member
, "--whole-archive")))
1386 if (! bfd_link_add_symbols (member
, &link_info
))
1387 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1388 member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1392 entry
->loaded
= true;
1398 if (! bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1399 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1401 entry
->loaded
= true;
1406 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1407 indicating that it is a wildcard. Separate lang_input_section
1408 statements are created for each part of the expansion; they are
1409 added after the wild statement S. OUTPUT is the output section. */
1412 wild (s
, section
, file
, target
, output
)
1413 lang_wild_statement_type
*s
;
1414 const char *section
;
1417 lang_output_section_statement_type
*output
;
1419 walk_wild (s
, section
, file
, output_section_callback
, (void *) output
);
1421 if (section
!= (char *) NULL
1422 && strcmp (section
, "COMMON") == 0
1423 && default_common_section
== NULL
)
1425 /* Remember the section that common is going to in case we later
1426 get something which doesn't know where to put it. */
1427 default_common_section
= output
;
1431 /* Open the output file. */
1439 if (output_target
== (char *) NULL
)
1441 if (current_target
!= (char *) NULL
)
1442 output_target
= current_target
;
1444 output_target
= default_target
;
1446 output
= bfd_openw (name
, output_target
);
1448 if (output
== (bfd
*) NULL
)
1450 if (bfd_get_error () == bfd_error_invalid_target
)
1452 einfo (_("%P%F: target %s not found\n"), output_target
);
1454 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1457 delete_output_file_on_failure
= true;
1459 /* output->flags |= D_PAGED;*/
1461 if (! bfd_set_format (output
, bfd_object
))
1462 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1463 if (! bfd_set_arch_mach (output
,
1464 ldfile_output_architecture
,
1465 ldfile_output_machine
))
1466 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1468 link_info
.hash
= bfd_link_hash_table_create (output
);
1469 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1470 einfo (_("%P%F: can not create link hash table: %E\n"));
1472 bfd_set_gp_size (output
, g_switch_value
);
1480 ldlang_open_output (statement
)
1481 lang_statement_union_type
* statement
;
1483 switch (statement
->header
.type
)
1485 case lang_output_statement_enum
:
1486 ASSERT (output_bfd
== (bfd
*) NULL
);
1487 output_bfd
= open_output (statement
->output_statement
.name
);
1488 ldemul_set_output_arch ();
1489 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1490 output_bfd
->flags
|= D_PAGED
;
1492 output_bfd
->flags
&= ~D_PAGED
;
1493 if (config
.text_read_only
)
1494 output_bfd
->flags
|= WP_TEXT
;
1496 output_bfd
->flags
&= ~WP_TEXT
;
1497 if (link_info
.traditional_format
)
1498 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1500 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1503 case lang_target_statement_enum
:
1504 current_target
= statement
->target_statement
.target
;
1511 /* Open all the input files. */
1514 open_input_bfds (s
, force
)
1515 lang_statement_union_type
*s
;
1518 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1520 switch (s
->header
.type
)
1522 case lang_constructors_statement_enum
:
1523 open_input_bfds (constructor_list
.head
, force
);
1525 case lang_output_section_statement_enum
:
1526 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1528 case lang_wild_statement_enum
:
1529 /* Maybe we should load the file's symbols */
1530 if (s
->wild_statement
.filename
1531 && ! wildcardp (s
->wild_statement
.filename
))
1532 (void) lookup_name (s
->wild_statement
.filename
);
1533 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1535 case lang_group_statement_enum
:
1537 struct bfd_link_hash_entry
*undefs
;
1539 /* We must continually search the entries in the group
1540 until no new symbols are added to the list of undefined
1545 undefs
= link_info
.hash
->undefs_tail
;
1546 open_input_bfds (s
->group_statement
.children
.head
, true);
1548 while (undefs
!= link_info
.hash
->undefs_tail
);
1551 case lang_target_statement_enum
:
1552 current_target
= s
->target_statement
.target
;
1554 case lang_input_statement_enum
:
1555 if (s
->input_statement
.real
== true)
1557 lang_statement_list_type add
;
1559 s
->input_statement
.target
= current_target
;
1561 /* If we are being called from within a group, and this
1562 is an archive which has already been searched, then
1563 force it to be researched. */
1565 && s
->input_statement
.loaded
1566 && bfd_check_format (s
->input_statement
.the_bfd
,
1568 s
->input_statement
.loaded
= false;
1570 lang_list_init (&add
);
1572 load_symbols (&s
->input_statement
, &add
);
1574 if (add
.head
!= NULL
)
1576 *add
.tail
= s
->next
;
1587 /* If there are [COMMONS] statements, put a wild one into the bss section */
1590 lang_reasonable_defaults ()
1593 lang_output_section_statement_lookup (".text");
1594 lang_output_section_statement_lookup (".data");
1596 default_common_section
=
1597 lang_output_section_statement_lookup (".bss");
1600 if (placed_commons
== false)
1602 lang_wild_statement_type
*new =
1603 new_stat (lang_wild_statement
,
1604 &default_common_section
->children
);
1606 new->section_name
= "COMMON";
1607 new->filename
= (char *) NULL
;
1608 lang_list_init (&new->children
);
1615 Add the supplied name to the symbol table as an undefined reference.
1616 Remove items from the chain as we open input bfds
1618 typedef struct ldlang_undef_chain_list
1620 struct ldlang_undef_chain_list
*next
;
1622 } ldlang_undef_chain_list_type
;
1624 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
1627 ldlang_add_undef (name
)
1628 CONST
char *CONST name
;
1630 ldlang_undef_chain_list_type
*new =
1631 ((ldlang_undef_chain_list_type
*)
1632 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
1634 new->next
= ldlang_undef_chain_list_head
;
1635 ldlang_undef_chain_list_head
= new;
1637 new->name
= buystring (name
);
1640 /* Run through the list of undefineds created above and place them
1641 into the linker hash table as undefined symbols belonging to the
1645 lang_place_undefineds ()
1647 ldlang_undef_chain_list_type
*ptr
;
1649 for (ptr
= ldlang_undef_chain_list_head
;
1650 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
1653 struct bfd_link_hash_entry
*h
;
1655 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
1656 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1657 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1658 if (h
->type
== bfd_link_hash_new
)
1660 h
->type
= bfd_link_hash_undefined
;
1661 h
->u
.undef
.abfd
= NULL
;
1662 bfd_link_add_undef (link_info
.hash
, h
);
1667 /* Open input files and attatch to output sections */
1669 map_input_to_output_sections (s
, target
, output_section_statement
)
1670 lang_statement_union_type
* s
;
1672 lang_output_section_statement_type
* output_section_statement
;
1674 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1676 switch (s
->header
.type
)
1680 case lang_wild_statement_enum
:
1681 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1682 s
->wild_statement
.filename
, target
,
1683 output_section_statement
);
1686 case lang_constructors_statement_enum
:
1687 map_input_to_output_sections (constructor_list
.head
,
1689 output_section_statement
);
1691 case lang_output_section_statement_enum
:
1692 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1694 &s
->output_section_statement
);
1696 case lang_output_statement_enum
:
1698 case lang_target_statement_enum
:
1699 target
= s
->target_statement
.target
;
1701 case lang_group_statement_enum
:
1702 map_input_to_output_sections (s
->group_statement
.children
.head
,
1704 output_section_statement
);
1706 case lang_fill_statement_enum
:
1707 case lang_input_section_enum
:
1708 case lang_object_symbols_statement_enum
:
1709 case lang_data_statement_enum
:
1710 case lang_reloc_statement_enum
:
1711 case lang_padding_statement_enum
:
1712 case lang_input_statement_enum
:
1713 if (output_section_statement
!= NULL
1714 && output_section_statement
->bfd_section
== NULL
)
1715 init_os (output_section_statement
);
1717 case lang_assignment_statement_enum
:
1718 if (output_section_statement
!= NULL
1719 && output_section_statement
->bfd_section
== NULL
)
1720 init_os (output_section_statement
);
1722 /* Make sure that any sections mentioned in the assignment
1724 exp_init_os (s
->assignment_statement
.exp
);
1726 case lang_afile_asection_pair_statement_enum
:
1729 case lang_address_statement_enum
:
1730 /* Mark the specified section with the supplied address */
1732 lang_output_section_statement_type
*os
=
1733 lang_output_section_statement_lookup
1734 (s
->address_statement
.section_name
);
1736 if (os
->bfd_section
== NULL
)
1738 os
->addr_tree
= s
->address_statement
.address
;
1746 print_output_section_statement (output_section_statement
)
1747 lang_output_section_statement_type
* output_section_statement
;
1749 asection
*section
= output_section_statement
->bfd_section
;
1752 if (output_section_statement
!= abs_output_section
)
1754 minfo ("\n%s", output_section_statement
->name
);
1756 if (section
!= NULL
)
1758 print_dot
= section
->vma
;
1760 len
= strlen (output_section_statement
->name
);
1761 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
1766 while (len
< SECTION_NAME_MAP_LENGTH
)
1772 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
1774 if (output_section_statement
->load_base
!= NULL
)
1778 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
1779 "load base", lang_final_phase_enum
);
1780 minfo (_(" load address 0x%V"), addr
);
1787 print_statement_list (output_section_statement
->children
.head
,
1788 output_section_statement
);
1792 print_assignment (assignment
, output_section
)
1793 lang_assignment_statement_type
* assignment
;
1794 lang_output_section_statement_type
* output_section
;
1797 etree_value_type result
;
1799 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1802 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
1803 lang_final_phase_enum
, print_dot
, &print_dot
);
1805 minfo ("0x%V", result
.value
+ result
.section
->bfd_section
->vma
);
1816 exp_print_tree (assignment
->exp
);
1822 print_input_statement (statm
)
1823 lang_input_statement_type
* statm
;
1825 if (statm
->filename
!= (char *) NULL
)
1827 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1831 /* Print all symbols defined in a particular section. This is called
1832 via bfd_link_hash_traverse. */
1835 print_one_symbol (hash_entry
, ptr
)
1836 struct bfd_link_hash_entry
*hash_entry
;
1839 asection
*sec
= (asection
*) ptr
;
1841 if ((hash_entry
->type
== bfd_link_hash_defined
1842 || hash_entry
->type
== bfd_link_hash_defweak
)
1843 && sec
== hash_entry
->u
.def
.section
)
1847 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1850 (hash_entry
->u
.def
.value
1851 + hash_entry
->u
.def
.section
->output_offset
1852 + hash_entry
->u
.def
.section
->output_section
->vma
));
1854 minfo (" %T\n", hash_entry
->root
.string
);
1860 /* Print information about an input section to the map file. */
1863 print_input_section (in
)
1864 lang_input_section_type
* in
;
1866 asection
*i
= in
->section
;
1867 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
1873 minfo ("%s", i
->name
);
1875 if (i
->output_section
!= NULL
)
1879 len
= 1 + strlen (i
->name
);
1880 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
1885 while (len
< SECTION_NAME_MAP_LENGTH
)
1891 minfo ("0x%V %W %B\n",
1892 i
->output_section
->vma
+ i
->output_offset
, size
,
1895 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
1897 len
= SECTION_NAME_MAP_LENGTH
+ 3;
1909 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
1912 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
1914 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
;
1920 print_fill_statement (fill
)
1921 lang_fill_statement_type
* fill
;
1923 fprintf (config
.map_file
, " FILL mask 0x%x\n", fill
->fill
);
1927 print_data_statement (data
)
1928 lang_data_statement_type
* data
;
1935 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1938 addr
= data
->output_vma
;
1939 if (data
->output_section
!= NULL
)
1940 addr
+= data
->output_section
->vma
;
1968 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
1970 if (data
->exp
->type
.node_class
!= etree_value
)
1973 exp_print_tree (data
->exp
);
1978 print_dot
= addr
+ size
;
1981 /* Print an address statement. These are generated by options like
1985 print_address_statement (address
)
1986 lang_address_statement_type
*address
;
1988 minfo (_("Address of section %s set to "), address
->section_name
);
1989 exp_print_tree (address
->address
);
1993 /* Print a reloc statement. */
1996 print_reloc_statement (reloc
)
1997 lang_reloc_statement_type
*reloc
;
2003 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2006 addr
= reloc
->output_vma
;
2007 if (reloc
->output_section
!= NULL
)
2008 addr
+= reloc
->output_section
->vma
;
2010 size
= bfd_get_reloc_size (reloc
->howto
);
2012 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2014 if (reloc
->name
!= NULL
)
2015 minfo ("%s+", reloc
->name
);
2017 minfo ("%s+", reloc
->section
->name
);
2019 exp_print_tree (reloc
->addend_exp
);
2023 print_dot
= addr
+ size
;
2027 print_padding_statement (s
)
2028 lang_padding_statement_type
*s
;
2035 len
= sizeof " *fill*" - 1;
2036 while (len
< SECTION_NAME_MAP_LENGTH
)
2042 addr
= s
->output_offset
;
2043 if (s
->output_section
!= NULL
)
2044 addr
+= s
->output_section
->vma
;
2045 minfo ("0x%V %W", addr
, s
->size
);
2048 minfo (" %u", s
->fill
);
2052 print_dot
= addr
+ s
->size
;
2056 print_wild_statement (w
, os
)
2057 lang_wild_statement_type
* w
;
2058 lang_output_section_statement_type
* os
;
2062 if (w
->filenames_sorted
)
2064 if (w
->exclude_filename
!= NULL
)
2065 minfo ("EXCLUDE_FILE ( %s )", w
->exclude_filename
);
2066 if (w
->filename
!= NULL
)
2067 minfo ("%s", w
->filename
);
2070 if (w
->filenames_sorted
)
2074 if (w
->sections_sorted
)
2076 if (w
->section_name
!= NULL
)
2077 minfo ("%s", w
->section_name
);
2080 if (w
->sections_sorted
)
2086 print_statement_list (w
->children
.head
, os
);
2089 /* Print a group statement. */
2093 lang_group_statement_type
*s
;
2094 lang_output_section_statement_type
*os
;
2096 fprintf (config
.map_file
, "START GROUP\n");
2097 print_statement_list (s
->children
.head
, os
);
2098 fprintf (config
.map_file
, "END GROUP\n");
2101 /* Print the list of statements in S.
2102 This can be called for any statement type. */
2105 print_statement_list (s
, os
)
2106 lang_statement_union_type
*s
;
2107 lang_output_section_statement_type
*os
;
2111 print_statement (s
, os
);
2116 /* Print the first statement in statement list S.
2117 This can be called for any statement type. */
2120 print_statement (s
, os
)
2121 lang_statement_union_type
*s
;
2122 lang_output_section_statement_type
*os
;
2124 switch (s
->header
.type
)
2127 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2130 case lang_constructors_statement_enum
:
2131 if (constructor_list
.head
!= NULL
)
2133 if (constructors_sorted
)
2134 minfo (" SORT (CONSTRUCTORS)\n");
2136 minfo (" CONSTRUCTORS\n");
2137 print_statement_list (constructor_list
.head
, os
);
2140 case lang_wild_statement_enum
:
2141 print_wild_statement (&s
->wild_statement
, os
);
2143 case lang_address_statement_enum
:
2144 print_address_statement (&s
->address_statement
);
2146 case lang_object_symbols_statement_enum
:
2147 minfo (" CREATE_OBJECT_SYMBOLS\n");
2149 case lang_fill_statement_enum
:
2150 print_fill_statement (&s
->fill_statement
);
2152 case lang_data_statement_enum
:
2153 print_data_statement (&s
->data_statement
);
2155 case lang_reloc_statement_enum
:
2156 print_reloc_statement (&s
->reloc_statement
);
2158 case lang_input_section_enum
:
2159 print_input_section (&s
->input_section
);
2161 case lang_padding_statement_enum
:
2162 print_padding_statement (&s
->padding_statement
);
2164 case lang_output_section_statement_enum
:
2165 print_output_section_statement (&s
->output_section_statement
);
2167 case lang_assignment_statement_enum
:
2168 print_assignment (&s
->assignment_statement
, os
);
2170 case lang_target_statement_enum
:
2171 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2173 case lang_output_statement_enum
:
2174 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2175 if (output_target
!= NULL
)
2176 minfo (" %s", output_target
);
2179 case lang_input_statement_enum
:
2180 print_input_statement (&s
->input_statement
);
2182 case lang_group_statement_enum
:
2183 print_group (&s
->group_statement
, os
);
2185 case lang_afile_asection_pair_statement_enum
:
2194 print_statement_list (statement_list
.head
, abs_output_section
);
2197 /* Print the first N statements in statement list S to STDERR.
2198 If N == 0, nothing is printed.
2199 If N < 0, the entire list is printed.
2200 Intended to be called from GDB. */
2203 dprint_statement (s
, n
)
2204 lang_statement_union_type
* s
;
2207 FILE *map_save
= config
.map_file
;
2209 config
.map_file
= stderr
;
2212 print_statement_list (s
, abs_output_section
);
2215 while (s
&& --n
>= 0)
2217 print_statement (s
, abs_output_section
);
2222 config
.map_file
= map_save
;
2226 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
2227 lang_statement_union_type
** this_ptr
;
2230 asection
* output_section_statement
;
2233 /* Align this section first to the
2234 input sections requirement, then
2235 to the output section's requirement.
2236 If this alignment is > than any seen before,
2237 then record it too. Perform the alignment by
2238 inserting a magic 'padding' statement.
2241 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
2243 if (alignment_needed
!= 0)
2245 lang_statement_union_type
*new =
2246 ((lang_statement_union_type
*)
2247 stat_alloc (sizeof (lang_padding_statement_type
)));
2249 /* Link into existing chain */
2250 new->header
.next
= *this_ptr
;
2252 new->header
.type
= lang_padding_statement_enum
;
2253 new->padding_statement
.output_section
= output_section_statement
;
2254 new->padding_statement
.output_offset
=
2255 dot
- output_section_statement
->vma
;
2256 new->padding_statement
.fill
= fill
;
2257 new->padding_statement
.size
= alignment_needed
;
2261 /* Remember the most restrictive alignment */
2262 if (power
> output_section_statement
->alignment_power
)
2264 output_section_statement
->alignment_power
= power
;
2266 output_section_statement
->_raw_size
+= alignment_needed
;
2267 return alignment_needed
+ dot
;
2271 /* Work out how much this section will move the dot point */
2273 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
2274 lang_statement_union_type
** this_ptr
;
2275 lang_output_section_statement_type
* output_section_statement
;
2280 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2281 asection
*i
= is
->section
;
2283 if (is
->ifile
->just_syms_flag
== false)
2285 if (output_section_statement
->subsection_alignment
!= -1)
2286 i
->alignment_power
=
2287 output_section_statement
->subsection_alignment
;
2289 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
2290 output_section_statement
->bfd_section
, dot
);
2292 /* Remember where in the output section this input section goes */
2294 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
2296 /* Mark how big the output section must be to contain this now
2298 if (i
->_cooked_size
!= 0)
2299 dot
+= i
->_cooked_size
;
2301 dot
+= i
->_raw_size
;
2302 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
2306 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2312 /* Check to see if any allocated sections overlap with other allocated
2313 sections. This can happen when the linker script specifically specifies
2314 the output section addresses of the two sections. */
2316 lang_check_section_addresses ()
2320 /* Scan all sections in the output list. */
2321 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2322 /* Ignore sections which are not loaded or which have no contents. */
2323 if ((bfd_get_section_flags (output_bfd
, s
) & (SEC_ALLOC
| SEC_LOAD
))
2324 && bfd_section_size (output_bfd
, s
) != 0)
2328 /* Once we reach section 's' stop our seach. This prevents two
2329 warning messages from being produced, one for 'section A overlaps
2330 section B' and one for 'section B overlaps section A'. */
2331 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2338 /* Only consider loadable sections with real contents. */
2339 if (((bfd_get_section_flags (output_bfd
, os
)
2340 & (SEC_ALLOC
| SEC_LOAD
)) == 0)
2341 || bfd_section_size (output_bfd
, os
) == 0)
2344 /* We must check the sections' LMA addresses not their
2345 VMA addresses because overlay sections can have
2346 overlapping VMAs but they must have distinct LMAs. */
2347 s_start
= bfd_section_lma (output_bfd
, s
);
2348 os_start
= bfd_section_lma (output_bfd
, os
);
2349 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) - 1;
2350 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) - 1;
2352 /* Look for an overlap. */
2353 if ((s_end
< os_start
) || (s_start
> os_end
))
2357 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2358 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2360 /* Once we have found one overlap for this section,
2361 stop looking for others. */
2367 /* This variable indicates whether bfd_relax_section should be called
2370 static boolean relax_again
;
2372 /* Set the sizes for all the output sections. */
2375 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2376 lang_statement_union_type
* s
;
2377 lang_output_section_statement_type
* output_section_statement
;
2378 lang_statement_union_type
** prev
;
2383 /* Size up the sections from their constituent parts. */
2384 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2386 switch (s
->header
.type
)
2388 case lang_output_section_statement_enum
:
2391 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
2393 if (os
->bfd_section
== NULL
)
2394 /* This section was never actually created. */
2397 /* If this is a COFF shared library section, use the size and
2398 address from the input section. FIXME: This is COFF
2399 specific; it would be cleaner if there were some other way
2400 to do this, but nothing simple comes to mind. */
2401 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2405 if (os
->children
.head
== NULL
2406 || os
->children
.head
->next
!= NULL
2407 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2408 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2411 input
= os
->children
.head
->input_section
.section
;
2412 bfd_set_section_vma (os
->bfd_section
->owner
,
2414 bfd_section_vma (input
->owner
, input
));
2415 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2419 if (bfd_is_abs_section (os
->bfd_section
))
2421 /* No matter what happens, an abs section starts at zero. */
2422 ASSERT (os
->bfd_section
->vma
== 0);
2426 if (os
->addr_tree
== (etree_type
*) NULL
)
2428 /* No address specified for this section, get one
2429 from the region specification. */
2430 if (os
->region
== (lang_memory_region_type
*) NULL
2431 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2432 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2433 && os
->region
->name
[0] == '*'
2434 && strcmp (os
->region
->name
, "*default*") == 0))
2436 os
->region
= lang_memory_default (os
->bfd_section
);
2439 /* If a loadable section is using the default memory
2440 region, and some non default memory regions were
2441 defined, issue a warning. */
2442 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2443 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2444 && ! link_info
.relocateable
2445 && strcmp (os
->region
->name
, "*default*") == 0
2446 && lang_memory_region_list
!= NULL
2447 && (strcmp (lang_memory_region_list
->name
, "*default*") != 0
2448 || lang_memory_region_list
->next
!= NULL
))
2449 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2450 bfd_get_section_name (output_bfd
, os
->bfd_section
));
2452 dot
= os
->region
->current
;
2454 if (os
->section_alignment
== -1)
2459 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
2461 if (dot
!= olddot
&& config
.warn_section_align
)
2462 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2463 os
->name
, (unsigned int) (dot
- olddot
));
2470 r
= exp_fold_tree (os
->addr_tree
,
2472 lang_allocating_phase_enum
,
2474 if (r
.valid_p
== false)
2476 einfo (_("%F%S: non constant address expression for section %s\n"),
2479 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2482 /* The section starts here.
2483 First, align to what the section needs. */
2485 if (os
->section_alignment
!= -1)
2486 dot
= align_power (dot
, os
->section_alignment
);
2488 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2490 os
->bfd_section
->output_offset
= 0;
2493 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
2494 os
->fill
, dot
, relax
);
2496 /* Ignore the size of the input sections, use the vma and size to
2499 after
= ALIGN_N (os
->bfd_section
->vma
+
2500 os
->bfd_section
->_raw_size
,
2501 /* The coercion here is important, see ld.h. */
2502 (bfd_vma
) os
->block_value
);
2504 if (bfd_is_abs_section (os
->bfd_section
))
2505 ASSERT (after
== os
->bfd_section
->vma
);
2507 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
2508 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
2509 os
->processed
= true;
2511 /* Update dot in the region ?
2512 We only do this if the section is going to be allocated,
2513 since unallocated sections do not contribute to the region's
2514 overall size in memory. */
2515 if (os
->region
!= (lang_memory_region_type
*) NULL
2516 && (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2517 & (SEC_ALLOC
| SEC_LOAD
)))
2519 os
->region
->current
= dot
;
2521 /* Make sure this isn't silly. */
2522 if (os
->region
->current
< os
->region
->origin
2523 || (os
->region
->current
- os
->region
->origin
2524 > os
->region
->length
))
2526 if (os
->addr_tree
!= (etree_type
*) NULL
)
2528 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2529 os
->region
->current
,
2530 os
->bfd_section
->owner
,
2531 os
->bfd_section
->name
,
2536 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2538 os
->bfd_section
->owner
,
2539 os
->bfd_section
->name
);
2541 /* Reset the region pointer. */
2542 os
->region
->current
= os
->region
->origin
;
2548 case lang_constructors_statement_enum
:
2549 dot
= lang_size_sections (constructor_list
.head
,
2550 output_section_statement
,
2551 &s
->wild_statement
.children
.head
,
2556 case lang_data_statement_enum
:
2558 unsigned int size
= 0;
2560 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
2561 s
->data_statement
.output_section
=
2562 output_section_statement
->bfd_section
;
2564 switch (s
->data_statement
.type
)
2582 output_section_statement
->bfd_section
->_raw_size
+= size
;
2583 /* The output section gets contents, and then we inspect for
2584 any flags set in the input script which override any ALLOC. */
2585 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
2586 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
)) {
2587 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
| SEC_LOAD
;
2592 case lang_reloc_statement_enum
:
2596 s
->reloc_statement
.output_vma
=
2597 dot
- output_section_statement
->bfd_section
->vma
;
2598 s
->reloc_statement
.output_section
=
2599 output_section_statement
->bfd_section
;
2600 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
2602 output_section_statement
->bfd_section
->_raw_size
+= size
;
2606 case lang_wild_statement_enum
:
2608 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
2609 output_section_statement
,
2610 &s
->wild_statement
.children
.head
,
2616 case lang_object_symbols_statement_enum
:
2617 link_info
.create_object_symbols_section
=
2618 output_section_statement
->bfd_section
;
2620 case lang_output_statement_enum
:
2621 case lang_target_statement_enum
:
2623 case lang_input_section_enum
:
2627 i
= (*prev
)->input_section
.section
;
2630 if (i
->_cooked_size
== 0)
2631 i
->_cooked_size
= i
->_raw_size
;
2637 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
2638 einfo (_("%P%F: can't relax section: %E\n"));
2642 dot
= size_input_section (prev
,
2643 output_section_statement
,
2644 output_section_statement
->fill
,
2648 case lang_input_statement_enum
:
2650 case lang_fill_statement_enum
:
2651 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
2653 fill
= s
->fill_statement
.fill
;
2655 case lang_assignment_statement_enum
:
2657 bfd_vma newdot
= dot
;
2659 exp_fold_tree (s
->assignment_statement
.exp
,
2660 output_section_statement
,
2661 lang_allocating_phase_enum
,
2667 /* The assignment changed dot. Insert a pad. */
2668 if (output_section_statement
== abs_output_section
)
2670 /* If we don't have an output section, then just adjust
2671 the default memory address. */
2672 lang_memory_region_lookup ("*default*")->current
= newdot
;
2676 lang_statement_union_type
*new =
2677 ((lang_statement_union_type
*)
2678 stat_alloc (sizeof (lang_padding_statement_type
)));
2680 /* Link into existing chain. */
2681 new->header
.next
= *prev
;
2683 new->header
.type
= lang_padding_statement_enum
;
2684 new->padding_statement
.output_section
=
2685 output_section_statement
->bfd_section
;
2686 new->padding_statement
.output_offset
=
2687 dot
- output_section_statement
->bfd_section
->vma
;
2688 new->padding_statement
.fill
= fill
;
2689 new->padding_statement
.size
= newdot
- dot
;
2690 output_section_statement
->bfd_section
->_raw_size
+=
2691 new->padding_statement
.size
;
2699 case lang_padding_statement_enum
:
2700 /* If we are relaxing, and this is not the first pass, some
2701 padding statements may have been inserted during previous
2702 passes. We may have to move the padding statement to a new
2703 location if dot has a different value at this point in this
2704 pass than it did at this point in the previous pass. */
2705 s
->padding_statement
.output_offset
=
2706 dot
- output_section_statement
->bfd_section
->vma
;
2707 dot
+= s
->padding_statement
.size
;
2708 output_section_statement
->bfd_section
->_raw_size
+=
2709 s
->padding_statement
.size
;
2712 case lang_group_statement_enum
:
2713 dot
= lang_size_sections (s
->group_statement
.children
.head
,
2714 output_section_statement
,
2715 &s
->group_statement
.children
.head
,
2723 /* This can only get here when relaxing is turned on. */
2725 case lang_address_statement_enum
:
2728 prev
= &s
->header
.next
;
2734 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
2735 lang_statement_union_type
* s
;
2736 lang_output_section_statement_type
* output_section_statement
;
2740 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2742 switch (s
->header
.type
)
2744 case lang_constructors_statement_enum
:
2745 dot
= lang_do_assignments (constructor_list
.head
,
2746 output_section_statement
,
2751 case lang_output_section_statement_enum
:
2753 lang_output_section_statement_type
*os
=
2754 &(s
->output_section_statement
);
2756 if (os
->bfd_section
!= NULL
)
2758 dot
= os
->bfd_section
->vma
;
2759 (void) lang_do_assignments (os
->children
.head
, os
,
2761 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
2765 /* If nothing has been placed into the output section then
2766 it won't have a bfd_section. */
2767 if (os
->bfd_section
)
2769 os
->bfd_section
->lma
2770 = exp_get_abs_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
2775 case lang_wild_statement_enum
:
2777 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
2778 output_section_statement
,
2783 case lang_object_symbols_statement_enum
:
2784 case lang_output_statement_enum
:
2785 case lang_target_statement_enum
:
2787 case lang_common_statement_enum
:
2790 case lang_data_statement_enum
:
2792 etree_value_type value
;
2794 value
= exp_fold_tree (s
->data_statement
.exp
,
2796 lang_final_phase_enum
, dot
, &dot
);
2797 s
->data_statement
.value
= value
.value
;
2798 if (value
.valid_p
== false)
2799 einfo (_("%F%P: invalid data statement\n"));
2801 switch (s
->data_statement
.type
)
2819 case lang_reloc_statement_enum
:
2821 etree_value_type value
;
2823 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
2825 lang_final_phase_enum
, dot
, &dot
);
2826 s
->reloc_statement
.addend_value
= value
.value
;
2827 if (value
.valid_p
== false)
2828 einfo (_("%F%P: invalid reloc statement\n"));
2830 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
);
2833 case lang_input_section_enum
:
2835 asection
*in
= s
->input_section
.section
;
2837 if (in
->_cooked_size
!= 0)
2838 dot
+= in
->_cooked_size
;
2840 dot
+= in
->_raw_size
;
2844 case lang_input_statement_enum
:
2846 case lang_fill_statement_enum
:
2847 fill
= s
->fill_statement
.fill
;
2849 case lang_assignment_statement_enum
:
2851 exp_fold_tree (s
->assignment_statement
.exp
,
2852 output_section_statement
,
2853 lang_final_phase_enum
,
2859 case lang_padding_statement_enum
:
2860 dot
+= s
->padding_statement
.size
;
2863 case lang_group_statement_enum
:
2864 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
2865 output_section_statement
,
2873 case lang_address_statement_enum
:
2881 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
2882 operator .startof. (section_name), it produces an undefined symbol
2883 .startof.section_name. Similarly, when it sees
2884 .sizeof. (section_name), it produces an undefined symbol
2885 .sizeof.section_name. For all the output sections, we look for
2886 such symbols, and set them to the correct value. */
2893 if (link_info
.relocateable
)
2896 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2898 const char *secname
;
2900 struct bfd_link_hash_entry
*h
;
2902 secname
= bfd_get_section_name (output_bfd
, s
);
2903 buf
= xmalloc (10 + strlen (secname
));
2905 sprintf (buf
, ".startof.%s", secname
);
2906 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
2907 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
2909 h
->type
= bfd_link_hash_defined
;
2910 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
2911 h
->u
.def
.section
= bfd_abs_section_ptr
;
2914 sprintf (buf
, ".sizeof.%s", secname
);
2915 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
2916 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
2918 h
->type
= bfd_link_hash_defined
;
2919 if (s
->_cooked_size
!= 0)
2920 h
->u
.def
.value
= s
->_cooked_size
;
2922 h
->u
.def
.value
= s
->_raw_size
;
2923 h
->u
.def
.section
= bfd_abs_section_ptr
;
2933 struct bfd_link_hash_entry
*h
;
2936 if (link_info
.relocateable
|| link_info
.shared
)
2941 if (entry_symbol
== (char *) NULL
)
2943 /* No entry has been specified. Look for start, but don't warn
2944 if we don't find it. */
2945 entry_symbol
= "start";
2949 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
2950 if (h
!= (struct bfd_link_hash_entry
*) NULL
2951 && (h
->type
== bfd_link_hash_defined
2952 || h
->type
== bfd_link_hash_defweak
)
2953 && h
->u
.def
.section
->output_section
!= NULL
)
2957 val
= (h
->u
.def
.value
2958 + bfd_get_section_vma (output_bfd
,
2959 h
->u
.def
.section
->output_section
)
2960 + h
->u
.def
.section
->output_offset
);
2961 if (! bfd_set_start_address (output_bfd
, val
))
2962 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
);
2969 /* We couldn't find the entry symbol. Try parsing it as a
2971 val
= bfd_scan_vma (entry_symbol
, &send
, 0);
2974 if (! bfd_set_start_address (output_bfd
, val
))
2975 einfo (_("%P%F: can't set start address\n"));
2981 /* Can't find the entry symbol, and it's not a number. Use
2982 the first address in the text section. */
2983 ts
= bfd_get_section_by_name (output_bfd
, ".text");
2984 if (ts
!= (asection
*) NULL
)
2987 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
2988 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
2989 if (! bfd_set_start_address (output_bfd
,
2990 bfd_get_section_vma (output_bfd
,
2992 einfo (_("%P%F: can't set start address\n"));
2997 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3004 /* This is a small function used when we want to ignore errors from
3008 #ifdef ANSI_PROTOTYPES
3009 ignore_bfd_errors (const char *s
, ...)
3011 ignore_bfd_errors (s
)
3015 /* Don't do anything. */
3018 /* Check that the architecture of all the input files is compatible
3019 with the output file. Also call the backend to let it do any
3020 other checking that is needed. */
3025 lang_statement_union_type
*file
;
3027 CONST bfd_arch_info_type
*compatible
;
3029 for (file
= file_chain
.head
;
3030 file
!= (lang_statement_union_type
*) NULL
;
3031 file
= file
->input_statement
.next
)
3033 input_bfd
= file
->input_statement
.the_bfd
;
3034 compatible
= bfd_arch_get_compatible (input_bfd
,
3036 if (compatible
== NULL
)
3038 if (command_line
.warn_mismatch
)
3039 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3040 bfd_printable_name (input_bfd
), input_bfd
,
3041 bfd_printable_name (output_bfd
));
3045 bfd_error_handler_type pfn
= NULL
;
3047 /* If we aren't supposed to warn about mismatched input
3048 files, temporarily set the BFD error handler to a
3049 function which will do nothing. We still want to call
3050 bfd_merge_private_bfd_data, since it may set up
3051 information which is needed in the output file. */
3052 if (! command_line
.warn_mismatch
)
3053 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3054 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3056 if (command_line
.warn_mismatch
)
3057 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3060 if (! command_line
.warn_mismatch
)
3061 bfd_set_error_handler (pfn
);
3066 /* Look through all the global common symbols and attach them to the
3067 correct section. The -sort-common command line switch may be used
3068 to roughly sort the entries by size. */
3073 if (link_info
.relocateable
3074 && ! command_line
.force_common_definition
)
3077 if (! config
.sort_common
)
3078 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3083 for (power
= 4; power
>= 0; power
--)
3084 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3089 /* Place one common symbol in the correct section. */
3092 lang_one_common (h
, info
)
3093 struct bfd_link_hash_entry
*h
;
3096 unsigned int power_of_two
;
3100 if (h
->type
!= bfd_link_hash_common
)
3104 power_of_two
= h
->u
.c
.p
->alignment_power
;
3106 if (config
.sort_common
3107 && power_of_two
< (unsigned int) *(int *) info
)
3110 section
= h
->u
.c
.p
->section
;
3112 /* Increase the size of the section. */
3113 section
->_cooked_size
= ALIGN_N (section
->_cooked_size
,
3114 (bfd_size_type
) (1 << power_of_two
));
3116 /* Adjust the alignment if necessary. */
3117 if (power_of_two
> section
->alignment_power
)
3118 section
->alignment_power
= power_of_two
;
3120 /* Change the symbol from common to defined. */
3121 h
->type
= bfd_link_hash_defined
;
3122 h
->u
.def
.section
= section
;
3123 h
->u
.def
.value
= section
->_cooked_size
;
3125 /* Increase the size of the section. */
3126 section
->_cooked_size
+= size
;
3128 /* Make sure the section is allocated in memory, and make sure that
3129 it is no longer a common section. */
3130 section
->flags
|= SEC_ALLOC
;
3131 section
->flags
&= ~ SEC_IS_COMMON
;
3133 if (config
.map_file
!= NULL
)
3135 static boolean header_printed
;
3140 if (! header_printed
)
3142 minfo (_("\nAllocating common symbols\n"));
3143 minfo (_("Common symbol size file\n\n"));
3144 header_printed
= true;
3147 name
= demangle (h
->root
.string
);
3149 len
= strlen (name
);
3164 if (size
<= 0xffffffff)
3165 sprintf (buf
, "%lx", (unsigned long) size
);
3167 sprintf_vma (buf
, size
);
3177 minfo ("%B\n", section
->owner
);
3184 run through the input files and ensure that every input
3185 section has somewhere to go. If one is found without
3186 a destination then create an input request and place it
3187 into the statement tree.
3191 lang_place_orphans ()
3193 lang_input_statement_type
*file
;
3195 for (file
= (lang_input_statement_type
*) file_chain
.head
;
3196 file
!= (lang_input_statement_type
*) NULL
;
3197 file
= (lang_input_statement_type
*) file
->next
)
3201 for (s
= file
->the_bfd
->sections
;
3202 s
!= (asection
*) NULL
;
3205 if (s
->output_section
== (asection
*) NULL
)
3207 /* This section of the file is not attatched, root
3208 around for a sensible place for it to go */
3210 if (file
->just_syms_flag
)
3212 /* We are only retrieving symbol values from this
3213 file. We want the symbols to act as though the
3214 values in the file are absolute. */
3215 s
->output_section
= bfd_abs_section_ptr
;
3216 s
->output_offset
= s
->vma
;
3218 else if (strcmp (s
->name
, "COMMON") == 0)
3220 /* This is a lonely common section which must have
3221 come from an archive. We attach to the section
3222 with the wildcard. */
3223 if (! link_info
.relocateable
3224 || command_line
.force_common_definition
)
3226 if (default_common_section
== NULL
)
3229 /* This message happens when using the
3230 svr3.ifile linker script, so I have
3232 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3234 default_common_section
=
3235 lang_output_section_statement_lookup (".bss");
3238 wild_doit (&default_common_section
->children
, s
,
3239 default_common_section
, file
);
3242 else if (ldemul_place_orphan (file
, s
))
3246 lang_output_section_statement_type
*os
=
3247 lang_output_section_statement_lookup (s
->name
);
3249 wild_doit (&os
->children
, s
, os
, file
);
3258 lang_set_flags (ptr
, flags
)
3259 lang_memory_region_type
*ptr
;
3262 flagword
*ptr_flags
= &ptr
->flags
;
3264 ptr
->flags
= ptr
->not_flags
= 0;
3270 ptr_flags
= (ptr_flags
== &ptr
->flags
) ? &ptr
->not_flags
: &ptr
->flags
;
3274 *ptr_flags
|= SEC_ALLOC
;
3278 *ptr_flags
|= SEC_READONLY
;
3282 *ptr_flags
|= SEC_DATA
;
3286 *ptr_flags
|= SEC_CODE
;
3291 *ptr_flags
|= SEC_LOAD
;
3295 einfo (_("%P%F: invalid syntax in flags\n"));
3302 /* Call a function on each input file. This function will be called
3303 on an archive, but not on the elements. */
3306 lang_for_each_input_file (func
)
3307 void (*func
) PARAMS ((lang_input_statement_type
*));
3309 lang_input_statement_type
*f
;
3311 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3313 f
= (lang_input_statement_type
*) f
->next_real_file
)
3317 /* Call a function on each file. The function will be called on all
3318 the elements of an archive which are included in the link, but will
3319 not be called on the archive file itself. */
3322 lang_for_each_file (func
)
3323 void (*func
) PARAMS ((lang_input_statement_type
*));
3325 lang_input_statement_type
*f
;
3327 for (f
= (lang_input_statement_type
*) file_chain
.head
;
3328 f
!= (lang_input_statement_type
*) NULL
;
3329 f
= (lang_input_statement_type
*) f
->next
)
3340 lang_for_each_input_section (func
)
3341 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
3343 lang_input_statement_type
*f
;
3345 for (f
= (lang_input_statement_type
*) file_chain
.head
;
3346 f
!= (lang_input_statement_type
*) NULL
;
3347 f
= (lang_input_statement_type
*) f
->next
)
3351 for (s
= f
->the_bfd
->sections
;
3352 s
!= (asection
*) NULL
;
3355 func (f
->the_bfd
, s
);
3363 ldlang_add_file (entry
)
3364 lang_input_statement_type
* entry
;
3368 lang_statement_append (&file_chain
,
3369 (lang_statement_union_type
*) entry
,
3372 /* The BFD linker needs to have a list of all input BFDs involved in
3374 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3375 ASSERT (entry
->the_bfd
!= output_bfd
);
3376 for (pp
= &link_info
.input_bfds
;
3377 *pp
!= (bfd
*) NULL
;
3378 pp
= &(*pp
)->link_next
)
3380 *pp
= entry
->the_bfd
;
3381 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3382 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3384 /* Look through the sections and check for any which should not be
3385 included in the link. We need to do this now, so that we can
3386 notice when the backend linker tries to report multiple
3387 definition errors for symbols which are in sections we aren't
3388 going to link. FIXME: It might be better to entirely ignore
3389 symbols which are defined in sections which are going to be
3390 discarded. This would require modifying the backend linker for
3391 each backend which might set the SEC_LINK_ONCE flag. If we do
3392 this, we should probably handle SEC_EXCLUDE in the same way. */
3394 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
3398 lang_add_output (name
, from_script
)
3402 /* Make -o on command line override OUTPUT in script. */
3403 if (had_output_filename
== false || !from_script
)
3405 output_filename
= name
;
3406 had_output_filename
= true;
3411 static lang_output_section_statement_type
*current_section
;
3423 for (l
= 0; l
< 32; l
++)
3425 if (i
>= (unsigned int) x
)
3434 lang_enter_output_section_statement (output_section_statement_name
,
3435 address_exp
, sectype
, block_value
,
3436 align
, subalign
, ebase
)
3437 const char *output_section_statement_name
;
3438 etree_type
* address_exp
;
3439 enum section_type sectype
;
3440 bfd_vma block_value
;
3442 etree_type
*subalign
;
3445 lang_output_section_statement_type
*os
;
3449 lang_output_section_statement_lookup (output_section_statement_name
);
3453 /* Add this statement to tree */
3454 /* add_statement(lang_output_section_statement_enum,
3455 output_section_statement);*/
3456 /* Make next things chain into subchain of this */
3458 if (os
->addr_tree
==
3459 (etree_type
*) NULL
)
3464 os
->sectype
= sectype
;
3465 if (sectype
!= noload_section
)
3466 os
->flags
= SEC_NO_FLAGS
;
3468 os
->flags
= SEC_NEVER_LOAD
;
3469 os
->block_value
= block_value
? block_value
: 1;
3470 stat_ptr
= &os
->children
;
3472 os
->subsection_alignment
= topower(
3473 exp_get_value_int(subalign
, -1,
3474 "subsection alignment",
3476 os
->section_alignment
= topower(
3477 exp_get_value_int(align
, -1,
3478 "section alignment", 0));
3480 os
->load_base
= ebase
;
3487 lang_output_statement_type
*new =
3488 new_stat (lang_output_statement
, stat_ptr
);
3490 new->name
= output_filename
;
3493 /* Reset the current counters in the regions */
3495 reset_memory_regions ()
3497 lang_memory_region_type
*p
= lang_memory_region_list
;
3499 for (p
= lang_memory_region_list
;
3500 p
!= (lang_memory_region_type
*) NULL
;
3503 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
3504 p
->current
= p
->origin
;
3508 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3509 as needed. SECTION may be NULL, in which case it is a wild card. */
3512 gc_section_callback (ptr
, section
, file
, data
)
3513 lang_wild_statement_type
*ptr
;
3515 lang_input_statement_type
*file
;
3518 /* If the wild pattern was marked KEEP, the member sections
3519 should be as well. */
3520 if (ptr
->keep_sections
)
3521 section
->flags
|= SEC_KEEP
;
3524 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
3525 may be NULL, indicating that it is a wildcard. */
3528 lang_gc_wild (s
, section
, file
)
3529 lang_wild_statement_type
*s
;
3530 const char *section
;
3533 walk_wild (s
, section
, file
, gc_section_callback
, NULL
);
3536 /* Iterate over sections marking them against GC. */
3539 lang_gc_sections_1 (s
)
3540 lang_statement_union_type
* s
;
3542 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
3544 switch (s
->header
.type
)
3546 case lang_wild_statement_enum
:
3547 lang_gc_wild (&s
->wild_statement
,
3548 s
->wild_statement
.section_name
,
3549 s
->wild_statement
.filename
);
3551 case lang_constructors_statement_enum
:
3552 lang_gc_sections_1 (constructor_list
.head
);
3554 case lang_output_section_statement_enum
:
3555 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
3557 case lang_group_statement_enum
:
3558 lang_gc_sections_1 (s
->group_statement
.children
.head
);
3569 struct bfd_link_hash_entry
*h
;
3570 ldlang_undef_chain_list_type
*ulist
, fake_list_start
;
3572 /* Keep all sections so marked in the link script. */
3574 lang_gc_sections_1 (statement_list
.head
);
3576 /* Keep all sections containing symbols undefined on the command-line.
3577 Handle the entry symbol at the same time. */
3579 fake_list_start
.next
= ldlang_undef_chain_list_head
;
3580 if (entry_symbol
== NULL
)
3581 fake_list_start
.name
= "start";
3583 fake_list_start
.name
= (char *) entry_symbol
;
3585 for (ulist
= &fake_list_start
; ulist
; ulist
= ulist
->next
)
3587 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
3588 false, false, false);
3590 if (h
!= (struct bfd_link_hash_entry
*) NULL
3591 && (h
->type
== bfd_link_hash_defined
3592 || h
->type
== bfd_link_hash_defweak
)
3593 && ! bfd_is_abs_section (h
->u
.def
.section
))
3595 h
->u
.def
.section
->flags
|= SEC_KEEP
;
3599 bfd_gc_sections (output_bfd
, &link_info
);
3605 lang_reasonable_defaults ();
3606 current_target
= default_target
;
3608 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
3610 ldemul_create_output_section_statements ();
3612 /* Add to the hash table all undefineds on the command line */
3613 lang_place_undefineds ();
3615 /* Create a bfd for each input file */
3616 current_target
= default_target
;
3617 open_input_bfds (statement_list
.head
, false);
3619 ldemul_after_open ();
3621 /* Make sure that we're not mixing architectures. We call this
3622 after all the input files have been opened, but before we do any
3623 other processing, so that any operations merge_private_bfd_data
3624 does on the output file will be known during the rest of the
3628 /* Handle .exports instead of a version script if we're told to do so. */
3629 if (command_line
.version_exports_section
)
3630 lang_do_version_exports_section ();
3632 /* Build all sets based on the information gathered from the input
3634 ldctor_build_sets ();
3636 /* Remove unreferenced sections if asked to. */
3637 if (command_line
.gc_sections
)
3638 lang_gc_sections ();
3640 /* Size up the common data */
3643 /* Run through the contours of the script and attach input sections
3644 to the correct output sections
3646 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
3647 (lang_output_section_statement_type
*) NULL
);
3650 /* Find any sections not attached explicitly and handle them */
3651 lang_place_orphans ();
3653 ldemul_before_allocation ();
3655 /* We must record the program headers before we try to fix the
3656 section positions, since they will affect SIZEOF_HEADERS. */
3657 lang_record_phdrs ();
3659 /* Now run around and relax if we can */
3660 if (command_line
.relax
)
3662 /* First time round is a trial run to get the 'worst case'
3663 addresses of the objects if there was no relaxing. */
3664 lang_size_sections (statement_list
.head
,
3666 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
3668 /* Keep relaxing until bfd_relax_section gives up. */
3671 reset_memory_regions ();
3673 relax_again
= false;
3675 /* Note: pe-dll.c does something like this also. If you find
3676 you need to change this code, you probably need to change
3677 pe-dll.c also. DJ */
3679 /* Do all the assignments with our current guesses as to
3681 lang_do_assignments (statement_list
.head
,
3683 (fill_type
) 0, (bfd_vma
) 0);
3685 /* Perform another relax pass - this time we know where the
3686 globals are, so can make better guess. */
3687 lang_size_sections (statement_list
.head
,
3689 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
3691 while (relax_again
);
3695 /* Size up the sections. */
3696 lang_size_sections (statement_list
.head
,
3698 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
3701 /* See if anything special should be done now we know how big
3703 ldemul_after_allocation ();
3705 /* Fix any .startof. or .sizeof. symbols. */
3706 lang_set_startof ();
3708 /* Do all the assignments, now that we know the final restingplaces
3709 of all the symbols */
3711 lang_do_assignments (statement_list
.head
,
3713 (fill_type
) 0, (bfd_vma
) 0);
3715 /* Make sure that the section addresses make sense. */
3716 if (! link_info
.relocateable
3717 && command_line
.check_section_addresses
)
3718 lang_check_section_addresses ();
3726 /* EXPORTED TO YACC */
3729 lang_add_wild (section_name
, sections_sorted
, filename
, filenames_sorted
,
3730 keep_sections
, exclude_filename
)
3731 const char *const section_name
;
3732 boolean sections_sorted
;
3733 const char *const filename
;
3734 boolean filenames_sorted
;
3735 boolean keep_sections
;
3736 const char *exclude_filename
;
3738 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
3741 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
3743 placed_commons
= true;
3745 if (filename
!= NULL
&& ! wildcardp (filename
))
3747 lang_has_input_file
= true;
3749 new->section_name
= section_name
;
3750 new->sections_sorted
= sections_sorted
;
3751 new->filename
= filename
;
3752 new->filenames_sorted
= filenames_sorted
;
3753 new->keep_sections
= keep_sections
;
3754 new->exclude_filename
= exclude_filename
;
3755 lang_list_init (&new->children
);
3759 lang_section_start (name
, address
)
3761 etree_type
* address
;
3763 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
3765 ad
->section_name
= name
;
3766 ad
->address
= address
;
3769 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
3770 because of a -e argument on the command line, or zero if this is
3771 called by ENTRY in a linker script. Command line arguments take
3775 lang_add_entry (name
, cmdline
)
3779 if (entry_symbol
== NULL
3781 || ! entry_from_cmdline
)
3783 entry_symbol
= name
;
3784 entry_from_cmdline
= cmdline
;
3789 lang_add_target (name
)
3792 lang_target_statement_type
*new = new_stat (lang_target_statement
,
3808 map_option_f
= true;
3819 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
3826 lang_add_data (type
, exp
)
3828 union etree_union
*exp
;
3831 lang_data_statement_type
*new = new_stat (lang_data_statement
,
3839 /* Create a new reloc statement. RELOC is the BFD relocation type to
3840 generate. HOWTO is the corresponding howto structure (we could
3841 look this up, but the caller has already done so). SECTION is the
3842 section to generate a reloc against, or NAME is the name of the
3843 symbol to generate a reloc against. Exactly one of SECTION and
3844 NAME must be NULL. ADDEND is an expression for the addend. */
3847 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
3848 bfd_reloc_code_real_type reloc
;
3849 reloc_howto_type
*howto
;
3852 union etree_union
*addend
;
3854 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
3858 p
->section
= section
;
3860 p
->addend_exp
= addend
;
3862 p
->addend_value
= 0;
3863 p
->output_section
= NULL
;
3867 lang_assignment_statement_type
*
3868 lang_add_assignment (exp
)
3871 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
3879 lang_add_attribute (attribute
)
3880 enum statement_enum attribute
;
3882 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
3889 if (startup_file
!= (char *) NULL
)
3891 einfo (_("%P%Fmultiple STARTUP files\n"));
3893 first_file
->filename
= name
;
3894 first_file
->local_sym_name
= name
;
3895 first_file
->real
= true;
3897 startup_file
= name
;
3904 lang_float_flag
= maybe
;
3908 lang_leave_output_section_statement (fill
, memspec
, phdrs
)
3910 const char *memspec
;
3911 struct lang_output_section_phdr_list
*phdrs
;
3913 current_section
->fill
= fill
;
3914 current_section
->region
= lang_memory_region_lookup (memspec
);
3915 current_section
->phdrs
= phdrs
;
3916 stat_ptr
= &statement_list
;
3920 Create an absolute symbol with the given name with the value of the
3921 address of first byte of the section named.
3923 If the symbol already exists, then do nothing.
3926 lang_abs_symbol_at_beginning_of (secname
, name
)
3927 const char *secname
;
3930 struct bfd_link_hash_entry
*h
;
3932 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
3933 if (h
== (struct bfd_link_hash_entry
*) NULL
)
3934 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3936 if (h
->type
== bfd_link_hash_new
3937 || h
->type
== bfd_link_hash_undefined
)
3941 h
->type
= bfd_link_hash_defined
;
3943 sec
= bfd_get_section_by_name (output_bfd
, secname
);
3944 if (sec
== (asection
*) NULL
)
3947 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
3949 h
->u
.def
.section
= bfd_abs_section_ptr
;
3954 Create an absolute symbol with the given name with the value of the
3955 address of the first byte after the end of the section named.
3957 If the symbol already exists, then do nothing.
3960 lang_abs_symbol_at_end_of (secname
, name
)
3961 const char *secname
;
3964 struct bfd_link_hash_entry
*h
;
3966 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
3967 if (h
== (struct bfd_link_hash_entry
*) NULL
)
3968 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3970 if (h
->type
== bfd_link_hash_new
3971 || h
->type
== bfd_link_hash_undefined
)
3975 h
->type
= bfd_link_hash_defined
;
3977 sec
= bfd_get_section_by_name (output_bfd
, secname
);
3978 if (sec
== (asection
*) NULL
)
3981 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
3982 + bfd_section_size (output_bfd
, sec
));
3984 h
->u
.def
.section
= bfd_abs_section_ptr
;
3989 lang_statement_append (list
, element
, field
)
3990 lang_statement_list_type
* list
;
3991 lang_statement_union_type
* element
;
3992 lang_statement_union_type
** field
;
3994 *(list
->tail
) = element
;
3998 /* Set the output format type. -oformat overrides scripts. */
4001 lang_add_output_format (format
, big
, little
, from_script
)
4007 if (output_target
== NULL
|| !from_script
)
4009 if (command_line
.endian
== ENDIAN_BIG
4012 else if (command_line
.endian
== ENDIAN_LITTLE
4016 output_target
= format
;
4020 /* Enter a group. This creates a new lang_group_statement, and sets
4021 stat_ptr to build new statements within the group. */
4026 lang_group_statement_type
*g
;
4028 g
= new_stat (lang_group_statement
, stat_ptr
);
4029 lang_list_init (&g
->children
);
4030 stat_ptr
= &g
->children
;
4033 /* Leave a group. This just resets stat_ptr to start writing to the
4034 regular list of statements again. Note that this will not work if
4035 groups can occur inside anything else which can adjust stat_ptr,
4036 but currently they can't. */
4041 stat_ptr
= &statement_list
;
4044 /* Add a new program header. This is called for each entry in a PHDRS
4045 command in a linker script. */
4048 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4056 struct lang_phdr
*n
, **pp
;
4058 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4061 n
->type
= exp_get_value_int (type
, 0, "program header type",
4062 lang_final_phase_enum
);
4063 n
->filehdr
= filehdr
;
4068 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4073 /* Record the program header information in the output BFD. FIXME: We
4074 should not be calling an ELF specific function here. */
4077 lang_record_phdrs ()
4081 struct lang_output_section_phdr_list
*last
;
4082 struct lang_phdr
*l
;
4083 lang_statement_union_type
*u
;
4086 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4088 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4095 for (u
= lang_output_section_statement
.head
;
4097 u
= u
->output_section_statement
.next
)
4099 lang_output_section_statement_type
*os
;
4100 struct lang_output_section_phdr_list
*pl
;
4102 os
= &u
->output_section_statement
;
4109 if (os
->sectype
== noload_section
4110 || os
->bfd_section
== NULL
4111 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4116 if (os
->bfd_section
== NULL
)
4119 for (; pl
!= NULL
; pl
= pl
->next
)
4121 if (strcmp (pl
->name
, l
->name
) == 0)
4126 secs
= ((asection
**)
4127 xrealloc (secs
, alc
* sizeof (asection
*)));
4129 secs
[c
] = os
->bfd_section
;
4136 if (l
->flags
== NULL
)
4139 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4140 lang_final_phase_enum
);
4145 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4146 lang_final_phase_enum
);
4148 if (! bfd_record_phdr (output_bfd
, l
->type
,
4149 l
->flags
== NULL
? false : true,
4151 l
->at
== NULL
? false : true,
4152 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4153 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4158 /* Make sure all the phdr assignments succeeded. */
4159 for (u
= lang_output_section_statement
.head
;
4161 u
= u
->output_section_statement
.next
)
4163 struct lang_output_section_phdr_list
*pl
;
4165 if (u
->output_section_statement
.bfd_section
== NULL
)
4168 for (pl
= u
->output_section_statement
.phdrs
;
4171 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4172 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4173 u
->output_section_statement
.name
, pl
->name
);
4177 /* Record a list of sections which may not be cross referenced. */
4180 lang_add_nocrossref (l
)
4181 struct lang_nocrossref
*l
;
4183 struct lang_nocrossrefs
*n
;
4185 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4186 n
->next
= nocrossref_list
;
4188 nocrossref_list
= n
;
4190 /* Set notice_all so that we get informed about all symbols. */
4191 link_info
.notice_all
= true;
4194 /* Overlay handling. We handle overlays with some static variables. */
4196 /* The overlay virtual address. */
4197 static etree_type
*overlay_vma
;
4199 /* The overlay load address. */
4200 static etree_type
*overlay_lma
;
4202 /* Whether nocrossrefs is set for this overlay. */
4203 static int overlay_nocrossrefs
;
4205 /* An expression for the maximum section size seen so far. */
4206 static etree_type
*overlay_max
;
4208 /* A list of all the sections in this overlay. */
4212 struct overlay_list
*next
;
4213 lang_output_section_statement_type
*os
;
4216 static struct overlay_list
*overlay_list
;
4218 /* Start handling an overlay. */
4221 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
4222 etree_type
*vma_expr
;
4223 etree_type
*lma_expr
;
4226 /* The grammar should prevent nested overlays from occurring. */
4227 ASSERT (overlay_vma
== NULL
4228 && overlay_lma
== NULL
4229 && overlay_list
== NULL
4230 && overlay_max
== NULL
);
4232 overlay_vma
= vma_expr
;
4233 overlay_lma
= lma_expr
;
4234 overlay_nocrossrefs
= nocrossrefs
;
4237 /* Start a section in an overlay. We handle this by calling
4238 lang_enter_output_section_statement with the correct VMA and LMA. */
4241 lang_enter_overlay_section (name
)
4244 struct overlay_list
*n
;
4247 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4248 0, 0, 0, overlay_lma
);
4250 /* If this is the first section, then base the VMA and LMA of future
4251 sections on this one. This will work correctly even if `.' is
4252 used in the addresses. */
4253 if (overlay_list
== NULL
)
4255 overlay_vma
= exp_nameop (ADDR
, name
);
4256 overlay_lma
= exp_nameop (LOADADDR
, name
);
4259 /* Remember the section. */
4260 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4261 n
->os
= current_section
;
4262 n
->next
= overlay_list
;
4265 size
= exp_nameop (SIZEOF
, name
);
4267 /* Adjust the LMA for the next section. */
4268 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
4270 /* Arrange to work out the maximum section end address. */
4271 if (overlay_max
== NULL
)
4274 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4277 /* Finish a section in an overlay. There isn't any special to do
4281 lang_leave_overlay_section (fill
, phdrs
)
4283 struct lang_output_section_phdr_list
*phdrs
;
4290 name
= current_section
->name
;
4292 lang_leave_output_section_statement (fill
, "*default*", phdrs
);
4294 /* Define the magic symbols. */
4296 clean
= xmalloc (strlen (name
) + 1);
4298 for (s1
= name
; *s1
!= '\0'; s1
++)
4299 if (isalnum ((unsigned char) *s1
) || *s1
== '_')
4303 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4304 sprintf (buf
, "__load_start_%s", clean
);
4305 lang_add_assignment (exp_assop ('=', buf
,
4306 exp_nameop (LOADADDR
, name
)));
4308 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4309 sprintf (buf
, "__load_stop_%s", clean
);
4310 lang_add_assignment (exp_assop ('=', buf
,
4312 exp_nameop (LOADADDR
, name
),
4313 exp_nameop (SIZEOF
, name
))));
4318 /* Finish an overlay. If there are any overlay wide settings, this
4319 looks through all the sections in the overlay and sets them. */
4322 lang_leave_overlay (fill
, memspec
, phdrs
)
4324 const char *memspec
;
4325 struct lang_output_section_phdr_list
*phdrs
;
4327 lang_memory_region_type
*region
;
4328 struct overlay_list
*l
;
4329 struct lang_nocrossref
*nocrossref
;
4331 if (memspec
== NULL
)
4334 region
= lang_memory_region_lookup (memspec
);
4341 struct overlay_list
*next
;
4343 if (fill
!= 0 && l
->os
->fill
== 0)
4345 if (region
!= NULL
&& l
->os
->region
== NULL
)
4346 l
->os
->region
= region
;
4347 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4348 l
->os
->phdrs
= phdrs
;
4350 if (overlay_nocrossrefs
)
4352 struct lang_nocrossref
*nc
;
4354 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
4355 nc
->name
= l
->os
->name
;
4356 nc
->next
= nocrossref
;
4365 if (nocrossref
!= NULL
)
4366 lang_add_nocrossref (nocrossref
);
4368 /* Update . for the end of the overlay. */
4369 lang_add_assignment (exp_assop ('=', ".",
4370 exp_binop ('+', overlay_vma
, overlay_max
)));
4374 overlay_nocrossrefs
= 0;
4375 overlay_list
= NULL
;
4379 /* Version handling. This is only useful for ELF. */
4381 /* This global variable holds the version tree that we build. */
4383 struct bfd_elf_version_tree
*lang_elf_version_info
;
4386 lang_vers_match_lang_c (expr
, sym
)
4387 struct bfd_elf_version_expr
*expr
;
4390 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4392 return fnmatch (expr
->pattern
, sym
, 0) == 0;
4396 lang_vers_match_lang_cplusplus (expr
, sym
)
4397 struct bfd_elf_version_expr
*expr
;
4403 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4406 alt_sym
= cplus_demangle(sym
, /* DMGL_NO_TPARAMS */ 0);
4409 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4410 Should we early out false in this case? */
4411 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4415 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4423 lang_vers_match_lang_java (expr
, sym
)
4424 struct bfd_elf_version_expr
*expr
;
4430 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4433 alt_sym
= cplus_demangle(sym
, DMGL_JAVA
);
4436 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4437 Should we early out false in this case? */
4438 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4442 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4449 /* This is called for each variable name or match expression. */
4451 struct bfd_elf_version_expr
*
4452 lang_new_vers_regex (orig
, new, lang
)
4453 struct bfd_elf_version_expr
*orig
;
4457 struct bfd_elf_version_expr
*ret
;
4459 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
4463 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
4464 ret
->match
= lang_vers_match_lang_c
;
4465 else if (strcasecmp (lang
, "C++") == 0)
4466 ret
->match
= lang_vers_match_lang_cplusplus
;
4467 else if (strcasecmp (lang
, "Java") == 0)
4468 ret
->match
= lang_vers_match_lang_java
;
4471 einfo (_("%X%P: unknown language `%s' in version information\n"),
4473 ret
->match
= lang_vers_match_lang_c
;
4479 /* This is called for each set of variable names and match
4482 struct bfd_elf_version_tree
*
4483 lang_new_vers_node (globals
, locals
)
4484 struct bfd_elf_version_expr
*globals
;
4485 struct bfd_elf_version_expr
*locals
;
4487 struct bfd_elf_version_tree
*ret
;
4489 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
4493 ret
->globals
= globals
;
4494 ret
->locals
= locals
;
4496 ret
->name_indx
= (unsigned int) -1;
4501 /* This static variable keeps track of version indices. */
4503 static int version_index
;
4505 /* This is called when we know the name and dependencies of the
4509 lang_register_vers_node (name
, version
, deps
)
4511 struct bfd_elf_version_tree
*version
;
4512 struct bfd_elf_version_deps
*deps
;
4514 struct bfd_elf_version_tree
*t
, **pp
;
4515 struct bfd_elf_version_expr
*e1
;
4517 /* Make sure this node has a unique name. */
4518 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4519 if (strcmp (t
->name
, name
) == 0)
4520 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
4522 /* Check the global and local match names, and make sure there
4523 aren't any duplicates. */
4525 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
4527 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4529 struct bfd_elf_version_expr
*e2
;
4531 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
4532 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
4533 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4538 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
4540 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4542 struct bfd_elf_version_expr
*e2
;
4544 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
4545 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
4546 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4551 version
->deps
= deps
;
4552 version
->name
= name
;
4554 version
->vernum
= version_index
;
4556 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4561 /* This is called when we see a version dependency. */
4563 struct bfd_elf_version_deps
*
4564 lang_add_vers_depend (list
, name
)
4565 struct bfd_elf_version_deps
*list
;
4568 struct bfd_elf_version_deps
*ret
;
4569 struct bfd_elf_version_tree
*t
;
4571 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
4574 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4576 if (strcmp (t
->name
, name
) == 0)
4578 ret
->version_needed
= t
;
4583 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
4589 lang_do_version_exports_section ()
4591 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
4593 LANG_FOR_EACH_INPUT_STATEMENT (is
)
4595 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
4602 len
= bfd_section_size (is
->the_bfd
, sec
);
4603 contents
= xmalloc (len
);
4604 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
4605 einfo (_("%X%P: unable to read .exports section contents"), sec
);
4608 while (p
< contents
+len
)
4610 greg
= lang_new_vers_regex (greg
, p
, NULL
);
4611 p
= strchr (p
, '\0') + 1;
4614 /* Do not free the contents, as we used them creating the regex. */
4616 /* Do not include this section in the link. */
4617 bfd_set_section_flags (is
->the_bfd
, sec
,
4618 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
4621 lreg
= lang_new_vers_regex (NULL
, "*", NULL
);
4622 lang_register_vers_node (command_line
.version_exports_section
,
4623 lang_new_vers_node (greg
, lreg
), NULL
);