1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
6 This file is part of GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
45 static lang_statement_union_type
*new_statement
PARAMS ((enum statement_enum
,
47 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 const char *current_target
;
62 static const char *output_target
;
63 static lang_statement_list_type statement_list
;
64 static struct lang_phdr
*lang_phdr_list
;
66 static void lang_for_each_statement_worker
67 PARAMS ((void (*) (lang_statement_union_type
*),
68 lang_statement_union_type
*));
69 static lang_input_statement_type
*new_afile
70 PARAMS ((const char *, lang_input_file_enum_type
, const char *, boolean
));
71 static lang_memory_region_type
*lang_memory_default
PARAMS ((asection
*));
72 static void lang_map_flags
PARAMS ((flagword
));
73 static void init_os
PARAMS ((lang_output_section_statement_type
*));
74 static void exp_init_os
PARAMS ((etree_type
*));
75 static void section_already_linked
PARAMS ((bfd
*, asection
*, PTR
));
76 static struct bfd_hash_entry
*already_linked_newfunc
77 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
78 static void already_linked_table_init
PARAMS ((void));
79 static void already_linked_table_free
PARAMS ((void));
80 static boolean wildcardp
PARAMS ((const char *));
81 static lang_statement_union_type
*wild_sort
82 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
84 static void output_section_callback
85 PARAMS ((lang_wild_statement_type
*, asection
*,
86 lang_input_statement_type
*, PTR
));
87 static lang_input_statement_type
*lookup_name
PARAMS ((const char *));
88 static void load_symbols
89 PARAMS ((lang_input_statement_type
*, lang_statement_list_type
*));
91 PARAMS ((lang_wild_statement_type
*, const char *, const char *,
92 const char *, lang_output_section_statement_type
*));
93 static bfd
*open_output
PARAMS ((const char *));
94 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*));
95 static void open_input_bfds
PARAMS ((lang_statement_union_type
*, boolean
));
96 static void lang_reasonable_defaults
PARAMS ((void));
97 static void lang_place_undefineds
PARAMS ((void));
98 static void map_input_to_output_sections
99 PARAMS ((lang_statement_union_type
*, const char *,
100 lang_output_section_statement_type
*));
101 static void print_output_section_statement
102 PARAMS ((lang_output_section_statement_type
*));
103 static void print_assignment
104 PARAMS ((lang_assignment_statement_type
*,
105 lang_output_section_statement_type
*));
106 static void print_input_statement
PARAMS ((lang_input_statement_type
*));
107 static boolean print_one_symbol
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
108 static void print_input_section
PARAMS ((lang_input_section_type
*));
109 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*));
110 static void print_data_statement
PARAMS ((lang_data_statement_type
*));
111 static void print_address_statement
PARAMS ((lang_address_statement_type
*));
112 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*));
113 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*));
114 static void print_wild_statement
115 PARAMS ((lang_wild_statement_type
*, lang_output_section_statement_type
*));
116 static void print_group
117 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
118 static void print_statement
119 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
120 static void print_statement_list
121 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
122 static void print_statements
PARAMS ((void));
123 static bfd_vma insert_pad
124 PARAMS ((lang_statement_union_type
**, fill_type
,
125 unsigned int, asection
*, bfd_vma
));
126 static bfd_vma size_input_section
127 PARAMS ((lang_statement_union_type
**, lang_output_section_statement_type
*,
128 fill_type
, bfd_vma
, boolean
));
129 static void lang_finish
PARAMS ((void));
130 static void ignore_bfd_errors
PARAMS ((const char *, ...));
131 static void record_bfd_errors
PARAMS ((const char *, ...));
132 static void lang_check
PARAMS ((void));
133 static void lang_common
PARAMS ((void));
134 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
135 static void lang_place_orphans
PARAMS ((void));
136 static int topower
PARAMS ((int));
137 static void lang_set_startof
PARAMS ((void));
138 static void reset_memory_regions
PARAMS ((void));
139 static void gc_section_callback
140 PARAMS ((lang_wild_statement_type
*, asection
*,
141 lang_input_statement_type
*, PTR
));
142 static void lang_record_phdrs
PARAMS ((void));
143 static void lang_gc_wild
144 PARAMS ((lang_wild_statement_type
*, const char *, const char *));
145 static void lang_gc_sections_1
PARAMS ((lang_statement_union_type
*));
146 static void lang_gc_sections
PARAMS ((void));
147 static int lang_vers_match_lang_c
148 PARAMS ((struct bfd_elf_version_expr
*, const char *));
149 static int lang_vers_match_lang_cplusplus
150 PARAMS ((struct bfd_elf_version_expr
*, const char *));
151 static int lang_vers_match_lang_java
152 PARAMS ((struct bfd_elf_version_expr
*, const char *));
153 static void lang_do_version_exports_section
PARAMS ((void));
154 static void lang_check_section_addresses
PARAMS ((void));
155 static void os_region_check
156 PARAMS ((lang_output_section_statement_type
*,
157 struct memory_region_struct
*, etree_type
*, bfd_vma
));
159 typedef void (*callback_t
) PARAMS ((lang_wild_statement_type
*,
160 asection
*, lang_input_statement_type
*,
162 static void walk_wild
163 PARAMS ((lang_wild_statement_type
*, const char *, const char *,
165 static void walk_wild_section
166 PARAMS ((lang_wild_statement_type
*, const char *,
167 lang_input_statement_type
*, callback_t
, PTR
));
168 static void walk_wild_file
169 PARAMS ((lang_wild_statement_type
*, const char *,
170 lang_input_statement_type
*, callback_t
, PTR
));
172 static int get_target
PARAMS ((const bfd_target
*, PTR
));
173 static void stricpy
PARAMS ((char *, char *));
174 static void strcut
PARAMS ((char *, char *));
175 static int name_compare
PARAMS ((char *, char *));
176 static int closest_target_match
PARAMS ((const bfd_target
*, PTR
));
177 static char * get_first_input_target
PARAMS ((void));
180 lang_output_section_statement_type
*abs_output_section
;
181 lang_statement_list_type lang_output_section_statement
;
182 lang_statement_list_type
*stat_ptr
= &statement_list
;
183 lang_statement_list_type file_chain
= { NULL
, NULL
};
184 const char *entry_symbol
= NULL
;
185 boolean entry_from_cmdline
;
186 boolean lang_has_input_file
= false;
187 boolean had_output_filename
= false;
188 boolean lang_float_flag
= false;
189 boolean delete_output_file_on_failure
= false;
190 struct lang_nocrossrefs
*nocrossref_list
;
191 struct unique_sections
*unique_section_list
;
193 etree_type
*base
; /* Relocation base - or null */
195 #if defined(__STDC__) || defined(ALMOST_STDC)
196 #define cat(a,b) a##b
198 #define cat(a,b) a/**/b
201 /* Don't beautify the line below with "innocent" whitespace, it breaks the K&R C preprocessor! */
202 #define new_stat(x, y) (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
204 #define outside_section_address(q) ((q)->output_offset + (q)->output_section->vma)
206 #define outside_symbol_address(q) ((q)->value + outside_section_address (q->section))
208 #define SECTION_NAME_MAP_LENGTH (16)
214 return obstack_alloc (&stat_obstack
, size
);
218 unique_section_p (secnam
)
221 struct unique_sections
*unam
;
223 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
224 if (wildcardp (unam
->name
)
225 ? fnmatch (unam
->name
, secnam
, 0) == 0
226 : strcmp (unam
->name
, secnam
) == 0)
234 /* Generic traversal routines for finding matching sections. */
237 walk_wild_section (ptr
, section
, file
, callback
, data
)
238 lang_wild_statement_type
*ptr
;
240 lang_input_statement_type
*file
;
244 /* Don't process sections from files which were excluded. */
245 if (ptr
->exclude_filename_list
!= NULL
)
247 struct name_list
*list_tmp
;
248 for (list_tmp
= ptr
->exclude_filename_list
; list_tmp
; list_tmp
= list_tmp
->next
)
252 if (wildcardp (list_tmp
->name
))
253 match
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0 ? true : false;
255 match
= strcmp (list_tmp
->name
, file
->filename
) == 0 ? true : false;
262 if (file
->just_syms_flag
== false)
264 register asection
*s
;
265 boolean wildcard
= false;
268 wildcard
= wildcardp (section
);
270 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
273 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
278 match
= fnmatch (section
, sname
, 0) == 0 ? true : false;
280 match
= strcmp (section
, sname
) == 0 ? true : false;
282 /* If this is a wild-card output section statement, exclude
283 sections that match UNIQUE_SECTION_LIST. */
284 if (match
&& (data
== NULL
|| !unique_section_p (sname
)))
285 (*callback
) (ptr
, s
, file
, data
);
290 /* Handle a wild statement for a single file F. */
293 walk_wild_file (s
, section
, f
, callback
, data
)
294 lang_wild_statement_type
*s
;
296 lang_input_statement_type
*f
;
300 if (f
->the_bfd
== NULL
301 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
302 walk_wild_section (s
, section
, f
, callback
, data
);
307 /* This is an archive file. We must map each member of the
308 archive separately. */
309 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
310 while (member
!= NULL
)
312 /* When lookup_name is called, it will call the add_symbols
313 entry point for the archive. For each element of the
314 archive which is included, BFD will call ldlang_add_file,
315 which will set the usrdata field of the member to the
316 lang_input_statement. */
317 if (member
->usrdata
!= NULL
)
319 walk_wild_section (s
, section
,
320 (lang_input_statement_type
*) member
->usrdata
,
324 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
330 walk_wild (s
, section
, file
, callback
, data
)
331 lang_wild_statement_type
*s
;
337 if (file
== (char *) NULL
)
339 /* Perform the iteration over all files in the list. */
340 LANG_FOR_EACH_INPUT_STATEMENT (f
)
342 walk_wild_file (s
, section
, f
, callback
, data
);
345 else if (wildcardp (file
))
347 LANG_FOR_EACH_INPUT_STATEMENT (f
)
349 if (fnmatch (file
, f
->filename
, FNM_FILE_NAME
) == 0)
350 walk_wild_file (s
, section
, f
, callback
, data
);
355 lang_input_statement_type
*f
;
357 /* Perform the iteration over a single file. */
358 f
= lookup_name (file
);
359 walk_wild_file (s
, section
, f
, callback
, data
);
363 /* lang_for_each_statement walks the parse tree and calls the provided
364 function for each node. */
367 lang_for_each_statement_worker (func
, s
)
368 void (*func
) PARAMS ((lang_statement_union_type
*));
369 lang_statement_union_type
*s
;
371 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
375 switch (s
->header
.type
)
377 case lang_constructors_statement_enum
:
378 lang_for_each_statement_worker (func
, constructor_list
.head
);
380 case lang_output_section_statement_enum
:
381 lang_for_each_statement_worker
383 s
->output_section_statement
.children
.head
);
385 case lang_wild_statement_enum
:
386 lang_for_each_statement_worker
388 s
->wild_statement
.children
.head
);
390 case lang_group_statement_enum
:
391 lang_for_each_statement_worker (func
,
392 s
->group_statement
.children
.head
);
394 case lang_data_statement_enum
:
395 case lang_reloc_statement_enum
:
396 case lang_object_symbols_statement_enum
:
397 case lang_output_statement_enum
:
398 case lang_target_statement_enum
:
399 case lang_input_section_enum
:
400 case lang_input_statement_enum
:
401 case lang_assignment_statement_enum
:
402 case lang_padding_statement_enum
:
403 case lang_address_statement_enum
:
404 case lang_fill_statement_enum
:
414 lang_for_each_statement (func
)
415 void (*func
) PARAMS ((lang_statement_union_type
*));
417 lang_for_each_statement_worker (func
, statement_list
.head
);
420 /*----------------------------------------------------------------------*/
423 lang_list_init (list
)
424 lang_statement_list_type
*list
;
426 list
->head
= (lang_statement_union_type
*) NULL
;
427 list
->tail
= &list
->head
;
430 /* Build a new statement node for the parse tree. */
432 static lang_statement_union_type
*
433 new_statement (type
, size
, list
)
434 enum statement_enum type
;
436 lang_statement_list_type
*list
;
438 lang_statement_union_type
*new = (lang_statement_union_type
*)
441 new->header
.type
= type
;
442 new->header
.next
= (lang_statement_union_type
*) NULL
;
443 lang_statement_append (list
, new, &new->header
.next
);
447 /* Build a new input file node for the language. There are several
448 ways in which we treat an input file, eg, we only look at symbols,
449 or prefix it with a -l etc.
451 We can be supplied with requests for input files more than once;
452 they may, for example be split over serveral lines like foo.o(.text)
453 foo.o(.data) etc, so when asked for a file we check that we havn't
454 got it already so we don't duplicate the bfd. */
456 static lang_input_statement_type
*
457 new_afile (name
, file_type
, target
, add_to_list
)
459 lang_input_file_enum_type file_type
;
463 lang_input_statement_type
*p
;
466 p
= new_stat (lang_input_statement
, stat_ptr
);
469 p
= ((lang_input_statement_type
*)
470 stat_alloc (sizeof (lang_input_statement_type
)));
471 p
->header
.next
= NULL
;
474 lang_has_input_file
= true;
478 case lang_input_file_is_symbols_only_enum
:
480 p
->is_archive
= false;
482 p
->local_sym_name
= name
;
483 p
->just_syms_flag
= true;
484 p
->search_dirs_flag
= false;
486 case lang_input_file_is_fake_enum
:
488 p
->is_archive
= false;
490 p
->local_sym_name
= name
;
491 p
->just_syms_flag
= false;
492 p
->search_dirs_flag
= false;
494 case lang_input_file_is_l_enum
:
495 p
->is_archive
= true;
498 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
499 p
->just_syms_flag
= false;
500 p
->search_dirs_flag
= true;
502 case lang_input_file_is_marker_enum
:
504 p
->is_archive
= false;
506 p
->local_sym_name
= name
;
507 p
->just_syms_flag
= false;
508 p
->search_dirs_flag
= true;
510 case lang_input_file_is_search_file_enum
:
512 p
->is_archive
= false;
514 p
->local_sym_name
= name
;
515 p
->just_syms_flag
= false;
516 p
->search_dirs_flag
= true;
518 case lang_input_file_is_file_enum
:
520 p
->is_archive
= false;
522 p
->local_sym_name
= name
;
523 p
->just_syms_flag
= false;
524 p
->search_dirs_flag
= false;
529 p
->the_bfd
= (bfd
*) NULL
;
530 p
->asymbols
= (asymbol
**) NULL
;
531 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
532 p
->next
= (lang_statement_union_type
*) NULL
;
534 p
->dynamic
= config
.dynamic_link
;
535 p
->whole_archive
= whole_archive
;
537 lang_statement_append (&input_file_chain
,
538 (lang_statement_union_type
*) p
,
543 lang_input_statement_type
*
544 lang_add_input_file (name
, file_type
, target
)
546 lang_input_file_enum_type file_type
;
549 lang_has_input_file
= true;
550 return new_afile (name
, file_type
, target
, true);
553 /* Build enough state so that the parser can build its tree. */
558 obstack_begin (&stat_obstack
, 1000);
560 stat_ptr
= &statement_list
;
562 lang_list_init (stat_ptr
);
564 lang_list_init (&input_file_chain
);
565 lang_list_init (&lang_output_section_statement
);
566 lang_list_init (&file_chain
);
567 first_file
= lang_add_input_file ((char *) NULL
,
568 lang_input_file_is_marker_enum
,
571 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
573 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
577 /*----------------------------------------------------------------------
578 A region is an area of memory declared with the
579 MEMORY { name:org=exp, len=exp ... }
582 We maintain a list of all the regions here.
584 If no regions are specified in the script, then the default is used
585 which is created when looked up to be the entire data space. */
587 static lang_memory_region_type
*lang_memory_region_list
;
588 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
590 lang_memory_region_type
*
591 lang_memory_region_lookup (name
)
592 const char *const name
;
594 lang_memory_region_type
*p
;
596 for (p
= lang_memory_region_list
;
597 p
!= (lang_memory_region_type
*) NULL
;
600 if (strcmp (p
->name
, name
) == 0)
607 /* This code used to always use the first region in the list as the
608 default region. I changed it to instead use a region
609 encompassing all of memory as the default region. This permits
610 NOLOAD sections to work reasonably without requiring a region.
611 People should specify what region they mean, if they really want
613 if (strcmp (name
, "*default*") == 0)
615 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
617 return lang_memory_region_list
;
623 lang_memory_region_type
*new =
624 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
626 new->name
= buystring (name
);
627 new->next
= (lang_memory_region_type
*) NULL
;
629 *lang_memory_region_list_tail
= new;
630 lang_memory_region_list_tail
= &new->next
;
634 new->length
= ~(bfd_size_type
) 0;
636 new->had_full_message
= false;
642 static lang_memory_region_type
*
643 lang_memory_default (section
)
646 lang_memory_region_type
*p
;
648 flagword sec_flags
= section
->flags
;
650 /* Override SEC_DATA to mean a writable section. */
651 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
652 sec_flags
|= SEC_DATA
;
654 for (p
= lang_memory_region_list
;
655 p
!= (lang_memory_region_type
*) NULL
;
658 if ((p
->flags
& sec_flags
) != 0
659 && (p
->not_flags
& sec_flags
) == 0)
664 return lang_memory_region_lookup ("*default*");
667 lang_output_section_statement_type
*
668 lang_output_section_find (name
)
669 const char *const name
;
671 lang_statement_union_type
*u
;
672 lang_output_section_statement_type
*lookup
;
674 for (u
= lang_output_section_statement
.head
;
675 u
!= (lang_statement_union_type
*) NULL
;
678 lookup
= &u
->output_section_statement
;
679 if (strcmp (name
, lookup
->name
) == 0)
684 return (lang_output_section_statement_type
*) NULL
;
687 lang_output_section_statement_type
*
688 lang_output_section_statement_lookup (name
)
689 const char *const name
;
691 lang_output_section_statement_type
*lookup
;
693 lookup
= lang_output_section_find (name
);
694 if (lookup
== (lang_output_section_statement_type
*) NULL
)
697 lookup
= (lang_output_section_statement_type
*)
698 new_stat (lang_output_section_statement
, stat_ptr
);
699 lookup
->region
= (lang_memory_region_type
*) NULL
;
700 lookup
->lma_region
= (lang_memory_region_type
*) NULL
;
702 lookup
->block_value
= 1;
705 lookup
->next
= (lang_statement_union_type
*) NULL
;
706 lookup
->bfd_section
= (asection
*) NULL
;
707 lookup
->processed
= false;
708 lookup
->sectype
= normal_section
;
709 lookup
->addr_tree
= (etree_type
*) NULL
;
710 lang_list_init (&lookup
->children
);
712 lookup
->memspec
= (const char *) NULL
;
714 lookup
->subsection_alignment
= -1;
715 lookup
->section_alignment
= -1;
716 lookup
->load_base
= (union etree_union
*) NULL
;
717 lookup
->phdrs
= NULL
;
719 lang_statement_append (&lang_output_section_statement
,
720 (lang_statement_union_type
*) lookup
,
727 lang_map_flags (flag
)
730 if (flag
& SEC_ALLOC
)
736 if (flag
& SEC_READONLY
)
749 lang_memory_region_type
*m
;
751 minfo (_("\nMemory Configuration\n\n"));
752 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
753 _("Name"), _("Origin"), _("Length"), _("Attributes"));
755 for (m
= lang_memory_region_list
;
756 m
!= (lang_memory_region_type
*) NULL
;
762 fprintf (config
.map_file
, "%-16s ", m
->name
);
764 sprintf_vma (buf
, m
->origin
);
765 minfo ("0x%s ", buf
);
773 minfo ("0x%V", m
->length
);
774 if (m
->flags
|| m
->not_flags
)
782 lang_map_flags (m
->flags
);
788 lang_map_flags (m
->not_flags
);
795 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
800 /* Initialize an output section. */
804 lang_output_section_statement_type
*s
;
806 section_userdata_type
*new;
808 if (s
->bfd_section
!= NULL
)
811 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
812 einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME
);
814 new = ((section_userdata_type
*)
815 stat_alloc (sizeof (section_userdata_type
)));
817 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
818 if (s
->bfd_section
== (asection
*) NULL
)
819 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
820 if (s
->bfd_section
== (asection
*) NULL
)
822 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
823 output_bfd
->xvec
->name
, s
->name
);
825 s
->bfd_section
->output_section
= s
->bfd_section
;
827 /* We initialize an output sections output offset to minus its own
828 vma to allow us to output a section through itself. */
829 s
->bfd_section
->output_offset
= 0;
830 get_userdata (s
->bfd_section
) = (PTR
) new;
832 /* If there is a base address, make sure that any sections it might
833 mention are initialized. */
834 if (s
->addr_tree
!= NULL
)
835 exp_init_os (s
->addr_tree
);
838 /* Make sure that all output sections mentioned in an expression are
845 switch (exp
->type
.node_class
)
848 exp_init_os (exp
->assign
.src
);
852 exp_init_os (exp
->binary
.lhs
);
853 exp_init_os (exp
->binary
.rhs
);
857 exp_init_os (exp
->trinary
.cond
);
858 exp_init_os (exp
->trinary
.lhs
);
859 exp_init_os (exp
->trinary
.rhs
);
863 exp_init_os (exp
->unary
.child
);
867 switch (exp
->type
.node_code
)
873 lang_output_section_statement_type
*os
;
875 os
= lang_output_section_find (exp
->name
.name
);
876 if (os
!= NULL
&& os
->bfd_section
== NULL
)
887 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
888 once into the output. This routine checks each section, and
889 arrange to discard it if a section of the same name has already
890 been linked. If the section has COMDAT information, then it uses
891 that to decide whether the section should be included. This code
892 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
893 that is, it does not depend solely upon the section name.
894 section_already_linked is called via bfd_map_over_sections. */
896 /* This is the shape of the elements inside the already_linked hash
897 table. It maps a name onto a list of already_linked elements with
898 the same name. It's possible to get more than one element in a
899 list if the COMDAT sections have different names. */
901 struct already_linked_hash_entry
903 struct bfd_hash_entry root
;
904 struct already_linked
*entry
;
907 struct already_linked
909 struct already_linked
*next
;
913 /* The hash table. */
915 static struct bfd_hash_table already_linked_table
;
918 section_already_linked (abfd
, sec
, data
)
923 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
926 struct already_linked
*l
;
927 struct already_linked_hash_entry
*already_linked_list
;
929 /* If we are only reading symbols from this object, then we want to
930 discard all sections. */
931 if (entry
->just_syms_flag
)
933 sec
->output_section
= bfd_abs_section_ptr
;
934 sec
->output_offset
= sec
->vma
;
938 flags
= bfd_get_section_flags (abfd
, sec
);
940 if ((flags
& SEC_LINK_ONCE
) == 0)
943 /* FIXME: When doing a relocatable link, we may have trouble
944 copying relocations in other sections that refer to local symbols
945 in the section being discarded. Those relocations will have to
946 be converted somehow; as of this writing I'm not sure that any of
947 the backends handle that correctly.
949 It is tempting to instead not discard link once sections when
950 doing a relocatable link (technically, they should be discarded
951 whenever we are building constructors). However, that fails,
952 because the linker winds up combining all the link once sections
953 into a single large link once section, which defeats the purpose
954 of having link once sections in the first place.
956 Also, not merging link once sections in a relocatable link
957 causes trouble for MIPS ELF, which relies in link once semantics
958 to handle the .reginfo section correctly. */
960 name
= bfd_get_section_name (abfd
, sec
);
962 already_linked_list
=
963 ((struct already_linked_hash_entry
*)
964 bfd_hash_lookup (&already_linked_table
, name
, true, false));
966 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
968 if (sec
->comdat
== NULL
969 || l
->sec
->comdat
== NULL
970 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
972 /* The section has already been linked. See if we should
974 switch (flags
& SEC_LINK_DUPLICATES
)
979 case SEC_LINK_DUPLICATES_DISCARD
:
982 case SEC_LINK_DUPLICATES_ONE_ONLY
:
983 if (sec
->comdat
== NULL
)
984 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
987 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
988 abfd
, name
, sec
->comdat
->name
);
991 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
992 /* FIXME: We should really dig out the contents of both
993 sections and memcmp them. The COFF/PE spec says that
994 the Microsoft linker does not implement this
995 correctly, so I'm not going to bother doing it
998 case SEC_LINK_DUPLICATES_SAME_SIZE
:
999 if (bfd_section_size (abfd
, sec
)
1000 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1001 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1006 /* Set the output_section field so that wild_doit does not
1007 create a lang_input_section structure for this section.
1008 Since there might be a symbol in the section being
1009 discarded, we must retain a pointer to the section which
1010 we are really going to use. */
1011 sec
->output_section
= bfd_abs_section_ptr
;
1012 sec
->kept_section
= l
->sec
;
1018 /* This is the first section with this name. Record it. Allocate
1019 the memory from the same obstack as the hash table is kept in. */
1021 l
= ((struct already_linked
*)
1022 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1025 l
->next
= already_linked_list
->entry
;
1026 already_linked_list
->entry
= l
;
1029 /* Support routines for the hash table used by section_already_linked,
1030 initialize the table, fill in an entry and remove the table. */
1032 static struct bfd_hash_entry
*
1033 already_linked_newfunc (entry
, table
, string
)
1034 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1035 struct bfd_hash_table
*table
;
1036 const char *string ATTRIBUTE_UNUSED
;
1038 struct already_linked_hash_entry
*ret
=
1039 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1043 return (struct bfd_hash_entry
*) ret
;
1047 already_linked_table_init ()
1049 if (! bfd_hash_table_init_n (&already_linked_table
,
1050 already_linked_newfunc
,
1052 einfo (_("%P%F: Failed to create hash table\n"));
1056 already_linked_table_free ()
1058 bfd_hash_table_free (&already_linked_table
);
1061 /* The wild routines.
1063 These expand statements like *(.text) and foo.o to a list of
1064 explicit actions, like foo.o(.text), bar.o(.text) and
1065 foo.o(.text, .data). */
1067 /* Return true if the PATTERN argument is a wildcard pattern.
1068 Although backslashes are treated specially if a pattern contains
1069 wildcards, we do not consider the mere presence of a backslash to
1070 be enough to cause the the pattern to be treated as a wildcard.
1071 That lets us handle DOS filenames more naturally. */
1075 const char *pattern
;
1079 for (s
= pattern
; *s
!= '\0'; ++s
)
1087 /* Add SECTION to the output section OUTPUT. Do this by creating a
1088 lang_input_section statement which is placed at PTR. FILE is the
1089 input file which holds SECTION. */
1092 wild_doit (ptr
, section
, output
, file
)
1093 lang_statement_list_type
*ptr
;
1095 lang_output_section_statement_type
*output
;
1096 lang_input_statement_type
*file
;
1101 flags
= bfd_get_section_flags (section
->owner
, section
);
1105 /* If we are doing a final link, discard sections marked with
1107 if (! link_info
.relocateable
1108 && (flags
& SEC_EXCLUDE
) != 0)
1111 /* Discard input sections which are assigned to a section named
1112 DISCARD_SECTION_NAME. */
1113 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1116 /* Discard debugging sections if we are stripping debugging
1118 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1119 && (flags
& SEC_DEBUGGING
) != 0)
1124 if (section
->output_section
== NULL
)
1126 /* This prevents future calls from assigning this section. */
1127 section
->output_section
= bfd_abs_section_ptr
;
1132 if (section
->output_section
== NULL
)
1135 lang_input_section_type
*new;
1138 if (output
->bfd_section
== NULL
)
1146 /* Add a section reference to the list. */
1147 new = new_stat (lang_input_section
, ptr
);
1149 new->section
= section
;
1151 section
->output_section
= output
->bfd_section
;
1153 flags
= section
->flags
;
1155 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1156 to an output section, because we want to be able to include a
1157 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1158 section (I don't know why we want to do this, but we do).
1159 build_link_order in ldwrite.c handles this case by turning
1160 the embedded SEC_NEVER_LOAD section into a fill. */
1162 flags
&= ~ SEC_NEVER_LOAD
;
1164 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1165 already been processed. One reason to do this is that on pe
1166 format targets, .text$foo sections go into .text and it's odd
1167 to see .text with SEC_LINK_ONCE set. */
1169 if (! link_info
.relocateable
)
1170 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1172 /* If this is not the first input section, and the SEC_READONLY
1173 flag is not currently set, then don't set it just because the
1174 input section has it set. */
1176 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1177 flags
&= ~ SEC_READONLY
;
1179 section
->output_section
->flags
|= flags
;
1181 /* If SEC_READONLY is not set in the input section, then clear
1182 it from the output section. */
1183 if ((section
->flags
& SEC_READONLY
) == 0)
1184 section
->output_section
->flags
&= ~SEC_READONLY
;
1186 switch (output
->sectype
)
1188 case normal_section
:
1193 case overlay_section
:
1194 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1196 case noload_section
:
1197 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1198 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1202 /* Copy over SEC_SMALL_DATA. */
1203 if (section
->flags
& SEC_SMALL_DATA
)
1204 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1206 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1207 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1209 /* If supplied an aligment, then force it. */
1210 if (output
->section_alignment
!= -1)
1211 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1213 if (section
->flags
& SEC_BLOCK
)
1215 section
->output_section
->flags
|= SEC_BLOCK
;
1216 /* FIXME: This value should really be obtained from the bfd... */
1217 output
->block_value
= 128;
1222 /* Handle wildcard sorting. This returns the lang_input_section which
1223 should follow the one we are going to create for SECTION and FILE,
1224 based on the sorting requirements of WILD. It returns NULL if the
1225 new section should just go at the end of the current list. */
1227 static lang_statement_union_type
*
1228 wild_sort (wild
, file
, section
)
1229 lang_wild_statement_type
*wild
;
1230 lang_input_statement_type
*file
;
1233 const char *section_name
;
1234 lang_statement_union_type
*l
;
1236 if (! wild
->filenames_sorted
&& ! wild
->sections_sorted
)
1239 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1240 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->next
)
1242 lang_input_section_type
*ls
;
1244 if (l
->header
.type
!= lang_input_section_enum
)
1246 ls
= &l
->input_section
;
1248 /* Sorting by filename takes precedence over sorting by section
1251 if (wild
->filenames_sorted
)
1253 const char *fn
, *ln
;
1257 /* The PE support for the .idata section as generated by
1258 dlltool assumes that files will be sorted by the name of
1259 the archive and then the name of the file within the
1262 if (file
->the_bfd
!= NULL
1263 && bfd_my_archive (file
->the_bfd
) != NULL
)
1265 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1270 fn
= file
->filename
;
1274 if (ls
->ifile
->the_bfd
!= NULL
1275 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1277 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1282 ln
= ls
->ifile
->filename
;
1286 i
= strcmp (fn
, ln
);
1295 fn
= file
->filename
;
1297 ln
= ls
->ifile
->filename
;
1299 i
= strcmp (fn
, ln
);
1307 /* Here either the files are not sorted by name, or we are
1308 looking at the sections for this file. */
1310 if (wild
->sections_sorted
)
1312 if (strcmp (section_name
,
1313 bfd_get_section_name (ls
->ifile
->the_bfd
,
1323 /* Expand a wild statement for a particular FILE. SECTION may be
1324 NULL, in which case it is a wild card. */
1327 output_section_callback (ptr
, section
, file
, output
)
1328 lang_wild_statement_type
*ptr
;
1330 lang_input_statement_type
*file
;
1333 lang_statement_union_type
*before
;
1335 /* If the wild pattern was marked KEEP, the member sections
1336 should be as well. */
1337 if (ptr
->keep_sections
)
1338 section
->flags
|= SEC_KEEP
;
1340 before
= wild_sort (ptr
, file
, section
);
1342 /* Here BEFORE points to the lang_input_section which
1343 should follow the one we are about to add. If BEFORE
1344 is NULL, then the section should just go at the end
1345 of the current list. */
1348 wild_doit (&ptr
->children
, section
,
1349 (lang_output_section_statement_type
*) output
,
1353 lang_statement_list_type list
;
1354 lang_statement_union_type
**pp
;
1356 lang_list_init (&list
);
1357 wild_doit (&list
, section
,
1358 (lang_output_section_statement_type
*) output
,
1361 /* If we are discarding the section, LIST.HEAD will
1363 if (list
.head
!= NULL
)
1365 ASSERT (list
.head
->next
== NULL
);
1367 for (pp
= &ptr
->children
.head
;
1370 ASSERT (*pp
!= NULL
);
1372 list
.head
->next
= *pp
;
1378 /* This is passed a file name which must have been seen already and
1379 added to the statement tree. We will see if it has been opened
1380 already and had its symbols read. If not then we'll read it. */
1382 static lang_input_statement_type
*
1386 lang_input_statement_type
*search
;
1388 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1389 search
!= (lang_input_statement_type
*) NULL
;
1390 search
= (lang_input_statement_type
*) search
->next_real_file
)
1392 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1394 if (search
->filename
!= (char *) NULL
1395 && name
!= (char *) NULL
1396 && strcmp (search
->filename
, name
) == 0)
1400 if (search
== (lang_input_statement_type
*) NULL
)
1401 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1404 /* If we have already added this file, or this file is not real
1405 (FIXME: can that ever actually happen?) or the name is NULL
1406 (FIXME: can that ever actually happen?) don't add this file. */
1409 || search
->filename
== (const char *) NULL
)
1412 load_symbols (search
, (lang_statement_list_type
*) NULL
);
1417 /* Get the symbols for an input file. */
1420 load_symbols (entry
, place
)
1421 lang_input_statement_type
*entry
;
1422 lang_statement_list_type
*place
;
1429 ldfile_open_file (entry
);
1431 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1432 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1435 lang_statement_list_type
*hold
;
1437 err
= bfd_get_error ();
1438 if (err
== bfd_error_file_ambiguously_recognized
)
1442 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1443 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1444 for (p
= matching
; *p
!= NULL
; p
++)
1448 else if (err
!= bfd_error_file_not_recognized
1450 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1452 bfd_close (entry
->the_bfd
);
1453 entry
->the_bfd
= NULL
;
1455 /* See if the emulation has some special knowledge. */
1457 if (ldemul_unrecognized_file (entry
))
1460 /* Try to interpret the file as a linker script. */
1462 ldfile_open_command_file (entry
->filename
);
1467 ldfile_assumed_script
= true;
1468 parser_input
= input_script
;
1470 ldfile_assumed_script
= false;
1477 if (ldemul_recognized_file (entry
))
1480 /* We don't call ldlang_add_file for an archive. Instead, the
1481 add_symbols entry point will call ldlang_add_file, via the
1482 add_archive_element callback, for each element of the archive
1484 switch (bfd_get_format (entry
->the_bfd
))
1490 ldlang_add_file (entry
);
1491 if (trace_files
|| trace_file_tries
)
1492 info_msg ("%I\n", entry
);
1496 if (entry
->whole_archive
)
1498 bfd
*member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1500 while (member
!= NULL
)
1502 if (! bfd_check_format (member
, bfd_object
))
1503 einfo (_("%F%B: object %B in archive is not object\n"),
1504 entry
->the_bfd
, member
);
1505 if (! ((*link_info
.callbacks
->add_archive_element
)
1506 (&link_info
, member
, "--whole-archive")))
1508 if (! bfd_link_add_symbols (member
, &link_info
))
1509 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1510 member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1514 entry
->loaded
= true;
1520 if (! bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1521 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1523 entry
->loaded
= true;
1526 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1527 indicating that it is a wildcard. Separate lang_input_section
1528 statements are created for each part of the expansion; they are
1529 added after the wild statement S. OUTPUT is the output section. */
1532 wild (s
, section
, file
, target
, output
)
1533 lang_wild_statement_type
*s
;
1534 const char *section
;
1536 const char *target ATTRIBUTE_UNUSED
;
1537 lang_output_section_statement_type
*output
;
1539 walk_wild (s
, section
, file
, output_section_callback
, (PTR
) output
);
1541 if (section
!= (char *) NULL
1542 && strcmp (section
, "COMMON") == 0
1543 && default_common_section
== NULL
)
1545 /* Remember the section that common is going to in case we later
1546 get something which doesn't know where to put it. */
1547 default_common_section
= output
;
1551 /* Return true iff target is the sought target. */
1554 get_target (target
, data
)
1555 const bfd_target
*target
;
1558 const char *sought
= (const char *) data
;
1560 return strcmp (target
->name
, sought
) == 0;
1563 /* Like strcpy() but convert to lower case as well. */
1572 while ((c
= *src
++) != 0)
1574 if (isupper ((unsigned char) c
))
1583 /* Remove the first occurance of needle (if any) in haystack
1587 strcut (haystack
, needle
)
1591 haystack
= strstr (haystack
, needle
);
1597 for (src
= haystack
+ strlen (needle
); *src
;)
1598 *haystack
++ = *src
++;
1604 /* Compare two target format name strings.
1605 Return a value indicating how "similar" they are. */
1608 name_compare (first
, second
)
1616 copy1
= xmalloc (strlen (first
) + 1);
1617 copy2
= xmalloc (strlen (second
) + 1);
1619 /* Convert the names to lower case. */
1620 stricpy (copy1
, first
);
1621 stricpy (copy2
, second
);
1623 /* Remove and endian strings from the name. */
1624 strcut (copy1
, "big");
1625 strcut (copy1
, "little");
1626 strcut (copy2
, "big");
1627 strcut (copy2
, "little");
1629 /* Return a value based on how many characters match,
1630 starting from the beginning. If both strings are
1631 the same then return 10 * their length. */
1632 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1633 if (copy1
[result
] == 0)
1645 /* Set by closest_target_match() below. */
1646 static const bfd_target
*winner
;
1648 /* Scan all the valid bfd targets looking for one that has the endianness
1649 requirement that was specified on the command line, and is the nearest
1650 match to the original output target. */
1653 closest_target_match (target
, data
)
1654 const bfd_target
*target
;
1657 const bfd_target
*original
= (const bfd_target
*) data
;
1659 if (command_line
.endian
== ENDIAN_BIG
1660 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1663 if (command_line
.endian
== ENDIAN_LITTLE
1664 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1667 /* Must be the same flavour. */
1668 if (target
->flavour
!= original
->flavour
)
1671 /* If we have not found a potential winner yet, then record this one. */
1678 /* Oh dear, we now have two potential candidates for a successful match.
1679 Compare their names and choose the better one. */
1680 if (name_compare (target
->name
, original
->name
) > name_compare (winner
->name
, original
->name
))
1683 /* Keep on searching until wqe have checked them all. */
1687 /* Return the BFD target format of the first input file. */
1690 get_first_input_target ()
1692 char *target
= NULL
;
1694 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1696 if (s
->header
.type
== lang_input_statement_enum
1699 ldfile_open_file (s
);
1701 if (s
->the_bfd
!= NULL
1702 && bfd_check_format (s
->the_bfd
, bfd_object
))
1704 target
= bfd_get_target (s
->the_bfd
);
1715 /* Open the output file. */
1723 /* Has the user told us which output format to use? */
1724 if (output_target
== (char *) NULL
)
1726 /* No - has the current target been set to something other than
1728 if (current_target
!= default_target
)
1729 output_target
= current_target
;
1731 /* No - can we determine the format of the first input file? */
1734 output_target
= get_first_input_target ();
1736 /* Failed - use the default output target. */
1737 if (output_target
== NULL
)
1738 output_target
= default_target
;
1742 /* Has the user requested a particular endianness on the command
1744 if (command_line
.endian
!= ENDIAN_UNSET
)
1746 const bfd_target
*target
;
1747 enum bfd_endian desired_endian
;
1749 /* Get the chosen target. */
1750 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1752 /* If the target is not supported, we cannot do anything. */
1755 if (command_line
.endian
== ENDIAN_BIG
)
1756 desired_endian
= BFD_ENDIAN_BIG
;
1758 desired_endian
= BFD_ENDIAN_LITTLE
;
1760 /* See if the target has the wrong endianness. This should
1761 not happen if the linker script has provided big and
1762 little endian alternatives, but some scrips don't do
1764 if (target
->byteorder
!= desired_endian
)
1766 /* If it does, then see if the target provides
1767 an alternative with the correct endianness. */
1768 if (target
->alternative_target
!= NULL
1769 && (target
->alternative_target
->byteorder
== desired_endian
))
1770 output_target
= target
->alternative_target
->name
;
1773 /* Try to find a target as similar as possible to
1774 the default target, but which has the desired
1775 endian characteristic. */
1776 (void) bfd_search_for_target (closest_target_match
, (PTR
) target
);
1778 /* Oh dear - we could not find any targets that
1779 satisfy our requirements. */
1781 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1783 output_target
= winner
->name
;
1789 output
= bfd_openw (name
, output_target
);
1791 if (output
== (bfd
*) NULL
)
1793 if (bfd_get_error () == bfd_error_invalid_target
)
1794 einfo (_("%P%F: target %s not found\n"), output_target
);
1796 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1799 delete_output_file_on_failure
= true;
1802 output
->flags
|= D_PAGED
;
1805 if (! bfd_set_format (output
, bfd_object
))
1806 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1807 if (! bfd_set_arch_mach (output
,
1808 ldfile_output_architecture
,
1809 ldfile_output_machine
))
1810 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1812 link_info
.hash
= bfd_link_hash_table_create (output
);
1813 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1814 einfo (_("%P%F: can not create link hash table: %E\n"));
1816 bfd_set_gp_size (output
, g_switch_value
);
1821 ldlang_open_output (statement
)
1822 lang_statement_union_type
*statement
;
1824 switch (statement
->header
.type
)
1826 case lang_output_statement_enum
:
1827 ASSERT (output_bfd
== (bfd
*) NULL
);
1828 output_bfd
= open_output (statement
->output_statement
.name
);
1829 ldemul_set_output_arch ();
1830 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1831 output_bfd
->flags
|= D_PAGED
;
1833 output_bfd
->flags
&= ~D_PAGED
;
1834 if (config
.text_read_only
)
1835 output_bfd
->flags
|= WP_TEXT
;
1837 output_bfd
->flags
&= ~WP_TEXT
;
1838 if (link_info
.traditional_format
)
1839 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1841 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1844 case lang_target_statement_enum
:
1845 current_target
= statement
->target_statement
.target
;
1852 /* Open all the input files. */
1855 open_input_bfds (s
, force
)
1856 lang_statement_union_type
*s
;
1859 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1861 switch (s
->header
.type
)
1863 case lang_constructors_statement_enum
:
1864 open_input_bfds (constructor_list
.head
, force
);
1866 case lang_output_section_statement_enum
:
1867 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1869 case lang_wild_statement_enum
:
1870 /* Maybe we should load the file's symbols. */
1871 if (s
->wild_statement
.filename
1872 && ! wildcardp (s
->wild_statement
.filename
))
1873 (void) lookup_name (s
->wild_statement
.filename
);
1874 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1876 case lang_group_statement_enum
:
1878 struct bfd_link_hash_entry
*undefs
;
1880 /* We must continually search the entries in the group
1881 until no new symbols are added to the list of undefined
1886 undefs
= link_info
.hash
->undefs_tail
;
1887 open_input_bfds (s
->group_statement
.children
.head
, true);
1889 while (undefs
!= link_info
.hash
->undefs_tail
);
1892 case lang_target_statement_enum
:
1893 current_target
= s
->target_statement
.target
;
1895 case lang_input_statement_enum
:
1896 if (s
->input_statement
.real
)
1898 lang_statement_list_type add
;
1899 bfd_error_handler_type pfn
;
1901 s
->input_statement
.target
= current_target
;
1903 /* If we are being called from within a group, and this
1904 is an archive which has already been searched, then
1905 force it to be researched unless the whole archive
1906 has been loaded already. */
1908 && !s
->input_statement
.whole_archive
1909 && s
->input_statement
.loaded
1910 && bfd_check_format (s
->input_statement
.the_bfd
,
1912 s
->input_statement
.loaded
= false;
1914 lang_list_init (& add
);
1916 /* We need to know if an error occurs whilst loading the
1917 symbols, since this means that a valid executable can
1919 pfn
= bfd_set_error_handler (record_bfd_errors
);
1921 load_symbols (&s
->input_statement
, &add
);
1923 bfd_set_error_handler (pfn
);
1925 if (add
.head
!= NULL
)
1927 *add
.tail
= s
->next
;
1938 /* If there are [COMMONS] statements, put a wild one into the bss
1942 lang_reasonable_defaults ()
1945 lang_output_section_statement_lookup (".text");
1946 lang_output_section_statement_lookup (".data");
1948 default_common_section
= lang_output_section_statement_lookup (".bss");
1950 if (placed_commons
== false)
1952 lang_wild_statement_type
*new =
1953 new_stat (lang_wild_statement
,
1954 &default_common_section
->children
);
1956 new->section_name
= "COMMON";
1957 new->filename
= (char *) NULL
;
1958 lang_list_init (&new->children
);
1963 /* Add the supplied name to the symbol table as an undefined reference.
1964 Remove items from the chain as we open input bfds. */
1965 typedef struct ldlang_undef_chain_list
1967 struct ldlang_undef_chain_list
*next
;
1969 } ldlang_undef_chain_list_type
;
1971 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
1974 ldlang_add_undef (name
)
1975 const char *const name
;
1977 ldlang_undef_chain_list_type
*new =
1978 ((ldlang_undef_chain_list_type
*)
1979 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
1981 new->next
= ldlang_undef_chain_list_head
;
1982 ldlang_undef_chain_list_head
= new;
1984 new->name
= buystring (name
);
1987 /* Run through the list of undefineds created above and place them
1988 into the linker hash table as undefined symbols belonging to the
1992 lang_place_undefineds ()
1994 ldlang_undef_chain_list_type
*ptr
;
1996 for (ptr
= ldlang_undef_chain_list_head
;
1997 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
2000 struct bfd_link_hash_entry
*h
;
2002 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
2003 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2004 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2005 if (h
->type
== bfd_link_hash_new
)
2007 h
->type
= bfd_link_hash_undefined
;
2008 h
->u
.undef
.abfd
= NULL
;
2009 bfd_link_add_undef (link_info
.hash
, h
);
2014 /* Open input files and attatch to output sections. */
2017 map_input_to_output_sections (s
, target
, output_section_statement
)
2018 lang_statement_union_type
*s
;
2020 lang_output_section_statement_type
*output_section_statement
;
2022 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2024 switch (s
->header
.type
)
2027 case lang_wild_statement_enum
:
2028 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
2029 s
->wild_statement
.filename
, target
,
2030 output_section_statement
);
2033 case lang_constructors_statement_enum
:
2034 map_input_to_output_sections (constructor_list
.head
,
2036 output_section_statement
);
2038 case lang_output_section_statement_enum
:
2039 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2041 &s
->output_section_statement
);
2043 case lang_output_statement_enum
:
2045 case lang_target_statement_enum
:
2046 target
= s
->target_statement
.target
;
2048 case lang_group_statement_enum
:
2049 map_input_to_output_sections (s
->group_statement
.children
.head
,
2051 output_section_statement
);
2053 case lang_fill_statement_enum
:
2054 case lang_input_section_enum
:
2055 case lang_object_symbols_statement_enum
:
2056 case lang_data_statement_enum
:
2057 case lang_reloc_statement_enum
:
2058 case lang_padding_statement_enum
:
2059 case lang_input_statement_enum
:
2060 if (output_section_statement
!= NULL
2061 && output_section_statement
->bfd_section
== NULL
)
2062 init_os (output_section_statement
);
2064 case lang_assignment_statement_enum
:
2065 if (output_section_statement
!= NULL
2066 && output_section_statement
->bfd_section
== NULL
)
2067 init_os (output_section_statement
);
2069 /* Make sure that any sections mentioned in the assignment
2071 exp_init_os (s
->assignment_statement
.exp
);
2073 case lang_afile_asection_pair_statement_enum
:
2076 case lang_address_statement_enum
:
2077 /* Mark the specified section with the supplied address. */
2079 lang_output_section_statement_type
*os
=
2080 lang_output_section_statement_lookup
2081 (s
->address_statement
.section_name
);
2083 if (os
->bfd_section
== NULL
)
2085 os
->addr_tree
= s
->address_statement
.address
;
2093 print_output_section_statement (output_section_statement
)
2094 lang_output_section_statement_type
*output_section_statement
;
2096 asection
*section
= output_section_statement
->bfd_section
;
2099 if (output_section_statement
!= abs_output_section
)
2101 minfo ("\n%s", output_section_statement
->name
);
2103 if (section
!= NULL
)
2105 print_dot
= section
->vma
;
2107 len
= strlen (output_section_statement
->name
);
2108 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2113 while (len
< SECTION_NAME_MAP_LENGTH
)
2119 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2121 if (output_section_statement
->load_base
!= NULL
)
2125 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2126 "load base", lang_final_phase_enum
);
2127 minfo (_(" load address 0x%V"), addr
);
2134 print_statement_list (output_section_statement
->children
.head
,
2135 output_section_statement
);
2139 print_assignment (assignment
, output_section
)
2140 lang_assignment_statement_type
*assignment
;
2141 lang_output_section_statement_type
*output_section
;
2144 etree_value_type result
;
2146 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2149 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2150 lang_final_phase_enum
, print_dot
, &print_dot
);
2152 minfo ("0x%V", result
.value
+ result
.section
->bfd_section
->vma
);
2163 exp_print_tree (assignment
->exp
);
2169 print_input_statement (statm
)
2170 lang_input_statement_type
*statm
;
2172 if (statm
->filename
!= (char *) NULL
)
2174 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2178 /* Print all symbols defined in a particular section. This is called
2179 via bfd_link_hash_traverse. */
2182 print_one_symbol (hash_entry
, ptr
)
2183 struct bfd_link_hash_entry
*hash_entry
;
2186 asection
*sec
= (asection
*) ptr
;
2188 if ((hash_entry
->type
== bfd_link_hash_defined
2189 || hash_entry
->type
== bfd_link_hash_defweak
)
2190 && sec
== hash_entry
->u
.def
.section
)
2194 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2197 (hash_entry
->u
.def
.value
2198 + hash_entry
->u
.def
.section
->output_offset
2199 + hash_entry
->u
.def
.section
->output_section
->vma
));
2201 minfo (" %T\n", hash_entry
->root
.string
);
2207 /* Print information about an input section to the map file. */
2210 print_input_section (in
)
2211 lang_input_section_type
*in
;
2213 asection
*i
= in
->section
;
2214 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2215 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2216 ldfile_output_machine
);
2221 minfo ("%s", i
->name
);
2223 if (i
->output_section
!= NULL
)
2227 len
= 1 + strlen (i
->name
);
2228 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2233 while (len
< SECTION_NAME_MAP_LENGTH
)
2239 minfo ("0x%V %W %B\n",
2240 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2243 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2245 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2257 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2260 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2262 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2268 print_fill_statement (fill
)
2269 lang_fill_statement_type
*fill
;
2271 fprintf (config
.map_file
, " FILL mask 0x%x\n", fill
->fill
);
2275 print_data_statement (data
)
2276 lang_data_statement_type
*data
;
2282 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2283 ldfile_output_machine
);
2285 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2288 addr
= data
->output_vma
;
2289 if (data
->output_section
!= NULL
)
2290 addr
+= data
->output_section
->vma
;
2318 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2320 if (data
->exp
->type
.node_class
!= etree_value
)
2323 exp_print_tree (data
->exp
);
2328 print_dot
= addr
+ size
/ opb
;
2332 /* Print an address statement. These are generated by options like
2336 print_address_statement (address
)
2337 lang_address_statement_type
*address
;
2339 minfo (_("Address of section %s set to "), address
->section_name
);
2340 exp_print_tree (address
->address
);
2344 /* Print a reloc statement. */
2347 print_reloc_statement (reloc
)
2348 lang_reloc_statement_type
*reloc
;
2353 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2354 ldfile_output_machine
);
2356 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2359 addr
= reloc
->output_vma
;
2360 if (reloc
->output_section
!= NULL
)
2361 addr
+= reloc
->output_section
->vma
;
2363 size
= bfd_get_reloc_size (reloc
->howto
);
2365 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2367 if (reloc
->name
!= NULL
)
2368 minfo ("%s+", reloc
->name
);
2370 minfo ("%s+", reloc
->section
->name
);
2372 exp_print_tree (reloc
->addend_exp
);
2376 print_dot
= addr
+ size
/ opb
;
2380 print_padding_statement (s
)
2381 lang_padding_statement_type
*s
;
2385 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2386 ldfile_output_machine
);
2390 len
= sizeof " *fill*" - 1;
2391 while (len
< SECTION_NAME_MAP_LENGTH
)
2397 addr
= s
->output_offset
;
2398 if (s
->output_section
!= NULL
)
2399 addr
+= s
->output_section
->vma
;
2400 minfo ("0x%V %W", addr
, s
->size
);
2403 minfo (" %u", s
->fill
);
2407 print_dot
= addr
+ s
->size
/ opb
;
2411 print_wild_statement (w
, os
)
2412 lang_wild_statement_type
*w
;
2413 lang_output_section_statement_type
*os
;
2417 if (w
->filenames_sorted
)
2419 if (w
->exclude_filename_list
!= NULL
)
2422 minfo ("EXCLUDE_FILE ( %s", w
->exclude_filename_list
->name
);
2423 for (tmp
= w
->exclude_filename_list
->next
; tmp
; tmp
= tmp
->next
)
2424 minfo (", %s", tmp
->name
);
2427 if (w
->filename
!= NULL
)
2428 minfo ("%s", w
->filename
);
2431 if (w
->filenames_sorted
)
2435 if (w
->sections_sorted
)
2437 if (w
->section_name
!= NULL
)
2438 minfo ("%s", w
->section_name
);
2441 if (w
->sections_sorted
)
2447 print_statement_list (w
->children
.head
, os
);
2450 /* Print a group statement. */
2454 lang_group_statement_type
*s
;
2455 lang_output_section_statement_type
*os
;
2457 fprintf (config
.map_file
, "START GROUP\n");
2458 print_statement_list (s
->children
.head
, os
);
2459 fprintf (config
.map_file
, "END GROUP\n");
2462 /* Print the list of statements in S.
2463 This can be called for any statement type. */
2466 print_statement_list (s
, os
)
2467 lang_statement_union_type
*s
;
2468 lang_output_section_statement_type
*os
;
2472 print_statement (s
, os
);
2477 /* Print the first statement in statement list S.
2478 This can be called for any statement type. */
2481 print_statement (s
, os
)
2482 lang_statement_union_type
*s
;
2483 lang_output_section_statement_type
*os
;
2485 switch (s
->header
.type
)
2488 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2491 case lang_constructors_statement_enum
:
2492 if (constructor_list
.head
!= NULL
)
2494 if (constructors_sorted
)
2495 minfo (" SORT (CONSTRUCTORS)\n");
2497 minfo (" CONSTRUCTORS\n");
2498 print_statement_list (constructor_list
.head
, os
);
2501 case lang_wild_statement_enum
:
2502 print_wild_statement (&s
->wild_statement
, os
);
2504 case lang_address_statement_enum
:
2505 print_address_statement (&s
->address_statement
);
2507 case lang_object_symbols_statement_enum
:
2508 minfo (" CREATE_OBJECT_SYMBOLS\n");
2510 case lang_fill_statement_enum
:
2511 print_fill_statement (&s
->fill_statement
);
2513 case lang_data_statement_enum
:
2514 print_data_statement (&s
->data_statement
);
2516 case lang_reloc_statement_enum
:
2517 print_reloc_statement (&s
->reloc_statement
);
2519 case lang_input_section_enum
:
2520 print_input_section (&s
->input_section
);
2522 case lang_padding_statement_enum
:
2523 print_padding_statement (&s
->padding_statement
);
2525 case lang_output_section_statement_enum
:
2526 print_output_section_statement (&s
->output_section_statement
);
2528 case lang_assignment_statement_enum
:
2529 print_assignment (&s
->assignment_statement
, os
);
2531 case lang_target_statement_enum
:
2532 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2534 case lang_output_statement_enum
:
2535 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2536 if (output_target
!= NULL
)
2537 minfo (" %s", output_target
);
2540 case lang_input_statement_enum
:
2541 print_input_statement (&s
->input_statement
);
2543 case lang_group_statement_enum
:
2544 print_group (&s
->group_statement
, os
);
2546 case lang_afile_asection_pair_statement_enum
:
2555 print_statement_list (statement_list
.head
, abs_output_section
);
2558 /* Print the first N statements in statement list S to STDERR.
2559 If N == 0, nothing is printed.
2560 If N < 0, the entire list is printed.
2561 Intended to be called from GDB. */
2564 dprint_statement (s
, n
)
2565 lang_statement_union_type
*s
;
2568 FILE *map_save
= config
.map_file
;
2570 config
.map_file
= stderr
;
2573 print_statement_list (s
, abs_output_section
);
2576 while (s
&& --n
>= 0)
2578 print_statement (s
, abs_output_section
);
2583 config
.map_file
= map_save
;
2587 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
2588 lang_statement_union_type
**this_ptr
;
2591 asection
*output_section_statement
;
2594 /* Align this section first to the
2595 input sections requirement, then
2596 to the output section's requirement.
2597 If this alignment is > than any seen before,
2598 then record it too. Perform the alignment by
2599 inserting a magic 'padding' statement. */
2601 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2602 ldfile_output_machine
);
2603 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
2605 if (alignment_needed
!= 0)
2607 lang_statement_union_type
*new =
2608 ((lang_statement_union_type
*)
2609 stat_alloc (sizeof (lang_padding_statement_type
)));
2611 /* Link into existing chain. */
2612 new->header
.next
= *this_ptr
;
2614 new->header
.type
= lang_padding_statement_enum
;
2615 new->padding_statement
.output_section
= output_section_statement
;
2616 new->padding_statement
.output_offset
=
2617 dot
- output_section_statement
->vma
;
2618 new->padding_statement
.fill
= fill
;
2619 new->padding_statement
.size
= alignment_needed
* opb
;
2622 /* Remember the most restrictive alignment. */
2623 if (power
> output_section_statement
->alignment_power
)
2625 output_section_statement
->alignment_power
= power
;
2627 output_section_statement
->_raw_size
+= alignment_needed
* opb
;
2629 return dot
+ alignment_needed
;
2632 /* Work out how much this section will move the dot point. */
2635 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
2636 lang_statement_union_type
**this_ptr
;
2637 lang_output_section_statement_type
*output_section_statement
;
2640 boolean relax ATTRIBUTE_UNUSED
;
2642 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2643 asection
*i
= is
->section
;
2644 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2645 ldfile_output_machine
);
2647 if (is
->ifile
->just_syms_flag
== false)
2649 if (output_section_statement
->subsection_alignment
!= -1)
2650 i
->alignment_power
=
2651 output_section_statement
->subsection_alignment
;
2653 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
2654 output_section_statement
->bfd_section
, dot
);
2656 /* Remember where in the output section this input section goes. */
2658 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
2660 /* Mark how big the output section must be to contain this now. */
2661 if (i
->_cooked_size
!= 0)
2662 dot
+= i
->_cooked_size
/ opb
;
2664 dot
+= i
->_raw_size
/ opb
;
2665 output_section_statement
->bfd_section
->_raw_size
=
2666 (dot
- output_section_statement
->bfd_section
->vma
) * opb
;
2670 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2676 #define IGNORE_SECTION(bfd, s) \
2677 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) != (SEC_ALLOC | SEC_LOAD)) \
2678 || bfd_section_size (bfd, s) == 0)
2679 /* Check to see if any allocated sections overlap with other allocated
2680 sections. This can happen when the linker script specifically specifies
2681 the output section addresses of the two sections. */
2684 lang_check_section_addresses ()
2687 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2690 /* Scan all sections in the output list. */
2691 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2695 /* Ignore sections which are not loaded or which have no contents. */
2696 if (IGNORE_SECTION (output_bfd
, s
))
2699 /* Once we reach section 's' stop our seach. This prevents two
2700 warning messages from being produced, one for 'section A overlaps
2701 section B' and one for 'section B overlaps section A'. */
2702 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2709 /* Only consider loadable sections with real contents. */
2710 if (IGNORE_SECTION (output_bfd
, os
))
2713 /* We must check the sections' LMA addresses not their
2714 VMA addresses because overlay sections can have
2715 overlapping VMAs but they must have distinct LMAs. */
2716 s_start
= bfd_section_lma (output_bfd
, s
);
2717 os_start
= bfd_section_lma (output_bfd
, os
);
2718 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2719 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2721 /* Look for an overlap. */
2722 if ((s_end
< os_start
) || (s_start
> os_end
))
2726 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2727 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2729 /* Once we have found one overlap for this section,
2730 stop looking for others. */
2736 /* This variable indicates whether bfd_relax_section should be called
2739 static boolean relax_again
;
2741 /* Make sure the new address is within the region. We explicitly permit the
2742 current address to be at the exact end of the region when the address is
2743 non-zero, in case the region is at the end of addressable memory and the
2744 calculation wraps around. */
2747 os_region_check (os
, region
, tree
, base
)
2748 lang_output_section_statement_type
*os
;
2749 struct memory_region_struct
*region
;
2753 if ((region
->current
< region
->origin
2754 || (region
->current
- region
->origin
> region
->length
))
2755 && ((region
->current
!= region
->origin
+ region
->length
)
2758 if (tree
!= (etree_type
*) NULL
)
2760 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2762 os
->bfd_section
->owner
,
2763 os
->bfd_section
->name
,
2768 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2770 os
->bfd_section
->owner
,
2771 os
->bfd_section
->name
);
2773 /* Reset the region pointer. */
2774 region
->current
= region
->origin
;
2778 /* Set the sizes for all the output sections. */
2781 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2782 lang_statement_union_type
*s
;
2783 lang_output_section_statement_type
*output_section_statement
;
2784 lang_statement_union_type
**prev
;
2789 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2790 ldfile_output_machine
);
2792 /* Size up the sections from their constituent parts. */
2793 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2795 switch (s
->header
.type
)
2797 case lang_output_section_statement_enum
:
2800 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
2802 if (os
->bfd_section
== NULL
)
2803 /* This section was never actually created. */
2806 /* If this is a COFF shared library section, use the size and
2807 address from the input section. FIXME: This is COFF
2808 specific; it would be cleaner if there were some other way
2809 to do this, but nothing simple comes to mind. */
2810 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2814 if (os
->children
.head
== NULL
2815 || os
->children
.head
->next
!= NULL
2816 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2817 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2820 input
= os
->children
.head
->input_section
.section
;
2821 bfd_set_section_vma (os
->bfd_section
->owner
,
2823 bfd_section_vma (input
->owner
, input
));
2824 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2828 if (bfd_is_abs_section (os
->bfd_section
))
2830 /* No matter what happens, an abs section starts at zero. */
2831 ASSERT (os
->bfd_section
->vma
== 0);
2835 if (os
->addr_tree
== (etree_type
*) NULL
)
2837 /* No address specified for this section, get one
2838 from the region specification. */
2839 if (os
->region
== (lang_memory_region_type
*) NULL
2840 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2841 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2842 && os
->region
->name
[0] == '*'
2843 && strcmp (os
->region
->name
, "*default*") == 0))
2845 os
->region
= lang_memory_default (os
->bfd_section
);
2848 /* If a loadable section is using the default memory
2849 region, and some non default memory regions were
2850 defined, issue a warning. */
2851 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2852 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2853 && ! link_info
.relocateable
2854 && strcmp (os
->region
->name
, "*default*") == 0
2855 && lang_memory_region_list
!= NULL
2856 && (strcmp (lang_memory_region_list
->name
, "*default*") != 0
2857 || lang_memory_region_list
->next
!= NULL
))
2858 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2859 bfd_get_section_name (output_bfd
, os
->bfd_section
));
2861 dot
= os
->region
->current
;
2863 if (os
->section_alignment
== -1)
2868 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
2870 if (dot
!= olddot
&& config
.warn_section_align
)
2871 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2872 os
->name
, (unsigned int) (dot
- olddot
));
2879 r
= exp_fold_tree (os
->addr_tree
,
2881 lang_allocating_phase_enum
,
2883 if (r
.valid_p
== false)
2885 einfo (_("%F%S: non constant address expression for section %s\n"),
2888 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2891 /* The section starts here.
2892 First, align to what the section needs. */
2894 if (os
->section_alignment
!= -1)
2895 dot
= align_power (dot
, os
->section_alignment
);
2897 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2899 os
->bfd_section
->output_offset
= 0;
2902 (void) lang_size_sections (os
->children
.head
, os
,
2904 os
->fill
, dot
, relax
);
2906 /* Put the section within the requested block size, or
2907 align at the block boundary. */
2908 after
= ALIGN_N (os
->bfd_section
->vma
2909 + os
->bfd_section
->_raw_size
/ opb
,
2910 /* The coercion here is important, see ld.h. */
2911 (bfd_vma
) os
->block_value
);
2913 if (bfd_is_abs_section (os
->bfd_section
))
2914 ASSERT (after
== os
->bfd_section
->vma
);
2916 os
->bfd_section
->_raw_size
=
2917 (after
- os
->bfd_section
->vma
) * opb
;
2918 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
2919 os
->processed
= true;
2921 /* Update dot in the region ?
2922 We only do this if the section is going to be allocated,
2923 since unallocated sections do not contribute to the region's
2924 overall size in memory.
2926 If the SEC_NEVER_LOAD bit is not set, it will affect the
2927 addresses of sections after it. We have to update
2929 if (os
->region
!= (lang_memory_region_type
*) NULL
2930 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2931 & SEC_NEVER_LOAD
) == 0
2932 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2933 & (SEC_ALLOC
| SEC_LOAD
))))
2935 os
->region
->current
= dot
;
2937 /* Make sure the new address is within the region. */
2938 os_region_check (os
, os
->region
, os
->addr_tree
,
2939 os
->bfd_section
->vma
);
2941 /* If there's no load address specified, use the run
2942 region as the load region. */
2943 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
2944 os
->lma_region
= os
->region
;
2946 if (os
->lma_region
!= NULL
)
2948 if (os
->load_base
!= NULL
)
2950 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
2954 /* Don't allocate twice. */
2955 if (os
->lma_region
!= os
->region
)
2957 /* Set load_base, which will be handled later. */
2959 exp_intop (os
->lma_region
->current
);
2960 os
->lma_region
->current
+=
2961 os
->bfd_section
->_raw_size
/ opb
;
2962 os_region_check (os
, os
->lma_region
, NULL
,
2963 os
->bfd_section
->lma
);
2971 case lang_constructors_statement_enum
:
2972 dot
= lang_size_sections (constructor_list
.head
,
2973 output_section_statement
,
2974 &s
->wild_statement
.children
.head
,
2979 case lang_data_statement_enum
:
2981 unsigned int size
= 0;
2983 s
->data_statement
.output_vma
=
2984 dot
- output_section_statement
->bfd_section
->vma
;
2985 s
->data_statement
.output_section
=
2986 output_section_statement
->bfd_section
;
2988 switch (s
->data_statement
.type
)
3009 output_section_statement
->bfd_section
->_raw_size
+= size
;
3010 /* The output section gets contents, and then we inspect for
3011 any flags set in the input script which override any ALLOC. */
3012 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3013 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3015 output_section_statement
->bfd_section
->flags
|=
3016 SEC_ALLOC
| SEC_LOAD
;
3021 case lang_reloc_statement_enum
:
3025 s
->reloc_statement
.output_vma
=
3026 dot
- output_section_statement
->bfd_section
->vma
;
3027 s
->reloc_statement
.output_section
=
3028 output_section_statement
->bfd_section
;
3029 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3031 output_section_statement
->bfd_section
->_raw_size
+= size
;
3035 case lang_wild_statement_enum
:
3037 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
3038 output_section_statement
,
3039 &s
->wild_statement
.children
.head
,
3044 case lang_object_symbols_statement_enum
:
3045 link_info
.create_object_symbols_section
=
3046 output_section_statement
->bfd_section
;
3048 case lang_output_statement_enum
:
3049 case lang_target_statement_enum
:
3051 case lang_input_section_enum
:
3055 i
= (*prev
)->input_section
.section
;
3058 if (i
->_cooked_size
== 0)
3059 i
->_cooked_size
= i
->_raw_size
;
3065 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3066 einfo (_("%P%F: can't relax section: %E\n"));
3070 dot
= size_input_section (prev
,
3071 output_section_statement
,
3072 output_section_statement
->fill
,
3076 case lang_input_statement_enum
:
3078 case lang_fill_statement_enum
:
3079 s
->fill_statement
.output_section
=
3080 output_section_statement
->bfd_section
;
3082 fill
= s
->fill_statement
.fill
;
3084 case lang_assignment_statement_enum
:
3086 bfd_vma newdot
= dot
;
3088 exp_fold_tree (s
->assignment_statement
.exp
,
3089 output_section_statement
,
3090 lang_allocating_phase_enum
,
3096 /* The assignment changed dot. Insert a pad. */
3097 if (output_section_statement
== abs_output_section
)
3099 /* If we don't have an output section, then just adjust
3100 the default memory address. */
3101 lang_memory_region_lookup ("*default*")->current
= newdot
;
3105 lang_statement_union_type
*new =
3106 ((lang_statement_union_type
*)
3107 stat_alloc (sizeof (lang_padding_statement_type
)));
3109 /* Link into existing chain. */
3110 new->header
.next
= *prev
;
3112 new->header
.type
= lang_padding_statement_enum
;
3113 new->padding_statement
.output_section
=
3114 output_section_statement
->bfd_section
;
3115 new->padding_statement
.output_offset
=
3116 dot
- output_section_statement
->bfd_section
->vma
;
3117 new->padding_statement
.fill
= fill
;
3118 new->padding_statement
.size
= (newdot
- dot
) * opb
;
3119 output_section_statement
->bfd_section
->_raw_size
+=
3120 new->padding_statement
.size
;
3128 case lang_padding_statement_enum
:
3129 /* If we are relaxing, and this is not the first pass, some
3130 padding statements may have been inserted during previous
3131 passes. We may have to move the padding statement to a new
3132 location if dot has a different value at this point in this
3133 pass than it did at this point in the previous pass. */
3134 s
->padding_statement
.output_offset
=
3135 dot
- output_section_statement
->bfd_section
->vma
;
3136 dot
+= s
->padding_statement
.size
/ opb
;
3137 output_section_statement
->bfd_section
->_raw_size
+=
3138 s
->padding_statement
.size
;
3141 case lang_group_statement_enum
:
3142 dot
= lang_size_sections (s
->group_statement
.children
.head
,
3143 output_section_statement
,
3144 &s
->group_statement
.children
.head
,
3152 /* This can only get here when relaxing is turned on. */
3154 case lang_address_statement_enum
:
3157 prev
= &s
->header
.next
;
3163 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3164 lang_statement_union_type
*s
;
3165 lang_output_section_statement_type
*output_section_statement
;
3169 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3170 ldfile_output_machine
);
3172 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
3174 switch (s
->header
.type
)
3176 case lang_constructors_statement_enum
:
3177 dot
= lang_do_assignments (constructor_list
.head
,
3178 output_section_statement
,
3183 case lang_output_section_statement_enum
:
3185 lang_output_section_statement_type
*os
=
3186 &(s
->output_section_statement
);
3188 if (os
->bfd_section
!= NULL
)
3190 dot
= os
->bfd_section
->vma
;
3191 (void) lang_do_assignments (os
->children
.head
, os
,
3193 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3198 /* If nothing has been placed into the output section then
3199 it won't have a bfd_section. */
3200 if (os
->bfd_section
)
3202 os
->bfd_section
->lma
3203 = exp_get_abs_int (os
->load_base
, 0, "load base",
3204 lang_final_phase_enum
);
3209 case lang_wild_statement_enum
:
3211 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3212 output_section_statement
,
3217 case lang_object_symbols_statement_enum
:
3218 case lang_output_statement_enum
:
3219 case lang_target_statement_enum
:
3221 case lang_common_statement_enum
:
3224 case lang_data_statement_enum
:
3226 etree_value_type value
;
3228 value
= exp_fold_tree (s
->data_statement
.exp
,
3230 lang_final_phase_enum
, dot
, &dot
);
3231 s
->data_statement
.value
= value
.value
;
3232 if (value
.valid_p
== false)
3233 einfo (_("%F%P: invalid data statement\n"));
3237 switch (s
->data_statement
.type
)
3261 case lang_reloc_statement_enum
:
3263 etree_value_type value
;
3265 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3267 lang_final_phase_enum
, dot
, &dot
);
3268 s
->reloc_statement
.addend_value
= value
.value
;
3269 if (value
.valid_p
== false)
3270 einfo (_("%F%P: invalid reloc statement\n"));
3272 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3275 case lang_input_section_enum
:
3277 asection
*in
= s
->input_section
.section
;
3279 if (in
->_cooked_size
!= 0)
3280 dot
+= in
->_cooked_size
/ opb
;
3282 dot
+= in
->_raw_size
/ opb
;
3286 case lang_input_statement_enum
:
3288 case lang_fill_statement_enum
:
3289 fill
= s
->fill_statement
.fill
;
3291 case lang_assignment_statement_enum
:
3293 exp_fold_tree (s
->assignment_statement
.exp
,
3294 output_section_statement
,
3295 lang_final_phase_enum
,
3301 case lang_padding_statement_enum
:
3302 dot
+= s
->padding_statement
.size
/ opb
;
3305 case lang_group_statement_enum
:
3306 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3307 output_section_statement
,
3315 case lang_address_statement_enum
:
3323 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3324 operator .startof. (section_name), it produces an undefined symbol
3325 .startof.section_name. Similarly, when it sees
3326 .sizeof. (section_name), it produces an undefined symbol
3327 .sizeof.section_name. For all the output sections, we look for
3328 such symbols, and set them to the correct value. */
3335 if (link_info
.relocateable
)
3338 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3340 const char *secname
;
3342 struct bfd_link_hash_entry
*h
;
3344 secname
= bfd_get_section_name (output_bfd
, s
);
3345 buf
= xmalloc (10 + strlen (secname
));
3347 sprintf (buf
, ".startof.%s", secname
);
3348 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3349 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3351 h
->type
= bfd_link_hash_defined
;
3352 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3353 h
->u
.def
.section
= bfd_abs_section_ptr
;
3356 sprintf (buf
, ".sizeof.%s", secname
);
3357 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3358 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3360 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3361 ldfile_output_machine
);
3362 h
->type
= bfd_link_hash_defined
;
3363 if (s
->_cooked_size
!= 0)
3364 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3366 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3367 h
->u
.def
.section
= bfd_abs_section_ptr
;
3377 struct bfd_link_hash_entry
*h
;
3380 if (link_info
.relocateable
|| link_info
.shared
)
3385 if (entry_symbol
== (char *) NULL
)
3387 /* No entry has been specified. Look for start, but don't warn
3388 if we don't find it. */
3389 entry_symbol
= "start";
3393 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
3394 if (h
!= (struct bfd_link_hash_entry
*) NULL
3395 && (h
->type
== bfd_link_hash_defined
3396 || h
->type
== bfd_link_hash_defweak
)
3397 && h
->u
.def
.section
->output_section
!= NULL
)
3401 val
= (h
->u
.def
.value
3402 + bfd_get_section_vma (output_bfd
,
3403 h
->u
.def
.section
->output_section
)
3404 + h
->u
.def
.section
->output_offset
);
3405 if (! bfd_set_start_address (output_bfd
, val
))
3406 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
);
3413 /* We couldn't find the entry symbol. Try parsing it as a
3415 val
= bfd_scan_vma (entry_symbol
, &send
, 0);
3418 if (! bfd_set_start_address (output_bfd
, val
))
3419 einfo (_("%P%F: can't set start address\n"));
3425 /* Can't find the entry symbol, and it's not a number. Use
3426 the first address in the text section. */
3427 ts
= bfd_get_section_by_name (output_bfd
, ".text");
3428 if (ts
!= (asection
*) NULL
)
3431 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3432 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
3433 if (! bfd_set_start_address (output_bfd
,
3434 bfd_get_section_vma (output_bfd
,
3436 einfo (_("%P%F: can't set start address\n"));
3441 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3449 /* This is the routine to handle BFD error messages. */
3451 #ifdef ANSI_PROTOTYPES
3454 record_bfd_errors (const char *s
, ...)
3462 vfprintf (stderr
, s
, p
);
3466 fprintf (stderr
, "\n");
3471 #else /* ! defined (ANSI_PROTOTYPES) */
3474 record_bfd_errors (va_alist
)
3484 s
= va_arg (p
, const char *);
3485 vfprintf (stderr
, s
, p
);
3489 fprintf (stderr
, "\n");
3494 #endif /* ! defined (ANSI_PROTOTYPES) */
3495 /* This is a small function used when we want to ignore errors from
3499 #ifdef ANSI_PROTOTYPES
3500 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3502 ignore_bfd_errors (s
)
3503 const char *s ATTRIBUTE_UNUSED
;
3506 /* Don't do anything. */
3509 /* Check that the architecture of all the input files is compatible
3510 with the output file. Also call the backend to let it do any
3511 other checking that is needed. */
3516 lang_statement_union_type
*file
;
3518 const bfd_arch_info_type
*compatible
;
3520 for (file
= file_chain
.head
;
3521 file
!= (lang_statement_union_type
*) NULL
;
3522 file
= file
->input_statement
.next
)
3524 input_bfd
= file
->input_statement
.the_bfd
;
3525 compatible
= bfd_arch_get_compatible (input_bfd
,
3527 if (compatible
== NULL
)
3529 if (command_line
.warn_mismatch
)
3530 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3531 bfd_printable_name (input_bfd
), input_bfd
,
3532 bfd_printable_name (output_bfd
));
3534 else if (bfd_count_sections (input_bfd
))
3536 /* If the input bfd has no contents, it shouldn't set the
3537 private data of the output bfd. */
3539 bfd_error_handler_type pfn
= NULL
;
3541 /* If we aren't supposed to warn about mismatched input
3542 files, temporarily set the BFD error handler to a
3543 function which will do nothing. We still want to call
3544 bfd_merge_private_bfd_data, since it may set up
3545 information which is needed in the output file. */
3546 if (! command_line
.warn_mismatch
)
3547 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3548 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3550 if (command_line
.warn_mismatch
)
3551 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3554 if (! command_line
.warn_mismatch
)
3555 bfd_set_error_handler (pfn
);
3560 /* Look through all the global common symbols and attach them to the
3561 correct section. The -sort-common command line switch may be used
3562 to roughly sort the entries by size. */
3567 if (link_info
.relocateable
3568 && ! command_line
.force_common_definition
)
3571 if (! config
.sort_common
)
3572 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3577 for (power
= 4; power
>= 0; power
--)
3578 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3583 /* Place one common symbol in the correct section. */
3586 lang_one_common (h
, info
)
3587 struct bfd_link_hash_entry
*h
;
3590 unsigned int power_of_two
;
3593 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3594 ldfile_output_machine
);
3596 if (h
->type
!= bfd_link_hash_common
)
3600 power_of_two
= h
->u
.c
.p
->alignment_power
;
3602 if (config
.sort_common
3603 && power_of_two
< (unsigned int) *(int *) info
)
3606 section
= h
->u
.c
.p
->section
;
3608 /* Increase the size of the section. */
3609 section
->_cooked_size
= ALIGN_N ((section
->_cooked_size
+ opb
- 1) / opb
,
3610 (bfd_size_type
) (1 << power_of_two
)) * opb
;
3612 /* Adjust the alignment if necessary. */
3613 if (power_of_two
> section
->alignment_power
)
3614 section
->alignment_power
= power_of_two
;
3616 /* Change the symbol from common to defined. */
3617 h
->type
= bfd_link_hash_defined
;
3618 h
->u
.def
.section
= section
;
3619 h
->u
.def
.value
= section
->_cooked_size
;
3621 /* Increase the size of the section. */
3622 section
->_cooked_size
+= size
;
3624 /* Make sure the section is allocated in memory, and make sure that
3625 it is no longer a common section. */
3626 section
->flags
|= SEC_ALLOC
;
3627 section
->flags
&= ~SEC_IS_COMMON
;
3629 if (config
.map_file
!= NULL
)
3631 static boolean header_printed
;
3636 if (! header_printed
)
3638 minfo (_("\nAllocating common symbols\n"));
3639 minfo (_("Common symbol size file\n\n"));
3640 header_printed
= true;
3643 name
= demangle (h
->root
.string
);
3645 len
= strlen (name
);
3660 if (size
<= 0xffffffff)
3661 sprintf (buf
, "%lx", (unsigned long) size
);
3663 sprintf_vma (buf
, size
);
3673 minfo ("%B\n", section
->owner
);
3679 /* Run through the input files and ensure that every input section has
3680 somewhere to go. If one is found without a destination then create
3681 an input request and place it into the statement tree. */
3684 lang_place_orphans ()
3686 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3690 for (s
= file
->the_bfd
->sections
;
3691 s
!= (asection
*) NULL
;
3694 if (s
->output_section
== (asection
*) NULL
)
3696 /* This section of the file is not attatched, root
3697 around for a sensible place for it to go. */
3699 if (file
->just_syms_flag
)
3701 /* We are only retrieving symbol values from this
3702 file. We want the symbols to act as though the
3703 values in the file are absolute. */
3704 s
->output_section
= bfd_abs_section_ptr
;
3705 s
->output_offset
= s
->vma
;
3707 else if (strcmp (s
->name
, "COMMON") == 0)
3709 /* This is a lonely common section which must have
3710 come from an archive. We attach to the section
3711 with the wildcard. */
3712 if (! link_info
.relocateable
3713 || command_line
.force_common_definition
)
3715 if (default_common_section
== NULL
)
3718 /* This message happens when using the
3719 svr3.ifile linker script, so I have
3721 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3723 default_common_section
=
3724 lang_output_section_statement_lookup (".bss");
3727 wild_doit (&default_common_section
->children
, s
,
3728 default_common_section
, file
);
3731 else if (ldemul_place_orphan (file
, s
))
3735 lang_output_section_statement_type
*os
=
3736 lang_output_section_statement_lookup (s
->name
);
3738 wild_doit (&os
->children
, s
, os
, file
);
3746 lang_set_flags (ptr
, flags
, invert
)
3747 lang_memory_region_type
*ptr
;
3751 flagword
*ptr_flags
;
3753 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3759 *ptr_flags
|= SEC_ALLOC
;
3763 *ptr_flags
|= SEC_READONLY
;
3767 *ptr_flags
|= SEC_DATA
;
3771 *ptr_flags
|= SEC_CODE
;
3776 *ptr_flags
|= SEC_LOAD
;
3780 einfo (_("%P%F: invalid syntax in flags\n"));
3787 /* Call a function on each input file. This function will be called
3788 on an archive, but not on the elements. */
3791 lang_for_each_input_file (func
)
3792 void (*func
) PARAMS ((lang_input_statement_type
*));
3794 lang_input_statement_type
*f
;
3796 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3798 f
= (lang_input_statement_type
*) f
->next_real_file
)
3802 /* Call a function on each file. The function will be called on all
3803 the elements of an archive which are included in the link, but will
3804 not be called on the archive file itself. */
3807 lang_for_each_file (func
)
3808 void (*func
) PARAMS ((lang_input_statement_type
*));
3810 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3821 lang_for_each_input_section (func
)
3822 void (*func
) PARAMS ((bfd
*ab
, asection
*as
));
3824 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3828 for (s
= f
->the_bfd
->sections
;
3829 s
!= (asection
*) NULL
;
3832 func (f
->the_bfd
, s
);
3840 ldlang_add_file (entry
)
3841 lang_input_statement_type
*entry
;
3845 lang_statement_append (&file_chain
,
3846 (lang_statement_union_type
*) entry
,
3849 /* The BFD linker needs to have a list of all input BFDs involved in
3851 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3852 ASSERT (entry
->the_bfd
!= output_bfd
);
3853 for (pp
= &link_info
.input_bfds
;
3854 *pp
!= (bfd
*) NULL
;
3855 pp
= &(*pp
)->link_next
)
3857 *pp
= entry
->the_bfd
;
3858 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3859 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3861 /* Look through the sections and check for any which should not be
3862 included in the link. We need to do this now, so that we can
3863 notice when the backend linker tries to report multiple
3864 definition errors for symbols which are in sections we aren't
3865 going to link. FIXME: It might be better to entirely ignore
3866 symbols which are defined in sections which are going to be
3867 discarded. This would require modifying the backend linker for
3868 each backend which might set the SEC_LINK_ONCE flag. If we do
3869 this, we should probably handle SEC_EXCLUDE in the same way. */
3871 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
3875 lang_add_output (name
, from_script
)
3879 /* Make -o on command line override OUTPUT in script. */
3880 if (had_output_filename
== false || !from_script
)
3882 output_filename
= name
;
3883 had_output_filename
= true;
3887 static lang_output_section_statement_type
*current_section
;
3899 for (l
= 0; l
< 32; l
++)
3901 if (i
>= (unsigned int) x
)
3909 lang_output_section_statement_type
*
3910 lang_enter_output_section_statement (output_section_statement_name
,
3911 address_exp
, sectype
, block_value
,
3912 align
, subalign
, ebase
)
3913 const char *output_section_statement_name
;
3914 etree_type
*address_exp
;
3915 enum section_type sectype
;
3916 bfd_vma block_value
;
3918 etree_type
*subalign
;
3921 lang_output_section_statement_type
*os
;
3925 lang_output_section_statement_lookup (output_section_statement_name
);
3927 /* Add this statement to tree. */
3929 add_statement (lang_output_section_statement_enum
,
3930 output_section_statement
);
3932 /* Make next things chain into subchain of this. */
3934 if (os
->addr_tree
== (etree_type
*) NULL
)
3936 os
->addr_tree
= address_exp
;
3938 os
->sectype
= sectype
;
3939 if (sectype
!= noload_section
)
3940 os
->flags
= SEC_NO_FLAGS
;
3942 os
->flags
= SEC_NEVER_LOAD
;
3943 os
->block_value
= block_value
? block_value
: 1;
3944 stat_ptr
= &os
->children
;
3946 os
->subsection_alignment
=
3947 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
3948 os
->section_alignment
=
3949 topower (exp_get_value_int (align
, -1, "section alignment", 0));
3951 os
->load_base
= ebase
;
3958 lang_output_statement_type
*new =
3959 new_stat (lang_output_statement
, stat_ptr
);
3961 new->name
= output_filename
;
3964 /* Reset the current counters in the regions. */
3967 reset_memory_regions ()
3969 lang_memory_region_type
*p
= lang_memory_region_list
;
3971 for (p
= lang_memory_region_list
;
3972 p
!= (lang_memory_region_type
*) NULL
;
3975 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
3976 p
->current
= p
->origin
;
3980 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3981 as needed. SECTION may be NULL, in which case it is a wild card. */
3984 gc_section_callback (ptr
, section
, file
, data
)
3985 lang_wild_statement_type
*ptr
;
3987 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
3988 PTR data ATTRIBUTE_UNUSED
;
3990 /* If the wild pattern was marked KEEP, the member sections
3991 should be as well. */
3992 if (ptr
->keep_sections
)
3993 section
->flags
|= SEC_KEEP
;
3996 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
3997 may be NULL, indicating that it is a wildcard. */
4000 lang_gc_wild (s
, section
, file
)
4001 lang_wild_statement_type
*s
;
4002 const char *section
;
4005 walk_wild (s
, section
, file
, gc_section_callback
, NULL
);
4008 /* Iterate over sections marking them against GC. */
4011 lang_gc_sections_1 (s
)
4012 lang_statement_union_type
*s
;
4014 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
4016 switch (s
->header
.type
)
4018 case lang_wild_statement_enum
:
4019 lang_gc_wild (&s
->wild_statement
,
4020 s
->wild_statement
.section_name
,
4021 s
->wild_statement
.filename
);
4023 case lang_constructors_statement_enum
:
4024 lang_gc_sections_1 (constructor_list
.head
);
4026 case lang_output_section_statement_enum
:
4027 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4029 case lang_group_statement_enum
:
4030 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4041 struct bfd_link_hash_entry
*h
;
4042 ldlang_undef_chain_list_type
*ulist
, fake_list_start
;
4044 /* Keep all sections so marked in the link script. */
4046 lang_gc_sections_1 (statement_list
.head
);
4048 /* Keep all sections containing symbols undefined on the command-line.
4049 Handle the entry symbol at the same time. */
4051 if (entry_symbol
!= NULL
)
4053 fake_list_start
.next
= ldlang_undef_chain_list_head
;
4054 fake_list_start
.name
= (char *) entry_symbol
;
4055 ulist
= &fake_list_start
;
4058 ulist
= ldlang_undef_chain_list_head
;
4060 for (; ulist
; ulist
= ulist
->next
)
4062 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4063 false, false, false);
4065 if (h
!= (struct bfd_link_hash_entry
*) NULL
4066 && (h
->type
== bfd_link_hash_defined
4067 || h
->type
== bfd_link_hash_defweak
)
4068 && ! bfd_is_abs_section (h
->u
.def
.section
))
4070 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4074 bfd_gc_sections (output_bfd
, &link_info
);
4080 lang_reasonable_defaults ();
4081 current_target
= default_target
;
4083 /* Open the output file. */
4084 lang_for_each_statement (ldlang_open_output
);
4086 ldemul_create_output_section_statements ();
4088 /* Add to the hash table all undefineds on the command line. */
4089 lang_place_undefineds ();
4091 already_linked_table_init ();
4093 /* Create a bfd for each input file. */
4094 current_target
= default_target
;
4095 open_input_bfds (statement_list
.head
, false);
4097 ldemul_after_open ();
4099 already_linked_table_free ();
4101 /* Make sure that we're not mixing architectures. We call this
4102 after all the input files have been opened, but before we do any
4103 other processing, so that any operations merge_private_bfd_data
4104 does on the output file will be known during the rest of the
4108 /* Handle .exports instead of a version script if we're told to do so. */
4109 if (command_line
.version_exports_section
)
4110 lang_do_version_exports_section ();
4112 /* Build all sets based on the information gathered from the input
4114 ldctor_build_sets ();
4116 /* Remove unreferenced sections if asked to. */
4117 if (command_line
.gc_sections
)
4118 lang_gc_sections ();
4120 /* Size up the common data. */
4123 /* Run through the contours of the script and attach input sections
4124 to the correct output sections. */
4125 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4126 (lang_output_section_statement_type
*) NULL
);
4128 /* Find any sections not attached explicitly and handle them. */
4129 lang_place_orphans ();
4131 ldemul_before_allocation ();
4133 /* We must record the program headers before we try to fix the
4134 section positions, since they will affect SIZEOF_HEADERS. */
4135 lang_record_phdrs ();
4137 /* Now run around and relax if we can. */
4138 if (command_line
.relax
)
4140 /* First time round is a trial run to get the 'worst case'
4141 addresses of the objects if there was no relaxing. */
4142 lang_size_sections (statement_list
.head
,
4144 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
4146 /* Keep relaxing until bfd_relax_section gives up. */
4149 reset_memory_regions ();
4151 relax_again
= false;
4153 /* Note: pe-dll.c does something like this also. If you find
4154 you need to change this code, you probably need to change
4155 pe-dll.c also. DJ */
4157 /* Do all the assignments with our current guesses as to
4159 lang_do_assignments (statement_list
.head
,
4161 (fill_type
) 0, (bfd_vma
) 0);
4163 /* Perform another relax pass - this time we know where the
4164 globals are, so can make better guess. */
4165 lang_size_sections (statement_list
.head
,
4167 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
4169 while (relax_again
);
4173 /* Size up the sections. */
4174 lang_size_sections (statement_list
.head
,
4176 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
4179 /* See if anything special should be done now we know how big
4181 ldemul_after_allocation ();
4183 /* Fix any .startof. or .sizeof. symbols. */
4184 lang_set_startof ();
4186 /* Do all the assignments, now that we know the final resting places
4187 of all the symbols. */
4189 lang_do_assignments (statement_list
.head
,
4191 (fill_type
) 0, (bfd_vma
) 0);
4193 /* Make sure that the section addresses make sense. */
4194 if (! link_info
.relocateable
4195 && command_line
.check_section_addresses
)
4196 lang_check_section_addresses ();
4204 /* EXPORTED TO YACC */
4207 lang_add_wild (section_name
, sections_sorted
, filename
, filenames_sorted
,
4208 keep_sections
, exclude_filename_list
)
4209 const char *const section_name
;
4210 boolean sections_sorted
;
4211 const char *const filename
;
4212 boolean filenames_sorted
;
4213 boolean keep_sections
;
4214 struct name_list
*exclude_filename_list
;
4216 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
4219 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
4221 placed_commons
= true;
4223 if (filename
!= NULL
&& ! wildcardp (filename
))
4225 lang_has_input_file
= true;
4227 new->section_name
= section_name
;
4228 new->sections_sorted
= sections_sorted
;
4229 new->filename
= filename
;
4230 new->filenames_sorted
= filenames_sorted
;
4231 new->keep_sections
= keep_sections
;
4232 new->exclude_filename_list
= exclude_filename_list
;
4233 lang_list_init (&new->children
);
4237 lang_section_start (name
, address
)
4239 etree_type
*address
;
4241 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
4243 ad
->section_name
= name
;
4244 ad
->address
= address
;
4247 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4248 because of a -e argument on the command line, or zero if this is
4249 called by ENTRY in a linker script. Command line arguments take
4253 lang_add_entry (name
, cmdline
)
4257 if (entry_symbol
== NULL
4259 || ! entry_from_cmdline
)
4261 entry_symbol
= name
;
4262 entry_from_cmdline
= cmdline
;
4267 lang_add_target (name
)
4270 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4286 map_option_f
= true;
4297 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4304 lang_add_data (type
, exp
)
4306 union etree_union
*exp
;
4309 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4317 /* Create a new reloc statement. RELOC is the BFD relocation type to
4318 generate. HOWTO is the corresponding howto structure (we could
4319 look this up, but the caller has already done so). SECTION is the
4320 section to generate a reloc against, or NAME is the name of the
4321 symbol to generate a reloc against. Exactly one of SECTION and
4322 NAME must be NULL. ADDEND is an expression for the addend. */
4325 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4326 bfd_reloc_code_real_type reloc
;
4327 reloc_howto_type
*howto
;
4330 union etree_union
*addend
;
4332 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4336 p
->section
= section
;
4338 p
->addend_exp
= addend
;
4340 p
->addend_value
= 0;
4341 p
->output_section
= NULL
;
4345 lang_assignment_statement_type
*
4346 lang_add_assignment (exp
)
4349 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4357 lang_add_attribute (attribute
)
4358 enum statement_enum attribute
;
4360 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4367 if (startup_file
!= (char *) NULL
)
4369 einfo (_("%P%Fmultiple STARTUP files\n"));
4371 first_file
->filename
= name
;
4372 first_file
->local_sym_name
= name
;
4373 first_file
->real
= true;
4375 startup_file
= name
;
4382 lang_float_flag
= maybe
;
4386 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4388 const char *memspec
;
4389 struct lang_output_section_phdr_list
*phdrs
;
4390 const char *lma_memspec
;
4392 current_section
->fill
= fill
;
4393 current_section
->region
= lang_memory_region_lookup (memspec
);
4394 if (strcmp (lma_memspec
, "*default*") != 0)
4396 current_section
->lma_region
= lang_memory_region_lookup (lma_memspec
);
4397 /* If no runtime region has been given, but the load region has
4398 been, use the load region. */
4399 if (strcmp (memspec
, "*default*") == 0)
4400 current_section
->region
= lang_memory_region_lookup (lma_memspec
);
4402 current_section
->phdrs
= phdrs
;
4403 stat_ptr
= &statement_list
;
4406 /* Create an absolute symbol with the given name with the value of the
4407 address of first byte of the section named.
4409 If the symbol already exists, then do nothing. */
4412 lang_abs_symbol_at_beginning_of (secname
, name
)
4413 const char *secname
;
4416 struct bfd_link_hash_entry
*h
;
4418 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4419 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4420 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4422 if (h
->type
== bfd_link_hash_new
4423 || h
->type
== bfd_link_hash_undefined
)
4427 h
->type
= bfd_link_hash_defined
;
4429 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4430 if (sec
== (asection
*) NULL
)
4433 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4435 h
->u
.def
.section
= bfd_abs_section_ptr
;
4439 /* Create an absolute symbol with the given name with the value of the
4440 address of the first byte after the end of the section named.
4442 If the symbol already exists, then do nothing. */
4445 lang_abs_symbol_at_end_of (secname
, name
)
4446 const char *secname
;
4449 struct bfd_link_hash_entry
*h
;
4451 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4452 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4453 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4455 if (h
->type
== bfd_link_hash_new
4456 || h
->type
== bfd_link_hash_undefined
)
4460 h
->type
= bfd_link_hash_defined
;
4462 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4463 if (sec
== (asection
*) NULL
)
4466 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4467 + bfd_section_size (output_bfd
, sec
) /
4468 bfd_octets_per_byte (output_bfd
));
4470 h
->u
.def
.section
= bfd_abs_section_ptr
;
4475 lang_statement_append (list
, element
, field
)
4476 lang_statement_list_type
*list
;
4477 lang_statement_union_type
*element
;
4478 lang_statement_union_type
**field
;
4480 *(list
->tail
) = element
;
4484 /* Set the output format type. -oformat overrides scripts. */
4487 lang_add_output_format (format
, big
, little
, from_script
)
4493 if (output_target
== NULL
|| !from_script
)
4495 if (command_line
.endian
== ENDIAN_BIG
4498 else if (command_line
.endian
== ENDIAN_LITTLE
4502 output_target
= format
;
4506 /* Enter a group. This creates a new lang_group_statement, and sets
4507 stat_ptr to build new statements within the group. */
4512 lang_group_statement_type
*g
;
4514 g
= new_stat (lang_group_statement
, stat_ptr
);
4515 lang_list_init (&g
->children
);
4516 stat_ptr
= &g
->children
;
4519 /* Leave a group. This just resets stat_ptr to start writing to the
4520 regular list of statements again. Note that this will not work if
4521 groups can occur inside anything else which can adjust stat_ptr,
4522 but currently they can't. */
4527 stat_ptr
= &statement_list
;
4530 /* Add a new program header. This is called for each entry in a PHDRS
4531 command in a linker script. */
4534 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4542 struct lang_phdr
*n
, **pp
;
4544 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4547 n
->type
= exp_get_value_int (type
, 0, "program header type",
4548 lang_final_phase_enum
);
4549 n
->filehdr
= filehdr
;
4554 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4559 /* Record the program header information in the output BFD. FIXME: We
4560 should not be calling an ELF specific function here. */
4563 lang_record_phdrs ()
4567 struct lang_output_section_phdr_list
*last
;
4568 struct lang_phdr
*l
;
4569 lang_statement_union_type
*u
;
4572 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4574 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4581 for (u
= lang_output_section_statement
.head
;
4583 u
= u
->output_section_statement
.next
)
4585 lang_output_section_statement_type
*os
;
4586 struct lang_output_section_phdr_list
*pl
;
4588 os
= &u
->output_section_statement
;
4595 if (os
->sectype
== noload_section
4596 || os
->bfd_section
== NULL
4597 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4602 if (os
->bfd_section
== NULL
)
4605 for (; pl
!= NULL
; pl
= pl
->next
)
4607 if (strcmp (pl
->name
, l
->name
) == 0)
4612 secs
= ((asection
**)
4613 xrealloc (secs
, alc
* sizeof (asection
*)));
4615 secs
[c
] = os
->bfd_section
;
4622 if (l
->flags
== NULL
)
4625 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4626 lang_final_phase_enum
);
4631 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4632 lang_final_phase_enum
);
4634 if (! bfd_record_phdr (output_bfd
, l
->type
,
4635 l
->flags
== NULL
? false : true,
4637 l
->at
== NULL
? false : true,
4638 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4639 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4644 /* Make sure all the phdr assignments succeeded. */
4645 for (u
= lang_output_section_statement
.head
;
4647 u
= u
->output_section_statement
.next
)
4649 struct lang_output_section_phdr_list
*pl
;
4651 if (u
->output_section_statement
.bfd_section
== NULL
)
4654 for (pl
= u
->output_section_statement
.phdrs
;
4657 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4658 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4659 u
->output_section_statement
.name
, pl
->name
);
4663 /* Record a list of sections which may not be cross referenced. */
4666 lang_add_nocrossref (l
)
4667 struct lang_nocrossref
*l
;
4669 struct lang_nocrossrefs
*n
;
4671 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4672 n
->next
= nocrossref_list
;
4674 nocrossref_list
= n
;
4676 /* Set notice_all so that we get informed about all symbols. */
4677 link_info
.notice_all
= true;
4680 /* Overlay handling. We handle overlays with some static variables. */
4682 /* The overlay virtual address. */
4683 static etree_type
*overlay_vma
;
4685 /* The overlay load address. */
4686 static etree_type
*overlay_lma
;
4688 /* Whether nocrossrefs is set for this overlay. */
4689 static int overlay_nocrossrefs
;
4691 /* An expression for the maximum section size seen so far. */
4692 static etree_type
*overlay_max
;
4694 /* A list of all the sections in this overlay. */
4696 struct overlay_list
{
4697 struct overlay_list
*next
;
4698 lang_output_section_statement_type
*os
;
4701 static struct overlay_list
*overlay_list
;
4703 /* Start handling an overlay. */
4706 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
4707 etree_type
*vma_expr
;
4708 etree_type
*lma_expr
;
4711 /* The grammar should prevent nested overlays from occurring. */
4712 ASSERT (overlay_vma
== NULL
4713 && overlay_lma
== NULL
4714 && overlay_list
== NULL
4715 && overlay_max
== NULL
);
4717 overlay_vma
= vma_expr
;
4718 overlay_lma
= lma_expr
;
4719 overlay_nocrossrefs
= nocrossrefs
;
4722 /* Start a section in an overlay. We handle this by calling
4723 lang_enter_output_section_statement with the correct VMA and LMA. */
4726 lang_enter_overlay_section (name
)
4729 struct overlay_list
*n
;
4732 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4733 0, 0, 0, overlay_lma
);
4735 /* If this is the first section, then base the VMA and LMA of future
4736 sections on this one. This will work correctly even if `.' is
4737 used in the addresses. */
4738 if (overlay_list
== NULL
)
4740 overlay_vma
= exp_nameop (ADDR
, name
);
4741 overlay_lma
= exp_nameop (LOADADDR
, name
);
4744 /* Remember the section. */
4745 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4746 n
->os
= current_section
;
4747 n
->next
= overlay_list
;
4750 size
= exp_nameop (SIZEOF
, name
);
4752 /* Adjust the LMA for the next section. */
4753 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
4755 /* Arrange to work out the maximum section end address. */
4756 if (overlay_max
== NULL
)
4759 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4762 /* Finish a section in an overlay. There isn't any special to do
4766 lang_leave_overlay_section (fill
, phdrs
)
4768 struct lang_output_section_phdr_list
*phdrs
;
4775 name
= current_section
->name
;
4777 lang_leave_output_section_statement (fill
, "*default*",
4778 phdrs
, "*default*");
4780 /* Define the magic symbols. */
4782 clean
= xmalloc (strlen (name
) + 1);
4784 for (s1
= name
; *s1
!= '\0'; s1
++)
4785 if (isalnum ((unsigned char) *s1
) || *s1
== '_')
4789 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4790 sprintf (buf
, "__load_start_%s", clean
);
4791 lang_add_assignment (exp_assop ('=', buf
,
4792 exp_nameop (LOADADDR
, name
)));
4794 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4795 sprintf (buf
, "__load_stop_%s", clean
);
4796 lang_add_assignment (exp_assop ('=', buf
,
4798 exp_nameop (LOADADDR
, name
),
4799 exp_nameop (SIZEOF
, name
))));
4804 /* Finish an overlay. If there are any overlay wide settings, this
4805 looks through all the sections in the overlay and sets them. */
4808 lang_leave_overlay (fill
, memspec
, phdrs
, lma_memspec
)
4810 const char *memspec
;
4811 struct lang_output_section_phdr_list
*phdrs
;
4812 const char *lma_memspec
;
4814 lang_memory_region_type
*region
;
4815 lang_memory_region_type
*lma_region
;
4816 struct overlay_list
*l
;
4817 struct lang_nocrossref
*nocrossref
;
4819 if (memspec
== NULL
)
4822 region
= lang_memory_region_lookup (memspec
);
4824 if (lma_memspec
== NULL
)
4827 lma_region
= lang_memory_region_lookup (lma_memspec
);
4834 struct overlay_list
*next
;
4836 if (fill
!= 0 && l
->os
->fill
== 0)
4838 if (region
!= NULL
&& l
->os
->region
== NULL
)
4839 l
->os
->region
= region
;
4840 /* We only set lma_region for the first overlay section, as
4841 subsequent overlay sections will have load_base set relative
4842 to the first section. Also, don't set lma_region if
4843 load_base is specified. FIXME: There should really be a test
4844 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4845 rather than letting LDADDR simply override LMA_REGION. */
4846 if (lma_region
!= NULL
&& l
->os
->lma_region
== NULL
4847 && l
->next
== NULL
&& l
->os
->load_base
== NULL
)
4848 l
->os
->lma_region
= lma_region
;
4849 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4850 l
->os
->phdrs
= phdrs
;
4852 if (overlay_nocrossrefs
)
4854 struct lang_nocrossref
*nc
;
4856 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
4857 nc
->name
= l
->os
->name
;
4858 nc
->next
= nocrossref
;
4867 if (nocrossref
!= NULL
)
4868 lang_add_nocrossref (nocrossref
);
4870 /* Update . for the end of the overlay. */
4871 lang_add_assignment (exp_assop ('=', ".",
4872 exp_binop ('+', overlay_vma
, overlay_max
)));
4876 overlay_nocrossrefs
= 0;
4877 overlay_list
= NULL
;
4881 /* Version handling. This is only useful for ELF. */
4883 /* This global variable holds the version tree that we build. */
4885 struct bfd_elf_version_tree
*lang_elf_version_info
;
4888 lang_vers_match_lang_c (expr
, sym
)
4889 struct bfd_elf_version_expr
*expr
;
4892 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4894 return fnmatch (expr
->pattern
, sym
, 0) == 0;
4898 lang_vers_match_lang_cplusplus (expr
, sym
)
4899 struct bfd_elf_version_expr
*expr
;
4905 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4908 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
4911 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4912 Should we early out false in this case? */
4913 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4917 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4925 lang_vers_match_lang_java (expr
, sym
)
4926 struct bfd_elf_version_expr
*expr
;
4932 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4935 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
4938 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4939 Should we early out false in this case? */
4940 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4944 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4951 /* This is called for each variable name or match expression. */
4953 struct bfd_elf_version_expr
*
4954 lang_new_vers_regex (orig
, new, lang
)
4955 struct bfd_elf_version_expr
*orig
;
4959 struct bfd_elf_version_expr
*ret
;
4961 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
4965 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
4966 ret
->match
= lang_vers_match_lang_c
;
4967 else if (strcasecmp (lang
, "C++") == 0)
4968 ret
->match
= lang_vers_match_lang_cplusplus
;
4969 else if (strcasecmp (lang
, "Java") == 0)
4970 ret
->match
= lang_vers_match_lang_java
;
4973 einfo (_("%X%P: unknown language `%s' in version information\n"),
4975 ret
->match
= lang_vers_match_lang_c
;
4981 /* This is called for each set of variable names and match
4984 struct bfd_elf_version_tree
*
4985 lang_new_vers_node (globals
, locals
)
4986 struct bfd_elf_version_expr
*globals
;
4987 struct bfd_elf_version_expr
*locals
;
4989 struct bfd_elf_version_tree
*ret
;
4991 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
4995 ret
->globals
= globals
;
4996 ret
->locals
= locals
;
4998 ret
->name_indx
= (unsigned int) -1;
5003 /* This static variable keeps track of version indices. */
5005 static int version_index
;
5007 /* This is called when we know the name and dependencies of the
5011 lang_register_vers_node (name
, version
, deps
)
5013 struct bfd_elf_version_tree
*version
;
5014 struct bfd_elf_version_deps
*deps
;
5016 struct bfd_elf_version_tree
*t
, **pp
;
5017 struct bfd_elf_version_expr
*e1
;
5019 /* Make sure this node has a unique name. */
5020 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5021 if (strcmp (t
->name
, name
) == 0)
5022 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5024 /* Check the global and local match names, and make sure there
5025 aren't any duplicates. */
5027 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5029 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5031 struct bfd_elf_version_expr
*e2
;
5033 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5034 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5035 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5040 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
5042 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5044 struct bfd_elf_version_expr
*e2
;
5046 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
5047 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5048 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5053 version
->deps
= deps
;
5054 version
->name
= name
;
5056 version
->vernum
= version_index
;
5058 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5063 /* This is called when we see a version dependency. */
5065 struct bfd_elf_version_deps
*
5066 lang_add_vers_depend (list
, name
)
5067 struct bfd_elf_version_deps
*list
;
5070 struct bfd_elf_version_deps
*ret
;
5071 struct bfd_elf_version_tree
*t
;
5073 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5076 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5078 if (strcmp (t
->name
, name
) == 0)
5080 ret
->version_needed
= t
;
5085 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5091 lang_do_version_exports_section ()
5093 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5095 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5097 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5104 len
= bfd_section_size (is
->the_bfd
, sec
);
5105 contents
= xmalloc (len
);
5106 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5107 einfo (_("%X%P: unable to read .exports section contents"), sec
);
5110 while (p
< contents
+ len
)
5112 greg
= lang_new_vers_regex (greg
, p
, NULL
);
5113 p
= strchr (p
, '\0') + 1;
5116 /* Do not free the contents, as we used them creating the regex. */
5118 /* Do not include this section in the link. */
5119 bfd_set_section_flags (is
->the_bfd
, sec
,
5120 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5123 lreg
= lang_new_vers_regex (NULL
, "*", NULL
);
5124 lang_register_vers_node (command_line
.version_exports_section
,
5125 lang_new_vers_node (greg
, lreg
), NULL
);
5129 lang_add_unique (name
)
5132 struct unique_sections
*ent
;
5134 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5135 if (strcmp (ent
->name
, name
) == 0)
5138 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
5139 ent
->name
= xstrdup (name
);
5140 ent
->next
= unique_section_list
;
5141 unique_section_list
= ent
;