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 *));
155 static int get_target
PARAMS ((const bfd_target
*, void *));
156 static void stricpy
PARAMS ((char *, char *));
157 static void strcut
PARAMS ((char *, char *));
158 static int name_compare
PARAMS ((char *, char *));
159 static int closest_target_match
PARAMS ((const bfd_target
*, void *));
160 static char * get_first_input_target
PARAMS ((void));
163 lang_output_section_statement_type
*abs_output_section
;
164 lang_statement_list_type
*stat_ptr
= &statement_list
;
165 lang_statement_list_type file_chain
= { NULL
, NULL
};
166 const char *entry_symbol
= NULL
;
167 boolean entry_from_cmdline
;
168 boolean lang_has_input_file
= false;
169 boolean had_output_filename
= false;
170 boolean lang_float_flag
= false;
171 boolean delete_output_file_on_failure
= false;
172 struct lang_nocrossrefs
*nocrossref_list
;
174 etree_type
*base
; /* Relocation base - or null */
177 #if defined(__STDC__) || defined(ALMOST_STDC)
178 #define cat(a,b) a##b
180 #define cat(a,b) a/**/b
183 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
185 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
187 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
189 #define SECTION_NAME_MAP_LENGTH (16)
195 return obstack_alloc (&stat_obstack
, size
);
198 /*----------------------------------------------------------------------
199 Generic traversal routines for finding matching sections.
203 walk_wild_section (ptr
, section
, file
, callback
, data
)
204 lang_wild_statement_type
*ptr
;
206 lang_input_statement_type
*file
;
210 /* Don't process sections from files which were excluded. */
211 if (ptr
->exclude_filename
!= NULL
)
215 if (wildcardp (ptr
->exclude_filename
))
216 match
= fnmatch (ptr
->exclude_filename
, file
->filename
, 0) == 0 ? true : false;
218 match
= strcmp (ptr
->exclude_filename
, file
->filename
) == 0 ? true : false;
224 if (file
->just_syms_flag
== false)
226 register asection
*s
;
232 wildcard
= wildcardp (section
);
234 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
244 name
= bfd_get_section_name (file
->the_bfd
, s
);
246 match
= fnmatch (section
, name
, 0) == 0 ? true : false;
248 match
= strcmp (section
, name
) == 0 ? true : false;
252 (*callback
) (ptr
, s
, file
, data
);
257 /* Handle a wild statement for a single file F. */
260 walk_wild_file (s
, section
, f
, callback
, data
)
261 lang_wild_statement_type
*s
;
263 lang_input_statement_type
*f
;
267 if (f
->the_bfd
== NULL
268 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
269 walk_wild_section (s
, section
, f
, callback
, data
);
274 /* This is an archive file. We must map each member of the
275 archive separately. */
276 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
277 while (member
!= NULL
)
279 /* When lookup_name is called, it will call the add_symbols
280 entry point for the archive. For each element of the
281 archive which is included, BFD will call ldlang_add_file,
282 which will set the usrdata field of the member to the
283 lang_input_statement. */
284 if (member
->usrdata
!= NULL
)
286 walk_wild_section (s
, section
,
287 (lang_input_statement_type
*) member
->usrdata
,
291 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
297 walk_wild (s
, section
, file
, callback
, data
)
298 lang_wild_statement_type
*s
;
304 if (file
== (char *) NULL
)
306 /* Perform the iteration over all files in the list. */
307 LANG_FOR_EACH_INPUT_STATEMENT (f
)
309 walk_wild_file (s
, section
, f
, callback
, data
);
312 else if (wildcardp (file
))
314 LANG_FOR_EACH_INPUT_STATEMENT (f
)
316 if (fnmatch (file
, f
->filename
, FNM_FILE_NAME
) == 0)
317 walk_wild_file (s
, section
, f
, callback
, data
);
322 lang_input_statement_type
*f
;
324 /* Perform the iteration over a single file. */
325 f
= lookup_name (file
);
326 walk_wild_file (s
, section
, f
, callback
, data
);
330 /*----------------------------------------------------------------------
331 lang_for_each_statement walks the parse tree and calls the provided
332 function for each node
336 lang_for_each_statement_worker (func
, s
)
337 void (*func
) PARAMS ((lang_statement_union_type
*));
338 lang_statement_union_type
*s
;
340 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
344 switch (s
->header
.type
)
346 case lang_constructors_statement_enum
:
347 lang_for_each_statement_worker (func
, constructor_list
.head
);
349 case lang_output_section_statement_enum
:
350 lang_for_each_statement_worker
352 s
->output_section_statement
.children
.head
);
354 case lang_wild_statement_enum
:
355 lang_for_each_statement_worker
357 s
->wild_statement
.children
.head
);
359 case lang_group_statement_enum
:
360 lang_for_each_statement_worker (func
,
361 s
->group_statement
.children
.head
);
363 case lang_data_statement_enum
:
364 case lang_reloc_statement_enum
:
365 case lang_object_symbols_statement_enum
:
366 case lang_output_statement_enum
:
367 case lang_target_statement_enum
:
368 case lang_input_section_enum
:
369 case lang_input_statement_enum
:
370 case lang_assignment_statement_enum
:
371 case lang_padding_statement_enum
:
372 case lang_address_statement_enum
:
373 case lang_fill_statement_enum
:
383 lang_for_each_statement (func
)
384 void (*func
) PARAMS ((lang_statement_union_type
*));
386 lang_for_each_statement_worker (func
,
387 statement_list
.head
);
390 /*----------------------------------------------------------------------*/
392 lang_list_init (list
)
393 lang_statement_list_type
*list
;
395 list
->head
= (lang_statement_union_type
*) NULL
;
396 list
->tail
= &list
->head
;
399 /*----------------------------------------------------------------------
401 build a new statement node for the parse tree
406 lang_statement_union_type
*
407 new_statement (type
, size
, list
)
408 enum statement_enum type
;
410 lang_statement_list_type
* list
;
412 lang_statement_union_type
*new = (lang_statement_union_type
*)
415 new->header
.type
= type
;
416 new->header
.next
= (lang_statement_union_type
*) NULL
;
417 lang_statement_append (list
, new, &new->header
.next
);
422 Build a new input file node for the language. There are several ways
423 in which we treat an input file, eg, we only look at symbols, or
424 prefix it with a -l etc.
426 We can be supplied with requests for input files more than once;
427 they may, for example be split over serveral lines like foo.o(.text)
428 foo.o(.data) etc, so when asked for a file we check that we havn't
429 got it already so we don't duplicate the bfd.
432 static lang_input_statement_type
*
433 new_afile (name
, file_type
, target
, add_to_list
)
435 lang_input_file_enum_type file_type
;
439 lang_input_statement_type
*p
;
442 p
= new_stat (lang_input_statement
, stat_ptr
);
445 p
= ((lang_input_statement_type
*)
446 stat_alloc (sizeof (lang_input_statement_type
)));
447 p
->header
.next
= NULL
;
450 lang_has_input_file
= true;
454 case lang_input_file_is_symbols_only_enum
:
456 p
->is_archive
= false;
458 p
->local_sym_name
= name
;
459 p
->just_syms_flag
= true;
460 p
->search_dirs_flag
= false;
462 case lang_input_file_is_fake_enum
:
464 p
->is_archive
= false;
466 p
->local_sym_name
= name
;
467 p
->just_syms_flag
= false;
468 p
->search_dirs_flag
= false;
470 case lang_input_file_is_l_enum
:
471 p
->is_archive
= true;
474 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
475 p
->just_syms_flag
= false;
476 p
->search_dirs_flag
= true;
478 case lang_input_file_is_marker_enum
:
480 p
->is_archive
= false;
482 p
->local_sym_name
= name
;
483 p
->just_syms_flag
= false;
484 p
->search_dirs_flag
= true;
486 case lang_input_file_is_search_file_enum
:
488 p
->is_archive
= false;
490 p
->local_sym_name
= name
;
491 p
->just_syms_flag
= false;
492 p
->search_dirs_flag
= true;
494 case lang_input_file_is_file_enum
:
496 p
->is_archive
= false;
498 p
->local_sym_name
= name
;
499 p
->just_syms_flag
= false;
500 p
->search_dirs_flag
= false;
505 p
->the_bfd
= (bfd
*) NULL
;
506 p
->asymbols
= (asymbol
**) NULL
;
507 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
508 p
->next
= (lang_statement_union_type
*) NULL
;
510 p
->dynamic
= config
.dynamic_link
;
511 p
->whole_archive
= whole_archive
;
513 lang_statement_append (&input_file_chain
,
514 (lang_statement_union_type
*) p
,
519 lang_input_statement_type
*
520 lang_add_input_file (name
, file_type
, target
)
522 lang_input_file_enum_type file_type
;
525 lang_has_input_file
= true;
526 return new_afile (name
, file_type
, target
, true);
529 /* Build enough state so that the parser can build its tree */
533 obstack_begin (&stat_obstack
, 1000);
535 stat_ptr
= &statement_list
;
537 lang_list_init (stat_ptr
);
539 lang_list_init (&input_file_chain
);
540 lang_list_init (&lang_output_section_statement
);
541 lang_list_init (&file_chain
);
542 first_file
= lang_add_input_file ((char *) NULL
,
543 lang_input_file_is_marker_enum
,
545 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
547 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
551 /*----------------------------------------------------------------------
552 A region is an area of memory declared with the
553 MEMORY { name:org=exp, len=exp ... }
556 We maintain a list of all the regions here
558 If no regions are specified in the script, then the default is used
559 which is created when looked up to be the entire data space
562 static lang_memory_region_type
*lang_memory_region_list
;
563 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
565 lang_memory_region_type
*
566 lang_memory_region_lookup (name
)
567 CONST
char *CONST name
;
569 lang_memory_region_type
*p
;
571 for (p
= lang_memory_region_list
;
572 p
!= (lang_memory_region_type
*) NULL
;
575 if (strcmp (p
->name
, name
) == 0)
582 /* This code used to always use the first region in the list as the
583 default region. I changed it to instead use a region
584 encompassing all of memory as the default region. This permits
585 NOLOAD sections to work reasonably without requiring a region.
586 People should specify what region they mean, if they really want
588 if (strcmp (name
, "*default*") == 0)
590 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
592 return lang_memory_region_list
;
598 lang_memory_region_type
*new =
599 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
601 new->name
= buystring (name
);
602 new->next
= (lang_memory_region_type
*) NULL
;
604 *lang_memory_region_list_tail
= new;
605 lang_memory_region_list_tail
= &new->next
;
609 new->length
= ~(bfd_size_type
)0;
611 new->had_full_message
= false;
618 lang_memory_region_type
*
619 lang_memory_default (section
)
622 lang_memory_region_type
*p
;
624 flagword sec_flags
= section
->flags
;
626 /* Override SEC_DATA to mean a writable section. */
627 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
628 sec_flags
|= SEC_DATA
;
630 for (p
= lang_memory_region_list
;
631 p
!= (lang_memory_region_type
*) NULL
;
634 if ((p
->flags
& sec_flags
) != 0
635 && (p
->not_flags
& sec_flags
) == 0)
640 return lang_memory_region_lookup ("*default*");
643 lang_output_section_statement_type
*
644 lang_output_section_find (name
)
645 CONST
char *CONST name
;
647 lang_statement_union_type
*u
;
648 lang_output_section_statement_type
*lookup
;
650 for (u
= lang_output_section_statement
.head
;
651 u
!= (lang_statement_union_type
*) NULL
;
654 lookup
= &u
->output_section_statement
;
655 if (strcmp (name
, lookup
->name
) == 0)
660 return (lang_output_section_statement_type
*) NULL
;
663 lang_output_section_statement_type
*
664 lang_output_section_statement_lookup (name
)
665 CONST
char *CONST name
;
667 lang_output_section_statement_type
*lookup
;
669 lookup
= lang_output_section_find (name
);
670 if (lookup
== (lang_output_section_statement_type
*) NULL
)
673 lookup
= (lang_output_section_statement_type
*)
674 new_stat (lang_output_section_statement
, stat_ptr
);
675 lookup
->region
= (lang_memory_region_type
*) NULL
;
677 lookup
->block_value
= 1;
680 lookup
->next
= (lang_statement_union_type
*) NULL
;
681 lookup
->bfd_section
= (asection
*) NULL
;
682 lookup
->processed
= false;
683 lookup
->sectype
= normal_section
;
684 lookup
->addr_tree
= (etree_type
*) NULL
;
685 lang_list_init (&lookup
->children
);
687 lookup
->memspec
= (CONST
char *) NULL
;
689 lookup
->subsection_alignment
= -1;
690 lookup
->section_alignment
= -1;
691 lookup
->load_base
= (union etree_union
*) NULL
;
692 lookup
->phdrs
= NULL
;
694 lang_statement_append (&lang_output_section_statement
,
695 (lang_statement_union_type
*) lookup
,
702 lang_map_flags (flag
)
705 if (flag
& SEC_ALLOC
)
711 if (flag
& SEC_READONLY
)
724 lang_memory_region_type
*m
;
726 minfo (_("\nMemory Configuration\n\n"));
727 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
728 _("Name"), _("Origin"), _("Length"), _("Attributes"));
730 for (m
= lang_memory_region_list
;
731 m
!= (lang_memory_region_type
*) NULL
;
737 fprintf (config
.map_file
, "%-16s ", m
->name
);
739 sprintf_vma (buf
, m
->origin
);
740 minfo ("0x%s ", buf
);
748 minfo ("0x%V", m
->length
);
749 if (m
->flags
|| m
->not_flags
)
757 lang_map_flags (m
->flags
);
763 lang_map_flags (m
->not_flags
);
770 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
775 /* Initialize an output section. */
779 lang_output_section_statement_type
*s
;
781 section_userdata_type
*new;
783 if (s
->bfd_section
!= NULL
)
786 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
787 einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME
);
789 new = ((section_userdata_type
*)
790 stat_alloc (sizeof (section_userdata_type
)));
792 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
793 if (s
->bfd_section
== (asection
*) NULL
)
794 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
795 if (s
->bfd_section
== (asection
*) NULL
)
797 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
798 output_bfd
->xvec
->name
, s
->name
);
800 s
->bfd_section
->output_section
= s
->bfd_section
;
802 /* We initialize an output sections output offset to minus its own */
803 /* vma to allow us to output a section through itself */
804 s
->bfd_section
->output_offset
= 0;
805 get_userdata (s
->bfd_section
) = (PTR
) new;
807 /* If there is a base address, make sure that any sections it might
808 mention are initialized. */
809 if (s
->addr_tree
!= NULL
)
810 exp_init_os (s
->addr_tree
);
813 /* Make sure that all output sections mentioned in an expression are
820 switch (exp
->type
.node_class
)
823 exp_init_os (exp
->assign
.src
);
827 exp_init_os (exp
->binary
.lhs
);
828 exp_init_os (exp
->binary
.rhs
);
832 exp_init_os (exp
->trinary
.cond
);
833 exp_init_os (exp
->trinary
.lhs
);
834 exp_init_os (exp
->trinary
.rhs
);
838 exp_init_os (exp
->unary
.child
);
842 switch (exp
->type
.node_code
)
848 lang_output_section_statement_type
*os
;
850 os
= lang_output_section_find (exp
->name
.name
);
851 if (os
!= NULL
&& os
->bfd_section
== NULL
)
862 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
863 once into the output. This routine checks each sections, and
864 arranges to discard it if a section of the same name has already
865 been linked. This code assumes that all relevant sections have the
866 SEC_LINK_ONCE flag set; that is, it does not depend solely upon the
867 section name. This is called via bfd_map_over_sections. */
871 section_already_linked (abfd
, sec
, data
)
876 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
879 struct sec_link_once
*next
;
882 static struct sec_link_once
*sec_link_once_list
;
885 struct sec_link_once
*l
;
887 /* If we are only reading symbols from this object, then we want to
888 discard all sections. */
889 if (entry
->just_syms_flag
)
891 sec
->output_section
= bfd_abs_section_ptr
;
892 sec
->output_offset
= sec
->vma
;
896 flags
= bfd_get_section_flags (abfd
, sec
);
898 if ((flags
& SEC_LINK_ONCE
) == 0)
901 /* FIXME: When doing a relocateable link, we may have trouble
902 copying relocations in other sections that refer to local symbols
903 in the section being discarded. Those relocations will have to
904 be converted somehow; as of this writing I'm not sure that any of
905 the backends handle that correctly.
907 It is tempting to instead not discard link once sections when
908 doing a relocateable link (technically, they should be discarded
909 whenever we are building constructors). However, that fails,
910 because the linker winds up combining all the link once sections
911 into a single large link once section, which defeats the purpose
912 of having link once sections in the first place.
914 Also, not merging link once sections in a relocateable link
915 causes trouble for MIPS ELF, which relies in link once semantics
916 to handle the .reginfo section correctly. */
918 name
= bfd_get_section_name (abfd
, sec
);
920 for (l
= sec_link_once_list
; l
!= NULL
; l
= l
->next
)
922 if (strcmp (name
, bfd_get_section_name (l
->sec
->owner
, l
->sec
)) == 0)
924 /* The section has already been linked. See if we should
926 switch (flags
& SEC_LINK_DUPLICATES
)
931 case SEC_LINK_DUPLICATES_DISCARD
:
934 case SEC_LINK_DUPLICATES_ONE_ONLY
:
935 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
939 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
940 /* FIXME: We should really dig out the contents of both
941 sections and memcmp them. The COFF/PE spec says that
942 the Microsoft linker does not implement this
943 correctly, so I'm not going to bother doing it
946 case SEC_LINK_DUPLICATES_SAME_SIZE
:
947 if (bfd_section_size (abfd
, sec
)
948 != bfd_section_size (l
->sec
->owner
, l
->sec
))
949 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
954 /* Set the output_section field so that wild_doit does not
955 create a lang_input_section structure for this section. */
956 sec
->output_section
= bfd_abs_section_ptr
;
962 /* This is the first section with this name. Record it. */
964 l
= (struct sec_link_once
*) xmalloc (sizeof *l
);
966 l
->next
= sec_link_once_list
;
967 sec_link_once_list
= l
;
970 /* The wild routines.
972 These expand statements like *(.text) and foo.o to a list of
973 explicit actions, like foo.o(.text), bar.o(.text) and
974 foo.o(.text, .data). */
976 /* Return true if the PATTERN argument is a wildcard pattern.
977 Although backslashes are treated specially if a pattern contains
978 wildcards, we do not consider the mere presence of a backslash to
979 be enough to cause the the pattern to be treated as a wildcard.
980 That lets us handle DOS filenames more naturally. */
988 for (s
= pattern
; *s
!= '\0'; ++s
)
996 /* Add SECTION to the output section OUTPUT. Do this by creating a
997 lang_input_section statement which is placed at PTR. FILE is the
998 input file which holds SECTION. */
1001 wild_doit (ptr
, section
, output
, file
)
1002 lang_statement_list_type
*ptr
;
1004 lang_output_section_statement_type
*output
;
1005 lang_input_statement_type
*file
;
1010 flags
= bfd_get_section_flags (section
->owner
, section
);
1014 /* If we are doing a final link, discard sections marked with
1016 if (! link_info
.relocateable
1017 && (flags
& SEC_EXCLUDE
) != 0)
1020 /* Discard input sections which are assigned to a section named
1021 DISCARD_SECTION_NAME. */
1022 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1025 /* Discard debugging sections if we are stripping debugging
1027 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1028 && (flags
& SEC_DEBUGGING
) != 0)
1033 if (section
->output_section
== NULL
)
1035 /* This prevents future calls from assigning this section. */
1036 section
->output_section
= bfd_abs_section_ptr
;
1041 if (section
->output_section
== NULL
)
1044 lang_input_section_type
*new;
1047 if (output
->bfd_section
== NULL
)
1055 /* Add a section reference to the list */
1056 new = new_stat (lang_input_section
, ptr
);
1058 new->section
= section
;
1060 section
->output_section
= output
->bfd_section
;
1062 flags
= section
->flags
;
1064 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1065 to an output section, because we want to be able to include a
1066 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1067 section (I don't know why we want to do this, but we do).
1068 build_link_order in ldwrite.c handles this case by turning
1069 the embedded SEC_NEVER_LOAD section into a fill. */
1071 flags
&= ~ SEC_NEVER_LOAD
;
1073 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1074 already been processed. One reason to do this is that on pe
1075 format targets, .text$foo sections go into .text and it's odd
1076 to see .text with SEC_LINK_ONCE set. */
1078 if (! link_info
.relocateable
)
1079 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1081 /* If this is not the first input section, and the SEC_READONLY
1082 flag is not currently set, then don't set it just because the
1083 input section has it set. */
1085 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1086 flags
&= ~ SEC_READONLY
;
1088 section
->output_section
->flags
|= flags
;
1090 /* If SEC_READONLY is not set in the input section, then clear
1091 it from the output section. */
1092 if ((section
->flags
& SEC_READONLY
) == 0)
1093 section
->output_section
->flags
&= ~SEC_READONLY
;
1095 switch (output
->sectype
)
1097 case normal_section
:
1102 case overlay_section
:
1103 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1105 case noload_section
:
1106 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1107 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1111 /* Copy over SEC_SMALL_DATA. */
1112 if (section
->flags
& SEC_SMALL_DATA
)
1113 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1115 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1116 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1118 /* If supplied an aligment, then force it. */
1119 if (output
->section_alignment
!= -1)
1120 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1124 /* Handle wildcard sorting. This returns the lang_input_section which
1125 should follow the one we are going to create for SECTION and FILE,
1126 based on the sorting requirements of WILD. It returns NULL if the
1127 new section should just go at the end of the current list. */
1129 static lang_statement_union_type
*
1130 wild_sort (wild
, file
, section
)
1131 lang_wild_statement_type
*wild
;
1132 lang_input_statement_type
*file
;
1135 const char *section_name
;
1136 lang_statement_union_type
*l
;
1138 if (! wild
->filenames_sorted
&& ! wild
->sections_sorted
)
1141 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1142 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->next
)
1144 lang_input_section_type
*ls
;
1146 if (l
->header
.type
!= lang_input_section_enum
)
1148 ls
= &l
->input_section
;
1150 /* Sorting by filename takes precedence over sorting by section
1153 if (wild
->filenames_sorted
)
1155 const char *fn
, *ln
;
1159 /* The PE support for the .idata section as generated by
1160 dlltool assumes that files will be sorted by the name of
1161 the archive and then the name of the file within the
1164 if (file
->the_bfd
!= NULL
1165 && bfd_my_archive (file
->the_bfd
) != NULL
)
1167 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1172 fn
= file
->filename
;
1176 if (ls
->ifile
->the_bfd
!= NULL
1177 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1179 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1184 ln
= ls
->ifile
->filename
;
1188 i
= strcmp (fn
, ln
);
1197 fn
= file
->filename
;
1199 ln
= ls
->ifile
->filename
;
1201 i
= strcmp (fn
, ln
);
1209 /* Here either the files are not sorted by name, or we are
1210 looking at the sections for this file. */
1212 if (wild
->sections_sorted
)
1214 if (strcmp (section_name
,
1215 bfd_get_section_name (ls
->ifile
->the_bfd
,
1225 /* Expand a wild statement for a particular FILE. SECTION may be
1226 NULL, in which case it is a wild card. */
1229 output_section_callback (ptr
, section
, file
, output
)
1230 lang_wild_statement_type
*ptr
;
1232 lang_input_statement_type
*file
;
1235 lang_statement_union_type
*before
;
1237 /* If the wild pattern was marked KEEP, the member sections
1238 should be as well. */
1239 if (ptr
->keep_sections
)
1240 section
->flags
|= SEC_KEEP
;
1242 before
= wild_sort (ptr
, file
, section
);
1244 /* Here BEFORE points to the lang_input_section which
1245 should follow the one we are about to add. If BEFORE
1246 is NULL, then the section should just go at the end
1247 of the current list. */
1250 wild_doit (&ptr
->children
, section
,
1251 (lang_output_section_statement_type
*) output
,
1255 lang_statement_list_type list
;
1256 lang_statement_union_type
**pp
;
1258 lang_list_init (&list
);
1259 wild_doit (&list
, section
,
1260 (lang_output_section_statement_type
*) output
,
1263 /* If we are discarding the section, LIST.HEAD will
1265 if (list
.head
!= NULL
)
1267 ASSERT (list
.head
->next
== NULL
);
1269 for (pp
= &ptr
->children
.head
;
1272 ASSERT (*pp
!= NULL
);
1274 list
.head
->next
= *pp
;
1280 /* This is passed a file name which must have been seen already and
1281 added to the statement tree. We will see if it has been opened
1282 already and had its symbols read. If not then we'll read it. */
1284 static lang_input_statement_type
*
1288 lang_input_statement_type
*search
;
1290 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1291 search
!= (lang_input_statement_type
*) NULL
;
1292 search
= (lang_input_statement_type
*) search
->next_real_file
)
1294 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1296 if (search
->filename
!= (char *) NULL
1297 && name
!= (char *) NULL
1298 && strcmp (search
->filename
, name
) == 0)
1302 if (search
== (lang_input_statement_type
*) NULL
)
1303 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1306 /* If we have already added this file, or this file is not real
1307 (FIXME: can that ever actually happen?) or the name is NULL
1308 (FIXME: can that ever actually happen?) don't add this file. */
1311 || search
->filename
== (const char *) NULL
)
1314 load_symbols (search
, (lang_statement_list_type
*) NULL
);
1319 /* Get the symbols for an input file. */
1322 load_symbols (entry
, place
)
1323 lang_input_statement_type
*entry
;
1324 lang_statement_list_type
*place
;
1331 ldfile_open_file (entry
);
1333 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1334 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1337 lang_statement_list_type
*hold
;
1339 err
= bfd_get_error ();
1340 if (err
== bfd_error_file_ambiguously_recognized
)
1344 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1345 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1346 for (p
= matching
; *p
!= NULL
; p
++)
1350 else if (err
!= bfd_error_file_not_recognized
1352 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1354 bfd_close (entry
->the_bfd
);
1355 entry
->the_bfd
= NULL
;
1357 /* See if the emulation has some special knowledge. */
1359 if (ldemul_unrecognized_file (entry
))
1362 /* Try to interpret the file as a linker script. */
1364 ldfile_open_command_file (entry
->filename
);
1369 ldfile_assumed_script
= true;
1370 parser_input
= input_script
;
1372 ldfile_assumed_script
= false;
1379 if (ldemul_recognized_file (entry
))
1382 /* We don't call ldlang_add_file for an archive. Instead, the
1383 add_symbols entry point will call ldlang_add_file, via the
1384 add_archive_element callback, for each element of the archive
1386 switch (bfd_get_format (entry
->the_bfd
))
1392 ldlang_add_file (entry
);
1393 if (trace_files
|| trace_file_tries
)
1394 info_msg ("%I\n", entry
);
1398 if (entry
->whole_archive
)
1400 bfd
*member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1402 while (member
!= NULL
)
1404 if (! bfd_check_format (member
, bfd_object
))
1405 einfo (_("%F%B: object %B in archive is not object\n"),
1406 entry
->the_bfd
, member
);
1407 if (! ((*link_info
.callbacks
->add_archive_element
)
1408 (&link_info
, member
, "--whole-archive")))
1410 if (! bfd_link_add_symbols (member
, &link_info
))
1411 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1412 member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1416 entry
->loaded
= true;
1422 if (! bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1423 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1425 entry
->loaded
= true;
1430 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1431 indicating that it is a wildcard. Separate lang_input_section
1432 statements are created for each part of the expansion; they are
1433 added after the wild statement S. OUTPUT is the output section. */
1436 wild (s
, section
, file
, target
, output
)
1437 lang_wild_statement_type
*s
;
1438 const char *section
;
1440 const char *target ATTRIBUTE_UNUSED
;
1441 lang_output_section_statement_type
*output
;
1443 walk_wild (s
, section
, file
, output_section_callback
, (void *) output
);
1445 if (section
!= (char *) NULL
1446 && strcmp (section
, "COMMON") == 0
1447 && default_common_section
== NULL
)
1449 /* Remember the section that common is going to in case we later
1450 get something which doesn't know where to put it. */
1451 default_common_section
= output
;
1455 /* Return true iff target is the sought target. */
1457 get_target (target
, data
)
1458 const bfd_target
* target
;
1461 const char * sought
= (const char *) data
;
1463 return strcmp (target
->name
, sought
) == 0;
1466 /* Like strcpy() but convert to lower case as well. */
1474 while ((c
= * src
++) != 0)
1476 if (isupper ((unsigned char) c
))
1485 /* Remove the first occurance of needle (if any) in haystack
1488 strcut (haystack
, needle
)
1492 haystack
= strstr (haystack
, needle
);
1498 for (src
= haystack
+ strlen (needle
); * src
;)
1499 * haystack
++ = * src
++;
1505 /* Compare two target format name strings.
1506 Return a value indicating how "similar" they are. */
1508 name_compare (first
, second
)
1516 copy1
= xmalloc (strlen (first
) + 1);
1517 copy2
= xmalloc (strlen (second
) + 1);
1519 /* Convert the names to lower case. */
1520 stricpy (copy1
, first
);
1521 stricpy (copy2
, second
);
1523 /* Remove and endian strings from the name. */
1524 strcut (copy1
, "big");
1525 strcut (copy1
, "little");
1526 strcut (copy2
, "big");
1527 strcut (copy2
, "little");
1529 /* Return a value based on how many characters match,
1530 starting from the beginning. If both strings are
1531 the same then return 10 * their length. */
1532 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1533 if (copy1
[result
] == 0)
1545 /* Set by closest_target_match() below. */
1546 static const bfd_target
* winner
;
1548 /* Scan all the valid bfd targets looking for one that has the endianness
1549 requirement that was specified on the command line, and is the nearest
1550 match to the original output target. */
1552 closest_target_match (target
, data
)
1553 const bfd_target
* target
;
1556 const bfd_target
* original
= (const bfd_target
*) data
;
1558 if (command_line
.endian
== ENDIAN_BIG
&& target
->byteorder
!= BFD_ENDIAN_BIG
)
1561 if (command_line
.endian
== ENDIAN_LITTLE
&& target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1564 /* Must be the same flavour. */
1565 if (target
->flavour
!= original
->flavour
)
1568 /* If we have not found a potential winner yet, then record this one. */
1575 /* Oh dear, we now have two potential candidates for a successful match.
1576 Compare their names and choose the better one. */
1577 if (name_compare (target
->name
, original
->name
) > name_compare (winner
->name
, original
->name
))
1580 /* Keep on searching until wqe have checked them all. */
1584 /* Return the BFD target format of the first input file. */
1586 get_first_input_target ()
1588 char * target
= NULL
;
1590 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1592 if (s
->header
.type
== lang_input_statement_enum
1595 ldfile_open_file (s
);
1597 if (s
->the_bfd
!= NULL
1598 && bfd_check_format (s
->the_bfd
, bfd_object
))
1600 target
= bfd_get_target (s
->the_bfd
);
1611 /* Open the output file. */
1619 /* Has the user told us which output format to use ? */
1620 if (output_target
== (char *) NULL
)
1622 /* No - has the current target been set to something other than the default ? */
1623 if (current_target
!= default_target
)
1624 output_target
= current_target
;
1626 /* No - can we determine the format of the first input file ? */
1629 output_target
= get_first_input_target ();
1631 /* Failed - use the default output target. */
1632 if (output_target
== NULL
)
1633 output_target
= default_target
;
1637 /* Has the user requested a particular endianness on the command line ? */
1638 if (command_line
.endian
!= ENDIAN_UNSET
)
1640 const bfd_target
* target
;
1643 /* Get the chosen target. */
1644 target
= bfd_search_for_target (get_target
, (void *) output_target
);
1646 if (command_line
.endian
== ENDIAN_BIG
)
1647 desired_endian
= BFD_ENDIAN_BIG
;
1649 desired_endian
= BFD_ENDIAN_LITTLE
;
1651 /* See if the target has the wrong endianness. This should not happen
1652 if the linker script has provided big and little endian alternatives,
1653 but some scrips don't do this. */
1654 if (target
->byteorder
!= desired_endian
)
1656 /* If it does, then see if the target provides
1657 an alternative with the correct endianness. */
1658 if (target
->alternative_target
!= NULL
1659 && (target
->alternative_target
->byteorder
== desired_endian
))
1660 output_target
= target
->alternative_target
->name
;
1663 /* Try to find a target as similar as possible to the default
1664 target, but which has the desired endian characteristic. */
1665 (void) bfd_search_for_target (closest_target_match
, (void *) target
);
1667 /* Oh dear - we could not find any targets that satisfy our requirements. */
1669 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1671 output_target
= winner
->name
;
1676 output
= bfd_openw (name
, output_target
);
1678 if (output
== (bfd
*) NULL
)
1680 if (bfd_get_error () == bfd_error_invalid_target
)
1681 einfo (_("%P%F: target %s not found\n"), output_target
);
1683 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1686 delete_output_file_on_failure
= true;
1688 /* output->flags |= D_PAGED;*/
1690 if (! bfd_set_format (output
, bfd_object
))
1691 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1692 if (! bfd_set_arch_mach (output
,
1693 ldfile_output_architecture
,
1694 ldfile_output_machine
))
1695 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1697 link_info
.hash
= bfd_link_hash_table_create (output
);
1698 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1699 einfo (_("%P%F: can not create link hash table: %E\n"));
1701 bfd_set_gp_size (output
, g_switch_value
);
1706 ldlang_open_output (statement
)
1707 lang_statement_union_type
* statement
;
1709 switch (statement
->header
.type
)
1711 case lang_output_statement_enum
:
1712 ASSERT (output_bfd
== (bfd
*) NULL
);
1713 output_bfd
= open_output (statement
->output_statement
.name
);
1714 ldemul_set_output_arch ();
1715 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1716 output_bfd
->flags
|= D_PAGED
;
1718 output_bfd
->flags
&= ~D_PAGED
;
1719 if (config
.text_read_only
)
1720 output_bfd
->flags
|= WP_TEXT
;
1722 output_bfd
->flags
&= ~WP_TEXT
;
1723 if (link_info
.traditional_format
)
1724 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1726 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1729 case lang_target_statement_enum
:
1730 current_target
= statement
->target_statement
.target
;
1737 /* Open all the input files. */
1740 open_input_bfds (s
, force
)
1741 lang_statement_union_type
*s
;
1744 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1746 switch (s
->header
.type
)
1748 case lang_constructors_statement_enum
:
1749 open_input_bfds (constructor_list
.head
, force
);
1751 case lang_output_section_statement_enum
:
1752 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1754 case lang_wild_statement_enum
:
1755 /* Maybe we should load the file's symbols */
1756 if (s
->wild_statement
.filename
1757 && ! wildcardp (s
->wild_statement
.filename
))
1758 (void) lookup_name (s
->wild_statement
.filename
);
1759 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1761 case lang_group_statement_enum
:
1763 struct bfd_link_hash_entry
*undefs
;
1765 /* We must continually search the entries in the group
1766 until no new symbols are added to the list of undefined
1771 undefs
= link_info
.hash
->undefs_tail
;
1772 open_input_bfds (s
->group_statement
.children
.head
, true);
1774 while (undefs
!= link_info
.hash
->undefs_tail
);
1777 case lang_target_statement_enum
:
1778 current_target
= s
->target_statement
.target
;
1780 case lang_input_statement_enum
:
1781 if (s
->input_statement
.real
)
1783 lang_statement_list_type add
;
1785 s
->input_statement
.target
= current_target
;
1787 /* If we are being called from within a group, and this
1788 is an archive which has already been searched, then
1789 force it to be researched. */
1791 && s
->input_statement
.loaded
1792 && bfd_check_format (s
->input_statement
.the_bfd
,
1794 s
->input_statement
.loaded
= false;
1796 lang_list_init (&add
);
1798 load_symbols (&s
->input_statement
, &add
);
1800 if (add
.head
!= NULL
)
1802 *add
.tail
= s
->next
;
1813 /* If there are [COMMONS] statements, put a wild one into the bss section */
1816 lang_reasonable_defaults ()
1819 lang_output_section_statement_lookup (".text");
1820 lang_output_section_statement_lookup (".data");
1822 default_common_section
=
1823 lang_output_section_statement_lookup (".bss");
1826 if (placed_commons
== false)
1828 lang_wild_statement_type
*new =
1829 new_stat (lang_wild_statement
,
1830 &default_common_section
->children
);
1832 new->section_name
= "COMMON";
1833 new->filename
= (char *) NULL
;
1834 lang_list_init (&new->children
);
1841 Add the supplied name to the symbol table as an undefined reference.
1842 Remove items from the chain as we open input bfds
1844 typedef struct ldlang_undef_chain_list
1846 struct ldlang_undef_chain_list
*next
;
1848 } ldlang_undef_chain_list_type
;
1850 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
1853 ldlang_add_undef (name
)
1854 CONST
char *CONST name
;
1856 ldlang_undef_chain_list_type
*new =
1857 ((ldlang_undef_chain_list_type
*)
1858 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
1860 new->next
= ldlang_undef_chain_list_head
;
1861 ldlang_undef_chain_list_head
= new;
1863 new->name
= buystring (name
);
1866 /* Run through the list of undefineds created above and place them
1867 into the linker hash table as undefined symbols belonging to the
1871 lang_place_undefineds ()
1873 ldlang_undef_chain_list_type
*ptr
;
1875 for (ptr
= ldlang_undef_chain_list_head
;
1876 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
1879 struct bfd_link_hash_entry
*h
;
1881 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
1882 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1883 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1884 if (h
->type
== bfd_link_hash_new
)
1886 h
->type
= bfd_link_hash_undefined
;
1887 h
->u
.undef
.abfd
= NULL
;
1888 bfd_link_add_undef (link_info
.hash
, h
);
1893 /* Open input files and attatch to output sections */
1895 map_input_to_output_sections (s
, target
, output_section_statement
)
1896 lang_statement_union_type
* s
;
1898 lang_output_section_statement_type
* output_section_statement
;
1900 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1902 switch (s
->header
.type
)
1906 case lang_wild_statement_enum
:
1907 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1908 s
->wild_statement
.filename
, target
,
1909 output_section_statement
);
1912 case lang_constructors_statement_enum
:
1913 map_input_to_output_sections (constructor_list
.head
,
1915 output_section_statement
);
1917 case lang_output_section_statement_enum
:
1918 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1920 &s
->output_section_statement
);
1922 case lang_output_statement_enum
:
1924 case lang_target_statement_enum
:
1925 target
= s
->target_statement
.target
;
1927 case lang_group_statement_enum
:
1928 map_input_to_output_sections (s
->group_statement
.children
.head
,
1930 output_section_statement
);
1932 case lang_fill_statement_enum
:
1933 case lang_input_section_enum
:
1934 case lang_object_symbols_statement_enum
:
1935 case lang_data_statement_enum
:
1936 case lang_reloc_statement_enum
:
1937 case lang_padding_statement_enum
:
1938 case lang_input_statement_enum
:
1939 if (output_section_statement
!= NULL
1940 && output_section_statement
->bfd_section
== NULL
)
1941 init_os (output_section_statement
);
1943 case lang_assignment_statement_enum
:
1944 if (output_section_statement
!= NULL
1945 && output_section_statement
->bfd_section
== NULL
)
1946 init_os (output_section_statement
);
1948 /* Make sure that any sections mentioned in the assignment
1950 exp_init_os (s
->assignment_statement
.exp
);
1952 case lang_afile_asection_pair_statement_enum
:
1955 case lang_address_statement_enum
:
1956 /* Mark the specified section with the supplied address */
1958 lang_output_section_statement_type
*os
=
1959 lang_output_section_statement_lookup
1960 (s
->address_statement
.section_name
);
1962 if (os
->bfd_section
== NULL
)
1964 os
->addr_tree
= s
->address_statement
.address
;
1972 print_output_section_statement (output_section_statement
)
1973 lang_output_section_statement_type
* output_section_statement
;
1975 asection
*section
= output_section_statement
->bfd_section
;
1978 if (output_section_statement
!= abs_output_section
)
1980 minfo ("\n%s", output_section_statement
->name
);
1982 if (section
!= NULL
)
1984 print_dot
= section
->vma
;
1986 len
= strlen (output_section_statement
->name
);
1987 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
1992 while (len
< SECTION_NAME_MAP_LENGTH
)
1998 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2000 if (output_section_statement
->load_base
!= NULL
)
2004 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2005 "load base", lang_final_phase_enum
);
2006 minfo (_(" load address 0x%V"), addr
);
2013 print_statement_list (output_section_statement
->children
.head
,
2014 output_section_statement
);
2018 print_assignment (assignment
, output_section
)
2019 lang_assignment_statement_type
* assignment
;
2020 lang_output_section_statement_type
* output_section
;
2023 etree_value_type result
;
2025 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2028 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2029 lang_final_phase_enum
, print_dot
, &print_dot
);
2031 minfo ("0x%V", result
.value
+ result
.section
->bfd_section
->vma
);
2042 exp_print_tree (assignment
->exp
);
2048 print_input_statement (statm
)
2049 lang_input_statement_type
* statm
;
2051 if (statm
->filename
!= (char *) NULL
)
2053 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2057 /* Print all symbols defined in a particular section. This is called
2058 via bfd_link_hash_traverse. */
2061 print_one_symbol (hash_entry
, ptr
)
2062 struct bfd_link_hash_entry
*hash_entry
;
2065 asection
*sec
= (asection
*) ptr
;
2067 if ((hash_entry
->type
== bfd_link_hash_defined
2068 || hash_entry
->type
== bfd_link_hash_defweak
)
2069 && sec
== hash_entry
->u
.def
.section
)
2073 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2076 (hash_entry
->u
.def
.value
2077 + hash_entry
->u
.def
.section
->output_offset
2078 + hash_entry
->u
.def
.section
->output_section
->vma
));
2080 minfo (" %T\n", hash_entry
->root
.string
);
2086 /* Print information about an input section to the map file. */
2089 print_input_section (in
)
2090 lang_input_section_type
* in
;
2092 asection
*i
= in
->section
;
2093 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2099 minfo ("%s", i
->name
);
2101 if (i
->output_section
!= NULL
)
2105 len
= 1 + strlen (i
->name
);
2106 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2111 while (len
< SECTION_NAME_MAP_LENGTH
)
2117 minfo ("0x%V %W %B\n",
2118 i
->output_section
->vma
+ i
->output_offset
, size
,
2121 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2123 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2135 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2138 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2140 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
;
2146 print_fill_statement (fill
)
2147 lang_fill_statement_type
* fill
;
2149 fprintf (config
.map_file
, " FILL mask 0x%x\n", fill
->fill
);
2153 print_data_statement (data
)
2154 lang_data_statement_type
* data
;
2161 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2164 addr
= data
->output_vma
;
2165 if (data
->output_section
!= NULL
)
2166 addr
+= data
->output_section
->vma
;
2194 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2196 if (data
->exp
->type
.node_class
!= etree_value
)
2199 exp_print_tree (data
->exp
);
2204 print_dot
= addr
+ size
;
2207 /* Print an address statement. These are generated by options like
2211 print_address_statement (address
)
2212 lang_address_statement_type
*address
;
2214 minfo (_("Address of section %s set to "), address
->section_name
);
2215 exp_print_tree (address
->address
);
2219 /* Print a reloc statement. */
2222 print_reloc_statement (reloc
)
2223 lang_reloc_statement_type
*reloc
;
2229 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2232 addr
= reloc
->output_vma
;
2233 if (reloc
->output_section
!= NULL
)
2234 addr
+= reloc
->output_section
->vma
;
2236 size
= bfd_get_reloc_size (reloc
->howto
);
2238 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2240 if (reloc
->name
!= NULL
)
2241 minfo ("%s+", reloc
->name
);
2243 minfo ("%s+", reloc
->section
->name
);
2245 exp_print_tree (reloc
->addend_exp
);
2249 print_dot
= addr
+ size
;
2253 print_padding_statement (s
)
2254 lang_padding_statement_type
*s
;
2261 len
= sizeof " *fill*" - 1;
2262 while (len
< SECTION_NAME_MAP_LENGTH
)
2268 addr
= s
->output_offset
;
2269 if (s
->output_section
!= NULL
)
2270 addr
+= s
->output_section
->vma
;
2271 minfo ("0x%V %W", addr
, s
->size
);
2274 minfo (" %u", s
->fill
);
2278 print_dot
= addr
+ s
->size
;
2282 print_wild_statement (w
, os
)
2283 lang_wild_statement_type
* w
;
2284 lang_output_section_statement_type
* os
;
2288 if (w
->filenames_sorted
)
2290 if (w
->exclude_filename
!= NULL
)
2291 minfo ("EXCLUDE_FILE ( %s )", w
->exclude_filename
);
2292 if (w
->filename
!= NULL
)
2293 minfo ("%s", w
->filename
);
2296 if (w
->filenames_sorted
)
2300 if (w
->sections_sorted
)
2302 if (w
->section_name
!= NULL
)
2303 minfo ("%s", w
->section_name
);
2306 if (w
->sections_sorted
)
2312 print_statement_list (w
->children
.head
, os
);
2315 /* Print a group statement. */
2319 lang_group_statement_type
*s
;
2320 lang_output_section_statement_type
*os
;
2322 fprintf (config
.map_file
, "START GROUP\n");
2323 print_statement_list (s
->children
.head
, os
);
2324 fprintf (config
.map_file
, "END GROUP\n");
2327 /* Print the list of statements in S.
2328 This can be called for any statement type. */
2331 print_statement_list (s
, os
)
2332 lang_statement_union_type
*s
;
2333 lang_output_section_statement_type
*os
;
2337 print_statement (s
, os
);
2342 /* Print the first statement in statement list S.
2343 This can be called for any statement type. */
2346 print_statement (s
, os
)
2347 lang_statement_union_type
*s
;
2348 lang_output_section_statement_type
*os
;
2350 switch (s
->header
.type
)
2353 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2356 case lang_constructors_statement_enum
:
2357 if (constructor_list
.head
!= NULL
)
2359 if (constructors_sorted
)
2360 minfo (" SORT (CONSTRUCTORS)\n");
2362 minfo (" CONSTRUCTORS\n");
2363 print_statement_list (constructor_list
.head
, os
);
2366 case lang_wild_statement_enum
:
2367 print_wild_statement (&s
->wild_statement
, os
);
2369 case lang_address_statement_enum
:
2370 print_address_statement (&s
->address_statement
);
2372 case lang_object_symbols_statement_enum
:
2373 minfo (" CREATE_OBJECT_SYMBOLS\n");
2375 case lang_fill_statement_enum
:
2376 print_fill_statement (&s
->fill_statement
);
2378 case lang_data_statement_enum
:
2379 print_data_statement (&s
->data_statement
);
2381 case lang_reloc_statement_enum
:
2382 print_reloc_statement (&s
->reloc_statement
);
2384 case lang_input_section_enum
:
2385 print_input_section (&s
->input_section
);
2387 case lang_padding_statement_enum
:
2388 print_padding_statement (&s
->padding_statement
);
2390 case lang_output_section_statement_enum
:
2391 print_output_section_statement (&s
->output_section_statement
);
2393 case lang_assignment_statement_enum
:
2394 print_assignment (&s
->assignment_statement
, os
);
2396 case lang_target_statement_enum
:
2397 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2399 case lang_output_statement_enum
:
2400 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2401 if (output_target
!= NULL
)
2402 minfo (" %s", output_target
);
2405 case lang_input_statement_enum
:
2406 print_input_statement (&s
->input_statement
);
2408 case lang_group_statement_enum
:
2409 print_group (&s
->group_statement
, os
);
2411 case lang_afile_asection_pair_statement_enum
:
2420 print_statement_list (statement_list
.head
, abs_output_section
);
2423 /* Print the first N statements in statement list S to STDERR.
2424 If N == 0, nothing is printed.
2425 If N < 0, the entire list is printed.
2426 Intended to be called from GDB. */
2429 dprint_statement (s
, n
)
2430 lang_statement_union_type
* s
;
2433 FILE *map_save
= config
.map_file
;
2435 config
.map_file
= stderr
;
2438 print_statement_list (s
, abs_output_section
);
2441 while (s
&& --n
>= 0)
2443 print_statement (s
, abs_output_section
);
2448 config
.map_file
= map_save
;
2452 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
2453 lang_statement_union_type
** this_ptr
;
2456 asection
* output_section_statement
;
2459 /* Align this section first to the
2460 input sections requirement, then
2461 to the output section's requirement.
2462 If this alignment is > than any seen before,
2463 then record it too. Perform the alignment by
2464 inserting a magic 'padding' statement.
2467 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
2469 if (alignment_needed
!= 0)
2471 lang_statement_union_type
*new =
2472 ((lang_statement_union_type
*)
2473 stat_alloc (sizeof (lang_padding_statement_type
)));
2475 /* Link into existing chain */
2476 new->header
.next
= *this_ptr
;
2478 new->header
.type
= lang_padding_statement_enum
;
2479 new->padding_statement
.output_section
= output_section_statement
;
2480 new->padding_statement
.output_offset
=
2481 dot
- output_section_statement
->vma
;
2482 new->padding_statement
.fill
= fill
;
2483 new->padding_statement
.size
= alignment_needed
;
2487 /* Remember the most restrictive alignment */
2488 if (power
> output_section_statement
->alignment_power
)
2490 output_section_statement
->alignment_power
= power
;
2492 output_section_statement
->_raw_size
+= alignment_needed
;
2493 return alignment_needed
+ dot
;
2497 /* Work out how much this section will move the dot point */
2499 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
2500 lang_statement_union_type
** this_ptr
;
2501 lang_output_section_statement_type
* output_section_statement
;
2504 boolean relax ATTRIBUTE_UNUSED
;
2506 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2507 asection
*i
= is
->section
;
2509 if (is
->ifile
->just_syms_flag
== false)
2511 if (output_section_statement
->subsection_alignment
!= -1)
2512 i
->alignment_power
=
2513 output_section_statement
->subsection_alignment
;
2515 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
2516 output_section_statement
->bfd_section
, dot
);
2518 /* Remember where in the output section this input section goes */
2520 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
2522 /* Mark how big the output section must be to contain this now
2524 if (i
->_cooked_size
!= 0)
2525 dot
+= i
->_cooked_size
;
2527 dot
+= i
->_raw_size
;
2528 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
2532 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2538 /* Check to see if any allocated sections overlap with other allocated
2539 sections. This can happen when the linker script specifically specifies
2540 the output section addresses of the two sections. */
2542 lang_check_section_addresses ()
2546 /* Scan all sections in the output list. */
2547 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2548 /* Ignore sections which are not loaded or which have no contents. */
2549 if ((bfd_get_section_flags (output_bfd
, s
) & (SEC_ALLOC
| SEC_LOAD
))
2550 && bfd_section_size (output_bfd
, s
) != 0)
2554 /* Once we reach section 's' stop our seach. This prevents two
2555 warning messages from being produced, one for 'section A overlaps
2556 section B' and one for 'section B overlaps section A'. */
2557 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2564 /* Only consider loadable sections with real contents. */
2565 if (((bfd_get_section_flags (output_bfd
, os
)
2566 & (SEC_ALLOC
| SEC_LOAD
)) == 0)
2567 || bfd_section_size (output_bfd
, os
) == 0)
2570 /* We must check the sections' LMA addresses not their
2571 VMA addresses because overlay sections can have
2572 overlapping VMAs but they must have distinct LMAs. */
2573 s_start
= bfd_section_lma (output_bfd
, s
);
2574 os_start
= bfd_section_lma (output_bfd
, os
);
2575 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) - 1;
2576 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) - 1;
2578 /* Look for an overlap. */
2579 if ((s_end
< os_start
) || (s_start
> os_end
))
2583 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2584 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2586 /* Once we have found one overlap for this section,
2587 stop looking for others. */
2593 /* This variable indicates whether bfd_relax_section should be called
2596 static boolean relax_again
;
2598 /* Set the sizes for all the output sections. */
2601 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2602 lang_statement_union_type
* s
;
2603 lang_output_section_statement_type
* output_section_statement
;
2604 lang_statement_union_type
** prev
;
2609 /* Size up the sections from their constituent parts. */
2610 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2612 switch (s
->header
.type
)
2614 case lang_output_section_statement_enum
:
2617 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
2619 if (os
->bfd_section
== NULL
)
2620 /* This section was never actually created. */
2623 /* If this is a COFF shared library section, use the size and
2624 address from the input section. FIXME: This is COFF
2625 specific; it would be cleaner if there were some other way
2626 to do this, but nothing simple comes to mind. */
2627 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2631 if (os
->children
.head
== NULL
2632 || os
->children
.head
->next
!= NULL
2633 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2634 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2637 input
= os
->children
.head
->input_section
.section
;
2638 bfd_set_section_vma (os
->bfd_section
->owner
,
2640 bfd_section_vma (input
->owner
, input
));
2641 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2645 if (bfd_is_abs_section (os
->bfd_section
))
2647 /* No matter what happens, an abs section starts at zero. */
2648 ASSERT (os
->bfd_section
->vma
== 0);
2652 if (os
->addr_tree
== (etree_type
*) NULL
)
2654 /* No address specified for this section, get one
2655 from the region specification. */
2656 if (os
->region
== (lang_memory_region_type
*) NULL
2657 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2658 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2659 && os
->region
->name
[0] == '*'
2660 && strcmp (os
->region
->name
, "*default*") == 0))
2662 os
->region
= lang_memory_default (os
->bfd_section
);
2665 /* If a loadable section is using the default memory
2666 region, and some non default memory regions were
2667 defined, issue a warning. */
2668 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2669 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2670 && ! link_info
.relocateable
2671 && strcmp (os
->region
->name
, "*default*") == 0
2672 && lang_memory_region_list
!= NULL
2673 && (strcmp (lang_memory_region_list
->name
, "*default*") != 0
2674 || lang_memory_region_list
->next
!= NULL
))
2675 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2676 bfd_get_section_name (output_bfd
, os
->bfd_section
));
2678 dot
= os
->region
->current
;
2680 if (os
->section_alignment
== -1)
2685 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
2687 if (dot
!= olddot
&& config
.warn_section_align
)
2688 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2689 os
->name
, (unsigned int) (dot
- olddot
));
2696 r
= exp_fold_tree (os
->addr_tree
,
2698 lang_allocating_phase_enum
,
2700 if (r
.valid_p
== false)
2702 einfo (_("%F%S: non constant address expression for section %s\n"),
2705 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2708 /* The section starts here.
2709 First, align to what the section needs. */
2711 if (os
->section_alignment
!= -1)
2712 dot
= align_power (dot
, os
->section_alignment
);
2714 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2716 os
->bfd_section
->output_offset
= 0;
2719 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
2720 os
->fill
, dot
, relax
);
2722 /* Ignore the size of the input sections, use the vma and size to
2725 after
= ALIGN_N (os
->bfd_section
->vma
+
2726 os
->bfd_section
->_raw_size
,
2727 /* The coercion here is important, see ld.h. */
2728 (bfd_vma
) os
->block_value
);
2730 if (bfd_is_abs_section (os
->bfd_section
))
2731 ASSERT (after
== os
->bfd_section
->vma
);
2733 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
2734 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
2735 os
->processed
= true;
2737 /* Update dot in the region ?
2738 We only do this if the section is going to be allocated,
2739 since unallocated sections do not contribute to the region's
2740 overall size in memory. */
2741 if (os
->region
!= (lang_memory_region_type
*) NULL
2742 && (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2743 & (SEC_ALLOC
| SEC_LOAD
)))
2745 os
->region
->current
= dot
;
2747 /* Make sure the new address is within the region. We
2748 explicitly permit the current address to be at the
2749 exact end of the region when the VMA is non-zero,
2750 in case the region is at the end of addressable
2751 memory and the calculation wraps around. */
2752 if ((os
->region
->current
< os
->region
->origin
2753 || (os
->region
->current
- os
->region
->origin
2754 > os
->region
->length
))
2755 && ((os
->region
->current
2756 != os
->region
->origin
+ os
->region
->length
)
2757 || os
->bfd_section
->vma
== 0))
2760 if (os
->addr_tree
!= (etree_type
*) NULL
)
2762 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2763 os
->region
->current
,
2764 os
->bfd_section
->owner
,
2765 os
->bfd_section
->name
,
2770 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2772 os
->bfd_section
->owner
,
2773 os
->bfd_section
->name
);
2775 /* Reset the region pointer. */
2776 os
->region
->current
= os
->region
->origin
;
2782 case lang_constructors_statement_enum
:
2783 dot
= lang_size_sections (constructor_list
.head
,
2784 output_section_statement
,
2785 &s
->wild_statement
.children
.head
,
2790 case lang_data_statement_enum
:
2792 unsigned int size
= 0;
2794 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
2795 s
->data_statement
.output_section
=
2796 output_section_statement
->bfd_section
;
2798 switch (s
->data_statement
.type
)
2816 output_section_statement
->bfd_section
->_raw_size
+= size
;
2817 /* The output section gets contents, and then we inspect for
2818 any flags set in the input script which override any ALLOC. */
2819 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
2820 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
)) {
2821 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
| SEC_LOAD
;
2826 case lang_reloc_statement_enum
:
2830 s
->reloc_statement
.output_vma
=
2831 dot
- output_section_statement
->bfd_section
->vma
;
2832 s
->reloc_statement
.output_section
=
2833 output_section_statement
->bfd_section
;
2834 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
2836 output_section_statement
->bfd_section
->_raw_size
+= size
;
2840 case lang_wild_statement_enum
:
2842 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
2843 output_section_statement
,
2844 &s
->wild_statement
.children
.head
,
2850 case lang_object_symbols_statement_enum
:
2851 link_info
.create_object_symbols_section
=
2852 output_section_statement
->bfd_section
;
2854 case lang_output_statement_enum
:
2855 case lang_target_statement_enum
:
2857 case lang_input_section_enum
:
2861 i
= (*prev
)->input_section
.section
;
2864 if (i
->_cooked_size
== 0)
2865 i
->_cooked_size
= i
->_raw_size
;
2871 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
2872 einfo (_("%P%F: can't relax section: %E\n"));
2876 dot
= size_input_section (prev
,
2877 output_section_statement
,
2878 output_section_statement
->fill
,
2882 case lang_input_statement_enum
:
2884 case lang_fill_statement_enum
:
2885 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
2887 fill
= s
->fill_statement
.fill
;
2889 case lang_assignment_statement_enum
:
2891 bfd_vma newdot
= dot
;
2893 exp_fold_tree (s
->assignment_statement
.exp
,
2894 output_section_statement
,
2895 lang_allocating_phase_enum
,
2901 /* The assignment changed dot. Insert a pad. */
2902 if (output_section_statement
== abs_output_section
)
2904 /* If we don't have an output section, then just adjust
2905 the default memory address. */
2906 lang_memory_region_lookup ("*default*")->current
= newdot
;
2910 lang_statement_union_type
*new =
2911 ((lang_statement_union_type
*)
2912 stat_alloc (sizeof (lang_padding_statement_type
)));
2914 /* Link into existing chain. */
2915 new->header
.next
= *prev
;
2917 new->header
.type
= lang_padding_statement_enum
;
2918 new->padding_statement
.output_section
=
2919 output_section_statement
->bfd_section
;
2920 new->padding_statement
.output_offset
=
2921 dot
- output_section_statement
->bfd_section
->vma
;
2922 new->padding_statement
.fill
= fill
;
2923 new->padding_statement
.size
= newdot
- dot
;
2924 output_section_statement
->bfd_section
->_raw_size
+=
2925 new->padding_statement
.size
;
2933 case lang_padding_statement_enum
:
2934 /* If we are relaxing, and this is not the first pass, some
2935 padding statements may have been inserted during previous
2936 passes. We may have to move the padding statement to a new
2937 location if dot has a different value at this point in this
2938 pass than it did at this point in the previous pass. */
2939 s
->padding_statement
.output_offset
=
2940 dot
- output_section_statement
->bfd_section
->vma
;
2941 dot
+= s
->padding_statement
.size
;
2942 output_section_statement
->bfd_section
->_raw_size
+=
2943 s
->padding_statement
.size
;
2946 case lang_group_statement_enum
:
2947 dot
= lang_size_sections (s
->group_statement
.children
.head
,
2948 output_section_statement
,
2949 &s
->group_statement
.children
.head
,
2957 /* This can only get here when relaxing is turned on. */
2959 case lang_address_statement_enum
:
2962 prev
= &s
->header
.next
;
2968 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
2969 lang_statement_union_type
* s
;
2970 lang_output_section_statement_type
* output_section_statement
;
2974 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2976 switch (s
->header
.type
)
2978 case lang_constructors_statement_enum
:
2979 dot
= lang_do_assignments (constructor_list
.head
,
2980 output_section_statement
,
2985 case lang_output_section_statement_enum
:
2987 lang_output_section_statement_type
*os
=
2988 &(s
->output_section_statement
);
2990 if (os
->bfd_section
!= NULL
)
2992 dot
= os
->bfd_section
->vma
;
2993 (void) lang_do_assignments (os
->children
.head
, os
,
2995 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
2999 /* If nothing has been placed into the output section then
3000 it won't have a bfd_section. */
3001 if (os
->bfd_section
)
3003 os
->bfd_section
->lma
3004 = exp_get_abs_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
3009 case lang_wild_statement_enum
:
3011 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3012 output_section_statement
,
3017 case lang_object_symbols_statement_enum
:
3018 case lang_output_statement_enum
:
3019 case lang_target_statement_enum
:
3021 case lang_common_statement_enum
:
3024 case lang_data_statement_enum
:
3026 etree_value_type value
;
3028 value
= exp_fold_tree (s
->data_statement
.exp
,
3030 lang_final_phase_enum
, dot
, &dot
);
3031 s
->data_statement
.value
= value
.value
;
3032 if (value
.valid_p
== false)
3033 einfo (_("%F%P: invalid data statement\n"));
3035 switch (s
->data_statement
.type
)
3053 case lang_reloc_statement_enum
:
3055 etree_value_type value
;
3057 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3059 lang_final_phase_enum
, dot
, &dot
);
3060 s
->reloc_statement
.addend_value
= value
.value
;
3061 if (value
.valid_p
== false)
3062 einfo (_("%F%P: invalid reloc statement\n"));
3064 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3067 case lang_input_section_enum
:
3069 asection
*in
= s
->input_section
.section
;
3071 if (in
->_cooked_size
!= 0)
3072 dot
+= in
->_cooked_size
;
3074 dot
+= in
->_raw_size
;
3078 case lang_input_statement_enum
:
3080 case lang_fill_statement_enum
:
3081 fill
= s
->fill_statement
.fill
;
3083 case lang_assignment_statement_enum
:
3085 exp_fold_tree (s
->assignment_statement
.exp
,
3086 output_section_statement
,
3087 lang_final_phase_enum
,
3093 case lang_padding_statement_enum
:
3094 dot
+= s
->padding_statement
.size
;
3097 case lang_group_statement_enum
:
3098 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3099 output_section_statement
,
3107 case lang_address_statement_enum
:
3115 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3116 operator .startof. (section_name), it produces an undefined symbol
3117 .startof.section_name. Similarly, when it sees
3118 .sizeof. (section_name), it produces an undefined symbol
3119 .sizeof.section_name. For all the output sections, we look for
3120 such symbols, and set them to the correct value. */
3127 if (link_info
.relocateable
)
3130 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3132 const char *secname
;
3134 struct bfd_link_hash_entry
*h
;
3136 secname
= bfd_get_section_name (output_bfd
, s
);
3137 buf
= xmalloc (10 + strlen (secname
));
3139 sprintf (buf
, ".startof.%s", secname
);
3140 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3141 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3143 h
->type
= bfd_link_hash_defined
;
3144 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3145 h
->u
.def
.section
= bfd_abs_section_ptr
;
3148 sprintf (buf
, ".sizeof.%s", secname
);
3149 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3150 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3152 h
->type
= bfd_link_hash_defined
;
3153 if (s
->_cooked_size
!= 0)
3154 h
->u
.def
.value
= s
->_cooked_size
;
3156 h
->u
.def
.value
= s
->_raw_size
;
3157 h
->u
.def
.section
= bfd_abs_section_ptr
;
3167 struct bfd_link_hash_entry
*h
;
3170 if (link_info
.relocateable
|| link_info
.shared
)
3175 if (entry_symbol
== (char *) NULL
)
3177 /* No entry has been specified. Look for start, but don't warn
3178 if we don't find it. */
3179 entry_symbol
= "start";
3183 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
3184 if (h
!= (struct bfd_link_hash_entry
*) NULL
3185 && (h
->type
== bfd_link_hash_defined
3186 || h
->type
== bfd_link_hash_defweak
)
3187 && h
->u
.def
.section
->output_section
!= NULL
)
3191 val
= (h
->u
.def
.value
3192 + bfd_get_section_vma (output_bfd
,
3193 h
->u
.def
.section
->output_section
)
3194 + h
->u
.def
.section
->output_offset
);
3195 if (! bfd_set_start_address (output_bfd
, val
))
3196 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
);
3203 /* We couldn't find the entry symbol. Try parsing it as a
3205 val
= bfd_scan_vma (entry_symbol
, &send
, 0);
3208 if (! bfd_set_start_address (output_bfd
, val
))
3209 einfo (_("%P%F: can't set start address\n"));
3215 /* Can't find the entry symbol, and it's not a number. Use
3216 the first address in the text section. */
3217 ts
= bfd_get_section_by_name (output_bfd
, ".text");
3218 if (ts
!= (asection
*) NULL
)
3221 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3222 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
3223 if (! bfd_set_start_address (output_bfd
,
3224 bfd_get_section_vma (output_bfd
,
3226 einfo (_("%P%F: can't set start address\n"));
3231 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3238 /* This is a small function used when we want to ignore errors from
3242 #ifdef ANSI_PROTOTYPES
3243 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3245 ignore_bfd_errors (s
)
3246 const char *s ATTRIBUTE_UNUSED
;
3249 /* Don't do anything. */
3252 /* Check that the architecture of all the input files is compatible
3253 with the output file. Also call the backend to let it do any
3254 other checking that is needed. */
3259 lang_statement_union_type
*file
;
3261 CONST bfd_arch_info_type
*compatible
;
3263 for (file
= file_chain
.head
;
3264 file
!= (lang_statement_union_type
*) NULL
;
3265 file
= file
->input_statement
.next
)
3267 input_bfd
= file
->input_statement
.the_bfd
;
3268 compatible
= bfd_arch_get_compatible (input_bfd
,
3270 if (compatible
== NULL
)
3272 if (command_line
.warn_mismatch
)
3273 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3274 bfd_printable_name (input_bfd
), input_bfd
,
3275 bfd_printable_name (output_bfd
));
3279 bfd_error_handler_type pfn
= NULL
;
3281 /* If we aren't supposed to warn about mismatched input
3282 files, temporarily set the BFD error handler to a
3283 function which will do nothing. We still want to call
3284 bfd_merge_private_bfd_data, since it may set up
3285 information which is needed in the output file. */
3286 if (! command_line
.warn_mismatch
)
3287 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3288 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3290 if (command_line
.warn_mismatch
)
3291 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3294 if (! command_line
.warn_mismatch
)
3295 bfd_set_error_handler (pfn
);
3300 /* Look through all the global common symbols and attach them to the
3301 correct section. The -sort-common command line switch may be used
3302 to roughly sort the entries by size. */
3307 if (link_info
.relocateable
3308 && ! command_line
.force_common_definition
)
3311 if (! config
.sort_common
)
3312 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3317 for (power
= 4; power
>= 0; power
--)
3318 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3323 /* Place one common symbol in the correct section. */
3326 lang_one_common (h
, info
)
3327 struct bfd_link_hash_entry
*h
;
3330 unsigned int power_of_two
;
3334 if (h
->type
!= bfd_link_hash_common
)
3338 power_of_two
= h
->u
.c
.p
->alignment_power
;
3340 if (config
.sort_common
3341 && power_of_two
< (unsigned int) *(int *) info
)
3344 section
= h
->u
.c
.p
->section
;
3346 /* Increase the size of the section. */
3347 section
->_cooked_size
= ALIGN_N (section
->_cooked_size
,
3348 (bfd_size_type
) (1 << power_of_two
));
3350 /* Adjust the alignment if necessary. */
3351 if (power_of_two
> section
->alignment_power
)
3352 section
->alignment_power
= power_of_two
;
3354 /* Change the symbol from common to defined. */
3355 h
->type
= bfd_link_hash_defined
;
3356 h
->u
.def
.section
= section
;
3357 h
->u
.def
.value
= section
->_cooked_size
;
3359 /* Increase the size of the section. */
3360 section
->_cooked_size
+= size
;
3362 /* Make sure the section is allocated in memory, and make sure that
3363 it is no longer a common section. */
3364 section
->flags
|= SEC_ALLOC
;
3365 section
->flags
&= ~ SEC_IS_COMMON
;
3367 if (config
.map_file
!= NULL
)
3369 static boolean header_printed
;
3374 if (! header_printed
)
3376 minfo (_("\nAllocating common symbols\n"));
3377 minfo (_("Common symbol size file\n\n"));
3378 header_printed
= true;
3381 name
= demangle (h
->root
.string
);
3383 len
= strlen (name
);
3398 if (size
<= 0xffffffff)
3399 sprintf (buf
, "%lx", (unsigned long) size
);
3401 sprintf_vma (buf
, size
);
3411 minfo ("%B\n", section
->owner
);
3418 run through the input files and ensure that every input
3419 section has somewhere to go. If one is found without
3420 a destination then create an input request and place it
3421 into the statement tree.
3425 lang_place_orphans ()
3427 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3431 for (s
= file
->the_bfd
->sections
;
3432 s
!= (asection
*) NULL
;
3435 if (s
->output_section
== (asection
*) NULL
)
3437 /* This section of the file is not attatched, root
3438 around for a sensible place for it to go */
3440 if (file
->just_syms_flag
)
3442 /* We are only retrieving symbol values from this
3443 file. We want the symbols to act as though the
3444 values in the file are absolute. */
3445 s
->output_section
= bfd_abs_section_ptr
;
3446 s
->output_offset
= s
->vma
;
3448 else if (strcmp (s
->name
, "COMMON") == 0)
3450 /* This is a lonely common section which must have
3451 come from an archive. We attach to the section
3452 with the wildcard. */
3453 if (! link_info
.relocateable
3454 || command_line
.force_common_definition
)
3456 if (default_common_section
== NULL
)
3459 /* This message happens when using the
3460 svr3.ifile linker script, so I have
3462 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3464 default_common_section
=
3465 lang_output_section_statement_lookup (".bss");
3468 wild_doit (&default_common_section
->children
, s
,
3469 default_common_section
, file
);
3472 else if (ldemul_place_orphan (file
, s
))
3476 lang_output_section_statement_type
*os
=
3477 lang_output_section_statement_lookup (s
->name
);
3479 wild_doit (&os
->children
, s
, os
, file
);
3488 lang_set_flags (ptr
, flags
, invert
)
3489 lang_memory_region_type
*ptr
;
3493 flagword
*ptr_flags
;
3495 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3501 *ptr_flags
|= SEC_ALLOC
;
3505 *ptr_flags
|= SEC_READONLY
;
3509 *ptr_flags
|= SEC_DATA
;
3513 *ptr_flags
|= SEC_CODE
;
3518 *ptr_flags
|= SEC_LOAD
;
3522 einfo (_("%P%F: invalid syntax in flags\n"));
3529 /* Call a function on each input file. This function will be called
3530 on an archive, but not on the elements. */
3533 lang_for_each_input_file (func
)
3534 void (*func
) PARAMS ((lang_input_statement_type
*));
3536 lang_input_statement_type
*f
;
3538 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3540 f
= (lang_input_statement_type
*) f
->next_real_file
)
3544 /* Call a function on each file. The function will be called on all
3545 the elements of an archive which are included in the link, but will
3546 not be called on the archive file itself. */
3549 lang_for_each_file (func
)
3550 void (*func
) PARAMS ((lang_input_statement_type
*));
3552 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3563 lang_for_each_input_section (func
)
3564 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
3566 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3570 for (s
= f
->the_bfd
->sections
;
3571 s
!= (asection
*) NULL
;
3574 func (f
->the_bfd
, s
);
3582 ldlang_add_file (entry
)
3583 lang_input_statement_type
* entry
;
3587 lang_statement_append (&file_chain
,
3588 (lang_statement_union_type
*) entry
,
3591 /* The BFD linker needs to have a list of all input BFDs involved in
3593 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3594 ASSERT (entry
->the_bfd
!= output_bfd
);
3595 for (pp
= &link_info
.input_bfds
;
3596 *pp
!= (bfd
*) NULL
;
3597 pp
= &(*pp
)->link_next
)
3599 *pp
= entry
->the_bfd
;
3600 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3601 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3603 /* Look through the sections and check for any which should not be
3604 included in the link. We need to do this now, so that we can
3605 notice when the backend linker tries to report multiple
3606 definition errors for symbols which are in sections we aren't
3607 going to link. FIXME: It might be better to entirely ignore
3608 symbols which are defined in sections which are going to be
3609 discarded. This would require modifying the backend linker for
3610 each backend which might set the SEC_LINK_ONCE flag. If we do
3611 this, we should probably handle SEC_EXCLUDE in the same way. */
3613 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
3617 lang_add_output (name
, from_script
)
3621 /* Make -o on command line override OUTPUT in script. */
3622 if (had_output_filename
== false || !from_script
)
3624 output_filename
= name
;
3625 had_output_filename
= true;
3630 static lang_output_section_statement_type
*current_section
;
3642 for (l
= 0; l
< 32; l
++)
3644 if (i
>= (unsigned int) x
)
3653 lang_enter_output_section_statement (output_section_statement_name
,
3654 address_exp
, sectype
, block_value
,
3655 align
, subalign
, ebase
)
3656 const char *output_section_statement_name
;
3657 etree_type
* address_exp
;
3658 enum section_type sectype
;
3659 bfd_vma block_value
;
3661 etree_type
*subalign
;
3664 lang_output_section_statement_type
*os
;
3668 lang_output_section_statement_lookup (output_section_statement_name
);
3672 /* Add this statement to tree */
3673 /* add_statement(lang_output_section_statement_enum,
3674 output_section_statement);*/
3675 /* Make next things chain into subchain of this */
3677 if (os
->addr_tree
==
3678 (etree_type
*) NULL
)
3683 os
->sectype
= sectype
;
3684 if (sectype
!= noload_section
)
3685 os
->flags
= SEC_NO_FLAGS
;
3687 os
->flags
= SEC_NEVER_LOAD
;
3688 os
->block_value
= block_value
? block_value
: 1;
3689 stat_ptr
= &os
->children
;
3691 os
->subsection_alignment
= topower(
3692 exp_get_value_int(subalign
, -1,
3693 "subsection alignment",
3695 os
->section_alignment
= topower(
3696 exp_get_value_int(align
, -1,
3697 "section alignment", 0));
3699 os
->load_base
= ebase
;
3706 lang_output_statement_type
*new =
3707 new_stat (lang_output_statement
, stat_ptr
);
3709 new->name
= output_filename
;
3712 /* Reset the current counters in the regions */
3714 reset_memory_regions ()
3716 lang_memory_region_type
*p
= lang_memory_region_list
;
3718 for (p
= lang_memory_region_list
;
3719 p
!= (lang_memory_region_type
*) NULL
;
3722 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
3723 p
->current
= p
->origin
;
3727 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3728 as needed. SECTION may be NULL, in which case it is a wild card. */
3731 gc_section_callback (ptr
, section
, file
, data
)
3732 lang_wild_statement_type
*ptr
;
3734 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
3735 void *data ATTRIBUTE_UNUSED
;
3737 /* If the wild pattern was marked KEEP, the member sections
3738 should be as well. */
3739 if (ptr
->keep_sections
)
3740 section
->flags
|= SEC_KEEP
;
3743 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
3744 may be NULL, indicating that it is a wildcard. */
3747 lang_gc_wild (s
, section
, file
)
3748 lang_wild_statement_type
*s
;
3749 const char *section
;
3752 walk_wild (s
, section
, file
, gc_section_callback
, NULL
);
3755 /* Iterate over sections marking them against GC. */
3758 lang_gc_sections_1 (s
)
3759 lang_statement_union_type
* s
;
3761 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
3763 switch (s
->header
.type
)
3765 case lang_wild_statement_enum
:
3766 lang_gc_wild (&s
->wild_statement
,
3767 s
->wild_statement
.section_name
,
3768 s
->wild_statement
.filename
);
3770 case lang_constructors_statement_enum
:
3771 lang_gc_sections_1 (constructor_list
.head
);
3773 case lang_output_section_statement_enum
:
3774 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
3776 case lang_group_statement_enum
:
3777 lang_gc_sections_1 (s
->group_statement
.children
.head
);
3788 struct bfd_link_hash_entry
*h
;
3789 ldlang_undef_chain_list_type
*ulist
, fake_list_start
;
3791 /* Keep all sections so marked in the link script. */
3793 lang_gc_sections_1 (statement_list
.head
);
3795 /* Keep all sections containing symbols undefined on the command-line.
3796 Handle the entry symbol at the same time. */
3798 if (entry_symbol
!= NULL
)
3800 fake_list_start
.next
= ldlang_undef_chain_list_head
;
3801 fake_list_start
.name
= (char *) entry_symbol
;
3802 ulist
= &fake_list_start
;
3805 ulist
= ldlang_undef_chain_list_head
;
3807 for (; ulist
; ulist
= ulist
->next
)
3809 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
3810 false, false, false);
3812 if (h
!= (struct bfd_link_hash_entry
*) NULL
3813 && (h
->type
== bfd_link_hash_defined
3814 || h
->type
== bfd_link_hash_defweak
)
3815 && ! bfd_is_abs_section (h
->u
.def
.section
))
3817 h
->u
.def
.section
->flags
|= SEC_KEEP
;
3821 bfd_gc_sections (output_bfd
, &link_info
);
3827 lang_reasonable_defaults ();
3828 current_target
= default_target
;
3830 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
3832 ldemul_create_output_section_statements ();
3834 /* Add to the hash table all undefineds on the command line */
3835 lang_place_undefineds ();
3837 /* Create a bfd for each input file */
3838 current_target
= default_target
;
3839 open_input_bfds (statement_list
.head
, false);
3841 ldemul_after_open ();
3843 /* Make sure that we're not mixing architectures. We call this
3844 after all the input files have been opened, but before we do any
3845 other processing, so that any operations merge_private_bfd_data
3846 does on the output file will be known during the rest of the
3850 /* Handle .exports instead of a version script if we're told to do so. */
3851 if (command_line
.version_exports_section
)
3852 lang_do_version_exports_section ();
3854 /* Build all sets based on the information gathered from the input
3856 ldctor_build_sets ();
3858 /* Remove unreferenced sections if asked to. */
3859 if (command_line
.gc_sections
)
3860 lang_gc_sections ();
3862 /* Size up the common data */
3865 /* Run through the contours of the script and attach input sections
3866 to the correct output sections
3868 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
3869 (lang_output_section_statement_type
*) NULL
);
3872 /* Find any sections not attached explicitly and handle them */
3873 lang_place_orphans ();
3875 ldemul_before_allocation ();
3877 /* We must record the program headers before we try to fix the
3878 section positions, since they will affect SIZEOF_HEADERS. */
3879 lang_record_phdrs ();
3881 /* Now run around and relax if we can */
3882 if (command_line
.relax
)
3884 /* First time round is a trial run to get the 'worst case'
3885 addresses of the objects if there was no relaxing. */
3886 lang_size_sections (statement_list
.head
,
3888 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
3890 /* Keep relaxing until bfd_relax_section gives up. */
3893 reset_memory_regions ();
3895 relax_again
= false;
3897 /* Note: pe-dll.c does something like this also. If you find
3898 you need to change this code, you probably need to change
3899 pe-dll.c also. DJ */
3901 /* Do all the assignments with our current guesses as to
3903 lang_do_assignments (statement_list
.head
,
3905 (fill_type
) 0, (bfd_vma
) 0);
3907 /* Perform another relax pass - this time we know where the
3908 globals are, so can make better guess. */
3909 lang_size_sections (statement_list
.head
,
3911 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
3913 while (relax_again
);
3917 /* Size up the sections. */
3918 lang_size_sections (statement_list
.head
,
3920 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
3923 /* See if anything special should be done now we know how big
3925 ldemul_after_allocation ();
3927 /* Fix any .startof. or .sizeof. symbols. */
3928 lang_set_startof ();
3930 /* Do all the assignments, now that we know the final restingplaces
3931 of all the symbols */
3933 lang_do_assignments (statement_list
.head
,
3935 (fill_type
) 0, (bfd_vma
) 0);
3937 /* Make sure that the section addresses make sense. */
3938 if (! link_info
.relocateable
3939 && command_line
.check_section_addresses
)
3940 lang_check_section_addresses ();
3948 /* EXPORTED TO YACC */
3951 lang_add_wild (section_name
, sections_sorted
, filename
, filenames_sorted
,
3952 keep_sections
, exclude_filename
)
3953 const char *const section_name
;
3954 boolean sections_sorted
;
3955 const char *const filename
;
3956 boolean filenames_sorted
;
3957 boolean keep_sections
;
3958 const char *exclude_filename
;
3960 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
3963 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
3965 placed_commons
= true;
3967 if (filename
!= NULL
&& ! wildcardp (filename
))
3969 lang_has_input_file
= true;
3971 new->section_name
= section_name
;
3972 new->sections_sorted
= sections_sorted
;
3973 new->filename
= filename
;
3974 new->filenames_sorted
= filenames_sorted
;
3975 new->keep_sections
= keep_sections
;
3976 new->exclude_filename
= exclude_filename
;
3977 lang_list_init (&new->children
);
3981 lang_section_start (name
, address
)
3983 etree_type
* address
;
3985 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
3987 ad
->section_name
= name
;
3988 ad
->address
= address
;
3991 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
3992 because of a -e argument on the command line, or zero if this is
3993 called by ENTRY in a linker script. Command line arguments take
3997 lang_add_entry (name
, cmdline
)
4001 if (entry_symbol
== NULL
4003 || ! entry_from_cmdline
)
4005 entry_symbol
= name
;
4006 entry_from_cmdline
= cmdline
;
4011 lang_add_target (name
)
4014 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4030 map_option_f
= true;
4041 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4048 lang_add_data (type
, exp
)
4050 union etree_union
*exp
;
4053 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4061 /* Create a new reloc statement. RELOC is the BFD relocation type to
4062 generate. HOWTO is the corresponding howto structure (we could
4063 look this up, but the caller has already done so). SECTION is the
4064 section to generate a reloc against, or NAME is the name of the
4065 symbol to generate a reloc against. Exactly one of SECTION and
4066 NAME must be NULL. ADDEND is an expression for the addend. */
4069 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4070 bfd_reloc_code_real_type reloc
;
4071 reloc_howto_type
*howto
;
4074 union etree_union
*addend
;
4076 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4080 p
->section
= section
;
4082 p
->addend_exp
= addend
;
4084 p
->addend_value
= 0;
4085 p
->output_section
= NULL
;
4089 lang_assignment_statement_type
*
4090 lang_add_assignment (exp
)
4093 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4101 lang_add_attribute (attribute
)
4102 enum statement_enum attribute
;
4104 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4111 if (startup_file
!= (char *) NULL
)
4113 einfo (_("%P%Fmultiple STARTUP files\n"));
4115 first_file
->filename
= name
;
4116 first_file
->local_sym_name
= name
;
4117 first_file
->real
= true;
4119 startup_file
= name
;
4126 lang_float_flag
= maybe
;
4130 lang_leave_output_section_statement (fill
, memspec
, phdrs
)
4132 const char *memspec
;
4133 struct lang_output_section_phdr_list
*phdrs
;
4135 current_section
->fill
= fill
;
4136 current_section
->region
= lang_memory_region_lookup (memspec
);
4137 current_section
->phdrs
= phdrs
;
4138 stat_ptr
= &statement_list
;
4142 Create an absolute symbol with the given name with the value of the
4143 address of first byte of the section named.
4145 If the symbol already exists, then do nothing.
4148 lang_abs_symbol_at_beginning_of (secname
, name
)
4149 const char *secname
;
4152 struct bfd_link_hash_entry
*h
;
4154 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4155 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4156 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4158 if (h
->type
== bfd_link_hash_new
4159 || h
->type
== bfd_link_hash_undefined
)
4163 h
->type
= bfd_link_hash_defined
;
4165 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4166 if (sec
== (asection
*) NULL
)
4169 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4171 h
->u
.def
.section
= bfd_abs_section_ptr
;
4176 Create an absolute symbol with the given name with the value of the
4177 address of the first byte after the end of the section named.
4179 If the symbol already exists, then do nothing.
4182 lang_abs_symbol_at_end_of (secname
, name
)
4183 const char *secname
;
4186 struct bfd_link_hash_entry
*h
;
4188 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4189 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4190 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4192 if (h
->type
== bfd_link_hash_new
4193 || h
->type
== bfd_link_hash_undefined
)
4197 h
->type
= bfd_link_hash_defined
;
4199 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4200 if (sec
== (asection
*) NULL
)
4203 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4204 + bfd_section_size (output_bfd
, sec
));
4206 h
->u
.def
.section
= bfd_abs_section_ptr
;
4211 lang_statement_append (list
, element
, field
)
4212 lang_statement_list_type
* list
;
4213 lang_statement_union_type
* element
;
4214 lang_statement_union_type
** field
;
4216 *(list
->tail
) = element
;
4220 /* Set the output format type. -oformat overrides scripts. */
4223 lang_add_output_format (format
, big
, little
, from_script
)
4229 if (output_target
== NULL
|| !from_script
)
4231 if (command_line
.endian
== ENDIAN_BIG
4234 else if (command_line
.endian
== ENDIAN_LITTLE
4238 output_target
= format
;
4242 /* Enter a group. This creates a new lang_group_statement, and sets
4243 stat_ptr to build new statements within the group. */
4248 lang_group_statement_type
*g
;
4250 g
= new_stat (lang_group_statement
, stat_ptr
);
4251 lang_list_init (&g
->children
);
4252 stat_ptr
= &g
->children
;
4255 /* Leave a group. This just resets stat_ptr to start writing to the
4256 regular list of statements again. Note that this will not work if
4257 groups can occur inside anything else which can adjust stat_ptr,
4258 but currently they can't. */
4263 stat_ptr
= &statement_list
;
4266 /* Add a new program header. This is called for each entry in a PHDRS
4267 command in a linker script. */
4270 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4278 struct lang_phdr
*n
, **pp
;
4280 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4283 n
->type
= exp_get_value_int (type
, 0, "program header type",
4284 lang_final_phase_enum
);
4285 n
->filehdr
= filehdr
;
4290 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4295 /* Record the program header information in the output BFD. FIXME: We
4296 should not be calling an ELF specific function here. */
4299 lang_record_phdrs ()
4303 struct lang_output_section_phdr_list
*last
;
4304 struct lang_phdr
*l
;
4305 lang_statement_union_type
*u
;
4308 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4310 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4317 for (u
= lang_output_section_statement
.head
;
4319 u
= u
->output_section_statement
.next
)
4321 lang_output_section_statement_type
*os
;
4322 struct lang_output_section_phdr_list
*pl
;
4324 os
= &u
->output_section_statement
;
4331 if (os
->sectype
== noload_section
4332 || os
->bfd_section
== NULL
4333 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4338 if (os
->bfd_section
== NULL
)
4341 for (; pl
!= NULL
; pl
= pl
->next
)
4343 if (strcmp (pl
->name
, l
->name
) == 0)
4348 secs
= ((asection
**)
4349 xrealloc (secs
, alc
* sizeof (asection
*)));
4351 secs
[c
] = os
->bfd_section
;
4358 if (l
->flags
== NULL
)
4361 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4362 lang_final_phase_enum
);
4367 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4368 lang_final_phase_enum
);
4370 if (! bfd_record_phdr (output_bfd
, l
->type
,
4371 l
->flags
== NULL
? false : true,
4373 l
->at
== NULL
? false : true,
4374 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4375 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4380 /* Make sure all the phdr assignments succeeded. */
4381 for (u
= lang_output_section_statement
.head
;
4383 u
= u
->output_section_statement
.next
)
4385 struct lang_output_section_phdr_list
*pl
;
4387 if (u
->output_section_statement
.bfd_section
== NULL
)
4390 for (pl
= u
->output_section_statement
.phdrs
;
4393 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4394 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4395 u
->output_section_statement
.name
, pl
->name
);
4399 /* Record a list of sections which may not be cross referenced. */
4402 lang_add_nocrossref (l
)
4403 struct lang_nocrossref
*l
;
4405 struct lang_nocrossrefs
*n
;
4407 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4408 n
->next
= nocrossref_list
;
4410 nocrossref_list
= n
;
4412 /* Set notice_all so that we get informed about all symbols. */
4413 link_info
.notice_all
= true;
4416 /* Overlay handling. We handle overlays with some static variables. */
4418 /* The overlay virtual address. */
4419 static etree_type
*overlay_vma
;
4421 /* The overlay load address. */
4422 static etree_type
*overlay_lma
;
4424 /* Whether nocrossrefs is set for this overlay. */
4425 static int overlay_nocrossrefs
;
4427 /* An expression for the maximum section size seen so far. */
4428 static etree_type
*overlay_max
;
4430 /* A list of all the sections in this overlay. */
4434 struct overlay_list
*next
;
4435 lang_output_section_statement_type
*os
;
4438 static struct overlay_list
*overlay_list
;
4440 /* Start handling an overlay. */
4443 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
4444 etree_type
*vma_expr
;
4445 etree_type
*lma_expr
;
4448 /* The grammar should prevent nested overlays from occurring. */
4449 ASSERT (overlay_vma
== NULL
4450 && overlay_lma
== NULL
4451 && overlay_list
== NULL
4452 && overlay_max
== NULL
);
4454 overlay_vma
= vma_expr
;
4455 overlay_lma
= lma_expr
;
4456 overlay_nocrossrefs
= nocrossrefs
;
4459 /* Start a section in an overlay. We handle this by calling
4460 lang_enter_output_section_statement with the correct VMA and LMA. */
4463 lang_enter_overlay_section (name
)
4466 struct overlay_list
*n
;
4469 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4470 0, 0, 0, overlay_lma
);
4472 /* If this is the first section, then base the VMA and LMA of future
4473 sections on this one. This will work correctly even if `.' is
4474 used in the addresses. */
4475 if (overlay_list
== NULL
)
4477 overlay_vma
= exp_nameop (ADDR
, name
);
4478 overlay_lma
= exp_nameop (LOADADDR
, name
);
4481 /* Remember the section. */
4482 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4483 n
->os
= current_section
;
4484 n
->next
= overlay_list
;
4487 size
= exp_nameop (SIZEOF
, name
);
4489 /* Adjust the LMA for the next section. */
4490 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
4492 /* Arrange to work out the maximum section end address. */
4493 if (overlay_max
== NULL
)
4496 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4499 /* Finish a section in an overlay. There isn't any special to do
4503 lang_leave_overlay_section (fill
, phdrs
)
4505 struct lang_output_section_phdr_list
*phdrs
;
4512 name
= current_section
->name
;
4514 lang_leave_output_section_statement (fill
, "*default*", phdrs
);
4516 /* Define the magic symbols. */
4518 clean
= xmalloc (strlen (name
) + 1);
4520 for (s1
= name
; *s1
!= '\0'; s1
++)
4521 if (isalnum ((unsigned char) *s1
) || *s1
== '_')
4525 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4526 sprintf (buf
, "__load_start_%s", clean
);
4527 lang_add_assignment (exp_assop ('=', buf
,
4528 exp_nameop (LOADADDR
, name
)));
4530 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4531 sprintf (buf
, "__load_stop_%s", clean
);
4532 lang_add_assignment (exp_assop ('=', buf
,
4534 exp_nameop (LOADADDR
, name
),
4535 exp_nameop (SIZEOF
, name
))));
4540 /* Finish an overlay. If there are any overlay wide settings, this
4541 looks through all the sections in the overlay and sets them. */
4544 lang_leave_overlay (fill
, memspec
, phdrs
)
4546 const char *memspec
;
4547 struct lang_output_section_phdr_list
*phdrs
;
4549 lang_memory_region_type
*region
;
4550 struct overlay_list
*l
;
4551 struct lang_nocrossref
*nocrossref
;
4553 if (memspec
== NULL
)
4556 region
= lang_memory_region_lookup (memspec
);
4563 struct overlay_list
*next
;
4565 if (fill
!= 0 && l
->os
->fill
== 0)
4567 if (region
!= NULL
&& l
->os
->region
== NULL
)
4568 l
->os
->region
= region
;
4569 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4570 l
->os
->phdrs
= phdrs
;
4572 if (overlay_nocrossrefs
)
4574 struct lang_nocrossref
*nc
;
4576 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
4577 nc
->name
= l
->os
->name
;
4578 nc
->next
= nocrossref
;
4587 if (nocrossref
!= NULL
)
4588 lang_add_nocrossref (nocrossref
);
4590 /* Update . for the end of the overlay. */
4591 lang_add_assignment (exp_assop ('=', ".",
4592 exp_binop ('+', overlay_vma
, overlay_max
)));
4596 overlay_nocrossrefs
= 0;
4597 overlay_list
= NULL
;
4601 /* Version handling. This is only useful for ELF. */
4603 /* This global variable holds the version tree that we build. */
4605 struct bfd_elf_version_tree
*lang_elf_version_info
;
4608 lang_vers_match_lang_c (expr
, sym
)
4609 struct bfd_elf_version_expr
*expr
;
4612 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4614 return fnmatch (expr
->pattern
, sym
, 0) == 0;
4618 lang_vers_match_lang_cplusplus (expr
, sym
)
4619 struct bfd_elf_version_expr
*expr
;
4625 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4628 alt_sym
= cplus_demangle(sym
, /* DMGL_NO_TPARAMS */ 0);
4631 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4632 Should we early out false in this case? */
4633 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4637 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4645 lang_vers_match_lang_java (expr
, sym
)
4646 struct bfd_elf_version_expr
*expr
;
4652 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4655 alt_sym
= cplus_demangle(sym
, DMGL_JAVA
);
4658 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4659 Should we early out false in this case? */
4660 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4664 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4671 /* This is called for each variable name or match expression. */
4673 struct bfd_elf_version_expr
*
4674 lang_new_vers_regex (orig
, new, lang
)
4675 struct bfd_elf_version_expr
*orig
;
4679 struct bfd_elf_version_expr
*ret
;
4681 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
4685 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
4686 ret
->match
= lang_vers_match_lang_c
;
4687 else if (strcasecmp (lang
, "C++") == 0)
4688 ret
->match
= lang_vers_match_lang_cplusplus
;
4689 else if (strcasecmp (lang
, "Java") == 0)
4690 ret
->match
= lang_vers_match_lang_java
;
4693 einfo (_("%X%P: unknown language `%s' in version information\n"),
4695 ret
->match
= lang_vers_match_lang_c
;
4701 /* This is called for each set of variable names and match
4704 struct bfd_elf_version_tree
*
4705 lang_new_vers_node (globals
, locals
)
4706 struct bfd_elf_version_expr
*globals
;
4707 struct bfd_elf_version_expr
*locals
;
4709 struct bfd_elf_version_tree
*ret
;
4711 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
4715 ret
->globals
= globals
;
4716 ret
->locals
= locals
;
4718 ret
->name_indx
= (unsigned int) -1;
4723 /* This static variable keeps track of version indices. */
4725 static int version_index
;
4727 /* This is called when we know the name and dependencies of the
4731 lang_register_vers_node (name
, version
, deps
)
4733 struct bfd_elf_version_tree
*version
;
4734 struct bfd_elf_version_deps
*deps
;
4736 struct bfd_elf_version_tree
*t
, **pp
;
4737 struct bfd_elf_version_expr
*e1
;
4739 /* Make sure this node has a unique name. */
4740 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4741 if (strcmp (t
->name
, name
) == 0)
4742 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
4744 /* Check the global and local match names, and make sure there
4745 aren't any duplicates. */
4747 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
4749 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4751 struct bfd_elf_version_expr
*e2
;
4753 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
4754 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
4755 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4760 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
4762 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4764 struct bfd_elf_version_expr
*e2
;
4766 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
4767 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
4768 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4773 version
->deps
= deps
;
4774 version
->name
= name
;
4776 version
->vernum
= version_index
;
4778 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4783 /* This is called when we see a version dependency. */
4785 struct bfd_elf_version_deps
*
4786 lang_add_vers_depend (list
, name
)
4787 struct bfd_elf_version_deps
*list
;
4790 struct bfd_elf_version_deps
*ret
;
4791 struct bfd_elf_version_tree
*t
;
4793 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
4796 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4798 if (strcmp (t
->name
, name
) == 0)
4800 ret
->version_needed
= t
;
4805 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
4811 lang_do_version_exports_section ()
4813 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
4815 LANG_FOR_EACH_INPUT_STATEMENT (is
)
4817 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
4824 len
= bfd_section_size (is
->the_bfd
, sec
);
4825 contents
= xmalloc (len
);
4826 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
4827 einfo (_("%X%P: unable to read .exports section contents"), sec
);
4830 while (p
< contents
+len
)
4832 greg
= lang_new_vers_regex (greg
, p
, NULL
);
4833 p
= strchr (p
, '\0') + 1;
4836 /* Do not free the contents, as we used them creating the regex. */
4838 /* Do not include this section in the link. */
4839 bfd_set_section_flags (is
->the_bfd
, sec
,
4840 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
4843 lreg
= lang_new_vers_regex (NULL
, "*", NULL
);
4844 lang_register_vers_node (command_line
.version_exports_section
,
4845 lang_new_vers_node (greg
, lreg
), NULL
);