1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 Free Software Foundation, Inc.
6 This file is part of GLD, the Gnu Linker.
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "libiberty.h"
45 static lang_statement_union_type
*new_statement
46 PARAMS ((enum statement_enum
, size_t, lang_statement_list_type
*));
49 static struct obstack stat_obstack
;
51 #define obstack_chunk_alloc xmalloc
52 #define obstack_chunk_free free
53 static const char *startup_file
;
54 static lang_statement_list_type input_file_chain
;
55 static boolean placed_commons
= false;
56 static lang_output_section_statement_type
*default_common_section
;
57 static boolean map_option_f
;
58 static bfd_vma print_dot
;
59 static lang_input_statement_type
*first_file
;
60 static const char *current_target
;
61 static const char *output_target
;
62 static lang_statement_list_type statement_list
;
63 static struct lang_phdr
*lang_phdr_list
;
65 static void lang_for_each_statement_worker
66 PARAMS ((void (*) (lang_statement_union_type
*),
67 lang_statement_union_type
*));
68 static lang_input_statement_type
*new_afile
69 PARAMS ((const char *, lang_input_file_enum_type
, const char *, boolean
));
70 static lang_memory_region_type
*lang_memory_default
PARAMS ((asection
*));
71 static void lang_map_flags
PARAMS ((flagword
));
72 static void init_os
PARAMS ((lang_output_section_statement_type
*));
73 static void exp_init_os
PARAMS ((etree_type
*));
74 static void section_already_linked
PARAMS ((bfd
*, asection
*, PTR
));
75 static struct bfd_hash_entry
*already_linked_newfunc
76 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
77 static void already_linked_table_init
PARAMS ((void));
78 static void already_linked_table_free
PARAMS ((void));
79 static boolean wildcardp
PARAMS ((const char *));
80 static lang_statement_union_type
*wild_sort
81 PARAMS ((lang_wild_statement_type
*, lang_input_statement_type
*,
83 static void output_section_callback
84 PARAMS ((lang_wild_statement_type
*, asection
*,
85 lang_input_statement_type
*, PTR
));
86 static lang_input_statement_type
*lookup_name
PARAMS ((const char *));
87 static void load_symbols
88 PARAMS ((lang_input_statement_type
*, lang_statement_list_type
*));
90 PARAMS ((lang_wild_statement_type
*, const char *, const char *,
91 const char *, lang_output_section_statement_type
*));
92 static bfd
*open_output
PARAMS ((const char *));
93 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*));
94 static void open_input_bfds
PARAMS ((lang_statement_union_type
*, boolean
));
95 static void lang_reasonable_defaults
PARAMS ((void));
96 static void lang_place_undefineds
PARAMS ((void));
97 static void map_input_to_output_sections
98 PARAMS ((lang_statement_union_type
*, const char *,
99 lang_output_section_statement_type
*));
100 static void print_output_section_statement
101 PARAMS ((lang_output_section_statement_type
*));
102 static void print_assignment
103 PARAMS ((lang_assignment_statement_type
*,
104 lang_output_section_statement_type
*));
105 static void print_input_statement
PARAMS ((lang_input_statement_type
*));
106 static boolean print_one_symbol
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
107 static void print_input_section
PARAMS ((lang_input_section_type
*));
108 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*));
109 static void print_data_statement
PARAMS ((lang_data_statement_type
*));
110 static void print_address_statement
PARAMS ((lang_address_statement_type
*));
111 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*));
112 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*));
113 static void print_wild_statement
114 PARAMS ((lang_wild_statement_type
*, lang_output_section_statement_type
*));
115 static void print_group
116 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
117 static void print_statement
118 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
119 static void print_statement_list
120 PARAMS ((lang_statement_union_type
*, lang_output_section_statement_type
*));
121 static void print_statements
PARAMS ((void));
122 static bfd_vma insert_pad
123 PARAMS ((lang_statement_union_type
**, fill_type
,
124 unsigned int, asection
*, bfd_vma
));
125 static bfd_vma size_input_section
126 PARAMS ((lang_statement_union_type
**, lang_output_section_statement_type
*,
127 fill_type
, bfd_vma
, boolean
));
128 static void lang_finish
PARAMS ((void));
129 static void ignore_bfd_errors
PARAMS ((const char *, ...));
130 static void lang_check
PARAMS ((void));
131 static void lang_common
PARAMS ((void));
132 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
133 static void lang_place_orphans
PARAMS ((void));
134 static int topower
PARAMS ((int));
135 static void lang_set_startof
PARAMS ((void));
136 static void reset_memory_regions
PARAMS ((void));
137 static void gc_section_callback
138 PARAMS ((lang_wild_statement_type
*, asection
*,
139 lang_input_statement_type
*, PTR
));
140 static void lang_record_phdrs
PARAMS ((void));
141 static void lang_gc_wild
142 PARAMS ((lang_wild_statement_type
*, const char *, const char *));
143 static void lang_gc_sections_1
PARAMS ((lang_statement_union_type
*));
144 static void lang_gc_sections
PARAMS ((void));
145 static int lang_vers_match_lang_c
146 PARAMS ((struct bfd_elf_version_expr
*, const char *));
147 static int lang_vers_match_lang_cplusplus
148 PARAMS ((struct bfd_elf_version_expr
*, const char *));
149 static int lang_vers_match_lang_java
150 PARAMS ((struct bfd_elf_version_expr
*, const char *));
151 static void lang_do_version_exports_section
PARAMS ((void));
152 static void lang_check_section_addresses
PARAMS ((void));
153 static void os_region_check
154 PARAMS ((lang_output_section_statement_type
*,
155 struct memory_region_struct
*, etree_type
*, bfd_vma
));
157 typedef void (*callback_t
) PARAMS ((lang_wild_statement_type
*,
158 asection
*, lang_input_statement_type
*,
160 static void walk_wild
161 PARAMS ((lang_wild_statement_type
*, const char *, const char *,
163 static void walk_wild_section
164 PARAMS ((lang_wild_statement_type
*, const char *,
165 lang_input_statement_type
*, callback_t
, PTR
));
166 static void walk_wild_file
167 PARAMS ((lang_wild_statement_type
*, const char *,
168 lang_input_statement_type
*, callback_t
, PTR
));
170 static int get_target
PARAMS ((const bfd_target
*, PTR
));
171 static void stricpy
PARAMS ((char *, char *));
172 static void strcut
PARAMS ((char *, char *));
173 static int name_compare
PARAMS ((char *, char *));
174 static int closest_target_match
PARAMS ((const bfd_target
*, PTR
));
175 static char * get_first_input_target
PARAMS ((void));
178 lang_output_section_statement_type
*abs_output_section
;
179 lang_statement_list_type lang_output_section_statement
;
180 lang_statement_list_type
*stat_ptr
= &statement_list
;
181 lang_statement_list_type file_chain
= { NULL
, NULL
};
182 const char *entry_symbol
= NULL
;
183 boolean entry_from_cmdline
;
184 boolean lang_has_input_file
= false;
185 boolean had_output_filename
= false;
186 boolean lang_float_flag
= false;
187 boolean delete_output_file_on_failure
= false;
188 struct lang_nocrossrefs
*nocrossref_list
;
189 struct unique_sections
*unique_section_list
;
191 etree_type
*base
; /* Relocation base - or null */
193 #if defined (__STDC__) || defined (ALMOST_STDC)
194 #define cat(a,b) a##b
196 #define cat(a,b) a/**/b
199 /* Don't beautify the line below with "innocent" whitespace, it breaks
200 the K&R C preprocessor! */
201 #define new_stat(x, y) \
202 (cat (x,_type)*) new_statement (cat (x,_enum), sizeof (cat (x,_type)), y)
204 #define outside_section_address(q) \
205 ((q)->output_offset + (q)->output_section->vma)
207 #define outside_symbol_address(q) \
208 ((q)->value + outside_section_address (q->section))
210 #define SECTION_NAME_MAP_LENGTH (16)
216 return obstack_alloc (&stat_obstack
, size
);
220 unique_section_p (secnam
)
223 struct unique_sections
*unam
;
225 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
226 if (wildcardp (unam
->name
)
227 ? fnmatch (unam
->name
, secnam
, 0) == 0
228 : strcmp (unam
->name
, secnam
) == 0)
236 /* Generic traversal routines for finding matching sections. */
239 walk_wild_section (ptr
, section
, file
, callback
, data
)
240 lang_wild_statement_type
*ptr
;
242 lang_input_statement_type
*file
;
246 /* Don't process sections from files which were excluded. */
247 if (ptr
->exclude_filename_list
!= NULL
)
249 struct name_list
*list_tmp
;
250 for (list_tmp
= ptr
->exclude_filename_list
;
252 list_tmp
= list_tmp
->next
)
256 if (wildcardp (list_tmp
->name
))
257 match
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
259 match
= strcmp (list_tmp
->name
, file
->filename
) == 0;
266 if (file
->just_syms_flag
== false)
268 register asection
*s
;
269 boolean wildcard
= false;
272 wildcard
= wildcardp (section
);
274 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
277 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
282 match
= fnmatch (section
, sname
, 0) == 0;
284 match
= strcmp (section
, sname
) == 0;
286 /* If this is a wild-card output section statement, exclude
287 sections that match UNIQUE_SECTION_LIST. */
288 if (match
&& (data
== NULL
|| !unique_section_p (sname
)))
289 (*callback
) (ptr
, s
, file
, data
);
294 /* Handle a wild statement for a single file F. */
297 walk_wild_file (s
, section
, f
, callback
, data
)
298 lang_wild_statement_type
*s
;
300 lang_input_statement_type
*f
;
304 if (f
->the_bfd
== NULL
305 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
306 walk_wild_section (s
, section
, f
, callback
, data
);
311 /* This is an archive file. We must map each member of the
312 archive separately. */
313 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
314 while (member
!= NULL
)
316 /* When lookup_name is called, it will call the add_symbols
317 entry point for the archive. For each element of the
318 archive which is included, BFD will call ldlang_add_file,
319 which will set the usrdata field of the member to the
320 lang_input_statement. */
321 if (member
->usrdata
!= NULL
)
323 walk_wild_section (s
, section
,
324 (lang_input_statement_type
*) member
->usrdata
,
328 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
334 walk_wild (s
, section
, file
, callback
, data
)
335 lang_wild_statement_type
*s
;
341 if (file
== (char *) NULL
)
343 /* Perform the iteration over all files in the list. */
344 LANG_FOR_EACH_INPUT_STATEMENT (f
)
346 walk_wild_file (s
, section
, f
, callback
, data
);
349 else if (wildcardp (file
))
351 LANG_FOR_EACH_INPUT_STATEMENT (f
)
353 if (fnmatch (file
, f
->filename
, FNM_FILE_NAME
) == 0)
354 walk_wild_file (s
, section
, f
, callback
, data
);
359 lang_input_statement_type
*f
;
361 /* Perform the iteration over a single file. */
362 f
= lookup_name (file
);
363 walk_wild_file (s
, section
, f
, callback
, data
);
367 /* lang_for_each_statement walks the parse tree and calls the provided
368 function for each node. */
371 lang_for_each_statement_worker (func
, s
)
372 void (*func
) PARAMS ((lang_statement_union_type
*));
373 lang_statement_union_type
*s
;
375 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
379 switch (s
->header
.type
)
381 case lang_constructors_statement_enum
:
382 lang_for_each_statement_worker (func
, constructor_list
.head
);
384 case lang_output_section_statement_enum
:
385 lang_for_each_statement_worker
387 s
->output_section_statement
.children
.head
);
389 case lang_wild_statement_enum
:
390 lang_for_each_statement_worker
392 s
->wild_statement
.children
.head
);
394 case lang_group_statement_enum
:
395 lang_for_each_statement_worker (func
,
396 s
->group_statement
.children
.head
);
398 case lang_data_statement_enum
:
399 case lang_reloc_statement_enum
:
400 case lang_object_symbols_statement_enum
:
401 case lang_output_statement_enum
:
402 case lang_target_statement_enum
:
403 case lang_input_section_enum
:
404 case lang_input_statement_enum
:
405 case lang_assignment_statement_enum
:
406 case lang_padding_statement_enum
:
407 case lang_address_statement_enum
:
408 case lang_fill_statement_enum
:
418 lang_for_each_statement (func
)
419 void (*func
) PARAMS ((lang_statement_union_type
*));
421 lang_for_each_statement_worker (func
, statement_list
.head
);
424 /*----------------------------------------------------------------------*/
427 lang_list_init (list
)
428 lang_statement_list_type
*list
;
430 list
->head
= (lang_statement_union_type
*) NULL
;
431 list
->tail
= &list
->head
;
434 /* Build a new statement node for the parse tree. */
436 static lang_statement_union_type
*
437 new_statement (type
, size
, list
)
438 enum statement_enum type
;
440 lang_statement_list_type
*list
;
442 lang_statement_union_type
*new = (lang_statement_union_type
*)
445 new->header
.type
= type
;
446 new->header
.next
= (lang_statement_union_type
*) NULL
;
447 lang_statement_append (list
, new, &new->header
.next
);
451 /* Build a new input file node for the language. There are several
452 ways in which we treat an input file, eg, we only look at symbols,
453 or prefix it with a -l etc.
455 We can be supplied with requests for input files more than once;
456 they may, for example be split over serveral lines like foo.o(.text)
457 foo.o(.data) etc, so when asked for a file we check that we haven't
458 got it already so we don't duplicate the bfd. */
460 static lang_input_statement_type
*
461 new_afile (name
, file_type
, target
, add_to_list
)
463 lang_input_file_enum_type file_type
;
467 lang_input_statement_type
*p
;
470 p
= new_stat (lang_input_statement
, stat_ptr
);
473 p
= ((lang_input_statement_type
*)
474 stat_alloc (sizeof (lang_input_statement_type
)));
475 p
->header
.next
= NULL
;
478 lang_has_input_file
= true;
482 case lang_input_file_is_symbols_only_enum
:
484 p
->is_archive
= false;
486 p
->local_sym_name
= name
;
487 p
->just_syms_flag
= true;
488 p
->search_dirs_flag
= false;
490 case lang_input_file_is_fake_enum
:
492 p
->is_archive
= false;
494 p
->local_sym_name
= name
;
495 p
->just_syms_flag
= false;
496 p
->search_dirs_flag
= false;
498 case lang_input_file_is_l_enum
:
499 p
->is_archive
= true;
502 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
503 p
->just_syms_flag
= false;
504 p
->search_dirs_flag
= true;
506 case lang_input_file_is_marker_enum
:
508 p
->is_archive
= false;
510 p
->local_sym_name
= name
;
511 p
->just_syms_flag
= false;
512 p
->search_dirs_flag
= true;
514 case lang_input_file_is_search_file_enum
:
516 p
->is_archive
= false;
518 p
->local_sym_name
= name
;
519 p
->just_syms_flag
= false;
520 p
->search_dirs_flag
= true;
522 case lang_input_file_is_file_enum
:
524 p
->is_archive
= false;
526 p
->local_sym_name
= name
;
527 p
->just_syms_flag
= false;
528 p
->search_dirs_flag
= false;
533 p
->the_bfd
= (bfd
*) NULL
;
534 p
->asymbols
= (asymbol
**) NULL
;
535 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
536 p
->next
= (lang_statement_union_type
*) NULL
;
538 p
->dynamic
= config
.dynamic_link
;
539 p
->whole_archive
= whole_archive
;
541 lang_statement_append (&input_file_chain
,
542 (lang_statement_union_type
*) p
,
547 lang_input_statement_type
*
548 lang_add_input_file (name
, file_type
, target
)
550 lang_input_file_enum_type file_type
;
553 lang_has_input_file
= true;
554 return new_afile (name
, file_type
, target
, true);
557 /* Build enough state so that the parser can build its tree. */
562 obstack_begin (&stat_obstack
, 1000);
564 stat_ptr
= &statement_list
;
566 lang_list_init (stat_ptr
);
568 lang_list_init (&input_file_chain
);
569 lang_list_init (&lang_output_section_statement
);
570 lang_list_init (&file_chain
);
571 first_file
= lang_add_input_file ((char *) NULL
,
572 lang_input_file_is_marker_enum
,
575 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
577 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
581 /*----------------------------------------------------------------------
582 A region is an area of memory declared with the
583 MEMORY { name:org=exp, len=exp ... }
586 We maintain a list of all the regions here.
588 If no regions are specified in the script, then the default is used
589 which is created when looked up to be the entire data space. */
591 static lang_memory_region_type
*lang_memory_region_list
;
592 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
594 lang_memory_region_type
*
595 lang_memory_region_lookup (name
)
596 const char *const name
;
598 lang_memory_region_type
*p
;
600 for (p
= lang_memory_region_list
;
601 p
!= (lang_memory_region_type
*) NULL
;
604 if (strcmp (p
->name
, name
) == 0)
611 /* This code used to always use the first region in the list as the
612 default region. I changed it to instead use a region
613 encompassing all of memory as the default region. This permits
614 NOLOAD sections to work reasonably without requiring a region.
615 People should specify what region they mean, if they really want
617 if (strcmp (name
, "*default*") == 0)
619 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
621 return lang_memory_region_list
;
627 lang_memory_region_type
*new =
628 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
630 new->name
= xstrdup (name
);
631 new->next
= (lang_memory_region_type
*) NULL
;
633 *lang_memory_region_list_tail
= new;
634 lang_memory_region_list_tail
= &new->next
;
638 new->length
= ~(bfd_size_type
) 0;
640 new->had_full_message
= false;
646 static lang_memory_region_type
*
647 lang_memory_default (section
)
650 lang_memory_region_type
*p
;
652 flagword sec_flags
= section
->flags
;
654 /* Override SEC_DATA to mean a writable section. */
655 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
656 sec_flags
|= SEC_DATA
;
658 for (p
= lang_memory_region_list
;
659 p
!= (lang_memory_region_type
*) NULL
;
662 if ((p
->flags
& sec_flags
) != 0
663 && (p
->not_flags
& sec_flags
) == 0)
668 return lang_memory_region_lookup ("*default*");
671 lang_output_section_statement_type
*
672 lang_output_section_find (name
)
673 const char *const name
;
675 lang_statement_union_type
*u
;
676 lang_output_section_statement_type
*lookup
;
678 for (u
= lang_output_section_statement
.head
;
679 u
!= (lang_statement_union_type
*) NULL
;
682 lookup
= &u
->output_section_statement
;
683 if (strcmp (name
, lookup
->name
) == 0)
688 return (lang_output_section_statement_type
*) NULL
;
691 lang_output_section_statement_type
*
692 lang_output_section_statement_lookup (name
)
693 const char *const name
;
695 lang_output_section_statement_type
*lookup
;
697 lookup
= lang_output_section_find (name
);
698 if (lookup
== (lang_output_section_statement_type
*) NULL
)
701 lookup
= (lang_output_section_statement_type
*)
702 new_stat (lang_output_section_statement
, stat_ptr
);
703 lookup
->region
= (lang_memory_region_type
*) NULL
;
704 lookup
->lma_region
= (lang_memory_region_type
*) NULL
;
706 lookup
->block_value
= 1;
709 lookup
->next
= (lang_statement_union_type
*) NULL
;
710 lookup
->bfd_section
= (asection
*) NULL
;
711 lookup
->processed
= false;
712 lookup
->sectype
= normal_section
;
713 lookup
->addr_tree
= (etree_type
*) NULL
;
714 lang_list_init (&lookup
->children
);
716 lookup
->memspec
= (const char *) NULL
;
718 lookup
->subsection_alignment
= -1;
719 lookup
->section_alignment
= -1;
720 lookup
->load_base
= (union etree_union
*) NULL
;
721 lookup
->phdrs
= NULL
;
723 lang_statement_append (&lang_output_section_statement
,
724 (lang_statement_union_type
*) lookup
,
731 lang_map_flags (flag
)
734 if (flag
& SEC_ALLOC
)
740 if (flag
& SEC_READONLY
)
753 lang_memory_region_type
*m
;
755 minfo (_("\nMemory Configuration\n\n"));
756 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
757 _("Name"), _("Origin"), _("Length"), _("Attributes"));
759 for (m
= lang_memory_region_list
;
760 m
!= (lang_memory_region_type
*) NULL
;
766 fprintf (config
.map_file
, "%-16s ", m
->name
);
768 sprintf_vma (buf
, m
->origin
);
769 minfo ("0x%s ", buf
);
777 minfo ("0x%V", m
->length
);
778 if (m
->flags
|| m
->not_flags
)
786 lang_map_flags (m
->flags
);
792 lang_map_flags (m
->not_flags
);
799 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
804 /* Initialize an output section. */
808 lang_output_section_statement_type
*s
;
810 section_userdata_type
*new;
812 if (s
->bfd_section
!= NULL
)
815 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
816 einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME
);
818 new = ((section_userdata_type
*)
819 stat_alloc (sizeof (section_userdata_type
)));
821 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
822 if (s
->bfd_section
== (asection
*) NULL
)
823 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
824 if (s
->bfd_section
== (asection
*) NULL
)
826 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
827 output_bfd
->xvec
->name
, s
->name
);
829 s
->bfd_section
->output_section
= s
->bfd_section
;
831 /* We initialize an output sections output offset to minus its own
832 vma to allow us to output a section through itself. */
833 s
->bfd_section
->output_offset
= 0;
834 get_userdata (s
->bfd_section
) = (PTR
) new;
836 /* If there is a base address, make sure that any sections it might
837 mention are initialized. */
838 if (s
->addr_tree
!= NULL
)
839 exp_init_os (s
->addr_tree
);
842 /* Make sure that all output sections mentioned in an expression are
849 switch (exp
->type
.node_class
)
852 exp_init_os (exp
->assign
.src
);
856 exp_init_os (exp
->binary
.lhs
);
857 exp_init_os (exp
->binary
.rhs
);
861 exp_init_os (exp
->trinary
.cond
);
862 exp_init_os (exp
->trinary
.lhs
);
863 exp_init_os (exp
->trinary
.rhs
);
867 exp_init_os (exp
->unary
.child
);
871 switch (exp
->type
.node_code
)
877 lang_output_section_statement_type
*os
;
879 os
= lang_output_section_find (exp
->name
.name
);
880 if (os
!= NULL
&& os
->bfd_section
== NULL
)
891 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
892 once into the output. This routine checks each section, and
893 arrange to discard it if a section of the same name has already
894 been linked. If the section has COMDAT information, then it uses
895 that to decide whether the section should be included. This code
896 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
897 that is, it does not depend solely upon the section name.
898 section_already_linked is called via bfd_map_over_sections. */
900 /* This is the shape of the elements inside the already_linked hash
901 table. It maps a name onto a list of already_linked elements with
902 the same name. It's possible to get more than one element in a
903 list if the COMDAT sections have different names. */
905 struct already_linked_hash_entry
907 struct bfd_hash_entry root
;
908 struct already_linked
*entry
;
911 struct already_linked
913 struct already_linked
*next
;
917 /* The hash table. */
919 static struct bfd_hash_table already_linked_table
;
922 section_already_linked (abfd
, sec
, data
)
927 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
930 struct already_linked
*l
;
931 struct already_linked_hash_entry
*already_linked_list
;
933 /* If we are only reading symbols from this object, then we want to
934 discard all sections. */
935 if (entry
->just_syms_flag
)
937 sec
->output_section
= bfd_abs_section_ptr
;
938 sec
->output_offset
= sec
->vma
;
942 flags
= bfd_get_section_flags (abfd
, sec
);
944 if ((flags
& SEC_LINK_ONCE
) == 0)
947 /* FIXME: When doing a relocatable link, we may have trouble
948 copying relocations in other sections that refer to local symbols
949 in the section being discarded. Those relocations will have to
950 be converted somehow; as of this writing I'm not sure that any of
951 the backends handle that correctly.
953 It is tempting to instead not discard link once sections when
954 doing a relocatable link (technically, they should be discarded
955 whenever we are building constructors). However, that fails,
956 because the linker winds up combining all the link once sections
957 into a single large link once section, which defeats the purpose
958 of having link once sections in the first place.
960 Also, not merging link once sections in a relocatable link
961 causes trouble for MIPS ELF, which relies in link once semantics
962 to handle the .reginfo section correctly. */
964 name
= bfd_get_section_name (abfd
, sec
);
966 already_linked_list
=
967 ((struct already_linked_hash_entry
*)
968 bfd_hash_lookup (&already_linked_table
, name
, true, false));
970 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
972 if (sec
->comdat
== NULL
973 || l
->sec
->comdat
== NULL
974 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
976 /* The section has already been linked. See if we should
978 switch (flags
& SEC_LINK_DUPLICATES
)
983 case SEC_LINK_DUPLICATES_DISCARD
:
986 case SEC_LINK_DUPLICATES_ONE_ONLY
:
987 if (sec
->comdat
== NULL
)
988 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
991 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
992 abfd
, name
, sec
->comdat
->name
);
995 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
996 /* FIXME: We should really dig out the contents of both
997 sections and memcmp them. The COFF/PE spec says that
998 the Microsoft linker does not implement this
999 correctly, so I'm not going to bother doing it
1002 case SEC_LINK_DUPLICATES_SAME_SIZE
:
1003 if (bfd_section_size (abfd
, sec
)
1004 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1005 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1010 /* Set the output_section field so that wild_doit does not
1011 create a lang_input_section structure for this section.
1012 Since there might be a symbol in the section being
1013 discarded, we must retain a pointer to the section which
1014 we are really going to use. */
1015 sec
->output_section
= bfd_abs_section_ptr
;
1016 sec
->kept_section
= l
->sec
;
1022 /* This is the first section with this name. Record it. Allocate
1023 the memory from the same obstack as the hash table is kept in. */
1025 l
= ((struct already_linked
*)
1026 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1029 l
->next
= already_linked_list
->entry
;
1030 already_linked_list
->entry
= l
;
1033 /* Support routines for the hash table used by section_already_linked,
1034 initialize the table, fill in an entry and remove the table. */
1036 static struct bfd_hash_entry
*
1037 already_linked_newfunc (entry
, table
, string
)
1038 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1039 struct bfd_hash_table
*table
;
1040 const char *string ATTRIBUTE_UNUSED
;
1042 struct already_linked_hash_entry
*ret
=
1043 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1047 return (struct bfd_hash_entry
*) ret
;
1051 already_linked_table_init ()
1053 if (! bfd_hash_table_init_n (&already_linked_table
,
1054 already_linked_newfunc
,
1056 einfo (_("%P%F: Failed to create hash table\n"));
1060 already_linked_table_free ()
1062 bfd_hash_table_free (&already_linked_table
);
1065 /* The wild routines.
1067 These expand statements like *(.text) and foo.o to a list of
1068 explicit actions, like foo.o(.text), bar.o(.text) and
1069 foo.o(.text, .data). */
1071 /* Return true if the PATTERN argument is a wildcard pattern.
1072 Although backslashes are treated specially if a pattern contains
1073 wildcards, we do not consider the mere presence of a backslash to
1074 be enough to cause the the pattern to be treated as a wildcard.
1075 That lets us handle DOS filenames more naturally. */
1079 const char *pattern
;
1083 for (s
= pattern
; *s
!= '\0'; ++s
)
1091 /* Add SECTION to the output section OUTPUT. Do this by creating a
1092 lang_input_section statement which is placed at PTR. FILE is the
1093 input file which holds SECTION. */
1096 wild_doit (ptr
, section
, output
, file
)
1097 lang_statement_list_type
*ptr
;
1099 lang_output_section_statement_type
*output
;
1100 lang_input_statement_type
*file
;
1105 flags
= bfd_get_section_flags (section
->owner
, section
);
1109 /* If we are doing a final link, discard sections marked with
1111 if (! link_info
.relocateable
1112 && (flags
& SEC_EXCLUDE
) != 0)
1115 /* Discard input sections which are assigned to a section named
1116 DISCARD_SECTION_NAME. */
1117 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1120 /* Discard debugging sections if we are stripping debugging
1122 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1123 && (flags
& SEC_DEBUGGING
) != 0)
1128 if (section
->output_section
== NULL
)
1130 /* This prevents future calls from assigning this section. */
1131 section
->output_section
= bfd_abs_section_ptr
;
1136 if (section
->output_section
== NULL
)
1139 lang_input_section_type
*new;
1142 if (output
->bfd_section
== NULL
)
1145 first
= ! output
->bfd_section
->linker_has_input
;
1146 output
->bfd_section
->linker_has_input
= 1;
1148 /* Add a section reference to the list. */
1149 new = new_stat (lang_input_section
, ptr
);
1151 new->section
= section
;
1153 section
->output_section
= output
->bfd_section
;
1155 flags
= section
->flags
;
1157 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1158 to an output section, because we want to be able to include a
1159 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1160 section (I don't know why we want to do this, but we do).
1161 build_link_order in ldwrite.c handles this case by turning
1162 the embedded SEC_NEVER_LOAD section into a fill. */
1164 flags
&= ~ SEC_NEVER_LOAD
;
1166 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1167 already been processed. One reason to do this is that on pe
1168 format targets, .text$foo sections go into .text and it's odd
1169 to see .text with SEC_LINK_ONCE set. */
1171 if (! link_info
.relocateable
)
1172 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1174 /* If this is not the first input section, and the SEC_READONLY
1175 flag is not currently set, then don't set it just because the
1176 input section has it set. */
1178 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1179 flags
&= ~ SEC_READONLY
;
1181 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1183 && ((section
->output_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1184 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1185 || ((flags
& SEC_MERGE
)
1186 && section
->output_section
->entsize
!= section
->entsize
)))
1188 section
->output_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1189 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1192 section
->output_section
->flags
|= flags
;
1194 if (flags
& SEC_MERGE
)
1195 section
->output_section
->entsize
= section
->entsize
;
1197 /* If SEC_READONLY is not set in the input section, then clear
1198 it from the output section. */
1199 if ((section
->flags
& SEC_READONLY
) == 0)
1200 section
->output_section
->flags
&= ~SEC_READONLY
;
1202 switch (output
->sectype
)
1204 case normal_section
:
1209 case overlay_section
:
1210 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1212 case noload_section
:
1213 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1214 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1218 /* Copy over SEC_SMALL_DATA. */
1219 if (section
->flags
& SEC_SMALL_DATA
)
1220 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1222 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1223 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1225 /* If supplied an aligment, then force it. */
1226 if (output
->section_alignment
!= -1)
1227 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1229 if (section
->flags
& SEC_BLOCK
)
1231 section
->output_section
->flags
|= SEC_BLOCK
;
1232 /* FIXME: This value should really be obtained from the bfd... */
1233 output
->block_value
= 128;
1238 /* Handle wildcard sorting. This returns the lang_input_section which
1239 should follow the one we are going to create for SECTION and FILE,
1240 based on the sorting requirements of WILD. It returns NULL if the
1241 new section should just go at the end of the current list. */
1243 static lang_statement_union_type
*
1244 wild_sort (wild
, file
, section
)
1245 lang_wild_statement_type
*wild
;
1246 lang_input_statement_type
*file
;
1249 const char *section_name
;
1250 lang_statement_union_type
*l
;
1252 if (! wild
->filenames_sorted
&& ! wild
->sections_sorted
)
1255 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1256 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->next
)
1258 lang_input_section_type
*ls
;
1260 if (l
->header
.type
!= lang_input_section_enum
)
1262 ls
= &l
->input_section
;
1264 /* Sorting by filename takes precedence over sorting by section
1267 if (wild
->filenames_sorted
)
1269 const char *fn
, *ln
;
1273 /* The PE support for the .idata section as generated by
1274 dlltool assumes that files will be sorted by the name of
1275 the archive and then the name of the file within the
1278 if (file
->the_bfd
!= NULL
1279 && bfd_my_archive (file
->the_bfd
) != NULL
)
1281 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1286 fn
= file
->filename
;
1290 if (ls
->ifile
->the_bfd
!= NULL
1291 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1293 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1298 ln
= ls
->ifile
->filename
;
1302 i
= strcmp (fn
, ln
);
1311 fn
= file
->filename
;
1313 ln
= ls
->ifile
->filename
;
1315 i
= strcmp (fn
, ln
);
1323 /* Here either the files are not sorted by name, or we are
1324 looking at the sections for this file. */
1326 if (wild
->sections_sorted
)
1328 if (strcmp (section_name
,
1329 bfd_get_section_name (ls
->ifile
->the_bfd
,
1339 /* Expand a wild statement for a particular FILE. SECTION may be
1340 NULL, in which case it is a wild card. */
1343 output_section_callback (ptr
, section
, file
, output
)
1344 lang_wild_statement_type
*ptr
;
1346 lang_input_statement_type
*file
;
1349 lang_statement_union_type
*before
;
1351 /* If the wild pattern was marked KEEP, the member sections
1352 should be as well. */
1353 if (ptr
->keep_sections
)
1354 section
->flags
|= SEC_KEEP
;
1356 before
= wild_sort (ptr
, file
, section
);
1358 /* Here BEFORE points to the lang_input_section which
1359 should follow the one we are about to add. If BEFORE
1360 is NULL, then the section should just go at the end
1361 of the current list. */
1364 wild_doit (&ptr
->children
, section
,
1365 (lang_output_section_statement_type
*) output
,
1369 lang_statement_list_type list
;
1370 lang_statement_union_type
**pp
;
1372 lang_list_init (&list
);
1373 wild_doit (&list
, section
,
1374 (lang_output_section_statement_type
*) output
,
1377 /* If we are discarding the section, LIST.HEAD will
1379 if (list
.head
!= NULL
)
1381 ASSERT (list
.head
->next
== NULL
);
1383 for (pp
= &ptr
->children
.head
;
1386 ASSERT (*pp
!= NULL
);
1388 list
.head
->next
= *pp
;
1394 /* This is passed a file name which must have been seen already and
1395 added to the statement tree. We will see if it has been opened
1396 already and had its symbols read. If not then we'll read it. */
1398 static lang_input_statement_type
*
1402 lang_input_statement_type
*search
;
1404 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1405 search
!= (lang_input_statement_type
*) NULL
;
1406 search
= (lang_input_statement_type
*) search
->next_real_file
)
1408 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1410 if (search
->filename
!= (char *) NULL
1411 && name
!= (char *) NULL
1412 && strcmp (search
->filename
, name
) == 0)
1416 if (search
== (lang_input_statement_type
*) NULL
)
1417 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1420 /* If we have already added this file, or this file is not real
1421 (FIXME: can that ever actually happen?) or the name is NULL
1422 (FIXME: can that ever actually happen?) don't add this file. */
1425 || search
->filename
== (const char *) NULL
)
1428 load_symbols (search
, (lang_statement_list_type
*) NULL
);
1433 /* Get the symbols for an input file. */
1436 load_symbols (entry
, place
)
1437 lang_input_statement_type
*entry
;
1438 lang_statement_list_type
*place
;
1445 ldfile_open_file (entry
);
1447 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1448 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1451 lang_statement_list_type
*hold
;
1453 err
= bfd_get_error ();
1455 /* See if the emulation has some special knowledge. */
1456 if (ldemul_unrecognized_file (entry
))
1459 if (err
== bfd_error_file_ambiguously_recognized
)
1463 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1464 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1465 for (p
= matching
; *p
!= NULL
; p
++)
1469 else if (err
!= bfd_error_file_not_recognized
1471 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1473 bfd_close (entry
->the_bfd
);
1474 entry
->the_bfd
= NULL
;
1476 /* Try to interpret the file as a linker script. */
1477 ldfile_open_command_file (entry
->filename
);
1482 ldfile_assumed_script
= true;
1483 parser_input
= input_script
;
1485 ldfile_assumed_script
= false;
1492 if (ldemul_recognized_file (entry
))
1495 /* We don't call ldlang_add_file for an archive. Instead, the
1496 add_symbols entry point will call ldlang_add_file, via the
1497 add_archive_element callback, for each element of the archive
1499 switch (bfd_get_format (entry
->the_bfd
))
1505 ldlang_add_file (entry
);
1506 if (trace_files
|| trace_file_tries
)
1507 info_msg ("%I\n", entry
);
1511 if (entry
->whole_archive
)
1513 bfd
*member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1515 while (member
!= NULL
)
1517 if (! bfd_check_format (member
, bfd_object
))
1518 einfo (_("%F%B: object %B in archive is not object\n"),
1519 entry
->the_bfd
, member
);
1520 if (! ((*link_info
.callbacks
->add_archive_element
)
1521 (&link_info
, member
, "--whole-archive")))
1523 if (! bfd_link_add_symbols (member
, &link_info
))
1524 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1525 member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1529 entry
->loaded
= true;
1535 if (! bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1536 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1538 entry
->loaded
= true;
1541 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1542 indicating that it is a wildcard. Separate lang_input_section
1543 statements are created for each part of the expansion; they are
1544 added after the wild statement S. OUTPUT is the output section. */
1547 wild (s
, section
, file
, target
, output
)
1548 lang_wild_statement_type
*s
;
1549 const char *section
;
1551 const char *target ATTRIBUTE_UNUSED
;
1552 lang_output_section_statement_type
*output
;
1554 walk_wild (s
, section
, file
, output_section_callback
, (PTR
) output
);
1556 if (section
!= (char *) NULL
1557 && strcmp (section
, "COMMON") == 0
1558 && default_common_section
== NULL
)
1560 /* Remember the section that common is going to in case we later
1561 get something which doesn't know where to put it. */
1562 default_common_section
= output
;
1566 /* Return true iff target is the sought target. */
1569 get_target (target
, data
)
1570 const bfd_target
*target
;
1573 const char *sought
= (const char *) data
;
1575 return strcmp (target
->name
, sought
) == 0;
1578 /* Like strcpy() but convert to lower case as well. */
1587 while ((c
= *src
++) != 0)
1589 if (isupper ((unsigned char) c
))
1598 /* Remove the first occurance of needle (if any) in haystack
1602 strcut (haystack
, needle
)
1606 haystack
= strstr (haystack
, needle
);
1612 for (src
= haystack
+ strlen (needle
); *src
;)
1613 *haystack
++ = *src
++;
1619 /* Compare two target format name strings.
1620 Return a value indicating how "similar" they are. */
1623 name_compare (first
, second
)
1631 copy1
= xmalloc (strlen (first
) + 1);
1632 copy2
= xmalloc (strlen (second
) + 1);
1634 /* Convert the names to lower case. */
1635 stricpy (copy1
, first
);
1636 stricpy (copy2
, second
);
1638 /* Remove and endian strings from the name. */
1639 strcut (copy1
, "big");
1640 strcut (copy1
, "little");
1641 strcut (copy2
, "big");
1642 strcut (copy2
, "little");
1644 /* Return a value based on how many characters match,
1645 starting from the beginning. If both strings are
1646 the same then return 10 * their length. */
1647 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1648 if (copy1
[result
] == 0)
1660 /* Set by closest_target_match() below. */
1661 static const bfd_target
*winner
;
1663 /* Scan all the valid bfd targets looking for one that has the endianness
1664 requirement that was specified on the command line, and is the nearest
1665 match to the original output target. */
1668 closest_target_match (target
, data
)
1669 const bfd_target
*target
;
1672 const bfd_target
*original
= (const bfd_target
*) data
;
1674 if (command_line
.endian
== ENDIAN_BIG
1675 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1678 if (command_line
.endian
== ENDIAN_LITTLE
1679 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1682 /* Must be the same flavour. */
1683 if (target
->flavour
!= original
->flavour
)
1686 /* If we have not found a potential winner yet, then record this one. */
1693 /* Oh dear, we now have two potential candidates for a successful match.
1694 Compare their names and choose the better one. */
1695 if (name_compare (target
->name
, original
->name
)
1696 > name_compare (winner
->name
, original
->name
))
1699 /* Keep on searching until wqe have checked them all. */
1703 /* Return the BFD target format of the first input file. */
1706 get_first_input_target ()
1708 char *target
= NULL
;
1710 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1712 if (s
->header
.type
== lang_input_statement_enum
1715 ldfile_open_file (s
);
1717 if (s
->the_bfd
!= NULL
1718 && bfd_check_format (s
->the_bfd
, bfd_object
))
1720 target
= bfd_get_target (s
->the_bfd
);
1731 /* Open the output file. */
1739 /* Has the user told us which output format to use? */
1740 if (output_target
== (char *) NULL
)
1742 /* No - has the current target been set to something other than
1744 if (current_target
!= default_target
)
1745 output_target
= current_target
;
1747 /* No - can we determine the format of the first input file? */
1750 output_target
= get_first_input_target ();
1752 /* Failed - use the default output target. */
1753 if (output_target
== NULL
)
1754 output_target
= default_target
;
1758 /* Has the user requested a particular endianness on the command
1760 if (command_line
.endian
!= ENDIAN_UNSET
)
1762 const bfd_target
*target
;
1763 enum bfd_endian desired_endian
;
1765 /* Get the chosen target. */
1766 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1768 /* If the target is not supported, we cannot do anything. */
1771 if (command_line
.endian
== ENDIAN_BIG
)
1772 desired_endian
= BFD_ENDIAN_BIG
;
1774 desired_endian
= BFD_ENDIAN_LITTLE
;
1776 /* See if the target has the wrong endianness. This should
1777 not happen if the linker script has provided big and
1778 little endian alternatives, but some scrips don't do
1780 if (target
->byteorder
!= desired_endian
)
1782 /* If it does, then see if the target provides
1783 an alternative with the correct endianness. */
1784 if (target
->alternative_target
!= NULL
1785 && (target
->alternative_target
->byteorder
== desired_endian
))
1786 output_target
= target
->alternative_target
->name
;
1789 /* Try to find a target as similar as possible to
1790 the default target, but which has the desired
1791 endian characteristic. */
1792 (void) bfd_search_for_target (closest_target_match
,
1795 /* Oh dear - we could not find any targets that
1796 satisfy our requirements. */
1798 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1800 output_target
= winner
->name
;
1806 output
= bfd_openw (name
, output_target
);
1808 if (output
== (bfd
*) NULL
)
1810 if (bfd_get_error () == bfd_error_invalid_target
)
1811 einfo (_("%P%F: target %s not found\n"), output_target
);
1813 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1816 delete_output_file_on_failure
= true;
1819 output
->flags
|= D_PAGED
;
1822 if (! bfd_set_format (output
, bfd_object
))
1823 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1824 if (! bfd_set_arch_mach (output
,
1825 ldfile_output_architecture
,
1826 ldfile_output_machine
))
1827 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1829 link_info
.hash
= bfd_link_hash_table_create (output
);
1830 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1831 einfo (_("%P%F: can not create link hash table: %E\n"));
1833 bfd_set_gp_size (output
, g_switch_value
);
1838 ldlang_open_output (statement
)
1839 lang_statement_union_type
*statement
;
1841 switch (statement
->header
.type
)
1843 case lang_output_statement_enum
:
1844 ASSERT (output_bfd
== (bfd
*) NULL
);
1845 output_bfd
= open_output (statement
->output_statement
.name
);
1846 ldemul_set_output_arch ();
1847 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1848 output_bfd
->flags
|= D_PAGED
;
1850 output_bfd
->flags
&= ~D_PAGED
;
1851 if (config
.text_read_only
)
1852 output_bfd
->flags
|= WP_TEXT
;
1854 output_bfd
->flags
&= ~WP_TEXT
;
1855 if (link_info
.traditional_format
)
1856 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1858 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1861 case lang_target_statement_enum
:
1862 current_target
= statement
->target_statement
.target
;
1869 /* Open all the input files. */
1872 open_input_bfds (s
, force
)
1873 lang_statement_union_type
*s
;
1876 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1878 switch (s
->header
.type
)
1880 case lang_constructors_statement_enum
:
1881 open_input_bfds (constructor_list
.head
, force
);
1883 case lang_output_section_statement_enum
:
1884 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1886 case lang_wild_statement_enum
:
1887 /* Maybe we should load the file's symbols. */
1888 if (s
->wild_statement
.filename
1889 && ! wildcardp (s
->wild_statement
.filename
))
1890 (void) lookup_name (s
->wild_statement
.filename
);
1891 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1893 case lang_group_statement_enum
:
1895 struct bfd_link_hash_entry
*undefs
;
1897 /* We must continually search the entries in the group
1898 until no new symbols are added to the list of undefined
1903 undefs
= link_info
.hash
->undefs_tail
;
1904 open_input_bfds (s
->group_statement
.children
.head
, true);
1906 while (undefs
!= link_info
.hash
->undefs_tail
);
1909 case lang_target_statement_enum
:
1910 current_target
= s
->target_statement
.target
;
1912 case lang_input_statement_enum
:
1913 if (s
->input_statement
.real
)
1915 lang_statement_list_type add
;
1917 s
->input_statement
.target
= current_target
;
1919 /* If we are being called from within a group, and this
1920 is an archive which has already been searched, then
1921 force it to be researched unless the whole archive
1922 has been loaded already. */
1924 && !s
->input_statement
.whole_archive
1925 && s
->input_statement
.loaded
1926 && bfd_check_format (s
->input_statement
.the_bfd
,
1928 s
->input_statement
.loaded
= false;
1930 lang_list_init (&add
);
1932 load_symbols (&s
->input_statement
, &add
);
1934 if (add
.head
!= NULL
)
1936 *add
.tail
= s
->next
;
1947 /* If there are [COMMONS] statements, put a wild one into the bss
1951 lang_reasonable_defaults ()
1954 lang_output_section_statement_lookup (".text");
1955 lang_output_section_statement_lookup (".data");
1957 default_common_section
= lang_output_section_statement_lookup (".bss");
1959 if (placed_commons
== false)
1961 lang_wild_statement_type
*new =
1962 new_stat (lang_wild_statement
,
1963 &default_common_section
->children
);
1965 new->section_name
= "COMMON";
1966 new->filename
= (char *) NULL
;
1967 lang_list_init (&new->children
);
1972 /* Add the supplied name to the symbol table as an undefined reference.
1973 Remove items from the chain as we open input bfds. */
1974 typedef struct ldlang_undef_chain_list
1976 struct ldlang_undef_chain_list
*next
;
1978 } ldlang_undef_chain_list_type
;
1980 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
1983 ldlang_add_undef (name
)
1984 const char *const name
;
1986 ldlang_undef_chain_list_type
*new =
1987 ((ldlang_undef_chain_list_type
*)
1988 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
1990 new->next
= ldlang_undef_chain_list_head
;
1991 ldlang_undef_chain_list_head
= new;
1993 new->name
= xstrdup (name
);
1996 /* Run through the list of undefineds created above and place them
1997 into the linker hash table as undefined symbols belonging to the
2001 lang_place_undefineds ()
2003 ldlang_undef_chain_list_type
*ptr
;
2005 for (ptr
= ldlang_undef_chain_list_head
;
2006 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
2009 struct bfd_link_hash_entry
*h
;
2011 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
2012 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2013 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2014 if (h
->type
== bfd_link_hash_new
)
2016 h
->type
= bfd_link_hash_undefined
;
2017 h
->u
.undef
.abfd
= NULL
;
2018 bfd_link_add_undef (link_info
.hash
, h
);
2023 /* Open input files and attatch to output sections. */
2026 map_input_to_output_sections (s
, target
, output_section_statement
)
2027 lang_statement_union_type
*s
;
2029 lang_output_section_statement_type
*output_section_statement
;
2031 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2033 switch (s
->header
.type
)
2036 case lang_wild_statement_enum
:
2037 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
2038 s
->wild_statement
.filename
, target
,
2039 output_section_statement
);
2042 case lang_constructors_statement_enum
:
2043 map_input_to_output_sections (constructor_list
.head
,
2045 output_section_statement
);
2047 case lang_output_section_statement_enum
:
2048 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2050 &s
->output_section_statement
);
2052 case lang_output_statement_enum
:
2054 case lang_target_statement_enum
:
2055 target
= s
->target_statement
.target
;
2057 case lang_group_statement_enum
:
2058 map_input_to_output_sections (s
->group_statement
.children
.head
,
2060 output_section_statement
);
2062 case lang_fill_statement_enum
:
2063 case lang_input_section_enum
:
2064 case lang_object_symbols_statement_enum
:
2065 case lang_data_statement_enum
:
2066 case lang_reloc_statement_enum
:
2067 case lang_padding_statement_enum
:
2068 case lang_input_statement_enum
:
2069 if (output_section_statement
!= NULL
2070 && output_section_statement
->bfd_section
== NULL
)
2071 init_os (output_section_statement
);
2073 case lang_assignment_statement_enum
:
2074 if (output_section_statement
!= NULL
2075 && output_section_statement
->bfd_section
== NULL
)
2076 init_os (output_section_statement
);
2078 /* Make sure that any sections mentioned in the assignment
2080 exp_init_os (s
->assignment_statement
.exp
);
2082 case lang_afile_asection_pair_statement_enum
:
2085 case lang_address_statement_enum
:
2086 /* Mark the specified section with the supplied address. */
2088 lang_output_section_statement_type
*os
=
2089 lang_output_section_statement_lookup
2090 (s
->address_statement
.section_name
);
2092 if (os
->bfd_section
== NULL
)
2094 os
->addr_tree
= s
->address_statement
.address
;
2102 print_output_section_statement (output_section_statement
)
2103 lang_output_section_statement_type
*output_section_statement
;
2105 asection
*section
= output_section_statement
->bfd_section
;
2108 if (output_section_statement
!= abs_output_section
)
2110 minfo ("\n%s", output_section_statement
->name
);
2112 if (section
!= NULL
)
2114 print_dot
= section
->vma
;
2116 len
= strlen (output_section_statement
->name
);
2117 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2122 while (len
< SECTION_NAME_MAP_LENGTH
)
2128 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2130 if (output_section_statement
->load_base
!= NULL
)
2134 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2135 "load base", lang_final_phase_enum
);
2136 minfo (_(" load address 0x%V"), addr
);
2143 print_statement_list (output_section_statement
->children
.head
,
2144 output_section_statement
);
2148 print_assignment (assignment
, output_section
)
2149 lang_assignment_statement_type
*assignment
;
2150 lang_output_section_statement_type
*output_section
;
2153 etree_value_type result
;
2155 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2158 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2159 lang_final_phase_enum
, print_dot
, &print_dot
);
2161 minfo ("0x%V", result
.value
+ result
.section
->bfd_section
->vma
);
2172 exp_print_tree (assignment
->exp
);
2178 print_input_statement (statm
)
2179 lang_input_statement_type
*statm
;
2181 if (statm
->filename
!= (char *) NULL
)
2183 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2187 /* Print all symbols defined in a particular section. This is called
2188 via bfd_link_hash_traverse. */
2191 print_one_symbol (hash_entry
, ptr
)
2192 struct bfd_link_hash_entry
*hash_entry
;
2195 asection
*sec
= (asection
*) ptr
;
2197 if ((hash_entry
->type
== bfd_link_hash_defined
2198 || hash_entry
->type
== bfd_link_hash_defweak
)
2199 && sec
== hash_entry
->u
.def
.section
)
2203 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2206 (hash_entry
->u
.def
.value
2207 + hash_entry
->u
.def
.section
->output_offset
2208 + hash_entry
->u
.def
.section
->output_section
->vma
));
2210 minfo (" %T\n", hash_entry
->root
.string
);
2216 /* Print information about an input section to the map file. */
2219 print_input_section (in
)
2220 lang_input_section_type
*in
;
2222 asection
*i
= in
->section
;
2223 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2224 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2225 ldfile_output_machine
);
2230 minfo ("%s", i
->name
);
2232 if (i
->output_section
!= NULL
)
2236 len
= 1 + strlen (i
->name
);
2237 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2242 while (len
< SECTION_NAME_MAP_LENGTH
)
2248 minfo ("0x%V %W %B\n",
2249 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2252 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2254 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2266 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2269 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2271 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2277 print_fill_statement (fill
)
2278 lang_fill_statement_type
*fill
;
2280 fprintf (config
.map_file
, " FILL mask 0x%x\n", fill
->fill
);
2284 print_data_statement (data
)
2285 lang_data_statement_type
*data
;
2291 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2292 ldfile_output_machine
);
2294 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2297 addr
= data
->output_vma
;
2298 if (data
->output_section
!= NULL
)
2299 addr
+= data
->output_section
->vma
;
2327 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2329 if (data
->exp
->type
.node_class
!= etree_value
)
2332 exp_print_tree (data
->exp
);
2337 print_dot
= addr
+ size
/ opb
;
2341 /* Print an address statement. These are generated by options like
2345 print_address_statement (address
)
2346 lang_address_statement_type
*address
;
2348 minfo (_("Address of section %s set to "), address
->section_name
);
2349 exp_print_tree (address
->address
);
2353 /* Print a reloc statement. */
2356 print_reloc_statement (reloc
)
2357 lang_reloc_statement_type
*reloc
;
2362 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2363 ldfile_output_machine
);
2365 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2368 addr
= reloc
->output_vma
;
2369 if (reloc
->output_section
!= NULL
)
2370 addr
+= reloc
->output_section
->vma
;
2372 size
= bfd_get_reloc_size (reloc
->howto
);
2374 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2376 if (reloc
->name
!= NULL
)
2377 minfo ("%s+", reloc
->name
);
2379 minfo ("%s+", reloc
->section
->name
);
2381 exp_print_tree (reloc
->addend_exp
);
2385 print_dot
= addr
+ size
/ opb
;
2389 print_padding_statement (s
)
2390 lang_padding_statement_type
*s
;
2394 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2395 ldfile_output_machine
);
2399 len
= sizeof " *fill*" - 1;
2400 while (len
< SECTION_NAME_MAP_LENGTH
)
2406 addr
= s
->output_offset
;
2407 if (s
->output_section
!= NULL
)
2408 addr
+= s
->output_section
->vma
;
2409 minfo ("0x%V %W", addr
, s
->size
);
2412 minfo (" %u", s
->fill
);
2416 print_dot
= addr
+ s
->size
/ opb
;
2420 print_wild_statement (w
, os
)
2421 lang_wild_statement_type
*w
;
2422 lang_output_section_statement_type
*os
;
2426 if (w
->filenames_sorted
)
2428 if (w
->exclude_filename_list
!= NULL
)
2431 minfo ("EXCLUDE_FILE ( %s", w
->exclude_filename_list
->name
);
2432 for (tmp
= w
->exclude_filename_list
->next
; tmp
; tmp
= tmp
->next
)
2433 minfo (", %s", tmp
->name
);
2436 if (w
->filename
!= NULL
)
2437 minfo ("%s", w
->filename
);
2440 if (w
->filenames_sorted
)
2444 if (w
->sections_sorted
)
2446 if (w
->section_name
!= NULL
)
2447 minfo ("%s", w
->section_name
);
2450 if (w
->sections_sorted
)
2456 print_statement_list (w
->children
.head
, os
);
2459 /* Print a group statement. */
2463 lang_group_statement_type
*s
;
2464 lang_output_section_statement_type
*os
;
2466 fprintf (config
.map_file
, "START GROUP\n");
2467 print_statement_list (s
->children
.head
, os
);
2468 fprintf (config
.map_file
, "END GROUP\n");
2471 /* Print the list of statements in S.
2472 This can be called for any statement type. */
2475 print_statement_list (s
, os
)
2476 lang_statement_union_type
*s
;
2477 lang_output_section_statement_type
*os
;
2481 print_statement (s
, os
);
2486 /* Print the first statement in statement list S.
2487 This can be called for any statement type. */
2490 print_statement (s
, os
)
2491 lang_statement_union_type
*s
;
2492 lang_output_section_statement_type
*os
;
2494 switch (s
->header
.type
)
2497 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2500 case lang_constructors_statement_enum
:
2501 if (constructor_list
.head
!= NULL
)
2503 if (constructors_sorted
)
2504 minfo (" SORT (CONSTRUCTORS)\n");
2506 minfo (" CONSTRUCTORS\n");
2507 print_statement_list (constructor_list
.head
, os
);
2510 case lang_wild_statement_enum
:
2511 print_wild_statement (&s
->wild_statement
, os
);
2513 case lang_address_statement_enum
:
2514 print_address_statement (&s
->address_statement
);
2516 case lang_object_symbols_statement_enum
:
2517 minfo (" CREATE_OBJECT_SYMBOLS\n");
2519 case lang_fill_statement_enum
:
2520 print_fill_statement (&s
->fill_statement
);
2522 case lang_data_statement_enum
:
2523 print_data_statement (&s
->data_statement
);
2525 case lang_reloc_statement_enum
:
2526 print_reloc_statement (&s
->reloc_statement
);
2528 case lang_input_section_enum
:
2529 print_input_section (&s
->input_section
);
2531 case lang_padding_statement_enum
:
2532 print_padding_statement (&s
->padding_statement
);
2534 case lang_output_section_statement_enum
:
2535 print_output_section_statement (&s
->output_section_statement
);
2537 case lang_assignment_statement_enum
:
2538 print_assignment (&s
->assignment_statement
, os
);
2540 case lang_target_statement_enum
:
2541 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2543 case lang_output_statement_enum
:
2544 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2545 if (output_target
!= NULL
)
2546 minfo (" %s", output_target
);
2549 case lang_input_statement_enum
:
2550 print_input_statement (&s
->input_statement
);
2552 case lang_group_statement_enum
:
2553 print_group (&s
->group_statement
, os
);
2555 case lang_afile_asection_pair_statement_enum
:
2564 print_statement_list (statement_list
.head
, abs_output_section
);
2567 /* Print the first N statements in statement list S to STDERR.
2568 If N == 0, nothing is printed.
2569 If N < 0, the entire list is printed.
2570 Intended to be called from GDB. */
2573 dprint_statement (s
, n
)
2574 lang_statement_union_type
*s
;
2577 FILE *map_save
= config
.map_file
;
2579 config
.map_file
= stderr
;
2582 print_statement_list (s
, abs_output_section
);
2585 while (s
&& --n
>= 0)
2587 print_statement (s
, abs_output_section
);
2592 config
.map_file
= map_save
;
2596 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
2597 lang_statement_union_type
**this_ptr
;
2600 asection
*output_section_statement
;
2603 /* Align this section first to the
2604 input sections requirement, then
2605 to the output section's requirement.
2606 If this alignment is > than any seen before,
2607 then record it too. Perform the alignment by
2608 inserting a magic 'padding' statement. */
2610 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2611 ldfile_output_machine
);
2612 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
2614 if (alignment_needed
!= 0)
2616 lang_statement_union_type
*new =
2617 ((lang_statement_union_type
*)
2618 stat_alloc (sizeof (lang_padding_statement_type
)));
2620 /* Link into existing chain. */
2621 new->header
.next
= *this_ptr
;
2623 new->header
.type
= lang_padding_statement_enum
;
2624 new->padding_statement
.output_section
= output_section_statement
;
2625 new->padding_statement
.output_offset
=
2626 dot
- output_section_statement
->vma
;
2627 new->padding_statement
.fill
= fill
;
2628 new->padding_statement
.size
= alignment_needed
* opb
;
2631 /* Remember the most restrictive alignment. */
2632 if (power
> output_section_statement
->alignment_power
)
2634 output_section_statement
->alignment_power
= power
;
2636 output_section_statement
->_raw_size
+= alignment_needed
* opb
;
2638 return dot
+ alignment_needed
;
2641 /* Work out how much this section will move the dot point. */
2644 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
2645 lang_statement_union_type
**this_ptr
;
2646 lang_output_section_statement_type
*output_section_statement
;
2649 boolean relax ATTRIBUTE_UNUSED
;
2651 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2652 asection
*i
= is
->section
;
2653 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2654 ldfile_output_machine
);
2656 if (is
->ifile
->just_syms_flag
== false)
2658 if (output_section_statement
->subsection_alignment
!= -1)
2659 i
->alignment_power
=
2660 output_section_statement
->subsection_alignment
;
2662 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
2663 output_section_statement
->bfd_section
, dot
);
2665 /* Remember where in the output section this input section goes. */
2667 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
2669 /* Mark how big the output section must be to contain this now. */
2670 if (i
->_cooked_size
!= 0)
2671 dot
+= i
->_cooked_size
/ opb
;
2673 dot
+= i
->_raw_size
/ opb
;
2674 output_section_statement
->bfd_section
->_raw_size
=
2675 (dot
- output_section_statement
->bfd_section
->vma
) * opb
;
2679 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2685 #define IGNORE_SECTION(bfd, s) \
2686 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2687 != (SEC_ALLOC | SEC_LOAD)) \
2688 || bfd_section_size (bfd, s) == 0)
2690 /* Check to see if any allocated sections overlap with other allocated
2691 sections. This can happen when the linker script specifically specifies
2692 the output section addresses of the two sections. */
2695 lang_check_section_addresses ()
2698 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2700 /* Scan all sections in the output list. */
2701 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2705 /* Ignore sections which are not loaded or which have no contents. */
2706 if (IGNORE_SECTION (output_bfd
, s
))
2709 /* Once we reach section 's' stop our seach. This prevents two
2710 warning messages from being produced, one for 'section A overlaps
2711 section B' and one for 'section B overlaps section A'. */
2712 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2719 /* Only consider loadable sections with real contents. */
2720 if (IGNORE_SECTION (output_bfd
, os
))
2723 /* We must check the sections' LMA addresses not their
2724 VMA addresses because overlay sections can have
2725 overlapping VMAs but they must have distinct LMAs. */
2726 s_start
= bfd_section_lma (output_bfd
, s
);
2727 os_start
= bfd_section_lma (output_bfd
, os
);
2728 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2729 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2731 /* Look for an overlap. */
2732 if ((s_end
< os_start
) || (s_start
> os_end
))
2736 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2737 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2739 /* Once we have found one overlap for this section,
2740 stop looking for others. */
2746 /* This variable indicates whether bfd_relax_section should be called
2749 static boolean relax_again
;
2751 /* Make sure the new address is within the region. We explicitly permit the
2752 current address to be at the exact end of the region when the address is
2753 non-zero, in case the region is at the end of addressable memory and the
2754 calculation wraps around. */
2757 os_region_check (os
, region
, tree
, base
)
2758 lang_output_section_statement_type
*os
;
2759 struct memory_region_struct
*region
;
2763 if ((region
->current
< region
->origin
2764 || (region
->current
- region
->origin
> region
->length
))
2765 && ((region
->current
!= region
->origin
+ region
->length
)
2768 if (tree
!= (etree_type
*) NULL
)
2770 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2772 os
->bfd_section
->owner
,
2773 os
->bfd_section
->name
,
2778 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2780 os
->bfd_section
->owner
,
2781 os
->bfd_section
->name
);
2783 /* Reset the region pointer. */
2784 region
->current
= region
->origin
;
2788 /* Set the sizes for all the output sections. */
2791 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2792 lang_statement_union_type
*s
;
2793 lang_output_section_statement_type
*output_section_statement
;
2794 lang_statement_union_type
**prev
;
2799 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2800 ldfile_output_machine
);
2802 /* Size up the sections from their constituent parts. */
2803 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2805 switch (s
->header
.type
)
2807 case lang_output_section_statement_enum
:
2810 lang_output_section_statement_type
*os
;
2812 os
= &s
->output_section_statement
;
2813 if (os
->bfd_section
== NULL
)
2814 /* This section was never actually created. */
2817 /* If this is a COFF shared library section, use the size and
2818 address from the input section. FIXME: This is COFF
2819 specific; it would be cleaner if there were some other way
2820 to do this, but nothing simple comes to mind. */
2821 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2825 if (os
->children
.head
== NULL
2826 || os
->children
.head
->next
!= NULL
2827 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2828 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2831 input
= os
->children
.head
->input_section
.section
;
2832 bfd_set_section_vma (os
->bfd_section
->owner
,
2834 bfd_section_vma (input
->owner
, input
));
2835 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2839 if (bfd_is_abs_section (os
->bfd_section
))
2841 /* No matter what happens, an abs section starts at zero. */
2842 ASSERT (os
->bfd_section
->vma
== 0);
2846 if (os
->addr_tree
== (etree_type
*) NULL
)
2848 /* No address specified for this section, get one
2849 from the region specification. */
2850 if (os
->region
== (lang_memory_region_type
*) NULL
2851 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2852 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2853 && os
->region
->name
[0] == '*'
2854 && strcmp (os
->region
->name
, "*default*") == 0))
2856 os
->region
= lang_memory_default (os
->bfd_section
);
2859 /* If a loadable section is using the default memory
2860 region, and some non default memory regions were
2861 defined, issue a warning. */
2862 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2863 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2864 && ! link_info
.relocateable
2865 && strcmp (os
->region
->name
, "*default*") == 0
2866 && lang_memory_region_list
!= NULL
2867 && (strcmp (lang_memory_region_list
->name
,
2869 || lang_memory_region_list
->next
!= NULL
))
2870 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2871 bfd_get_section_name (output_bfd
,
2874 dot
= os
->region
->current
;
2876 if (os
->section_alignment
== -1)
2881 dot
= align_power (dot
,
2882 os
->bfd_section
->alignment_power
);
2884 if (dot
!= olddot
&& config
.warn_section_align
)
2885 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2886 os
->name
, (unsigned int) (dot
- olddot
));
2893 r
= exp_fold_tree (os
->addr_tree
,
2895 lang_allocating_phase_enum
,
2897 if (r
.valid_p
== false)
2899 einfo (_("%F%S: non constant address expression for section %s\n"),
2902 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2905 /* The section starts here.
2906 First, align to what the section needs. */
2908 if (os
->section_alignment
!= -1)
2909 dot
= align_power (dot
, os
->section_alignment
);
2911 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2913 os
->bfd_section
->output_offset
= 0;
2916 (void) lang_size_sections (os
->children
.head
, os
,
2918 os
->fill
, dot
, relax
);
2920 /* Put the section within the requested block size, or
2921 align at the block boundary. */
2922 after
= ALIGN_N (os
->bfd_section
->vma
2923 + os
->bfd_section
->_raw_size
/ opb
,
2924 /* The coercion here is important, see ld.h. */
2925 (bfd_vma
) os
->block_value
);
2927 if (bfd_is_abs_section (os
->bfd_section
))
2928 ASSERT (after
== os
->bfd_section
->vma
);
2930 os
->bfd_section
->_raw_size
=
2931 (after
- os
->bfd_section
->vma
) * opb
;
2932 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
2933 os
->processed
= true;
2935 /* Update dot in the region ?
2936 We only do this if the section is going to be allocated,
2937 since unallocated sections do not contribute to the region's
2938 overall size in memory.
2940 If the SEC_NEVER_LOAD bit is not set, it will affect the
2941 addresses of sections after it. We have to update
2943 if (os
->region
!= (lang_memory_region_type
*) NULL
2944 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2945 & SEC_NEVER_LOAD
) == 0
2946 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2947 & (SEC_ALLOC
| SEC_LOAD
))))
2949 os
->region
->current
= dot
;
2951 /* Make sure the new address is within the region. */
2952 os_region_check (os
, os
->region
, os
->addr_tree
,
2953 os
->bfd_section
->vma
);
2955 /* If there's no load address specified, use the run
2956 region as the load region. */
2957 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
2958 os
->lma_region
= os
->region
;
2960 if (os
->lma_region
!= NULL
)
2962 if (os
->load_base
!= NULL
)
2964 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
2968 /* Don't allocate twice. */
2969 if (os
->lma_region
!= os
->region
)
2971 /* Set load_base, which will be handled later. */
2973 exp_intop (os
->lma_region
->current
);
2974 os
->lma_region
->current
+=
2975 os
->bfd_section
->_raw_size
/ opb
;
2976 os_region_check (os
, os
->lma_region
, NULL
,
2977 os
->bfd_section
->lma
);
2985 case lang_constructors_statement_enum
:
2986 dot
= lang_size_sections (constructor_list
.head
,
2987 output_section_statement
,
2988 &s
->wild_statement
.children
.head
,
2993 case lang_data_statement_enum
:
2995 unsigned int size
= 0;
2997 s
->data_statement
.output_vma
=
2998 dot
- output_section_statement
->bfd_section
->vma
;
2999 s
->data_statement
.output_section
=
3000 output_section_statement
->bfd_section
;
3002 switch (s
->data_statement
.type
)
3023 output_section_statement
->bfd_section
->_raw_size
+= size
;
3024 /* The output section gets contents, and then we inspect for
3025 any flags set in the input script which override any ALLOC. */
3026 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3027 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3029 output_section_statement
->bfd_section
->flags
|=
3030 SEC_ALLOC
| SEC_LOAD
;
3035 case lang_reloc_statement_enum
:
3039 s
->reloc_statement
.output_vma
=
3040 dot
- output_section_statement
->bfd_section
->vma
;
3041 s
->reloc_statement
.output_section
=
3042 output_section_statement
->bfd_section
;
3043 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3045 output_section_statement
->bfd_section
->_raw_size
+= size
;
3049 case lang_wild_statement_enum
:
3051 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
3052 output_section_statement
,
3053 &s
->wild_statement
.children
.head
,
3058 case lang_object_symbols_statement_enum
:
3059 link_info
.create_object_symbols_section
=
3060 output_section_statement
->bfd_section
;
3062 case lang_output_statement_enum
:
3063 case lang_target_statement_enum
:
3065 case lang_input_section_enum
:
3069 i
= (*prev
)->input_section
.section
;
3072 if (i
->_cooked_size
== 0)
3073 i
->_cooked_size
= i
->_raw_size
;
3079 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3080 einfo (_("%P%F: can't relax section: %E\n"));
3084 dot
= size_input_section (prev
,
3085 output_section_statement
,
3086 output_section_statement
->fill
,
3090 case lang_input_statement_enum
:
3092 case lang_fill_statement_enum
:
3093 s
->fill_statement
.output_section
=
3094 output_section_statement
->bfd_section
;
3096 fill
= s
->fill_statement
.fill
;
3098 case lang_assignment_statement_enum
:
3100 bfd_vma newdot
= dot
;
3102 exp_fold_tree (s
->assignment_statement
.exp
,
3103 output_section_statement
,
3104 lang_allocating_phase_enum
,
3110 /* The assignment changed dot. Insert a pad. */
3111 if (output_section_statement
== abs_output_section
)
3113 /* If we don't have an output section, then just adjust
3114 the default memory address. */
3115 lang_memory_region_lookup ("*default*")->current
= newdot
;
3119 lang_statement_union_type
*new =
3120 ((lang_statement_union_type
*)
3121 stat_alloc (sizeof (lang_padding_statement_type
)));
3123 /* Link into existing chain. */
3124 new->header
.next
= *prev
;
3126 new->header
.type
= lang_padding_statement_enum
;
3127 new->padding_statement
.output_section
=
3128 output_section_statement
->bfd_section
;
3129 new->padding_statement
.output_offset
=
3130 dot
- output_section_statement
->bfd_section
->vma
;
3131 new->padding_statement
.fill
= fill
;
3132 new->padding_statement
.size
= (newdot
- dot
) * opb
;
3133 output_section_statement
->bfd_section
->_raw_size
+=
3134 new->padding_statement
.size
;
3142 case lang_padding_statement_enum
:
3143 /* If we are relaxing, and this is not the first pass, some
3144 padding statements may have been inserted during previous
3145 passes. We may have to move the padding statement to a new
3146 location if dot has a different value at this point in this
3147 pass than it did at this point in the previous pass. */
3148 s
->padding_statement
.output_offset
=
3149 dot
- output_section_statement
->bfd_section
->vma
;
3150 dot
+= s
->padding_statement
.size
/ opb
;
3151 output_section_statement
->bfd_section
->_raw_size
+=
3152 s
->padding_statement
.size
;
3155 case lang_group_statement_enum
:
3156 dot
= lang_size_sections (s
->group_statement
.children
.head
,
3157 output_section_statement
,
3158 &s
->group_statement
.children
.head
,
3166 /* This can only get here when relaxing is turned on. */
3168 case lang_address_statement_enum
:
3171 prev
= &s
->header
.next
;
3177 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3178 lang_statement_union_type
*s
;
3179 lang_output_section_statement_type
*output_section_statement
;
3183 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3184 ldfile_output_machine
);
3186 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
3188 switch (s
->header
.type
)
3190 case lang_constructors_statement_enum
:
3191 dot
= lang_do_assignments (constructor_list
.head
,
3192 output_section_statement
,
3197 case lang_output_section_statement_enum
:
3199 lang_output_section_statement_type
*os
;
3201 os
= &(s
->output_section_statement
);
3202 if (os
->bfd_section
!= NULL
)
3204 dot
= os
->bfd_section
->vma
;
3205 (void) lang_do_assignments (os
->children
.head
, os
,
3207 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3212 /* If nothing has been placed into the output section then
3213 it won't have a bfd_section. */
3214 if (os
->bfd_section
)
3216 os
->bfd_section
->lma
3217 = exp_get_abs_int (os
->load_base
, 0, "load base",
3218 lang_final_phase_enum
);
3223 case lang_wild_statement_enum
:
3225 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3226 output_section_statement
,
3231 case lang_object_symbols_statement_enum
:
3232 case lang_output_statement_enum
:
3233 case lang_target_statement_enum
:
3235 case lang_common_statement_enum
:
3238 case lang_data_statement_enum
:
3240 etree_value_type value
;
3242 value
= exp_fold_tree (s
->data_statement
.exp
,
3244 lang_final_phase_enum
, dot
, &dot
);
3245 s
->data_statement
.value
= value
.value
;
3246 if (value
.valid_p
== false)
3247 einfo (_("%F%P: invalid data statement\n"));
3251 switch (s
->data_statement
.type
)
3275 case lang_reloc_statement_enum
:
3277 etree_value_type value
;
3279 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3281 lang_final_phase_enum
, dot
, &dot
);
3282 s
->reloc_statement
.addend_value
= value
.value
;
3283 if (value
.valid_p
== false)
3284 einfo (_("%F%P: invalid reloc statement\n"));
3286 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3289 case lang_input_section_enum
:
3291 asection
*in
= s
->input_section
.section
;
3293 if (in
->_cooked_size
!= 0)
3294 dot
+= in
->_cooked_size
/ opb
;
3296 dot
+= in
->_raw_size
/ opb
;
3300 case lang_input_statement_enum
:
3302 case lang_fill_statement_enum
:
3303 fill
= s
->fill_statement
.fill
;
3305 case lang_assignment_statement_enum
:
3307 exp_fold_tree (s
->assignment_statement
.exp
,
3308 output_section_statement
,
3309 lang_final_phase_enum
,
3315 case lang_padding_statement_enum
:
3316 dot
+= s
->padding_statement
.size
/ opb
;
3319 case lang_group_statement_enum
:
3320 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3321 output_section_statement
,
3329 case lang_address_statement_enum
:
3337 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3338 operator .startof. (section_name), it produces an undefined symbol
3339 .startof.section_name. Similarly, when it sees
3340 .sizeof. (section_name), it produces an undefined symbol
3341 .sizeof.section_name. For all the output sections, we look for
3342 such symbols, and set them to the correct value. */
3349 if (link_info
.relocateable
)
3352 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3354 const char *secname
;
3356 struct bfd_link_hash_entry
*h
;
3358 secname
= bfd_get_section_name (output_bfd
, s
);
3359 buf
= xmalloc (10 + strlen (secname
));
3361 sprintf (buf
, ".startof.%s", secname
);
3362 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3363 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3365 h
->type
= bfd_link_hash_defined
;
3366 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3367 h
->u
.def
.section
= bfd_abs_section_ptr
;
3370 sprintf (buf
, ".sizeof.%s", secname
);
3371 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3372 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3376 opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3377 ldfile_output_machine
);
3378 h
->type
= bfd_link_hash_defined
;
3379 if (s
->_cooked_size
!= 0)
3380 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3382 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3383 h
->u
.def
.section
= bfd_abs_section_ptr
;
3393 struct bfd_link_hash_entry
*h
;
3396 if (link_info
.relocateable
|| link_info
.shared
)
3401 if (entry_symbol
== (char *) NULL
)
3403 /* No entry has been specified. Look for start, but don't warn
3404 if we don't find it. */
3405 entry_symbol
= "start";
3409 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
3410 if (h
!= (struct bfd_link_hash_entry
*) NULL
3411 && (h
->type
== bfd_link_hash_defined
3412 || h
->type
== bfd_link_hash_defweak
)
3413 && h
->u
.def
.section
->output_section
!= NULL
)
3417 val
= (h
->u
.def
.value
3418 + bfd_get_section_vma (output_bfd
,
3419 h
->u
.def
.section
->output_section
)
3420 + h
->u
.def
.section
->output_offset
);
3421 if (! bfd_set_start_address (output_bfd
, val
))
3422 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
);
3429 /* We couldn't find the entry symbol. Try parsing it as a
3431 val
= bfd_scan_vma (entry_symbol
, &send
, 0);
3434 if (! bfd_set_start_address (output_bfd
, val
))
3435 einfo (_("%P%F: can't set start address\n"));
3441 /* Can't find the entry symbol, and it's not a number. Use
3442 the first address in the text section. */
3443 ts
= bfd_get_section_by_name (output_bfd
, ".text");
3444 if (ts
!= (asection
*) NULL
)
3447 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3448 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
3449 if (! bfd_set_start_address (output_bfd
,
3450 bfd_get_section_vma (output_bfd
,
3452 einfo (_("%P%F: can't set start address\n"));
3457 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3464 /* This is a small function used when we want to ignore errors from
3468 #ifdef ANSI_PROTOTYPES
3469 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3471 ignore_bfd_errors (s
)
3472 const char *s ATTRIBUTE_UNUSED
;
3475 /* Don't do anything. */
3478 /* Check that the architecture of all the input files is compatible
3479 with the output file. Also call the backend to let it do any
3480 other checking that is needed. */
3485 lang_statement_union_type
*file
;
3487 const bfd_arch_info_type
*compatible
;
3489 for (file
= file_chain
.head
;
3490 file
!= (lang_statement_union_type
*) NULL
;
3491 file
= file
->input_statement
.next
)
3493 input_bfd
= file
->input_statement
.the_bfd
;
3494 compatible
= bfd_arch_get_compatible (input_bfd
,
3496 if (compatible
== NULL
)
3498 if (command_line
.warn_mismatch
)
3499 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3500 bfd_printable_name (input_bfd
), input_bfd
,
3501 bfd_printable_name (output_bfd
));
3503 else if (bfd_count_sections (input_bfd
))
3505 /* If the input bfd has no contents, it shouldn't set the
3506 private data of the output bfd. */
3508 bfd_error_handler_type pfn
= NULL
;
3510 /* If we aren't supposed to warn about mismatched input
3511 files, temporarily set the BFD error handler to a
3512 function which will do nothing. We still want to call
3513 bfd_merge_private_bfd_data, since it may set up
3514 information which is needed in the output file. */
3515 if (! command_line
.warn_mismatch
)
3516 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3517 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3519 if (command_line
.warn_mismatch
)
3520 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3523 if (! command_line
.warn_mismatch
)
3524 bfd_set_error_handler (pfn
);
3529 /* Look through all the global common symbols and attach them to the
3530 correct section. The -sort-common command line switch may be used
3531 to roughly sort the entries by size. */
3536 if (link_info
.relocateable
3537 && ! command_line
.force_common_definition
)
3540 if (! config
.sort_common
)
3541 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3546 for (power
= 4; power
>= 0; power
--)
3547 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3552 /* Place one common symbol in the correct section. */
3555 lang_one_common (h
, info
)
3556 struct bfd_link_hash_entry
*h
;
3559 unsigned int power_of_two
;
3562 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3563 ldfile_output_machine
);
3565 if (h
->type
!= bfd_link_hash_common
)
3569 power_of_two
= h
->u
.c
.p
->alignment_power
;
3571 if (config
.sort_common
3572 && power_of_two
< (unsigned int) *(int *) info
)
3575 section
= h
->u
.c
.p
->section
;
3577 /* Increase the size of the section. */
3578 section
->_cooked_size
= ALIGN_N ((section
->_cooked_size
+ opb
- 1) / opb
,
3579 (bfd_size_type
) (1 << power_of_two
)) * opb
;
3581 /* Adjust the alignment if necessary. */
3582 if (power_of_two
> section
->alignment_power
)
3583 section
->alignment_power
= power_of_two
;
3585 /* Change the symbol from common to defined. */
3586 h
->type
= bfd_link_hash_defined
;
3587 h
->u
.def
.section
= section
;
3588 h
->u
.def
.value
= section
->_cooked_size
;
3590 /* Increase the size of the section. */
3591 section
->_cooked_size
+= size
;
3593 /* Make sure the section is allocated in memory, and make sure that
3594 it is no longer a common section. */
3595 section
->flags
|= SEC_ALLOC
;
3596 section
->flags
&= ~SEC_IS_COMMON
;
3598 if (config
.map_file
!= NULL
)
3600 static boolean header_printed
;
3605 if (! header_printed
)
3607 minfo (_("\nAllocating common symbols\n"));
3608 minfo (_("Common symbol size file\n\n"));
3609 header_printed
= true;
3612 name
= demangle (h
->root
.string
);
3614 len
= strlen (name
);
3629 if (size
<= 0xffffffff)
3630 sprintf (buf
, "%lx", (unsigned long) size
);
3632 sprintf_vma (buf
, size
);
3642 minfo ("%B\n", section
->owner
);
3648 /* Run through the input files and ensure that every input section has
3649 somewhere to go. If one is found without a destination then create
3650 an input request and place it into the statement tree. */
3653 lang_place_orphans ()
3655 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3659 for (s
= file
->the_bfd
->sections
;
3660 s
!= (asection
*) NULL
;
3663 if (s
->output_section
== (asection
*) NULL
)
3665 /* This section of the file is not attatched, root
3666 around for a sensible place for it to go. */
3668 if (file
->just_syms_flag
)
3670 /* We are only retrieving symbol values from this
3671 file. We want the symbols to act as though the
3672 values in the file are absolute. */
3673 s
->output_section
= bfd_abs_section_ptr
;
3674 s
->output_offset
= s
->vma
;
3676 else if (strcmp (s
->name
, "COMMON") == 0)
3678 /* This is a lonely common section which must have
3679 come from an archive. We attach to the section
3680 with the wildcard. */
3681 if (! link_info
.relocateable
3682 || command_line
.force_common_definition
)
3684 if (default_common_section
== NULL
)
3687 /* This message happens when using the
3688 svr3.ifile linker script, so I have
3690 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3692 default_common_section
=
3693 lang_output_section_statement_lookup (".bss");
3696 wild_doit (&default_common_section
->children
, s
,
3697 default_common_section
, file
);
3700 else if (ldemul_place_orphan (file
, s
))
3704 lang_output_section_statement_type
*os
=
3705 lang_output_section_statement_lookup (s
->name
);
3707 wild_doit (&os
->children
, s
, os
, file
);
3715 lang_set_flags (ptr
, flags
, invert
)
3716 lang_memory_region_type
*ptr
;
3720 flagword
*ptr_flags
;
3722 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3728 *ptr_flags
|= SEC_ALLOC
;
3732 *ptr_flags
|= SEC_READONLY
;
3736 *ptr_flags
|= SEC_DATA
;
3740 *ptr_flags
|= SEC_CODE
;
3745 *ptr_flags
|= SEC_LOAD
;
3749 einfo (_("%P%F: invalid syntax in flags\n"));
3756 /* Call a function on each input file. This function will be called
3757 on an archive, but not on the elements. */
3760 lang_for_each_input_file (func
)
3761 void (*func
) PARAMS ((lang_input_statement_type
*));
3763 lang_input_statement_type
*f
;
3765 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3767 f
= (lang_input_statement_type
*) f
->next_real_file
)
3771 /* Call a function on each file. The function will be called on all
3772 the elements of an archive which are included in the link, but will
3773 not be called on the archive file itself. */
3776 lang_for_each_file (func
)
3777 void (*func
) PARAMS ((lang_input_statement_type
*));
3779 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3790 lang_for_each_input_section (func
)
3791 void (*func
) PARAMS ((bfd
*ab
, asection
*as
));
3793 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3797 for (s
= f
->the_bfd
->sections
;
3798 s
!= (asection
*) NULL
;
3801 func (f
->the_bfd
, s
);
3809 ldlang_add_file (entry
)
3810 lang_input_statement_type
*entry
;
3814 lang_statement_append (&file_chain
,
3815 (lang_statement_union_type
*) entry
,
3818 /* The BFD linker needs to have a list of all input BFDs involved in
3820 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3821 ASSERT (entry
->the_bfd
!= output_bfd
);
3822 for (pp
= &link_info
.input_bfds
;
3823 *pp
!= (bfd
*) NULL
;
3824 pp
= &(*pp
)->link_next
)
3826 *pp
= entry
->the_bfd
;
3827 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3828 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3830 /* Look through the sections and check for any which should not be
3831 included in the link. We need to do this now, so that we can
3832 notice when the backend linker tries to report multiple
3833 definition errors for symbols which are in sections we aren't
3834 going to link. FIXME: It might be better to entirely ignore
3835 symbols which are defined in sections which are going to be
3836 discarded. This would require modifying the backend linker for
3837 each backend which might set the SEC_LINK_ONCE flag. If we do
3838 this, we should probably handle SEC_EXCLUDE in the same way. */
3840 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
3844 lang_add_output (name
, from_script
)
3848 /* Make -o on command line override OUTPUT in script. */
3849 if (had_output_filename
== false || !from_script
)
3851 output_filename
= name
;
3852 had_output_filename
= true;
3856 static lang_output_section_statement_type
*current_section
;
3868 for (l
= 0; l
< 32; l
++)
3870 if (i
>= (unsigned int) x
)
3878 lang_output_section_statement_type
*
3879 lang_enter_output_section_statement (output_section_statement_name
,
3880 address_exp
, sectype
, block_value
,
3881 align
, subalign
, ebase
)
3882 const char *output_section_statement_name
;
3883 etree_type
*address_exp
;
3884 enum section_type sectype
;
3885 bfd_vma block_value
;
3887 etree_type
*subalign
;
3890 lang_output_section_statement_type
*os
;
3894 lang_output_section_statement_lookup (output_section_statement_name
);
3896 /* Add this statement to tree. */
3898 add_statement (lang_output_section_statement_enum
,
3899 output_section_statement
);
3901 /* Make next things chain into subchain of this. */
3903 if (os
->addr_tree
== (etree_type
*) NULL
)
3905 os
->addr_tree
= address_exp
;
3907 os
->sectype
= sectype
;
3908 if (sectype
!= noload_section
)
3909 os
->flags
= SEC_NO_FLAGS
;
3911 os
->flags
= SEC_NEVER_LOAD
;
3912 os
->block_value
= block_value
? block_value
: 1;
3913 stat_ptr
= &os
->children
;
3915 os
->subsection_alignment
=
3916 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
3917 os
->section_alignment
=
3918 topower (exp_get_value_int (align
, -1, "section alignment", 0));
3920 os
->load_base
= ebase
;
3927 lang_output_statement_type
*new =
3928 new_stat (lang_output_statement
, stat_ptr
);
3930 new->name
= output_filename
;
3933 /* Reset the current counters in the regions. */
3936 reset_memory_regions ()
3938 lang_memory_region_type
*p
= lang_memory_region_list
;
3940 for (p
= lang_memory_region_list
;
3941 p
!= (lang_memory_region_type
*) NULL
;
3944 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
3945 p
->current
= p
->origin
;
3949 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3950 as needed. SECTION may be NULL, in which case it is a wild card. */
3953 gc_section_callback (ptr
, section
, file
, data
)
3954 lang_wild_statement_type
*ptr
;
3956 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
3957 PTR data ATTRIBUTE_UNUSED
;
3959 /* If the wild pattern was marked KEEP, the member sections
3960 should be as well. */
3961 if (ptr
->keep_sections
)
3962 section
->flags
|= SEC_KEEP
;
3965 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
3966 may be NULL, indicating that it is a wildcard. */
3969 lang_gc_wild (s
, section
, file
)
3970 lang_wild_statement_type
*s
;
3971 const char *section
;
3974 walk_wild (s
, section
, file
, gc_section_callback
, NULL
);
3977 /* Iterate over sections marking them against GC. */
3980 lang_gc_sections_1 (s
)
3981 lang_statement_union_type
*s
;
3983 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
3985 switch (s
->header
.type
)
3987 case lang_wild_statement_enum
:
3988 lang_gc_wild (&s
->wild_statement
,
3989 s
->wild_statement
.section_name
,
3990 s
->wild_statement
.filename
);
3992 case lang_constructors_statement_enum
:
3993 lang_gc_sections_1 (constructor_list
.head
);
3995 case lang_output_section_statement_enum
:
3996 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
3998 case lang_group_statement_enum
:
3999 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4010 struct bfd_link_hash_entry
*h
;
4011 ldlang_undef_chain_list_type
*ulist
, fake_list_start
;
4013 /* Keep all sections so marked in the link script. */
4015 lang_gc_sections_1 (statement_list
.head
);
4017 /* Keep all sections containing symbols undefined on the command-line.
4018 Handle the entry symbol at the same time. */
4020 if (entry_symbol
!= NULL
)
4022 fake_list_start
.next
= ldlang_undef_chain_list_head
;
4023 fake_list_start
.name
= (char *) entry_symbol
;
4024 ulist
= &fake_list_start
;
4027 ulist
= ldlang_undef_chain_list_head
;
4029 for (; ulist
; ulist
= ulist
->next
)
4031 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4032 false, false, false);
4034 if (h
!= (struct bfd_link_hash_entry
*) NULL
4035 && (h
->type
== bfd_link_hash_defined
4036 || h
->type
== bfd_link_hash_defweak
)
4037 && ! bfd_is_abs_section (h
->u
.def
.section
))
4039 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4043 bfd_gc_sections (output_bfd
, &link_info
);
4049 lang_reasonable_defaults ();
4050 current_target
= default_target
;
4052 /* Open the output file. */
4053 lang_for_each_statement (ldlang_open_output
);
4055 ldemul_create_output_section_statements ();
4057 /* Add to the hash table all undefineds on the command line. */
4058 lang_place_undefineds ();
4060 already_linked_table_init ();
4062 /* Create a bfd for each input file. */
4063 current_target
= default_target
;
4064 open_input_bfds (statement_list
.head
, false);
4066 ldemul_after_open ();
4068 already_linked_table_free ();
4070 /* Make sure that we're not mixing architectures. We call this
4071 after all the input files have been opened, but before we do any
4072 other processing, so that any operations merge_private_bfd_data
4073 does on the output file will be known during the rest of the
4077 /* Handle .exports instead of a version script if we're told to do so. */
4078 if (command_line
.version_exports_section
)
4079 lang_do_version_exports_section ();
4081 /* Build all sets based on the information gathered from the input
4083 ldctor_build_sets ();
4085 /* Remove unreferenced sections if asked to. */
4086 if (command_line
.gc_sections
)
4087 lang_gc_sections ();
4089 /* If there were any SEC_MERGE sections, finish their merging, so that
4090 section sizes can be computed. This has to be done after GC of sections,
4091 so that GCed sections are not merged, but before assigning output
4092 sections, since removing whole input sections is hard then. */
4093 bfd_merge_sections (output_bfd
, &link_info
);
4095 /* Size up the common data. */
4098 /* Run through the contours of the script and attach input sections
4099 to the correct output sections. */
4100 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4101 (lang_output_section_statement_type
*) NULL
);
4103 /* Find any sections not attached explicitly and handle them. */
4104 lang_place_orphans ();
4106 ldemul_before_allocation ();
4108 /* We must record the program headers before we try to fix the
4109 section positions, since they will affect SIZEOF_HEADERS. */
4110 lang_record_phdrs ();
4112 /* Now run around and relax if we can. */
4113 if (command_line
.relax
)
4115 /* First time round is a trial run to get the 'worst case'
4116 addresses of the objects if there was no relaxing. */
4117 lang_size_sections (statement_list
.head
,
4119 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
4121 /* Keep relaxing until bfd_relax_section gives up. */
4124 reset_memory_regions ();
4126 relax_again
= false;
4128 /* Note: pe-dll.c does something like this also. If you find
4129 you need to change this code, you probably need to change
4130 pe-dll.c also. DJ */
4132 /* Do all the assignments with our current guesses as to
4134 lang_do_assignments (statement_list
.head
,
4136 (fill_type
) 0, (bfd_vma
) 0);
4138 /* Perform another relax pass - this time we know where the
4139 globals are, so can make better guess. */
4140 lang_size_sections (statement_list
.head
,
4142 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
4144 while (relax_again
);
4148 /* Size up the sections. */
4149 lang_size_sections (statement_list
.head
,
4151 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
4154 /* See if anything special should be done now we know how big
4156 ldemul_after_allocation ();
4158 /* Fix any .startof. or .sizeof. symbols. */
4159 lang_set_startof ();
4161 /* Do all the assignments, now that we know the final resting places
4162 of all the symbols. */
4164 lang_do_assignments (statement_list
.head
,
4166 (fill_type
) 0, (bfd_vma
) 0);
4168 /* Make sure that the section addresses make sense. */
4169 if (! link_info
.relocateable
4170 && command_line
.check_section_addresses
)
4171 lang_check_section_addresses ();
4179 /* EXPORTED TO YACC */
4182 lang_add_wild (section_name
, sections_sorted
, filename
, filenames_sorted
,
4183 keep_sections
, exclude_filename_list
)
4184 const char *const section_name
;
4185 boolean sections_sorted
;
4186 const char *const filename
;
4187 boolean filenames_sorted
;
4188 boolean keep_sections
;
4189 struct name_list
*exclude_filename_list
;
4191 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
4194 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
4196 placed_commons
= true;
4198 if (filename
!= NULL
&& ! wildcardp (filename
))
4200 lang_has_input_file
= true;
4202 new->section_name
= section_name
;
4203 new->sections_sorted
= sections_sorted
;
4204 new->filename
= filename
;
4205 new->filenames_sorted
= filenames_sorted
;
4206 new->keep_sections
= keep_sections
;
4207 new->exclude_filename_list
= exclude_filename_list
;
4208 lang_list_init (&new->children
);
4212 lang_section_start (name
, address
)
4214 etree_type
*address
;
4216 lang_address_statement_type
*ad
;
4218 ad
= new_stat (lang_address_statement
, stat_ptr
);
4219 ad
->section_name
= name
;
4220 ad
->address
= address
;
4223 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4224 because of a -e argument on the command line, or zero if this is
4225 called by ENTRY in a linker script. Command line arguments take
4229 lang_add_entry (name
, cmdline
)
4233 if (entry_symbol
== NULL
4235 || ! entry_from_cmdline
)
4237 entry_symbol
= name
;
4238 entry_from_cmdline
= cmdline
;
4243 lang_add_target (name
)
4246 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4262 map_option_f
= true;
4273 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4280 lang_add_data (type
, exp
)
4282 union etree_union
*exp
;
4285 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4293 /* Create a new reloc statement. RELOC is the BFD relocation type to
4294 generate. HOWTO is the corresponding howto structure (we could
4295 look this up, but the caller has already done so). SECTION is the
4296 section to generate a reloc against, or NAME is the name of the
4297 symbol to generate a reloc against. Exactly one of SECTION and
4298 NAME must be NULL. ADDEND is an expression for the addend. */
4301 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4302 bfd_reloc_code_real_type reloc
;
4303 reloc_howto_type
*howto
;
4306 union etree_union
*addend
;
4308 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4312 p
->section
= section
;
4314 p
->addend_exp
= addend
;
4316 p
->addend_value
= 0;
4317 p
->output_section
= NULL
;
4321 lang_assignment_statement_type
*
4322 lang_add_assignment (exp
)
4325 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4333 lang_add_attribute (attribute
)
4334 enum statement_enum attribute
;
4336 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4343 if (startup_file
!= (char *) NULL
)
4345 einfo (_("%P%Fmultiple STARTUP files\n"));
4347 first_file
->filename
= name
;
4348 first_file
->local_sym_name
= name
;
4349 first_file
->real
= true;
4351 startup_file
= name
;
4358 lang_float_flag
= maybe
;
4362 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4364 const char *memspec
;
4365 struct lang_output_section_phdr_list
*phdrs
;
4366 const char *lma_memspec
;
4368 current_section
->fill
= fill
;
4369 current_section
->region
= lang_memory_region_lookup (memspec
);
4370 if (strcmp (lma_memspec
, "*default*") != 0)
4372 current_section
->lma_region
= lang_memory_region_lookup (lma_memspec
);
4373 /* If no runtime region has been given, but the load region has
4374 been, use the load region. */
4375 if (strcmp (memspec
, "*default*") == 0)
4376 current_section
->region
= lang_memory_region_lookup (lma_memspec
);
4378 current_section
->phdrs
= phdrs
;
4379 stat_ptr
= &statement_list
;
4382 /* Create an absolute symbol with the given name with the value of the
4383 address of first byte of the section named.
4385 If the symbol already exists, then do nothing. */
4388 lang_abs_symbol_at_beginning_of (secname
, name
)
4389 const char *secname
;
4392 struct bfd_link_hash_entry
*h
;
4394 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4395 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4396 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4398 if (h
->type
== bfd_link_hash_new
4399 || h
->type
== bfd_link_hash_undefined
)
4403 h
->type
= bfd_link_hash_defined
;
4405 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4406 if (sec
== (asection
*) NULL
)
4409 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4411 h
->u
.def
.section
= bfd_abs_section_ptr
;
4415 /* Create an absolute symbol with the given name with the value of the
4416 address of the first byte after the end of the section named.
4418 If the symbol already exists, then do nothing. */
4421 lang_abs_symbol_at_end_of (secname
, name
)
4422 const char *secname
;
4425 struct bfd_link_hash_entry
*h
;
4427 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4428 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4429 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4431 if (h
->type
== bfd_link_hash_new
4432 || h
->type
== bfd_link_hash_undefined
)
4436 h
->type
= bfd_link_hash_defined
;
4438 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4439 if (sec
== (asection
*) NULL
)
4442 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4443 + bfd_section_size (output_bfd
, sec
) /
4444 bfd_octets_per_byte (output_bfd
));
4446 h
->u
.def
.section
= bfd_abs_section_ptr
;
4451 lang_statement_append (list
, element
, field
)
4452 lang_statement_list_type
*list
;
4453 lang_statement_union_type
*element
;
4454 lang_statement_union_type
**field
;
4456 *(list
->tail
) = element
;
4460 /* Set the output format type. -oformat overrides scripts. */
4463 lang_add_output_format (format
, big
, little
, from_script
)
4469 if (output_target
== NULL
|| !from_script
)
4471 if (command_line
.endian
== ENDIAN_BIG
4474 else if (command_line
.endian
== ENDIAN_LITTLE
4478 output_target
= format
;
4482 /* Enter a group. This creates a new lang_group_statement, and sets
4483 stat_ptr to build new statements within the group. */
4488 lang_group_statement_type
*g
;
4490 g
= new_stat (lang_group_statement
, stat_ptr
);
4491 lang_list_init (&g
->children
);
4492 stat_ptr
= &g
->children
;
4495 /* Leave a group. This just resets stat_ptr to start writing to the
4496 regular list of statements again. Note that this will not work if
4497 groups can occur inside anything else which can adjust stat_ptr,
4498 but currently they can't. */
4503 stat_ptr
= &statement_list
;
4506 /* Add a new program header. This is called for each entry in a PHDRS
4507 command in a linker script. */
4510 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4518 struct lang_phdr
*n
, **pp
;
4520 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4523 n
->type
= exp_get_value_int (type
, 0, "program header type",
4524 lang_final_phase_enum
);
4525 n
->filehdr
= filehdr
;
4530 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4535 /* Record the program header information in the output BFD. FIXME: We
4536 should not be calling an ELF specific function here. */
4539 lang_record_phdrs ()
4543 struct lang_output_section_phdr_list
*last
;
4544 struct lang_phdr
*l
;
4545 lang_statement_union_type
*u
;
4548 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4550 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4557 for (u
= lang_output_section_statement
.head
;
4559 u
= u
->output_section_statement
.next
)
4561 lang_output_section_statement_type
*os
;
4562 struct lang_output_section_phdr_list
*pl
;
4564 os
= &u
->output_section_statement
;
4571 if (os
->sectype
== noload_section
4572 || os
->bfd_section
== NULL
4573 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4578 if (os
->bfd_section
== NULL
)
4581 for (; pl
!= NULL
; pl
= pl
->next
)
4583 if (strcmp (pl
->name
, l
->name
) == 0)
4588 secs
= ((asection
**)
4589 xrealloc (secs
, alc
* sizeof (asection
*)));
4591 secs
[c
] = os
->bfd_section
;
4598 if (l
->flags
== NULL
)
4601 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4602 lang_final_phase_enum
);
4607 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4608 lang_final_phase_enum
);
4610 if (! bfd_record_phdr (output_bfd
, l
->type
,
4611 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
4612 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4613 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4618 /* Make sure all the phdr assignments succeeded. */
4619 for (u
= lang_output_section_statement
.head
;
4621 u
= u
->output_section_statement
.next
)
4623 struct lang_output_section_phdr_list
*pl
;
4625 if (u
->output_section_statement
.bfd_section
== NULL
)
4628 for (pl
= u
->output_section_statement
.phdrs
;
4631 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4632 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4633 u
->output_section_statement
.name
, pl
->name
);
4637 /* Record a list of sections which may not be cross referenced. */
4640 lang_add_nocrossref (l
)
4641 struct lang_nocrossref
*l
;
4643 struct lang_nocrossrefs
*n
;
4645 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4646 n
->next
= nocrossref_list
;
4648 nocrossref_list
= n
;
4650 /* Set notice_all so that we get informed about all symbols. */
4651 link_info
.notice_all
= true;
4654 /* Overlay handling. We handle overlays with some static variables. */
4656 /* The overlay virtual address. */
4657 static etree_type
*overlay_vma
;
4659 /* The overlay load address. */
4660 static etree_type
*overlay_lma
;
4662 /* Whether nocrossrefs is set for this overlay. */
4663 static int overlay_nocrossrefs
;
4665 /* An expression for the maximum section size seen so far. */
4666 static etree_type
*overlay_max
;
4668 /* A list of all the sections in this overlay. */
4670 struct overlay_list
{
4671 struct overlay_list
*next
;
4672 lang_output_section_statement_type
*os
;
4675 static struct overlay_list
*overlay_list
;
4677 /* Start handling an overlay. */
4680 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
4681 etree_type
*vma_expr
;
4682 etree_type
*lma_expr
;
4685 /* The grammar should prevent nested overlays from occurring. */
4686 ASSERT (overlay_vma
== NULL
4687 && overlay_lma
== NULL
4688 && overlay_list
== NULL
4689 && overlay_max
== NULL
);
4691 overlay_vma
= vma_expr
;
4692 overlay_lma
= lma_expr
;
4693 overlay_nocrossrefs
= nocrossrefs
;
4696 /* Start a section in an overlay. We handle this by calling
4697 lang_enter_output_section_statement with the correct VMA and LMA. */
4700 lang_enter_overlay_section (name
)
4703 struct overlay_list
*n
;
4706 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4707 0, 0, 0, overlay_lma
);
4709 /* If this is the first section, then base the VMA and LMA of future
4710 sections on this one. This will work correctly even if `.' is
4711 used in the addresses. */
4712 if (overlay_list
== NULL
)
4714 overlay_vma
= exp_nameop (ADDR
, name
);
4715 overlay_lma
= exp_nameop (LOADADDR
, name
);
4718 /* Remember the section. */
4719 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4720 n
->os
= current_section
;
4721 n
->next
= overlay_list
;
4724 size
= exp_nameop (SIZEOF
, name
);
4726 /* Adjust the LMA for the next section. */
4727 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
4729 /* Arrange to work out the maximum section end address. */
4730 if (overlay_max
== NULL
)
4733 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4736 /* Finish a section in an overlay. There isn't any special to do
4740 lang_leave_overlay_section (fill
, phdrs
)
4742 struct lang_output_section_phdr_list
*phdrs
;
4749 name
= current_section
->name
;
4751 lang_leave_output_section_statement (fill
, "*default*",
4752 phdrs
, "*default*");
4754 /* Define the magic symbols. */
4756 clean
= xmalloc (strlen (name
) + 1);
4758 for (s1
= name
; *s1
!= '\0'; s1
++)
4759 if (isalnum ((unsigned char) *s1
) || *s1
== '_')
4763 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4764 sprintf (buf
, "__load_start_%s", clean
);
4765 lang_add_assignment (exp_assop ('=', buf
,
4766 exp_nameop (LOADADDR
, name
)));
4768 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4769 sprintf (buf
, "__load_stop_%s", clean
);
4770 lang_add_assignment (exp_assop ('=', buf
,
4772 exp_nameop (LOADADDR
, name
),
4773 exp_nameop (SIZEOF
, name
))));
4778 /* Finish an overlay. If there are any overlay wide settings, this
4779 looks through all the sections in the overlay and sets them. */
4782 lang_leave_overlay (fill
, memspec
, phdrs
, lma_memspec
)
4784 const char *memspec
;
4785 struct lang_output_section_phdr_list
*phdrs
;
4786 const char *lma_memspec
;
4788 lang_memory_region_type
*region
;
4789 lang_memory_region_type
*lma_region
;
4790 struct overlay_list
*l
;
4791 struct lang_nocrossref
*nocrossref
;
4793 if (memspec
== NULL
)
4796 region
= lang_memory_region_lookup (memspec
);
4798 if (lma_memspec
== NULL
)
4801 lma_region
= lang_memory_region_lookup (lma_memspec
);
4808 struct overlay_list
*next
;
4810 if (fill
!= 0 && l
->os
->fill
== 0)
4812 if (region
!= NULL
&& l
->os
->region
== NULL
)
4813 l
->os
->region
= region
;
4814 /* We only set lma_region for the first overlay section, as
4815 subsequent overlay sections will have load_base set relative
4816 to the first section. Also, don't set lma_region if
4817 load_base is specified. FIXME: There should really be a test
4818 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4819 rather than letting LDADDR simply override LMA_REGION. */
4820 if (lma_region
!= NULL
&& l
->os
->lma_region
== NULL
4821 && l
->next
== NULL
&& l
->os
->load_base
== NULL
)
4822 l
->os
->lma_region
= lma_region
;
4823 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4824 l
->os
->phdrs
= phdrs
;
4826 if (overlay_nocrossrefs
)
4828 struct lang_nocrossref
*nc
;
4830 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
4831 nc
->name
= l
->os
->name
;
4832 nc
->next
= nocrossref
;
4841 if (nocrossref
!= NULL
)
4842 lang_add_nocrossref (nocrossref
);
4844 /* Update . for the end of the overlay. */
4845 lang_add_assignment (exp_assop ('=', ".",
4846 exp_binop ('+', overlay_vma
, overlay_max
)));
4850 overlay_nocrossrefs
= 0;
4851 overlay_list
= NULL
;
4855 /* Version handling. This is only useful for ELF. */
4857 /* This global variable holds the version tree that we build. */
4859 struct bfd_elf_version_tree
*lang_elf_version_info
;
4862 lang_vers_match_lang_c (expr
, sym
)
4863 struct bfd_elf_version_expr
*expr
;
4866 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4868 return fnmatch (expr
->pattern
, sym
, 0) == 0;
4872 lang_vers_match_lang_cplusplus (expr
, sym
)
4873 struct bfd_elf_version_expr
*expr
;
4879 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4882 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
4885 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4886 Should we early out false in this case? */
4887 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4891 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4899 lang_vers_match_lang_java (expr
, sym
)
4900 struct bfd_elf_version_expr
*expr
;
4906 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4909 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
4912 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4913 Should we early out false in this case? */
4914 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4918 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4925 /* This is called for each variable name or match expression. */
4927 struct bfd_elf_version_expr
*
4928 lang_new_vers_regex (orig
, new, lang
)
4929 struct bfd_elf_version_expr
*orig
;
4933 struct bfd_elf_version_expr
*ret
;
4935 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
4939 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
4940 ret
->match
= lang_vers_match_lang_c
;
4941 else if (strcasecmp (lang
, "C++") == 0)
4942 ret
->match
= lang_vers_match_lang_cplusplus
;
4943 else if (strcasecmp (lang
, "Java") == 0)
4944 ret
->match
= lang_vers_match_lang_java
;
4947 einfo (_("%X%P: unknown language `%s' in version information\n"),
4949 ret
->match
= lang_vers_match_lang_c
;
4955 /* This is called for each set of variable names and match
4958 struct bfd_elf_version_tree
*
4959 lang_new_vers_node (globals
, locals
)
4960 struct bfd_elf_version_expr
*globals
;
4961 struct bfd_elf_version_expr
*locals
;
4963 struct bfd_elf_version_tree
*ret
;
4965 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
4969 ret
->globals
= globals
;
4970 ret
->locals
= locals
;
4972 ret
->name_indx
= (unsigned int) -1;
4977 /* This static variable keeps track of version indices. */
4979 static int version_index
;
4981 /* This is called when we know the name and dependencies of the
4985 lang_register_vers_node (name
, version
, deps
)
4987 struct bfd_elf_version_tree
*version
;
4988 struct bfd_elf_version_deps
*deps
;
4990 struct bfd_elf_version_tree
*t
, **pp
;
4991 struct bfd_elf_version_expr
*e1
;
4993 /* Make sure this node has a unique name. */
4994 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
4995 if (strcmp (t
->name
, name
) == 0)
4996 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
4998 /* Check the global and local match names, and make sure there
4999 aren't any duplicates. */
5001 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5003 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5005 struct bfd_elf_version_expr
*e2
;
5007 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5008 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5009 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5014 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
5016 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5018 struct bfd_elf_version_expr
*e2
;
5020 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
5021 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5022 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5027 version
->deps
= deps
;
5028 version
->name
= name
;
5030 version
->vernum
= version_index
;
5032 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5037 /* This is called when we see a version dependency. */
5039 struct bfd_elf_version_deps
*
5040 lang_add_vers_depend (list
, name
)
5041 struct bfd_elf_version_deps
*list
;
5044 struct bfd_elf_version_deps
*ret
;
5045 struct bfd_elf_version_tree
*t
;
5047 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5050 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5052 if (strcmp (t
->name
, name
) == 0)
5054 ret
->version_needed
= t
;
5059 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5065 lang_do_version_exports_section ()
5067 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5069 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5071 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5078 len
= bfd_section_size (is
->the_bfd
, sec
);
5079 contents
= xmalloc (len
);
5080 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5081 einfo (_("%X%P: unable to read .exports section contents"), sec
);
5084 while (p
< contents
+ len
)
5086 greg
= lang_new_vers_regex (greg
, p
, NULL
);
5087 p
= strchr (p
, '\0') + 1;
5090 /* Do not free the contents, as we used them creating the regex. */
5092 /* Do not include this section in the link. */
5093 bfd_set_section_flags (is
->the_bfd
, sec
,
5094 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5097 lreg
= lang_new_vers_regex (NULL
, "*", NULL
);
5098 lang_register_vers_node (command_line
.version_exports_section
,
5099 lang_new_vers_node (greg
, lreg
), NULL
);
5103 lang_add_unique (name
)
5106 struct unique_sections
*ent
;
5108 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5109 if (strcmp (ent
->name
, name
) == 0)
5112 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
5113 ent
->name
= xstrdup (name
);
5114 ent
->next
= unique_section_list
;
5115 unique_section_list
= ent
;