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 boolean 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
);
364 walk_wild_file (s
, section
, f
, callback
, data
);
368 /* lang_for_each_statement walks the parse tree and calls the provided
369 function for each node. */
372 lang_for_each_statement_worker (func
, s
)
373 void (*func
) PARAMS ((lang_statement_union_type
*));
374 lang_statement_union_type
*s
;
376 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
380 switch (s
->header
.type
)
382 case lang_constructors_statement_enum
:
383 lang_for_each_statement_worker (func
, constructor_list
.head
);
385 case lang_output_section_statement_enum
:
386 lang_for_each_statement_worker
388 s
->output_section_statement
.children
.head
);
390 case lang_wild_statement_enum
:
391 lang_for_each_statement_worker
393 s
->wild_statement
.children
.head
);
395 case lang_group_statement_enum
:
396 lang_for_each_statement_worker (func
,
397 s
->group_statement
.children
.head
);
399 case lang_data_statement_enum
:
400 case lang_reloc_statement_enum
:
401 case lang_object_symbols_statement_enum
:
402 case lang_output_statement_enum
:
403 case lang_target_statement_enum
:
404 case lang_input_section_enum
:
405 case lang_input_statement_enum
:
406 case lang_assignment_statement_enum
:
407 case lang_padding_statement_enum
:
408 case lang_address_statement_enum
:
409 case lang_fill_statement_enum
:
419 lang_for_each_statement (func
)
420 void (*func
) PARAMS ((lang_statement_union_type
*));
422 lang_for_each_statement_worker (func
, statement_list
.head
);
425 /*----------------------------------------------------------------------*/
428 lang_list_init (list
)
429 lang_statement_list_type
*list
;
431 list
->head
= (lang_statement_union_type
*) NULL
;
432 list
->tail
= &list
->head
;
435 /* Build a new statement node for the parse tree. */
437 static lang_statement_union_type
*
438 new_statement (type
, size
, list
)
439 enum statement_enum type
;
441 lang_statement_list_type
*list
;
443 lang_statement_union_type
*new = (lang_statement_union_type
*)
446 new->header
.type
= type
;
447 new->header
.next
= (lang_statement_union_type
*) NULL
;
448 lang_statement_append (list
, new, &new->header
.next
);
452 /* Build a new input file node for the language. There are several
453 ways in which we treat an input file, eg, we only look at symbols,
454 or prefix it with a -l etc.
456 We can be supplied with requests for input files more than once;
457 they may, for example be split over serveral lines like foo.o(.text)
458 foo.o(.data) etc, so when asked for a file we check that we haven't
459 got it already so we don't duplicate the bfd. */
461 static lang_input_statement_type
*
462 new_afile (name
, file_type
, target
, add_to_list
)
464 lang_input_file_enum_type file_type
;
468 lang_input_statement_type
*p
;
471 p
= new_stat (lang_input_statement
, stat_ptr
);
474 p
= ((lang_input_statement_type
*)
475 stat_alloc (sizeof (lang_input_statement_type
)));
476 p
->header
.next
= NULL
;
479 lang_has_input_file
= true;
483 case lang_input_file_is_symbols_only_enum
:
485 p
->is_archive
= false;
487 p
->local_sym_name
= name
;
488 p
->just_syms_flag
= true;
489 p
->search_dirs_flag
= false;
491 case lang_input_file_is_fake_enum
:
493 p
->is_archive
= false;
495 p
->local_sym_name
= name
;
496 p
->just_syms_flag
= false;
497 p
->search_dirs_flag
= false;
499 case lang_input_file_is_l_enum
:
500 p
->is_archive
= true;
503 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
504 p
->just_syms_flag
= false;
505 p
->search_dirs_flag
= true;
507 case lang_input_file_is_marker_enum
:
509 p
->is_archive
= false;
511 p
->local_sym_name
= name
;
512 p
->just_syms_flag
= false;
513 p
->search_dirs_flag
= true;
515 case lang_input_file_is_search_file_enum
:
517 p
->is_archive
= false;
519 p
->local_sym_name
= name
;
520 p
->just_syms_flag
= false;
521 p
->search_dirs_flag
= true;
523 case lang_input_file_is_file_enum
:
525 p
->is_archive
= false;
527 p
->local_sym_name
= name
;
528 p
->just_syms_flag
= false;
529 p
->search_dirs_flag
= false;
534 p
->the_bfd
= (bfd
*) NULL
;
535 p
->asymbols
= (asymbol
**) NULL
;
536 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
537 p
->next
= (lang_statement_union_type
*) NULL
;
539 p
->dynamic
= config
.dynamic_link
;
540 p
->whole_archive
= whole_archive
;
542 lang_statement_append (&input_file_chain
,
543 (lang_statement_union_type
*) p
,
548 lang_input_statement_type
*
549 lang_add_input_file (name
, file_type
, target
)
551 lang_input_file_enum_type file_type
;
554 lang_has_input_file
= true;
555 return new_afile (name
, file_type
, target
, true);
558 /* Build enough state so that the parser can build its tree. */
563 obstack_begin (&stat_obstack
, 1000);
565 stat_ptr
= &statement_list
;
567 lang_list_init (stat_ptr
);
569 lang_list_init (&input_file_chain
);
570 lang_list_init (&lang_output_section_statement
);
571 lang_list_init (&file_chain
);
572 first_file
= lang_add_input_file ((char *) NULL
,
573 lang_input_file_is_marker_enum
,
576 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
578 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
582 /*----------------------------------------------------------------------
583 A region is an area of memory declared with the
584 MEMORY { name:org=exp, len=exp ... }
587 We maintain a list of all the regions here.
589 If no regions are specified in the script, then the default is used
590 which is created when looked up to be the entire data space. */
592 static lang_memory_region_type
*lang_memory_region_list
;
593 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
595 lang_memory_region_type
*
596 lang_memory_region_lookup (name
)
597 const char *const name
;
599 lang_memory_region_type
*p
;
601 for (p
= lang_memory_region_list
;
602 p
!= (lang_memory_region_type
*) NULL
;
605 if (strcmp (p
->name
, name
) == 0)
612 /* This code used to always use the first region in the list as the
613 default region. I changed it to instead use a region
614 encompassing all of memory as the default region. This permits
615 NOLOAD sections to work reasonably without requiring a region.
616 People should specify what region they mean, if they really want
618 if (strcmp (name
, "*default*") == 0)
620 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
622 return lang_memory_region_list
;
628 lang_memory_region_type
*new =
629 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
631 new->name
= xstrdup (name
);
632 new->next
= (lang_memory_region_type
*) NULL
;
634 *lang_memory_region_list_tail
= new;
635 lang_memory_region_list_tail
= &new->next
;
639 new->length
= ~(bfd_size_type
) 0;
641 new->had_full_message
= false;
647 static lang_memory_region_type
*
648 lang_memory_default (section
)
651 lang_memory_region_type
*p
;
653 flagword sec_flags
= section
->flags
;
655 /* Override SEC_DATA to mean a writable section. */
656 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
657 sec_flags
|= SEC_DATA
;
659 for (p
= lang_memory_region_list
;
660 p
!= (lang_memory_region_type
*) NULL
;
663 if ((p
->flags
& sec_flags
) != 0
664 && (p
->not_flags
& sec_flags
) == 0)
669 return lang_memory_region_lookup ("*default*");
672 lang_output_section_statement_type
*
673 lang_output_section_find (name
)
674 const char *const name
;
676 lang_statement_union_type
*u
;
677 lang_output_section_statement_type
*lookup
;
679 for (u
= lang_output_section_statement
.head
;
680 u
!= (lang_statement_union_type
*) NULL
;
683 lookup
= &u
->output_section_statement
;
684 if (strcmp (name
, lookup
->name
) == 0)
689 return (lang_output_section_statement_type
*) NULL
;
692 lang_output_section_statement_type
*
693 lang_output_section_statement_lookup (name
)
694 const char *const name
;
696 lang_output_section_statement_type
*lookup
;
698 lookup
= lang_output_section_find (name
);
699 if (lookup
== (lang_output_section_statement_type
*) NULL
)
702 lookup
= (lang_output_section_statement_type
*)
703 new_stat (lang_output_section_statement
, stat_ptr
);
704 lookup
->region
= (lang_memory_region_type
*) NULL
;
705 lookup
->lma_region
= (lang_memory_region_type
*) NULL
;
707 lookup
->block_value
= 1;
710 lookup
->next
= (lang_statement_union_type
*) NULL
;
711 lookup
->bfd_section
= (asection
*) NULL
;
712 lookup
->processed
= false;
713 lookup
->sectype
= normal_section
;
714 lookup
->addr_tree
= (etree_type
*) NULL
;
715 lang_list_init (&lookup
->children
);
717 lookup
->memspec
= (const char *) NULL
;
719 lookup
->subsection_alignment
= -1;
720 lookup
->section_alignment
= -1;
721 lookup
->load_base
= (union etree_union
*) NULL
;
722 lookup
->phdrs
= NULL
;
724 lang_statement_append (&lang_output_section_statement
,
725 (lang_statement_union_type
*) lookup
,
732 lang_map_flags (flag
)
735 if (flag
& SEC_ALLOC
)
741 if (flag
& SEC_READONLY
)
754 lang_memory_region_type
*m
;
756 minfo (_("\nMemory Configuration\n\n"));
757 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
758 _("Name"), _("Origin"), _("Length"), _("Attributes"));
760 for (m
= lang_memory_region_list
;
761 m
!= (lang_memory_region_type
*) NULL
;
767 fprintf (config
.map_file
, "%-16s ", m
->name
);
769 sprintf_vma (buf
, m
->origin
);
770 minfo ("0x%s ", buf
);
778 minfo ("0x%V", m
->length
);
779 if (m
->flags
|| m
->not_flags
)
787 lang_map_flags (m
->flags
);
793 lang_map_flags (m
->not_flags
);
800 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
805 /* Initialize an output section. */
809 lang_output_section_statement_type
*s
;
811 section_userdata_type
*new;
813 if (s
->bfd_section
!= NULL
)
816 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
817 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
819 new = ((section_userdata_type
*)
820 stat_alloc (sizeof (section_userdata_type
)));
822 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
823 if (s
->bfd_section
== (asection
*) NULL
)
824 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
825 if (s
->bfd_section
== (asection
*) NULL
)
827 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
828 output_bfd
->xvec
->name
, s
->name
);
830 s
->bfd_section
->output_section
= s
->bfd_section
;
832 /* We initialize an output sections output offset to minus its own
833 vma to allow us to output a section through itself. */
834 s
->bfd_section
->output_offset
= 0;
835 get_userdata (s
->bfd_section
) = (PTR
) new;
837 /* If there is a base address, make sure that any sections it might
838 mention are initialized. */
839 if (s
->addr_tree
!= NULL
)
840 exp_init_os (s
->addr_tree
);
843 /* Make sure that all output sections mentioned in an expression are
850 switch (exp
->type
.node_class
)
853 exp_init_os (exp
->assign
.src
);
857 exp_init_os (exp
->binary
.lhs
);
858 exp_init_os (exp
->binary
.rhs
);
862 exp_init_os (exp
->trinary
.cond
);
863 exp_init_os (exp
->trinary
.lhs
);
864 exp_init_os (exp
->trinary
.rhs
);
868 exp_init_os (exp
->unary
.child
);
872 switch (exp
->type
.node_code
)
878 lang_output_section_statement_type
*os
;
880 os
= lang_output_section_find (exp
->name
.name
);
881 if (os
!= NULL
&& os
->bfd_section
== NULL
)
892 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
893 once into the output. This routine checks each section, and
894 arrange to discard it if a section of the same name has already
895 been linked. If the section has COMDAT information, then it uses
896 that to decide whether the section should be included. This code
897 assumes that all relevant sections have the SEC_LINK_ONCE flag set;
898 that is, it does not depend solely upon the section name.
899 section_already_linked is called via bfd_map_over_sections. */
901 /* This is the shape of the elements inside the already_linked hash
902 table. It maps a name onto a list of already_linked elements with
903 the same name. It's possible to get more than one element in a
904 list if the COMDAT sections have different names. */
906 struct already_linked_hash_entry
908 struct bfd_hash_entry root
;
909 struct already_linked
*entry
;
912 struct already_linked
914 struct already_linked
*next
;
918 /* The hash table. */
920 static struct bfd_hash_table already_linked_table
;
923 section_already_linked (abfd
, sec
, data
)
928 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
931 struct already_linked
*l
;
932 struct already_linked_hash_entry
*already_linked_list
;
934 /* If we are only reading symbols from this object, then we want to
935 discard all sections. */
936 if (entry
->just_syms_flag
)
938 sec
->output_section
= bfd_abs_section_ptr
;
939 sec
->output_offset
= sec
->vma
;
943 flags
= bfd_get_section_flags (abfd
, sec
);
945 if ((flags
& SEC_LINK_ONCE
) == 0)
948 /* FIXME: When doing a relocatable link, we may have trouble
949 copying relocations in other sections that refer to local symbols
950 in the section being discarded. Those relocations will have to
951 be converted somehow; as of this writing I'm not sure that any of
952 the backends handle that correctly.
954 It is tempting to instead not discard link once sections when
955 doing a relocatable link (technically, they should be discarded
956 whenever we are building constructors). However, that fails,
957 because the linker winds up combining all the link once sections
958 into a single large link once section, which defeats the purpose
959 of having link once sections in the first place.
961 Also, not merging link once sections in a relocatable link
962 causes trouble for MIPS ELF, which relies in link once semantics
963 to handle the .reginfo section correctly. */
965 name
= bfd_get_section_name (abfd
, sec
);
967 already_linked_list
=
968 ((struct already_linked_hash_entry
*)
969 bfd_hash_lookup (&already_linked_table
, name
, true, false));
971 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
973 if (sec
->comdat
== NULL
974 || l
->sec
->comdat
== NULL
975 || strcmp (sec
->comdat
->name
, l
->sec
->comdat
->name
) == 0)
977 /* The section has already been linked. See if we should
979 switch (flags
& SEC_LINK_DUPLICATES
)
984 case SEC_LINK_DUPLICATES_DISCARD
:
987 case SEC_LINK_DUPLICATES_ONE_ONLY
:
988 if (sec
->comdat
== NULL
)
989 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
992 einfo (_("%P: %B: warning: ignoring duplicate `%s' section symbol `%s'\n"),
993 abfd
, name
, sec
->comdat
->name
);
996 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
997 /* FIXME: We should really dig out the contents of both
998 sections and memcmp them. The COFF/PE spec says that
999 the Microsoft linker does not implement this
1000 correctly, so I'm not going to bother doing it
1003 case SEC_LINK_DUPLICATES_SAME_SIZE
:
1004 if (bfd_section_size (abfd
, sec
)
1005 != bfd_section_size (l
->sec
->owner
, l
->sec
))
1006 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
1011 /* Set the output_section field so that wild_doit does not
1012 create a lang_input_section structure for this section.
1013 Since there might be a symbol in the section being
1014 discarded, we must retain a pointer to the section which
1015 we are really going to use. */
1016 sec
->output_section
= bfd_abs_section_ptr
;
1017 sec
->kept_section
= l
->sec
;
1023 /* This is the first section with this name. Record it. Allocate
1024 the memory from the same obstack as the hash table is kept in. */
1026 l
= ((struct already_linked
*)
1027 bfd_hash_allocate (&already_linked_table
, sizeof *l
));
1030 l
->next
= already_linked_list
->entry
;
1031 already_linked_list
->entry
= l
;
1034 /* Support routines for the hash table used by section_already_linked,
1035 initialize the table, fill in an entry and remove the table. */
1037 static struct bfd_hash_entry
*
1038 already_linked_newfunc (entry
, table
, string
)
1039 struct bfd_hash_entry
*entry ATTRIBUTE_UNUSED
;
1040 struct bfd_hash_table
*table
;
1041 const char *string ATTRIBUTE_UNUSED
;
1043 struct already_linked_hash_entry
*ret
=
1044 bfd_hash_allocate (table
, sizeof (struct already_linked_hash_entry
));
1048 return (struct bfd_hash_entry
*) ret
;
1052 already_linked_table_init ()
1054 if (! bfd_hash_table_init_n (&already_linked_table
,
1055 already_linked_newfunc
,
1057 einfo (_("%P%F: Failed to create hash table\n"));
1061 already_linked_table_free ()
1063 bfd_hash_table_free (&already_linked_table
);
1066 /* The wild routines.
1068 These expand statements like *(.text) and foo.o to a list of
1069 explicit actions, like foo.o(.text), bar.o(.text) and
1070 foo.o(.text, .data). */
1072 /* Return true if the PATTERN argument is a wildcard pattern.
1073 Although backslashes are treated specially if a pattern contains
1074 wildcards, we do not consider the mere presence of a backslash to
1075 be enough to cause the the pattern to be treated as a wildcard.
1076 That lets us handle DOS filenames more naturally. */
1080 const char *pattern
;
1084 for (s
= pattern
; *s
!= '\0'; ++s
)
1092 /* Add SECTION to the output section OUTPUT. Do this by creating a
1093 lang_input_section statement which is placed at PTR. FILE is the
1094 input file which holds SECTION. */
1097 wild_doit (ptr
, section
, output
, file
)
1098 lang_statement_list_type
*ptr
;
1100 lang_output_section_statement_type
*output
;
1101 lang_input_statement_type
*file
;
1106 flags
= bfd_get_section_flags (section
->owner
, section
);
1110 /* If we are doing a final link, discard sections marked with
1112 if (! link_info
.relocateable
1113 && (flags
& SEC_EXCLUDE
) != 0)
1116 /* Discard input sections which are assigned to a section named
1117 DISCARD_SECTION_NAME. */
1118 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1121 /* Discard debugging sections if we are stripping debugging
1123 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1124 && (flags
& SEC_DEBUGGING
) != 0)
1129 if (section
->output_section
== NULL
)
1131 /* This prevents future calls from assigning this section. */
1132 section
->output_section
= bfd_abs_section_ptr
;
1137 if (section
->output_section
== NULL
)
1140 lang_input_section_type
*new;
1143 if (output
->bfd_section
== NULL
)
1146 first
= ! output
->bfd_section
->linker_has_input
;
1147 output
->bfd_section
->linker_has_input
= 1;
1149 /* Add a section reference to the list. */
1150 new = new_stat (lang_input_section
, ptr
);
1152 new->section
= section
;
1154 section
->output_section
= output
->bfd_section
;
1156 flags
= section
->flags
;
1158 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1159 to an output section, because we want to be able to include a
1160 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1161 section (I don't know why we want to do this, but we do).
1162 build_link_order in ldwrite.c handles this case by turning
1163 the embedded SEC_NEVER_LOAD section into a fill. */
1165 flags
&= ~ SEC_NEVER_LOAD
;
1167 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1168 already been processed. One reason to do this is that on pe
1169 format targets, .text$foo sections go into .text and it's odd
1170 to see .text with SEC_LINK_ONCE set. */
1172 if (! link_info
.relocateable
)
1173 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1175 /* If this is not the first input section, and the SEC_READONLY
1176 flag is not currently set, then don't set it just because the
1177 input section has it set. */
1179 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
1180 flags
&= ~ SEC_READONLY
;
1182 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1184 && ((section
->output_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1185 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1186 || ((flags
& SEC_MERGE
)
1187 && section
->output_section
->entsize
!= section
->entsize
)))
1189 section
->output_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1190 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1193 section
->output_section
->flags
|= flags
;
1195 if (flags
& SEC_MERGE
)
1196 section
->output_section
->entsize
= section
->entsize
;
1198 /* If SEC_READONLY is not set in the input section, then clear
1199 it from the output section. */
1200 if ((section
->flags
& SEC_READONLY
) == 0)
1201 section
->output_section
->flags
&= ~SEC_READONLY
;
1203 switch (output
->sectype
)
1205 case normal_section
:
1210 case overlay_section
:
1211 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1213 case noload_section
:
1214 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1215 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1219 /* Copy over SEC_SMALL_DATA. */
1220 if (section
->flags
& SEC_SMALL_DATA
)
1221 section
->output_section
->flags
|= SEC_SMALL_DATA
;
1223 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1224 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1226 /* If supplied an aligment, then force it. */
1227 if (output
->section_alignment
!= -1)
1228 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1230 if (section
->flags
& SEC_BLOCK
)
1232 section
->output_section
->flags
|= SEC_BLOCK
;
1233 /* FIXME: This value should really be obtained from the bfd... */
1234 output
->block_value
= 128;
1239 /* Handle wildcard sorting. This returns the lang_input_section which
1240 should follow the one we are going to create for SECTION and FILE,
1241 based on the sorting requirements of WILD. It returns NULL if the
1242 new section should just go at the end of the current list. */
1244 static lang_statement_union_type
*
1245 wild_sort (wild
, file
, section
)
1246 lang_wild_statement_type
*wild
;
1247 lang_input_statement_type
*file
;
1250 const char *section_name
;
1251 lang_statement_union_type
*l
;
1253 if (! wild
->filenames_sorted
&& ! wild
->sections_sorted
)
1256 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1257 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->next
)
1259 lang_input_section_type
*ls
;
1261 if (l
->header
.type
!= lang_input_section_enum
)
1263 ls
= &l
->input_section
;
1265 /* Sorting by filename takes precedence over sorting by section
1268 if (wild
->filenames_sorted
)
1270 const char *fn
, *ln
;
1274 /* The PE support for the .idata section as generated by
1275 dlltool assumes that files will be sorted by the name of
1276 the archive and then the name of the file within the
1279 if (file
->the_bfd
!= NULL
1280 && bfd_my_archive (file
->the_bfd
) != NULL
)
1282 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1287 fn
= file
->filename
;
1291 if (ls
->ifile
->the_bfd
!= NULL
1292 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1294 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1299 ln
= ls
->ifile
->filename
;
1303 i
= strcmp (fn
, ln
);
1312 fn
= file
->filename
;
1314 ln
= ls
->ifile
->filename
;
1316 i
= strcmp (fn
, ln
);
1324 /* Here either the files are not sorted by name, or we are
1325 looking at the sections for this file. */
1327 if (wild
->sections_sorted
)
1329 if (strcmp (section_name
,
1330 bfd_get_section_name (ls
->ifile
->the_bfd
,
1340 /* Expand a wild statement for a particular FILE. SECTION may be
1341 NULL, in which case it is a wild card. */
1344 output_section_callback (ptr
, section
, file
, output
)
1345 lang_wild_statement_type
*ptr
;
1347 lang_input_statement_type
*file
;
1350 lang_statement_union_type
*before
;
1352 /* If the wild pattern was marked KEEP, the member sections
1353 should be as well. */
1354 if (ptr
->keep_sections
)
1355 section
->flags
|= SEC_KEEP
;
1357 before
= wild_sort (ptr
, file
, section
);
1359 /* Here BEFORE points to the lang_input_section which
1360 should follow the one we are about to add. If BEFORE
1361 is NULL, then the section should just go at the end
1362 of the current list. */
1365 wild_doit (&ptr
->children
, section
,
1366 (lang_output_section_statement_type
*) output
,
1370 lang_statement_list_type list
;
1371 lang_statement_union_type
**pp
;
1373 lang_list_init (&list
);
1374 wild_doit (&list
, section
,
1375 (lang_output_section_statement_type
*) output
,
1378 /* If we are discarding the section, LIST.HEAD will
1380 if (list
.head
!= NULL
)
1382 ASSERT (list
.head
->next
== NULL
);
1384 for (pp
= &ptr
->children
.head
;
1387 ASSERT (*pp
!= NULL
);
1389 list
.head
->next
= *pp
;
1395 /* This is passed a file name which must have been seen already and
1396 added to the statement tree. We will see if it has been opened
1397 already and had its symbols read. If not then we'll read it. */
1399 static lang_input_statement_type
*
1403 lang_input_statement_type
*search
;
1405 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1406 search
!= (lang_input_statement_type
*) NULL
;
1407 search
= (lang_input_statement_type
*) search
->next_real_file
)
1409 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
1411 if (search
->filename
!= (char *) NULL
1412 && name
!= (char *) NULL
1413 && strcmp (search
->filename
, name
) == 0)
1417 if (search
== (lang_input_statement_type
*) NULL
)
1418 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
1421 /* If we have already added this file, or this file is not real
1422 (FIXME: can that ever actually happen?) or the name is NULL
1423 (FIXME: can that ever actually happen?) don't add this file. */
1426 || search
->filename
== (const char *) NULL
)
1429 if (! load_symbols (search
, (lang_statement_list_type
*) NULL
))
1435 /* Get the symbols for an input file. */
1438 load_symbols (entry
, place
)
1439 lang_input_statement_type
*entry
;
1440 lang_statement_list_type
*place
;
1447 ldfile_open_file (entry
);
1449 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1450 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1453 lang_statement_list_type
*hold
;
1454 boolean bad_load
= true;
1456 err
= bfd_get_error ();
1458 /* See if the emulation has some special knowledge. */
1459 if (ldemul_unrecognized_file (entry
))
1462 if (err
== bfd_error_file_ambiguously_recognized
)
1466 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1467 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1468 for (p
= matching
; *p
!= NULL
; p
++)
1472 else if (err
!= bfd_error_file_not_recognized
1474 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1478 bfd_close (entry
->the_bfd
);
1479 entry
->the_bfd
= NULL
;
1481 /* Try to interpret the file as a linker script. */
1482 ldfile_open_command_file (entry
->filename
);
1487 ldfile_assumed_script
= true;
1488 parser_input
= input_script
;
1490 ldfile_assumed_script
= false;
1497 if (ldemul_recognized_file (entry
))
1500 /* We don't call ldlang_add_file for an archive. Instead, the
1501 add_symbols entry point will call ldlang_add_file, via the
1502 add_archive_element callback, for each element of the archive
1504 switch (bfd_get_format (entry
->the_bfd
))
1510 ldlang_add_file (entry
);
1511 if (trace_files
|| trace_file_tries
)
1512 info_msg ("%I\n", entry
);
1516 if (entry
->whole_archive
)
1518 bfd
* member
= NULL
;
1519 boolean loaded
= true;
1523 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
1528 if (! bfd_check_format (member
, bfd_object
))
1530 einfo (_("%F%B: member %B in archive is not an object\n"),
1531 entry
->the_bfd
, member
);
1535 if (! ((*link_info
.callbacks
->add_archive_element
)
1536 (&link_info
, member
, "--whole-archive")))
1539 if (! bfd_link_add_symbols (member
, &link_info
))
1541 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1546 entry
->loaded
= loaded
;
1552 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1553 entry
->loaded
= true;
1555 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1557 return entry
->loaded
;
1560 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1561 indicating that it is a wildcard. Separate lang_input_section
1562 statements are created for each part of the expansion; they are
1563 added after the wild statement S. OUTPUT is the output section. */
1566 wild (s
, section
, file
, target
, output
)
1567 lang_wild_statement_type
*s
;
1568 const char *section
;
1570 const char *target ATTRIBUTE_UNUSED
;
1571 lang_output_section_statement_type
*output
;
1573 walk_wild (s
, section
, file
, output_section_callback
, (PTR
) output
);
1575 if (section
!= (char *) NULL
1576 && strcmp (section
, "COMMON") == 0
1577 && default_common_section
== NULL
)
1579 /* Remember the section that common is going to in case we later
1580 get something which doesn't know where to put it. */
1581 default_common_section
= output
;
1585 /* Return true iff target is the sought target. */
1588 get_target (target
, data
)
1589 const bfd_target
*target
;
1592 const char *sought
= (const char *) data
;
1594 return strcmp (target
->name
, sought
) == 0;
1597 /* Like strcpy() but convert to lower case as well. */
1606 while ((c
= *src
++) != 0)
1608 if (isupper ((unsigned char) c
))
1617 /* Remove the first occurance of needle (if any) in haystack
1621 strcut (haystack
, needle
)
1625 haystack
= strstr (haystack
, needle
);
1631 for (src
= haystack
+ strlen (needle
); *src
;)
1632 *haystack
++ = *src
++;
1638 /* Compare two target format name strings.
1639 Return a value indicating how "similar" they are. */
1642 name_compare (first
, second
)
1650 copy1
= xmalloc (strlen (first
) + 1);
1651 copy2
= xmalloc (strlen (second
) + 1);
1653 /* Convert the names to lower case. */
1654 stricpy (copy1
, first
);
1655 stricpy (copy2
, second
);
1657 /* Remove and endian strings from the name. */
1658 strcut (copy1
, "big");
1659 strcut (copy1
, "little");
1660 strcut (copy2
, "big");
1661 strcut (copy2
, "little");
1663 /* Return a value based on how many characters match,
1664 starting from the beginning. If both strings are
1665 the same then return 10 * their length. */
1666 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1667 if (copy1
[result
] == 0)
1679 /* Set by closest_target_match() below. */
1680 static const bfd_target
*winner
;
1682 /* Scan all the valid bfd targets looking for one that has the endianness
1683 requirement that was specified on the command line, and is the nearest
1684 match to the original output target. */
1687 closest_target_match (target
, data
)
1688 const bfd_target
*target
;
1691 const bfd_target
*original
= (const bfd_target
*) data
;
1693 if (command_line
.endian
== ENDIAN_BIG
1694 && target
->byteorder
!= BFD_ENDIAN_BIG
)
1697 if (command_line
.endian
== ENDIAN_LITTLE
1698 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
1701 /* Must be the same flavour. */
1702 if (target
->flavour
!= original
->flavour
)
1705 /* If we have not found a potential winner yet, then record this one. */
1712 /* Oh dear, we now have two potential candidates for a successful match.
1713 Compare their names and choose the better one. */
1714 if (name_compare (target
->name
, original
->name
)
1715 > name_compare (winner
->name
, original
->name
))
1718 /* Keep on searching until wqe have checked them all. */
1722 /* Return the BFD target format of the first input file. */
1725 get_first_input_target ()
1727 char *target
= NULL
;
1729 LANG_FOR_EACH_INPUT_STATEMENT (s
)
1731 if (s
->header
.type
== lang_input_statement_enum
1734 ldfile_open_file (s
);
1736 if (s
->the_bfd
!= NULL
1737 && bfd_check_format (s
->the_bfd
, bfd_object
))
1739 target
= bfd_get_target (s
->the_bfd
);
1750 /* Open the output file. */
1758 /* Has the user told us which output format to use? */
1759 if (output_target
== (char *) NULL
)
1761 /* No - has the current target been set to something other than
1763 if (current_target
!= default_target
)
1764 output_target
= current_target
;
1766 /* No - can we determine the format of the first input file? */
1769 output_target
= get_first_input_target ();
1771 /* Failed - use the default output target. */
1772 if (output_target
== NULL
)
1773 output_target
= default_target
;
1777 /* Has the user requested a particular endianness on the command
1779 if (command_line
.endian
!= ENDIAN_UNSET
)
1781 const bfd_target
*target
;
1782 enum bfd_endian desired_endian
;
1784 /* Get the chosen target. */
1785 target
= bfd_search_for_target (get_target
, (PTR
) output_target
);
1787 /* If the target is not supported, we cannot do anything. */
1790 if (command_line
.endian
== ENDIAN_BIG
)
1791 desired_endian
= BFD_ENDIAN_BIG
;
1793 desired_endian
= BFD_ENDIAN_LITTLE
;
1795 /* See if the target has the wrong endianness. This should
1796 not happen if the linker script has provided big and
1797 little endian alternatives, but some scrips don't do
1799 if (target
->byteorder
!= desired_endian
)
1801 /* If it does, then see if the target provides
1802 an alternative with the correct endianness. */
1803 if (target
->alternative_target
!= NULL
1804 && (target
->alternative_target
->byteorder
== desired_endian
))
1805 output_target
= target
->alternative_target
->name
;
1808 /* Try to find a target as similar as possible to
1809 the default target, but which has the desired
1810 endian characteristic. */
1811 (void) bfd_search_for_target (closest_target_match
,
1814 /* Oh dear - we could not find any targets that
1815 satisfy our requirements. */
1817 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1819 output_target
= winner
->name
;
1825 output
= bfd_openw (name
, output_target
);
1827 if (output
== (bfd
*) NULL
)
1829 if (bfd_get_error () == bfd_error_invalid_target
)
1830 einfo (_("%P%F: target %s not found\n"), output_target
);
1832 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
1835 delete_output_file_on_failure
= true;
1838 output
->flags
|= D_PAGED
;
1841 if (! bfd_set_format (output
, bfd_object
))
1842 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
1843 if (! bfd_set_arch_mach (output
,
1844 ldfile_output_architecture
,
1845 ldfile_output_machine
))
1846 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
1848 link_info
.hash
= bfd_link_hash_table_create (output
);
1849 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1850 einfo (_("%P%F: can not create link hash table: %E\n"));
1852 bfd_set_gp_size (output
, g_switch_value
);
1857 ldlang_open_output (statement
)
1858 lang_statement_union_type
*statement
;
1860 switch (statement
->header
.type
)
1862 case lang_output_statement_enum
:
1863 ASSERT (output_bfd
== (bfd
*) NULL
);
1864 output_bfd
= open_output (statement
->output_statement
.name
);
1865 ldemul_set_output_arch ();
1866 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1867 output_bfd
->flags
|= D_PAGED
;
1869 output_bfd
->flags
&= ~D_PAGED
;
1870 if (config
.text_read_only
)
1871 output_bfd
->flags
|= WP_TEXT
;
1873 output_bfd
->flags
&= ~WP_TEXT
;
1874 if (link_info
.traditional_format
)
1875 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1877 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1880 case lang_target_statement_enum
:
1881 current_target
= statement
->target_statement
.target
;
1888 /* Open all the input files. */
1891 open_input_bfds (s
, force
)
1892 lang_statement_union_type
*s
;
1895 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1897 switch (s
->header
.type
)
1899 case lang_constructors_statement_enum
:
1900 open_input_bfds (constructor_list
.head
, force
);
1902 case lang_output_section_statement_enum
:
1903 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1905 case lang_wild_statement_enum
:
1906 /* Maybe we should load the file's symbols. */
1907 if (s
->wild_statement
.filename
1908 && ! wildcardp (s
->wild_statement
.filename
))
1909 (void) lookup_name (s
->wild_statement
.filename
);
1910 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1912 case lang_group_statement_enum
:
1914 struct bfd_link_hash_entry
*undefs
;
1916 /* We must continually search the entries in the group
1917 until no new symbols are added to the list of undefined
1922 undefs
= link_info
.hash
->undefs_tail
;
1923 open_input_bfds (s
->group_statement
.children
.head
, true);
1925 while (undefs
!= link_info
.hash
->undefs_tail
);
1928 case lang_target_statement_enum
:
1929 current_target
= s
->target_statement
.target
;
1931 case lang_input_statement_enum
:
1932 if (s
->input_statement
.real
)
1934 lang_statement_list_type add
;
1936 s
->input_statement
.target
= current_target
;
1938 /* If we are being called from within a group, and this
1939 is an archive which has already been searched, then
1940 force it to be researched unless the whole archive
1941 has been loaded already. */
1943 && !s
->input_statement
.whole_archive
1944 && s
->input_statement
.loaded
1945 && bfd_check_format (s
->input_statement
.the_bfd
,
1947 s
->input_statement
.loaded
= false;
1949 lang_list_init (&add
);
1951 if (! load_symbols (&s
->input_statement
, &add
))
1952 config
.make_executable
= false;
1954 if (add
.head
!= NULL
)
1956 *add
.tail
= s
->next
;
1967 /* If there are [COMMONS] statements, put a wild one into the bss
1971 lang_reasonable_defaults ()
1974 lang_output_section_statement_lookup (".text");
1975 lang_output_section_statement_lookup (".data");
1977 default_common_section
= lang_output_section_statement_lookup (".bss");
1979 if (placed_commons
== false)
1981 lang_wild_statement_type
*new =
1982 new_stat (lang_wild_statement
,
1983 &default_common_section
->children
);
1985 new->section_name
= "COMMON";
1986 new->filename
= (char *) NULL
;
1987 lang_list_init (&new->children
);
1992 /* Add the supplied name to the symbol table as an undefined reference.
1993 Remove items from the chain as we open input bfds. */
1994 typedef struct ldlang_undef_chain_list
1996 struct ldlang_undef_chain_list
*next
;
1998 } ldlang_undef_chain_list_type
;
2000 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
2003 ldlang_add_undef (name
)
2004 const char *const name
;
2006 ldlang_undef_chain_list_type
*new =
2007 ((ldlang_undef_chain_list_type
*)
2008 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
2010 new->next
= ldlang_undef_chain_list_head
;
2011 ldlang_undef_chain_list_head
= new;
2013 new->name
= xstrdup (name
);
2016 /* Run through the list of undefineds created above and place them
2017 into the linker hash table as undefined symbols belonging to the
2021 lang_place_undefineds ()
2023 ldlang_undef_chain_list_type
*ptr
;
2025 for (ptr
= ldlang_undef_chain_list_head
;
2026 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
2029 struct bfd_link_hash_entry
*h
;
2031 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
2032 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2033 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2034 if (h
->type
== bfd_link_hash_new
)
2036 h
->type
= bfd_link_hash_undefined
;
2037 h
->u
.undef
.abfd
= NULL
;
2038 bfd_link_add_undef (link_info
.hash
, h
);
2043 /* Open input files and attatch to output sections. */
2046 map_input_to_output_sections (s
, target
, output_section_statement
)
2047 lang_statement_union_type
*s
;
2049 lang_output_section_statement_type
*output_section_statement
;
2051 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2053 switch (s
->header
.type
)
2056 case lang_wild_statement_enum
:
2057 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
2058 s
->wild_statement
.filename
, target
,
2059 output_section_statement
);
2062 case lang_constructors_statement_enum
:
2063 map_input_to_output_sections (constructor_list
.head
,
2065 output_section_statement
);
2067 case lang_output_section_statement_enum
:
2068 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2070 &s
->output_section_statement
);
2072 case lang_output_statement_enum
:
2074 case lang_target_statement_enum
:
2075 target
= s
->target_statement
.target
;
2077 case lang_group_statement_enum
:
2078 map_input_to_output_sections (s
->group_statement
.children
.head
,
2080 output_section_statement
);
2082 case lang_fill_statement_enum
:
2083 case lang_input_section_enum
:
2084 case lang_object_symbols_statement_enum
:
2085 case lang_data_statement_enum
:
2086 case lang_reloc_statement_enum
:
2087 case lang_padding_statement_enum
:
2088 case lang_input_statement_enum
:
2089 if (output_section_statement
!= NULL
2090 && output_section_statement
->bfd_section
== NULL
)
2091 init_os (output_section_statement
);
2093 case lang_assignment_statement_enum
:
2094 if (output_section_statement
!= NULL
2095 && output_section_statement
->bfd_section
== NULL
)
2096 init_os (output_section_statement
);
2098 /* Make sure that any sections mentioned in the assignment
2100 exp_init_os (s
->assignment_statement
.exp
);
2102 case lang_afile_asection_pair_statement_enum
:
2105 case lang_address_statement_enum
:
2106 /* Mark the specified section with the supplied address. */
2108 lang_output_section_statement_type
*os
=
2109 lang_output_section_statement_lookup
2110 (s
->address_statement
.section_name
);
2112 if (os
->bfd_section
== NULL
)
2114 os
->addr_tree
= s
->address_statement
.address
;
2122 print_output_section_statement (output_section_statement
)
2123 lang_output_section_statement_type
*output_section_statement
;
2125 asection
*section
= output_section_statement
->bfd_section
;
2128 if (output_section_statement
!= abs_output_section
)
2130 minfo ("\n%s", output_section_statement
->name
);
2132 if (section
!= NULL
)
2134 print_dot
= section
->vma
;
2136 len
= strlen (output_section_statement
->name
);
2137 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2142 while (len
< SECTION_NAME_MAP_LENGTH
)
2148 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
2150 if (output_section_statement
->load_base
!= NULL
)
2154 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2155 "load base", lang_final_phase_enum
);
2156 minfo (_(" load address 0x%V"), addr
);
2163 print_statement_list (output_section_statement
->children
.head
,
2164 output_section_statement
);
2168 print_assignment (assignment
, output_section
)
2169 lang_assignment_statement_type
*assignment
;
2170 lang_output_section_statement_type
*output_section
;
2173 etree_value_type result
;
2175 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2178 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
2179 lang_final_phase_enum
, print_dot
, &print_dot
);
2181 minfo ("0x%V", result
.value
+ result
.section
->bfd_section
->vma
);
2192 exp_print_tree (assignment
->exp
);
2198 print_input_statement (statm
)
2199 lang_input_statement_type
*statm
;
2201 if (statm
->filename
!= (char *) NULL
)
2203 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2207 /* Print all symbols defined in a particular section. This is called
2208 via bfd_link_hash_traverse. */
2211 print_one_symbol (hash_entry
, ptr
)
2212 struct bfd_link_hash_entry
*hash_entry
;
2215 asection
*sec
= (asection
*) ptr
;
2217 if ((hash_entry
->type
== bfd_link_hash_defined
2218 || hash_entry
->type
== bfd_link_hash_defweak
)
2219 && sec
== hash_entry
->u
.def
.section
)
2223 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2226 (hash_entry
->u
.def
.value
2227 + hash_entry
->u
.def
.section
->output_offset
2228 + hash_entry
->u
.def
.section
->output_section
->vma
));
2230 minfo (" %T\n", hash_entry
->root
.string
);
2236 /* Print information about an input section to the map file. */
2239 print_input_section (in
)
2240 lang_input_section_type
*in
;
2242 asection
*i
= in
->section
;
2243 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
2244 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2245 ldfile_output_machine
);
2250 minfo ("%s", i
->name
);
2252 if (i
->output_section
!= NULL
)
2256 len
= 1 + strlen (i
->name
);
2257 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2262 while (len
< SECTION_NAME_MAP_LENGTH
)
2268 minfo ("0x%V %W %B\n",
2269 i
->output_section
->vma
+ i
->output_offset
, size
/ opb
,
2272 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
2274 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2286 minfo (_("%W (size before relaxing)\n"), i
->_raw_size
);
2289 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
2291 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
/ opb
;
2297 print_fill_statement (fill
)
2298 lang_fill_statement_type
*fill
;
2300 fprintf (config
.map_file
, " FILL mask 0x%x\n", fill
->fill
);
2304 print_data_statement (data
)
2305 lang_data_statement_type
*data
;
2311 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2312 ldfile_output_machine
);
2314 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2317 addr
= data
->output_vma
;
2318 if (data
->output_section
!= NULL
)
2319 addr
+= data
->output_section
->vma
;
2347 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2349 if (data
->exp
->type
.node_class
!= etree_value
)
2352 exp_print_tree (data
->exp
);
2357 print_dot
= addr
+ size
/ opb
;
2361 /* Print an address statement. These are generated by options like
2365 print_address_statement (address
)
2366 lang_address_statement_type
*address
;
2368 minfo (_("Address of section %s set to "), address
->section_name
);
2369 exp_print_tree (address
->address
);
2373 /* Print a reloc statement. */
2376 print_reloc_statement (reloc
)
2377 lang_reloc_statement_type
*reloc
;
2382 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2383 ldfile_output_machine
);
2385 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2388 addr
= reloc
->output_vma
;
2389 if (reloc
->output_section
!= NULL
)
2390 addr
+= reloc
->output_section
->vma
;
2392 size
= bfd_get_reloc_size (reloc
->howto
);
2394 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
2396 if (reloc
->name
!= NULL
)
2397 minfo ("%s+", reloc
->name
);
2399 minfo ("%s+", reloc
->section
->name
);
2401 exp_print_tree (reloc
->addend_exp
);
2405 print_dot
= addr
+ size
/ opb
;
2409 print_padding_statement (s
)
2410 lang_padding_statement_type
*s
;
2414 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2415 ldfile_output_machine
);
2419 len
= sizeof " *fill*" - 1;
2420 while (len
< SECTION_NAME_MAP_LENGTH
)
2426 addr
= s
->output_offset
;
2427 if (s
->output_section
!= NULL
)
2428 addr
+= s
->output_section
->vma
;
2429 minfo ("0x%V %W", addr
, s
->size
);
2432 minfo (" %u", s
->fill
);
2436 print_dot
= addr
+ s
->size
/ opb
;
2440 print_wild_statement (w
, os
)
2441 lang_wild_statement_type
*w
;
2442 lang_output_section_statement_type
*os
;
2446 if (w
->filenames_sorted
)
2448 if (w
->exclude_filename_list
!= NULL
)
2451 minfo ("EXCLUDE_FILE ( %s", w
->exclude_filename_list
->name
);
2452 for (tmp
= w
->exclude_filename_list
->next
; tmp
; tmp
= tmp
->next
)
2453 minfo (", %s", tmp
->name
);
2456 if (w
->filename
!= NULL
)
2457 minfo ("%s", w
->filename
);
2460 if (w
->filenames_sorted
)
2464 if (w
->sections_sorted
)
2466 if (w
->section_name
!= NULL
)
2467 minfo ("%s", w
->section_name
);
2470 if (w
->sections_sorted
)
2476 print_statement_list (w
->children
.head
, os
);
2479 /* Print a group statement. */
2483 lang_group_statement_type
*s
;
2484 lang_output_section_statement_type
*os
;
2486 fprintf (config
.map_file
, "START GROUP\n");
2487 print_statement_list (s
->children
.head
, os
);
2488 fprintf (config
.map_file
, "END GROUP\n");
2491 /* Print the list of statements in S.
2492 This can be called for any statement type. */
2495 print_statement_list (s
, os
)
2496 lang_statement_union_type
*s
;
2497 lang_output_section_statement_type
*os
;
2501 print_statement (s
, os
);
2506 /* Print the first statement in statement list S.
2507 This can be called for any statement type. */
2510 print_statement (s
, os
)
2511 lang_statement_union_type
*s
;
2512 lang_output_section_statement_type
*os
;
2514 switch (s
->header
.type
)
2517 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
2520 case lang_constructors_statement_enum
:
2521 if (constructor_list
.head
!= NULL
)
2523 if (constructors_sorted
)
2524 minfo (" SORT (CONSTRUCTORS)\n");
2526 minfo (" CONSTRUCTORS\n");
2527 print_statement_list (constructor_list
.head
, os
);
2530 case lang_wild_statement_enum
:
2531 print_wild_statement (&s
->wild_statement
, os
);
2533 case lang_address_statement_enum
:
2534 print_address_statement (&s
->address_statement
);
2536 case lang_object_symbols_statement_enum
:
2537 minfo (" CREATE_OBJECT_SYMBOLS\n");
2539 case lang_fill_statement_enum
:
2540 print_fill_statement (&s
->fill_statement
);
2542 case lang_data_statement_enum
:
2543 print_data_statement (&s
->data_statement
);
2545 case lang_reloc_statement_enum
:
2546 print_reloc_statement (&s
->reloc_statement
);
2548 case lang_input_section_enum
:
2549 print_input_section (&s
->input_section
);
2551 case lang_padding_statement_enum
:
2552 print_padding_statement (&s
->padding_statement
);
2554 case lang_output_section_statement_enum
:
2555 print_output_section_statement (&s
->output_section_statement
);
2557 case lang_assignment_statement_enum
:
2558 print_assignment (&s
->assignment_statement
, os
);
2560 case lang_target_statement_enum
:
2561 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
2563 case lang_output_statement_enum
:
2564 minfo ("OUTPUT(%s", s
->output_statement
.name
);
2565 if (output_target
!= NULL
)
2566 minfo (" %s", output_target
);
2569 case lang_input_statement_enum
:
2570 print_input_statement (&s
->input_statement
);
2572 case lang_group_statement_enum
:
2573 print_group (&s
->group_statement
, os
);
2575 case lang_afile_asection_pair_statement_enum
:
2584 print_statement_list (statement_list
.head
, abs_output_section
);
2587 /* Print the first N statements in statement list S to STDERR.
2588 If N == 0, nothing is printed.
2589 If N < 0, the entire list is printed.
2590 Intended to be called from GDB. */
2593 dprint_statement (s
, n
)
2594 lang_statement_union_type
*s
;
2597 FILE *map_save
= config
.map_file
;
2599 config
.map_file
= stderr
;
2602 print_statement_list (s
, abs_output_section
);
2605 while (s
&& --n
>= 0)
2607 print_statement (s
, abs_output_section
);
2612 config
.map_file
= map_save
;
2616 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
2617 lang_statement_union_type
**this_ptr
;
2620 asection
*output_section_statement
;
2623 /* Align this section first to the
2624 input sections requirement, then
2625 to the output section's requirement.
2626 If this alignment is > than any seen before,
2627 then record it too. Perform the alignment by
2628 inserting a magic 'padding' statement. */
2630 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2631 ldfile_output_machine
);
2632 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
2634 if (alignment_needed
!= 0)
2636 lang_statement_union_type
*new =
2637 ((lang_statement_union_type
*)
2638 stat_alloc (sizeof (lang_padding_statement_type
)));
2640 /* Link into existing chain. */
2641 new->header
.next
= *this_ptr
;
2643 new->header
.type
= lang_padding_statement_enum
;
2644 new->padding_statement
.output_section
= output_section_statement
;
2645 new->padding_statement
.output_offset
=
2646 dot
- output_section_statement
->vma
;
2647 new->padding_statement
.fill
= fill
;
2648 new->padding_statement
.size
= alignment_needed
* opb
;
2651 /* Remember the most restrictive alignment. */
2652 if (power
> output_section_statement
->alignment_power
)
2654 output_section_statement
->alignment_power
= power
;
2656 output_section_statement
->_raw_size
+= alignment_needed
* opb
;
2658 return dot
+ alignment_needed
;
2661 /* Work out how much this section will move the dot point. */
2664 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
2665 lang_statement_union_type
**this_ptr
;
2666 lang_output_section_statement_type
*output_section_statement
;
2669 boolean relax ATTRIBUTE_UNUSED
;
2671 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2672 asection
*i
= is
->section
;
2673 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2674 ldfile_output_machine
);
2676 if (is
->ifile
->just_syms_flag
== false)
2678 if (output_section_statement
->subsection_alignment
!= -1)
2679 i
->alignment_power
=
2680 output_section_statement
->subsection_alignment
;
2682 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
2683 output_section_statement
->bfd_section
, dot
);
2685 /* Remember where in the output section this input section goes. */
2687 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
2689 /* Mark how big the output section must be to contain this now. */
2690 if (i
->_cooked_size
!= 0)
2691 dot
+= i
->_cooked_size
/ opb
;
2693 dot
+= i
->_raw_size
/ opb
;
2694 output_section_statement
->bfd_section
->_raw_size
=
2695 (dot
- output_section_statement
->bfd_section
->vma
) * opb
;
2699 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2705 #define IGNORE_SECTION(bfd, s) \
2706 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2707 != (SEC_ALLOC | SEC_LOAD)) \
2708 || bfd_section_size (bfd, s) == 0)
2710 /* Check to see if any allocated sections overlap with other allocated
2711 sections. This can happen when the linker script specifically specifies
2712 the output section addresses of the two sections. */
2715 lang_check_section_addresses ()
2718 unsigned opb
= bfd_octets_per_byte (output_bfd
);
2720 /* Scan all sections in the output list. */
2721 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2725 /* Ignore sections which are not loaded or which have no contents. */
2726 if (IGNORE_SECTION (output_bfd
, s
))
2729 /* Once we reach section 's' stop our seach. This prevents two
2730 warning messages from being produced, one for 'section A overlaps
2731 section B' and one for 'section B overlaps section A'. */
2732 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
2739 /* Only consider loadable sections with real contents. */
2740 if (IGNORE_SECTION (output_bfd
, os
))
2743 /* We must check the sections' LMA addresses not their
2744 VMA addresses because overlay sections can have
2745 overlapping VMAs but they must have distinct LMAs. */
2746 s_start
= bfd_section_lma (output_bfd
, s
);
2747 os_start
= bfd_section_lma (output_bfd
, os
);
2748 s_end
= s_start
+ bfd_section_size (output_bfd
, s
) / opb
- 1;
2749 os_end
= os_start
+ bfd_section_size (output_bfd
, os
) / opb
- 1;
2751 /* Look for an overlap. */
2752 if ((s_end
< os_start
) || (s_start
> os_end
))
2756 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2757 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
2759 /* Once we have found one overlap for this section,
2760 stop looking for others. */
2766 /* This variable indicates whether bfd_relax_section should be called
2769 static boolean relax_again
;
2771 /* Make sure the new address is within the region. We explicitly permit the
2772 current address to be at the exact end of the region when the address is
2773 non-zero, in case the region is at the end of addressable memory and the
2774 calculation wraps around. */
2777 os_region_check (os
, region
, tree
, base
)
2778 lang_output_section_statement_type
*os
;
2779 struct memory_region_struct
*region
;
2783 if ((region
->current
< region
->origin
2784 || (region
->current
- region
->origin
> region
->length
))
2785 && ((region
->current
!= region
->origin
+ region
->length
)
2788 if (tree
!= (etree_type
*) NULL
)
2790 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2792 os
->bfd_section
->owner
,
2793 os
->bfd_section
->name
,
2798 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2800 os
->bfd_section
->owner
,
2801 os
->bfd_section
->name
);
2803 /* Reset the region pointer. */
2804 region
->current
= region
->origin
;
2808 /* Set the sizes for all the output sections. */
2811 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2812 lang_statement_union_type
*s
;
2813 lang_output_section_statement_type
*output_section_statement
;
2814 lang_statement_union_type
**prev
;
2819 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2820 ldfile_output_machine
);
2822 /* Size up the sections from their constituent parts. */
2823 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2825 switch (s
->header
.type
)
2827 case lang_output_section_statement_enum
:
2830 lang_output_section_statement_type
*os
;
2832 os
= &s
->output_section_statement
;
2833 if (os
->bfd_section
== NULL
)
2834 /* This section was never actually created. */
2837 /* If this is a COFF shared library section, use the size and
2838 address from the input section. FIXME: This is COFF
2839 specific; it would be cleaner if there were some other way
2840 to do this, but nothing simple comes to mind. */
2841 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2845 if (os
->children
.head
== NULL
2846 || os
->children
.head
->next
!= NULL
2847 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2848 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2851 input
= os
->children
.head
->input_section
.section
;
2852 bfd_set_section_vma (os
->bfd_section
->owner
,
2854 bfd_section_vma (input
->owner
, input
));
2855 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2859 if (bfd_is_abs_section (os
->bfd_section
))
2861 /* No matter what happens, an abs section starts at zero. */
2862 ASSERT (os
->bfd_section
->vma
== 0);
2866 if (os
->addr_tree
== (etree_type
*) NULL
)
2868 /* No address specified for this section, get one
2869 from the region specification. */
2870 if (os
->region
== (lang_memory_region_type
*) NULL
2871 || (((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2872 & (SEC_ALLOC
| SEC_LOAD
)) != 0)
2873 && os
->region
->name
[0] == '*'
2874 && strcmp (os
->region
->name
, "*default*") == 0))
2876 os
->region
= lang_memory_default (os
->bfd_section
);
2879 /* If a loadable section is using the default memory
2880 region, and some non default memory regions were
2881 defined, issue a warning. */
2882 if ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2883 & (SEC_ALLOC
| SEC_LOAD
)) != 0
2884 && ! link_info
.relocateable
2885 && strcmp (os
->region
->name
, "*default*") == 0
2886 && lang_memory_region_list
!= NULL
2887 && (strcmp (lang_memory_region_list
->name
,
2889 || lang_memory_region_list
->next
!= NULL
))
2890 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2891 bfd_get_section_name (output_bfd
,
2894 dot
= os
->region
->current
;
2896 if (os
->section_alignment
== -1)
2901 dot
= align_power (dot
,
2902 os
->bfd_section
->alignment_power
);
2904 if (dot
!= olddot
&& config
.warn_section_align
)
2905 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2906 os
->name
, (unsigned int) (dot
- olddot
));
2913 r
= exp_fold_tree (os
->addr_tree
,
2915 lang_allocating_phase_enum
,
2917 if (r
.valid_p
== false)
2919 einfo (_("%F%S: non constant address expression for section %s\n"),
2922 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2925 /* The section starts here.
2926 First, align to what the section needs. */
2928 if (os
->section_alignment
!= -1)
2929 dot
= align_power (dot
, os
->section_alignment
);
2931 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2933 os
->bfd_section
->output_offset
= 0;
2936 (void) lang_size_sections (os
->children
.head
, os
,
2938 os
->fill
, dot
, relax
);
2940 /* Put the section within the requested block size, or
2941 align at the block boundary. */
2942 after
= ALIGN_N (os
->bfd_section
->vma
2943 + os
->bfd_section
->_raw_size
/ opb
,
2944 /* The coercion here is important, see ld.h. */
2945 (bfd_vma
) os
->block_value
);
2947 if (bfd_is_abs_section (os
->bfd_section
))
2948 ASSERT (after
== os
->bfd_section
->vma
);
2950 os
->bfd_section
->_raw_size
=
2951 (after
- os
->bfd_section
->vma
) * opb
;
2952 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
2953 os
->processed
= true;
2955 /* Update dot in the region ?
2956 We only do this if the section is going to be allocated,
2957 since unallocated sections do not contribute to the region's
2958 overall size in memory.
2960 If the SEC_NEVER_LOAD bit is not set, it will affect the
2961 addresses of sections after it. We have to update
2963 if (os
->region
!= (lang_memory_region_type
*) NULL
2964 && ((bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2965 & SEC_NEVER_LOAD
) == 0
2966 || (bfd_get_section_flags (output_bfd
, os
->bfd_section
)
2967 & (SEC_ALLOC
| SEC_LOAD
))))
2969 os
->region
->current
= dot
;
2971 /* Make sure the new address is within the region. */
2972 os_region_check (os
, os
->region
, os
->addr_tree
,
2973 os
->bfd_section
->vma
);
2975 /* If there's no load address specified, use the run
2976 region as the load region. */
2977 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
2978 os
->lma_region
= os
->region
;
2980 if (os
->lma_region
!= NULL
)
2982 if (os
->load_base
!= NULL
)
2984 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
2988 /* Don't allocate twice. */
2989 if (os
->lma_region
!= os
->region
)
2991 /* Set load_base, which will be handled later. */
2993 exp_intop (os
->lma_region
->current
);
2994 os
->lma_region
->current
+=
2995 os
->bfd_section
->_raw_size
/ opb
;
2996 os_region_check (os
, os
->lma_region
, NULL
,
2997 os
->bfd_section
->lma
);
3005 case lang_constructors_statement_enum
:
3006 dot
= lang_size_sections (constructor_list
.head
,
3007 output_section_statement
,
3008 &s
->wild_statement
.children
.head
,
3013 case lang_data_statement_enum
:
3015 unsigned int size
= 0;
3017 s
->data_statement
.output_vma
=
3018 dot
- output_section_statement
->bfd_section
->vma
;
3019 s
->data_statement
.output_section
=
3020 output_section_statement
->bfd_section
;
3022 switch (s
->data_statement
.type
)
3043 output_section_statement
->bfd_section
->_raw_size
+= size
;
3044 /* The output section gets contents, and then we inspect for
3045 any flags set in the input script which override any ALLOC. */
3046 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
3047 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
))
3049 output_section_statement
->bfd_section
->flags
|=
3050 SEC_ALLOC
| SEC_LOAD
;
3055 case lang_reloc_statement_enum
:
3059 s
->reloc_statement
.output_vma
=
3060 dot
- output_section_statement
->bfd_section
->vma
;
3061 s
->reloc_statement
.output_section
=
3062 output_section_statement
->bfd_section
;
3063 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3065 output_section_statement
->bfd_section
->_raw_size
+= size
;
3069 case lang_wild_statement_enum
:
3071 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
3072 output_section_statement
,
3073 &s
->wild_statement
.children
.head
,
3078 case lang_object_symbols_statement_enum
:
3079 link_info
.create_object_symbols_section
=
3080 output_section_statement
->bfd_section
;
3082 case lang_output_statement_enum
:
3083 case lang_target_statement_enum
:
3085 case lang_input_section_enum
:
3089 i
= (*prev
)->input_section
.section
;
3092 if (i
->_cooked_size
== 0)
3093 i
->_cooked_size
= i
->_raw_size
;
3099 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3100 einfo (_("%P%F: can't relax section: %E\n"));
3104 dot
= size_input_section (prev
,
3105 output_section_statement
,
3106 output_section_statement
->fill
,
3110 case lang_input_statement_enum
:
3112 case lang_fill_statement_enum
:
3113 s
->fill_statement
.output_section
=
3114 output_section_statement
->bfd_section
;
3116 fill
= s
->fill_statement
.fill
;
3118 case lang_assignment_statement_enum
:
3120 bfd_vma newdot
= dot
;
3122 exp_fold_tree (s
->assignment_statement
.exp
,
3123 output_section_statement
,
3124 lang_allocating_phase_enum
,
3130 /* The assignment changed dot. Insert a pad. */
3131 if (output_section_statement
== abs_output_section
)
3133 /* If we don't have an output section, then just adjust
3134 the default memory address. */
3135 lang_memory_region_lookup ("*default*")->current
= newdot
;
3139 lang_statement_union_type
*new =
3140 ((lang_statement_union_type
*)
3141 stat_alloc (sizeof (lang_padding_statement_type
)));
3143 /* Link into existing chain. */
3144 new->header
.next
= *prev
;
3146 new->header
.type
= lang_padding_statement_enum
;
3147 new->padding_statement
.output_section
=
3148 output_section_statement
->bfd_section
;
3149 new->padding_statement
.output_offset
=
3150 dot
- output_section_statement
->bfd_section
->vma
;
3151 new->padding_statement
.fill
= fill
;
3152 new->padding_statement
.size
= (newdot
- dot
) * opb
;
3153 output_section_statement
->bfd_section
->_raw_size
+=
3154 new->padding_statement
.size
;
3162 case lang_padding_statement_enum
:
3163 /* If we are relaxing, and this is not the first pass, some
3164 padding statements may have been inserted during previous
3165 passes. We may have to move the padding statement to a new
3166 location if dot has a different value at this point in this
3167 pass than it did at this point in the previous pass. */
3168 s
->padding_statement
.output_offset
=
3169 dot
- output_section_statement
->bfd_section
->vma
;
3170 dot
+= s
->padding_statement
.size
/ opb
;
3171 output_section_statement
->bfd_section
->_raw_size
+=
3172 s
->padding_statement
.size
;
3175 case lang_group_statement_enum
:
3176 dot
= lang_size_sections (s
->group_statement
.children
.head
,
3177 output_section_statement
,
3178 &s
->group_statement
.children
.head
,
3186 /* This can only get here when relaxing is turned on. */
3188 case lang_address_statement_enum
:
3191 prev
= &s
->header
.next
;
3197 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
3198 lang_statement_union_type
*s
;
3199 lang_output_section_statement_type
*output_section_statement
;
3203 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3204 ldfile_output_machine
);
3206 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
3208 switch (s
->header
.type
)
3210 case lang_constructors_statement_enum
:
3211 dot
= lang_do_assignments (constructor_list
.head
,
3212 output_section_statement
,
3217 case lang_output_section_statement_enum
:
3219 lang_output_section_statement_type
*os
;
3221 os
= &(s
->output_section_statement
);
3222 if (os
->bfd_section
!= NULL
)
3224 dot
= os
->bfd_section
->vma
;
3225 (void) lang_do_assignments (os
->children
.head
, os
,
3227 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
/ opb
;
3232 /* If nothing has been placed into the output section then
3233 it won't have a bfd_section. */
3234 if (os
->bfd_section
)
3236 os
->bfd_section
->lma
3237 = exp_get_abs_int (os
->load_base
, 0, "load base",
3238 lang_final_phase_enum
);
3243 case lang_wild_statement_enum
:
3245 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
3246 output_section_statement
,
3251 case lang_object_symbols_statement_enum
:
3252 case lang_output_statement_enum
:
3253 case lang_target_statement_enum
:
3255 case lang_common_statement_enum
:
3258 case lang_data_statement_enum
:
3260 etree_value_type value
;
3262 value
= exp_fold_tree (s
->data_statement
.exp
,
3264 lang_final_phase_enum
, dot
, &dot
);
3265 s
->data_statement
.value
= value
.value
;
3266 if (value
.valid_p
== false)
3267 einfo (_("%F%P: invalid data statement\n"));
3271 switch (s
->data_statement
.type
)
3295 case lang_reloc_statement_enum
:
3297 etree_value_type value
;
3299 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
3301 lang_final_phase_enum
, dot
, &dot
);
3302 s
->reloc_statement
.addend_value
= value
.value
;
3303 if (value
.valid_p
== false)
3304 einfo (_("%F%P: invalid reloc statement\n"));
3306 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
) / opb
;
3309 case lang_input_section_enum
:
3311 asection
*in
= s
->input_section
.section
;
3313 if (in
->_cooked_size
!= 0)
3314 dot
+= in
->_cooked_size
/ opb
;
3316 dot
+= in
->_raw_size
/ opb
;
3320 case lang_input_statement_enum
:
3322 case lang_fill_statement_enum
:
3323 fill
= s
->fill_statement
.fill
;
3325 case lang_assignment_statement_enum
:
3327 exp_fold_tree (s
->assignment_statement
.exp
,
3328 output_section_statement
,
3329 lang_final_phase_enum
,
3335 case lang_padding_statement_enum
:
3336 dot
+= s
->padding_statement
.size
/ opb
;
3339 case lang_group_statement_enum
:
3340 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
3341 output_section_statement
,
3349 case lang_address_statement_enum
:
3357 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3358 operator .startof. (section_name), it produces an undefined symbol
3359 .startof.section_name. Similarly, when it sees
3360 .sizeof. (section_name), it produces an undefined symbol
3361 .sizeof.section_name. For all the output sections, we look for
3362 such symbols, and set them to the correct value. */
3369 if (link_info
.relocateable
)
3372 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3374 const char *secname
;
3376 struct bfd_link_hash_entry
*h
;
3378 secname
= bfd_get_section_name (output_bfd
, s
);
3379 buf
= xmalloc (10 + strlen (secname
));
3381 sprintf (buf
, ".startof.%s", secname
);
3382 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3383 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3385 h
->type
= bfd_link_hash_defined
;
3386 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
3387 h
->u
.def
.section
= bfd_abs_section_ptr
;
3390 sprintf (buf
, ".sizeof.%s", secname
);
3391 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
3392 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
3396 opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3397 ldfile_output_machine
);
3398 h
->type
= bfd_link_hash_defined
;
3399 if (s
->_cooked_size
!= 0)
3400 h
->u
.def
.value
= s
->_cooked_size
/ opb
;
3402 h
->u
.def
.value
= s
->_raw_size
/ opb
;
3403 h
->u
.def
.section
= bfd_abs_section_ptr
;
3413 struct bfd_link_hash_entry
*h
;
3416 if (link_info
.relocateable
|| link_info
.shared
)
3421 if (entry_symbol
== (char *) NULL
)
3423 /* No entry has been specified. Look for start, but don't warn
3424 if we don't find it. */
3425 entry_symbol
= "start";
3429 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
3430 if (h
!= (struct bfd_link_hash_entry
*) NULL
3431 && (h
->type
== bfd_link_hash_defined
3432 || h
->type
== bfd_link_hash_defweak
)
3433 && h
->u
.def
.section
->output_section
!= NULL
)
3437 val
= (h
->u
.def
.value
3438 + bfd_get_section_vma (output_bfd
,
3439 h
->u
.def
.section
->output_section
)
3440 + h
->u
.def
.section
->output_offset
);
3441 if (! bfd_set_start_address (output_bfd
, val
))
3442 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
);
3449 /* We couldn't find the entry symbol. Try parsing it as a
3451 val
= bfd_scan_vma (entry_symbol
, &send
, 0);
3454 if (! bfd_set_start_address (output_bfd
, val
))
3455 einfo (_("%P%F: can't set start address\n"));
3461 /* Can't find the entry symbol, and it's not a number. Use
3462 the first address in the text section. */
3463 ts
= bfd_get_section_by_name (output_bfd
, ".text");
3464 if (ts
!= (asection
*) NULL
)
3467 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3468 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
3469 if (! bfd_set_start_address (output_bfd
,
3470 bfd_get_section_vma (output_bfd
,
3472 einfo (_("%P%F: can't set start address\n"));
3477 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3484 /* This is a small function used when we want to ignore errors from
3488 #ifdef ANSI_PROTOTYPES
3489 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
3491 ignore_bfd_errors (s
)
3492 const char *s ATTRIBUTE_UNUSED
;
3495 /* Don't do anything. */
3498 /* Check that the architecture of all the input files is compatible
3499 with the output file. Also call the backend to let it do any
3500 other checking that is needed. */
3505 lang_statement_union_type
*file
;
3507 const bfd_arch_info_type
*compatible
;
3509 for (file
= file_chain
.head
;
3510 file
!= (lang_statement_union_type
*) NULL
;
3511 file
= file
->input_statement
.next
)
3513 input_bfd
= file
->input_statement
.the_bfd
;
3514 compatible
= bfd_arch_get_compatible (input_bfd
,
3516 if (compatible
== NULL
)
3518 if (command_line
.warn_mismatch
)
3519 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3520 bfd_printable_name (input_bfd
), input_bfd
,
3521 bfd_printable_name (output_bfd
));
3523 else if (link_info
.relocateable
3524 && bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
3525 einfo (_("%P%F: Relocatable linking from format %s (%B) to format %s (%B) is not supported\n"),
3526 bfd_get_target (input_bfd
), input_bfd
,
3527 bfd_get_target (output_bfd
), output_bfd
);
3528 else if (bfd_count_sections (input_bfd
))
3530 /* If the input bfd has no contents, it shouldn't set the
3531 private data of the output bfd. */
3533 bfd_error_handler_type pfn
= NULL
;
3535 /* If we aren't supposed to warn about mismatched input
3536 files, temporarily set the BFD error handler to a
3537 function which will do nothing. We still want to call
3538 bfd_merge_private_bfd_data, since it may set up
3539 information which is needed in the output file. */
3540 if (! command_line
.warn_mismatch
)
3541 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
3542 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
3544 if (command_line
.warn_mismatch
)
3545 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3548 if (! command_line
.warn_mismatch
)
3549 bfd_set_error_handler (pfn
);
3554 /* Look through all the global common symbols and attach them to the
3555 correct section. The -sort-common command line switch may be used
3556 to roughly sort the entries by size. */
3561 if (link_info
.relocateable
3562 && ! command_line
.force_common_definition
)
3565 if (! config
.sort_common
)
3566 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
3571 for (power
= 4; power
>= 0; power
--)
3572 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
3577 /* Place one common symbol in the correct section. */
3580 lang_one_common (h
, info
)
3581 struct bfd_link_hash_entry
*h
;
3584 unsigned int power_of_two
;
3587 unsigned opb
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
3588 ldfile_output_machine
);
3590 if (h
->type
!= bfd_link_hash_common
)
3594 power_of_two
= h
->u
.c
.p
->alignment_power
;
3596 if (config
.sort_common
3597 && power_of_two
< (unsigned int) *(int *) info
)
3600 section
= h
->u
.c
.p
->section
;
3602 /* Increase the size of the section. */
3603 section
->_cooked_size
= ALIGN_N ((section
->_cooked_size
+ opb
- 1) / opb
,
3604 (bfd_size_type
) (1 << power_of_two
)) * opb
;
3606 /* Adjust the alignment if necessary. */
3607 if (power_of_two
> section
->alignment_power
)
3608 section
->alignment_power
= power_of_two
;
3610 /* Change the symbol from common to defined. */
3611 h
->type
= bfd_link_hash_defined
;
3612 h
->u
.def
.section
= section
;
3613 h
->u
.def
.value
= section
->_cooked_size
;
3615 /* Increase the size of the section. */
3616 section
->_cooked_size
+= size
;
3618 /* Make sure the section is allocated in memory, and make sure that
3619 it is no longer a common section. */
3620 section
->flags
|= SEC_ALLOC
;
3621 section
->flags
&= ~SEC_IS_COMMON
;
3623 if (config
.map_file
!= NULL
)
3625 static boolean header_printed
;
3630 if (! header_printed
)
3632 minfo (_("\nAllocating common symbols\n"));
3633 minfo (_("Common symbol size file\n\n"));
3634 header_printed
= true;
3637 name
= demangle (h
->root
.string
);
3639 len
= strlen (name
);
3654 if (size
<= 0xffffffff)
3655 sprintf (buf
, "%lx", (unsigned long) size
);
3657 sprintf_vma (buf
, size
);
3667 minfo ("%B\n", section
->owner
);
3673 /* Run through the input files and ensure that every input section has
3674 somewhere to go. If one is found without a destination then create
3675 an input request and place it into the statement tree. */
3678 lang_place_orphans ()
3680 LANG_FOR_EACH_INPUT_STATEMENT (file
)
3684 for (s
= file
->the_bfd
->sections
;
3685 s
!= (asection
*) NULL
;
3688 if (s
->output_section
== (asection
*) NULL
)
3690 /* This section of the file is not attatched, root
3691 around for a sensible place for it to go. */
3693 if (file
->just_syms_flag
)
3695 /* We are only retrieving symbol values from this
3696 file. We want the symbols to act as though the
3697 values in the file are absolute. */
3698 s
->output_section
= bfd_abs_section_ptr
;
3699 s
->output_offset
= s
->vma
;
3701 else if (strcmp (s
->name
, "COMMON") == 0)
3703 /* This is a lonely common section which must have
3704 come from an archive. We attach to the section
3705 with the wildcard. */
3706 if (! link_info
.relocateable
3707 || command_line
.force_common_definition
)
3709 if (default_common_section
== NULL
)
3712 /* This message happens when using the
3713 svr3.ifile linker script, so I have
3715 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3717 default_common_section
=
3718 lang_output_section_statement_lookup (".bss");
3721 wild_doit (&default_common_section
->children
, s
,
3722 default_common_section
, file
);
3725 else if (ldemul_place_orphan (file
, s
))
3729 lang_output_section_statement_type
*os
=
3730 lang_output_section_statement_lookup (s
->name
);
3732 wild_doit (&os
->children
, s
, os
, file
);
3740 lang_set_flags (ptr
, flags
, invert
)
3741 lang_memory_region_type
*ptr
;
3745 flagword
*ptr_flags
;
3747 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
3753 *ptr_flags
|= SEC_ALLOC
;
3757 *ptr_flags
|= SEC_READONLY
;
3761 *ptr_flags
|= SEC_DATA
;
3765 *ptr_flags
|= SEC_CODE
;
3770 *ptr_flags
|= SEC_LOAD
;
3774 einfo (_("%P%F: invalid syntax in flags\n"));
3781 /* Call a function on each input file. This function will be called
3782 on an archive, but not on the elements. */
3785 lang_for_each_input_file (func
)
3786 void (*func
) PARAMS ((lang_input_statement_type
*));
3788 lang_input_statement_type
*f
;
3790 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
3792 f
= (lang_input_statement_type
*) f
->next_real_file
)
3796 /* Call a function on each file. The function will be called on all
3797 the elements of an archive which are included in the link, but will
3798 not be called on the archive file itself. */
3801 lang_for_each_file (func
)
3802 void (*func
) PARAMS ((lang_input_statement_type
*));
3804 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3815 lang_for_each_input_section (func
)
3816 void (*func
) PARAMS ((bfd
*ab
, asection
*as
));
3818 LANG_FOR_EACH_INPUT_STATEMENT (f
)
3822 for (s
= f
->the_bfd
->sections
;
3823 s
!= (asection
*) NULL
;
3826 func (f
->the_bfd
, s
);
3834 ldlang_add_file (entry
)
3835 lang_input_statement_type
*entry
;
3839 lang_statement_append (&file_chain
,
3840 (lang_statement_union_type
*) entry
,
3843 /* The BFD linker needs to have a list of all input BFDs involved in
3845 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
3846 ASSERT (entry
->the_bfd
!= output_bfd
);
3847 for (pp
= &link_info
.input_bfds
;
3848 *pp
!= (bfd
*) NULL
;
3849 pp
= &(*pp
)->link_next
)
3851 *pp
= entry
->the_bfd
;
3852 entry
->the_bfd
->usrdata
= (PTR
) entry
;
3853 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
3855 /* Look through the sections and check for any which should not be
3856 included in the link. We need to do this now, so that we can
3857 notice when the backend linker tries to report multiple
3858 definition errors for symbols which are in sections we aren't
3859 going to link. FIXME: It might be better to entirely ignore
3860 symbols which are defined in sections which are going to be
3861 discarded. This would require modifying the backend linker for
3862 each backend which might set the SEC_LINK_ONCE flag. If we do
3863 this, we should probably handle SEC_EXCLUDE in the same way. */
3865 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
3869 lang_add_output (name
, from_script
)
3873 /* Make -o on command line override OUTPUT in script. */
3874 if (had_output_filename
== false || !from_script
)
3876 output_filename
= name
;
3877 had_output_filename
= true;
3881 static lang_output_section_statement_type
*current_section
;
3893 for (l
= 0; l
< 32; l
++)
3895 if (i
>= (unsigned int) x
)
3903 lang_output_section_statement_type
*
3904 lang_enter_output_section_statement (output_section_statement_name
,
3905 address_exp
, sectype
, block_value
,
3906 align
, subalign
, ebase
)
3907 const char *output_section_statement_name
;
3908 etree_type
*address_exp
;
3909 enum section_type sectype
;
3910 bfd_vma block_value
;
3912 etree_type
*subalign
;
3915 lang_output_section_statement_type
*os
;
3919 lang_output_section_statement_lookup (output_section_statement_name
);
3921 /* Add this statement to tree. */
3923 add_statement (lang_output_section_statement_enum
,
3924 output_section_statement
);
3926 /* Make next things chain into subchain of this. */
3928 if (os
->addr_tree
== (etree_type
*) NULL
)
3930 os
->addr_tree
= address_exp
;
3932 os
->sectype
= sectype
;
3933 if (sectype
!= noload_section
)
3934 os
->flags
= SEC_NO_FLAGS
;
3936 os
->flags
= SEC_NEVER_LOAD
;
3937 os
->block_value
= block_value
? block_value
: 1;
3938 stat_ptr
= &os
->children
;
3940 os
->subsection_alignment
=
3941 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
3942 os
->section_alignment
=
3943 topower (exp_get_value_int (align
, -1, "section alignment", 0));
3945 os
->load_base
= ebase
;
3952 lang_output_statement_type
*new =
3953 new_stat (lang_output_statement
, stat_ptr
);
3955 new->name
= output_filename
;
3958 /* Reset the current counters in the regions. */
3961 reset_memory_regions ()
3963 lang_memory_region_type
*p
= lang_memory_region_list
;
3965 for (p
= lang_memory_region_list
;
3966 p
!= (lang_memory_region_type
*) NULL
;
3969 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
3970 p
->current
= p
->origin
;
3974 /* Expand a wild statement for a particular FILE, marking its sections KEEP
3975 as needed. SECTION may be NULL, in which case it is a wild card. */
3978 gc_section_callback (ptr
, section
, file
, data
)
3979 lang_wild_statement_type
*ptr
;
3981 lang_input_statement_type
*file ATTRIBUTE_UNUSED
;
3982 PTR data ATTRIBUTE_UNUSED
;
3984 /* If the wild pattern was marked KEEP, the member sections
3985 should be as well. */
3986 if (ptr
->keep_sections
)
3987 section
->flags
|= SEC_KEEP
;
3990 /* Handle a wild statement, marking it against GC. SECTION or FILE or both
3991 may be NULL, indicating that it is a wildcard. */
3994 lang_gc_wild (s
, section
, file
)
3995 lang_wild_statement_type
*s
;
3996 const char *section
;
3999 walk_wild (s
, section
, file
, gc_section_callback
, NULL
);
4002 /* Iterate over sections marking them against GC. */
4005 lang_gc_sections_1 (s
)
4006 lang_statement_union_type
*s
;
4008 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
4010 switch (s
->header
.type
)
4012 case lang_wild_statement_enum
:
4013 lang_gc_wild (&s
->wild_statement
,
4014 s
->wild_statement
.section_name
,
4015 s
->wild_statement
.filename
);
4017 case lang_constructors_statement_enum
:
4018 lang_gc_sections_1 (constructor_list
.head
);
4020 case lang_output_section_statement_enum
:
4021 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4023 case lang_group_statement_enum
:
4024 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4035 struct bfd_link_hash_entry
*h
;
4036 ldlang_undef_chain_list_type
*ulist
, fake_list_start
;
4038 /* Keep all sections so marked in the link script. */
4040 lang_gc_sections_1 (statement_list
.head
);
4042 /* Keep all sections containing symbols undefined on the command-line.
4043 Handle the entry symbol at the same time. */
4045 if (entry_symbol
!= NULL
)
4047 fake_list_start
.next
= ldlang_undef_chain_list_head
;
4048 fake_list_start
.name
= (char *) entry_symbol
;
4049 ulist
= &fake_list_start
;
4052 ulist
= ldlang_undef_chain_list_head
;
4054 for (; ulist
; ulist
= ulist
->next
)
4056 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4057 false, false, false);
4059 if (h
!= (struct bfd_link_hash_entry
*) NULL
4060 && (h
->type
== bfd_link_hash_defined
4061 || h
->type
== bfd_link_hash_defweak
)
4062 && ! bfd_is_abs_section (h
->u
.def
.section
))
4064 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4068 bfd_gc_sections (output_bfd
, &link_info
);
4074 lang_reasonable_defaults ();
4075 current_target
= default_target
;
4077 /* Open the output file. */
4078 lang_for_each_statement (ldlang_open_output
);
4080 ldemul_create_output_section_statements ();
4082 /* Add to the hash table all undefineds on the command line. */
4083 lang_place_undefineds ();
4085 already_linked_table_init ();
4087 /* Create a bfd for each input file. */
4088 current_target
= default_target
;
4089 open_input_bfds (statement_list
.head
, false);
4091 ldemul_after_open ();
4093 already_linked_table_free ();
4095 /* Make sure that we're not mixing architectures. We call this
4096 after all the input files have been opened, but before we do any
4097 other processing, so that any operations merge_private_bfd_data
4098 does on the output file will be known during the rest of the
4102 /* Handle .exports instead of a version script if we're told to do so. */
4103 if (command_line
.version_exports_section
)
4104 lang_do_version_exports_section ();
4106 /* Build all sets based on the information gathered from the input
4108 ldctor_build_sets ();
4110 /* Remove unreferenced sections if asked to. */
4111 if (command_line
.gc_sections
)
4112 lang_gc_sections ();
4114 /* If there were any SEC_MERGE sections, finish their merging, so that
4115 section sizes can be computed. This has to be done after GC of sections,
4116 so that GCed sections are not merged, but before assigning output
4117 sections, since removing whole input sections is hard then. */
4118 bfd_merge_sections (output_bfd
, &link_info
);
4120 /* Size up the common data. */
4123 /* Run through the contours of the script and attach input sections
4124 to the correct output sections. */
4125 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
4126 (lang_output_section_statement_type
*) NULL
);
4128 /* Find any sections not attached explicitly and handle them. */
4129 lang_place_orphans ();
4131 ldemul_before_allocation ();
4133 /* We must record the program headers before we try to fix the
4134 section positions, since they will affect SIZEOF_HEADERS. */
4135 lang_record_phdrs ();
4137 /* Now run around and relax if we can. */
4138 if (command_line
.relax
)
4140 /* First time round is a trial run to get the 'worst case'
4141 addresses of the objects if there was no relaxing. */
4142 lang_size_sections (statement_list
.head
,
4144 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
4146 /* Keep relaxing until bfd_relax_section gives up. */
4149 reset_memory_regions ();
4151 relax_again
= false;
4153 /* Note: pe-dll.c does something like this also. If you find
4154 you need to change this code, you probably need to change
4155 pe-dll.c also. DJ */
4157 /* Do all the assignments with our current guesses as to
4159 lang_do_assignments (statement_list
.head
,
4161 (fill_type
) 0, (bfd_vma
) 0);
4163 /* Perform another relax pass - this time we know where the
4164 globals are, so can make better guess. */
4165 lang_size_sections (statement_list
.head
,
4167 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
4169 while (relax_again
);
4173 /* Size up the sections. */
4174 lang_size_sections (statement_list
.head
,
4176 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
4179 /* See if anything special should be done now we know how big
4181 ldemul_after_allocation ();
4183 /* Fix any .startof. or .sizeof. symbols. */
4184 lang_set_startof ();
4186 /* Do all the assignments, now that we know the final resting places
4187 of all the symbols. */
4189 lang_do_assignments (statement_list
.head
,
4191 (fill_type
) 0, (bfd_vma
) 0);
4193 /* Make sure that the section addresses make sense. */
4194 if (! link_info
.relocateable
4195 && command_line
.check_section_addresses
)
4196 lang_check_section_addresses ();
4204 /* EXPORTED TO YACC */
4207 lang_add_wild (section_name
, sections_sorted
, filename
, filenames_sorted
,
4208 keep_sections
, exclude_filename_list
)
4209 const char *const section_name
;
4210 boolean sections_sorted
;
4211 const char *const filename
;
4212 boolean filenames_sorted
;
4213 boolean keep_sections
;
4214 struct name_list
*exclude_filename_list
;
4216 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
4219 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
4221 placed_commons
= true;
4223 if (filename
!= NULL
&& ! wildcardp (filename
))
4225 lang_has_input_file
= true;
4227 new->section_name
= section_name
;
4228 new->sections_sorted
= sections_sorted
;
4229 new->filename
= filename
;
4230 new->filenames_sorted
= filenames_sorted
;
4231 new->keep_sections
= keep_sections
;
4232 new->exclude_filename_list
= exclude_filename_list
;
4233 lang_list_init (&new->children
);
4237 lang_section_start (name
, address
)
4239 etree_type
*address
;
4241 lang_address_statement_type
*ad
;
4243 ad
= new_stat (lang_address_statement
, stat_ptr
);
4244 ad
->section_name
= name
;
4245 ad
->address
= address
;
4248 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4249 because of a -e argument on the command line, or zero if this is
4250 called by ENTRY in a linker script. Command line arguments take
4254 lang_add_entry (name
, cmdline
)
4258 if (entry_symbol
== NULL
4260 || ! entry_from_cmdline
)
4262 entry_symbol
= name
;
4263 entry_from_cmdline
= cmdline
;
4268 lang_add_target (name
)
4271 lang_target_statement_type
*new = new_stat (lang_target_statement
,
4287 map_option_f
= true;
4298 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
4305 lang_add_data (type
, exp
)
4307 union etree_union
*exp
;
4310 lang_data_statement_type
*new = new_stat (lang_data_statement
,
4318 /* Create a new reloc statement. RELOC is the BFD relocation type to
4319 generate. HOWTO is the corresponding howto structure (we could
4320 look this up, but the caller has already done so). SECTION is the
4321 section to generate a reloc against, or NAME is the name of the
4322 symbol to generate a reloc against. Exactly one of SECTION and
4323 NAME must be NULL. ADDEND is an expression for the addend. */
4326 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
4327 bfd_reloc_code_real_type reloc
;
4328 reloc_howto_type
*howto
;
4331 union etree_union
*addend
;
4333 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
4337 p
->section
= section
;
4339 p
->addend_exp
= addend
;
4341 p
->addend_value
= 0;
4342 p
->output_section
= NULL
;
4346 lang_assignment_statement_type
*
4347 lang_add_assignment (exp
)
4350 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
4358 lang_add_attribute (attribute
)
4359 enum statement_enum attribute
;
4361 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
4368 if (startup_file
!= (char *) NULL
)
4370 einfo (_("%P%Fmultiple STARTUP files\n"));
4372 first_file
->filename
= name
;
4373 first_file
->local_sym_name
= name
;
4374 first_file
->real
= true;
4376 startup_file
= name
;
4383 lang_float_flag
= maybe
;
4387 lang_leave_output_section_statement (fill
, memspec
, phdrs
, lma_memspec
)
4389 const char *memspec
;
4390 struct lang_output_section_phdr_list
*phdrs
;
4391 const char *lma_memspec
;
4393 current_section
->fill
= fill
;
4394 current_section
->region
= lang_memory_region_lookup (memspec
);
4395 if (strcmp (lma_memspec
, "*default*") != 0)
4397 current_section
->lma_region
= lang_memory_region_lookup (lma_memspec
);
4398 /* If no runtime region has been given, but the load region has
4399 been, use the load region. */
4400 if (strcmp (memspec
, "*default*") == 0)
4401 current_section
->region
= lang_memory_region_lookup (lma_memspec
);
4403 current_section
->phdrs
= phdrs
;
4404 stat_ptr
= &statement_list
;
4407 /* Create an absolute symbol with the given name with the value of the
4408 address of first byte of the section named.
4410 If the symbol already exists, then do nothing. */
4413 lang_abs_symbol_at_beginning_of (secname
, name
)
4414 const char *secname
;
4417 struct bfd_link_hash_entry
*h
;
4419 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4420 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4421 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4423 if (h
->type
== bfd_link_hash_new
4424 || h
->type
== bfd_link_hash_undefined
)
4428 h
->type
= bfd_link_hash_defined
;
4430 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4431 if (sec
== (asection
*) NULL
)
4434 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
4436 h
->u
.def
.section
= bfd_abs_section_ptr
;
4440 /* Create an absolute symbol with the given name with the value of the
4441 address of the first byte after the end of the section named.
4443 If the symbol already exists, then do nothing. */
4446 lang_abs_symbol_at_end_of (secname
, name
)
4447 const char *secname
;
4450 struct bfd_link_hash_entry
*h
;
4452 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
4453 if (h
== (struct bfd_link_hash_entry
*) NULL
)
4454 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4456 if (h
->type
== bfd_link_hash_new
4457 || h
->type
== bfd_link_hash_undefined
)
4461 h
->type
= bfd_link_hash_defined
;
4463 sec
= bfd_get_section_by_name (output_bfd
, secname
);
4464 if (sec
== (asection
*) NULL
)
4467 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
4468 + bfd_section_size (output_bfd
, sec
) /
4469 bfd_octets_per_byte (output_bfd
));
4471 h
->u
.def
.section
= bfd_abs_section_ptr
;
4476 lang_statement_append (list
, element
, field
)
4477 lang_statement_list_type
*list
;
4478 lang_statement_union_type
*element
;
4479 lang_statement_union_type
**field
;
4481 *(list
->tail
) = element
;
4485 /* Set the output format type. -oformat overrides scripts. */
4488 lang_add_output_format (format
, big
, little
, from_script
)
4494 if (output_target
== NULL
|| !from_script
)
4496 if (command_line
.endian
== ENDIAN_BIG
4499 else if (command_line
.endian
== ENDIAN_LITTLE
4503 output_target
= format
;
4507 /* Enter a group. This creates a new lang_group_statement, and sets
4508 stat_ptr to build new statements within the group. */
4513 lang_group_statement_type
*g
;
4515 g
= new_stat (lang_group_statement
, stat_ptr
);
4516 lang_list_init (&g
->children
);
4517 stat_ptr
= &g
->children
;
4520 /* Leave a group. This just resets stat_ptr to start writing to the
4521 regular list of statements again. Note that this will not work if
4522 groups can occur inside anything else which can adjust stat_ptr,
4523 but currently they can't. */
4528 stat_ptr
= &statement_list
;
4531 /* Add a new program header. This is called for each entry in a PHDRS
4532 command in a linker script. */
4535 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
4543 struct lang_phdr
*n
, **pp
;
4545 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
4548 n
->type
= exp_get_value_int (type
, 0, "program header type",
4549 lang_final_phase_enum
);
4550 n
->filehdr
= filehdr
;
4555 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
4560 /* Record the program header information in the output BFD. FIXME: We
4561 should not be calling an ELF specific function here. */
4564 lang_record_phdrs ()
4568 struct lang_output_section_phdr_list
*last
;
4569 struct lang_phdr
*l
;
4570 lang_statement_union_type
*u
;
4573 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
4575 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
4582 for (u
= lang_output_section_statement
.head
;
4584 u
= u
->output_section_statement
.next
)
4586 lang_output_section_statement_type
*os
;
4587 struct lang_output_section_phdr_list
*pl
;
4589 os
= &u
->output_section_statement
;
4596 if (os
->sectype
== noload_section
4597 || os
->bfd_section
== NULL
4598 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
4603 if (os
->bfd_section
== NULL
)
4606 for (; pl
!= NULL
; pl
= pl
->next
)
4608 if (strcmp (pl
->name
, l
->name
) == 0)
4613 secs
= ((asection
**)
4614 xrealloc (secs
, alc
* sizeof (asection
*)));
4616 secs
[c
] = os
->bfd_section
;
4623 if (l
->flags
== NULL
)
4626 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
4627 lang_final_phase_enum
);
4632 at
= exp_get_vma (l
->at
, 0, "phdr load address",
4633 lang_final_phase_enum
);
4635 if (! bfd_record_phdr (output_bfd
, l
->type
,
4636 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
4637 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
4638 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4643 /* Make sure all the phdr assignments succeeded. */
4644 for (u
= lang_output_section_statement
.head
;
4646 u
= u
->output_section_statement
.next
)
4648 struct lang_output_section_phdr_list
*pl
;
4650 if (u
->output_section_statement
.bfd_section
== NULL
)
4653 for (pl
= u
->output_section_statement
.phdrs
;
4656 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
4657 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4658 u
->output_section_statement
.name
, pl
->name
);
4662 /* Record a list of sections which may not be cross referenced. */
4665 lang_add_nocrossref (l
)
4666 struct lang_nocrossref
*l
;
4668 struct lang_nocrossrefs
*n
;
4670 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
4671 n
->next
= nocrossref_list
;
4673 nocrossref_list
= n
;
4675 /* Set notice_all so that we get informed about all symbols. */
4676 link_info
.notice_all
= true;
4679 /* Overlay handling. We handle overlays with some static variables. */
4681 /* The overlay virtual address. */
4682 static etree_type
*overlay_vma
;
4684 /* The overlay load address. */
4685 static etree_type
*overlay_lma
;
4687 /* Whether nocrossrefs is set for this overlay. */
4688 static int overlay_nocrossrefs
;
4690 /* An expression for the maximum section size seen so far. */
4691 static etree_type
*overlay_max
;
4693 /* A list of all the sections in this overlay. */
4695 struct overlay_list
{
4696 struct overlay_list
*next
;
4697 lang_output_section_statement_type
*os
;
4700 static struct overlay_list
*overlay_list
;
4702 /* Start handling an overlay. */
4705 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
4706 etree_type
*vma_expr
;
4707 etree_type
*lma_expr
;
4710 /* The grammar should prevent nested overlays from occurring. */
4711 ASSERT (overlay_vma
== NULL
4712 && overlay_lma
== NULL
4713 && overlay_list
== NULL
4714 && overlay_max
== NULL
);
4716 overlay_vma
= vma_expr
;
4717 overlay_lma
= lma_expr
;
4718 overlay_nocrossrefs
= nocrossrefs
;
4721 /* Start a section in an overlay. We handle this by calling
4722 lang_enter_output_section_statement with the correct VMA and LMA. */
4725 lang_enter_overlay_section (name
)
4728 struct overlay_list
*n
;
4731 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
4732 0, 0, 0, overlay_lma
);
4734 /* If this is the first section, then base the VMA and LMA of future
4735 sections on this one. This will work correctly even if `.' is
4736 used in the addresses. */
4737 if (overlay_list
== NULL
)
4739 overlay_vma
= exp_nameop (ADDR
, name
);
4740 overlay_lma
= exp_nameop (LOADADDR
, name
);
4743 /* Remember the section. */
4744 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
4745 n
->os
= current_section
;
4746 n
->next
= overlay_list
;
4749 size
= exp_nameop (SIZEOF
, name
);
4751 /* Adjust the LMA for the next section. */
4752 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
4754 /* Arrange to work out the maximum section end address. */
4755 if (overlay_max
== NULL
)
4758 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
4761 /* Finish a section in an overlay. There isn't any special to do
4765 lang_leave_overlay_section (fill
, phdrs
)
4767 struct lang_output_section_phdr_list
*phdrs
;
4774 name
= current_section
->name
;
4776 lang_leave_output_section_statement (fill
, "*default*",
4777 phdrs
, "*default*");
4779 /* Define the magic symbols. */
4781 clean
= xmalloc (strlen (name
) + 1);
4783 for (s1
= name
; *s1
!= '\0'; s1
++)
4784 if (isalnum ((unsigned char) *s1
) || *s1
== '_')
4788 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
4789 sprintf (buf
, "__load_start_%s", clean
);
4790 lang_add_assignment (exp_assop ('=', buf
,
4791 exp_nameop (LOADADDR
, name
)));
4793 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
4794 sprintf (buf
, "__load_stop_%s", clean
);
4795 lang_add_assignment (exp_assop ('=', buf
,
4797 exp_nameop (LOADADDR
, name
),
4798 exp_nameop (SIZEOF
, name
))));
4803 /* Finish an overlay. If there are any overlay wide settings, this
4804 looks through all the sections in the overlay and sets them. */
4807 lang_leave_overlay (fill
, memspec
, phdrs
, lma_memspec
)
4809 const char *memspec
;
4810 struct lang_output_section_phdr_list
*phdrs
;
4811 const char *lma_memspec
;
4813 lang_memory_region_type
*region
;
4814 lang_memory_region_type
*lma_region
;
4815 struct overlay_list
*l
;
4816 struct lang_nocrossref
*nocrossref
;
4818 if (memspec
== NULL
)
4821 region
= lang_memory_region_lookup (memspec
);
4823 if (lma_memspec
== NULL
)
4826 lma_region
= lang_memory_region_lookup (lma_memspec
);
4833 struct overlay_list
*next
;
4835 if (fill
!= 0 && l
->os
->fill
== 0)
4837 if (region
!= NULL
&& l
->os
->region
== NULL
)
4838 l
->os
->region
= region
;
4839 /* We only set lma_region for the first overlay section, as
4840 subsequent overlay sections will have load_base set relative
4841 to the first section. Also, don't set lma_region if
4842 load_base is specified. FIXME: There should really be a test
4843 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4844 rather than letting LDADDR simply override LMA_REGION. */
4845 if (lma_region
!= NULL
&& l
->os
->lma_region
== NULL
4846 && l
->next
== NULL
&& l
->os
->load_base
== NULL
)
4847 l
->os
->lma_region
= lma_region
;
4848 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
4849 l
->os
->phdrs
= phdrs
;
4851 if (overlay_nocrossrefs
)
4853 struct lang_nocrossref
*nc
;
4855 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
4856 nc
->name
= l
->os
->name
;
4857 nc
->next
= nocrossref
;
4866 if (nocrossref
!= NULL
)
4867 lang_add_nocrossref (nocrossref
);
4869 /* Update . for the end of the overlay. */
4870 lang_add_assignment (exp_assop ('=', ".",
4871 exp_binop ('+', overlay_vma
, overlay_max
)));
4875 overlay_nocrossrefs
= 0;
4876 overlay_list
= NULL
;
4880 /* Version handling. This is only useful for ELF. */
4882 /* This global variable holds the version tree that we build. */
4884 struct bfd_elf_version_tree
*lang_elf_version_info
;
4887 lang_vers_match_lang_c (expr
, sym
)
4888 struct bfd_elf_version_expr
*expr
;
4891 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4893 return fnmatch (expr
->pattern
, sym
, 0) == 0;
4897 lang_vers_match_lang_cplusplus (expr
, sym
)
4898 struct bfd_elf_version_expr
*expr
;
4904 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4907 alt_sym
= cplus_demangle (sym
, /* DMGL_NO_TPARAMS */ 0);
4910 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4911 Should we early out false in this case? */
4912 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4916 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4924 lang_vers_match_lang_java (expr
, sym
)
4925 struct bfd_elf_version_expr
*expr
;
4931 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
4934 alt_sym
= cplus_demangle (sym
, DMGL_JAVA
);
4937 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4938 Should we early out false in this case? */
4939 result
= fnmatch (expr
->pattern
, sym
, 0) == 0;
4943 result
= fnmatch (expr
->pattern
, alt_sym
, 0) == 0;
4950 /* This is called for each variable name or match expression. */
4952 struct bfd_elf_version_expr
*
4953 lang_new_vers_regex (orig
, new, lang
)
4954 struct bfd_elf_version_expr
*orig
;
4958 struct bfd_elf_version_expr
*ret
;
4960 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
4964 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
4965 ret
->match
= lang_vers_match_lang_c
;
4966 else if (strcasecmp (lang
, "C++") == 0)
4967 ret
->match
= lang_vers_match_lang_cplusplus
;
4968 else if (strcasecmp (lang
, "Java") == 0)
4969 ret
->match
= lang_vers_match_lang_java
;
4972 einfo (_("%X%P: unknown language `%s' in version information\n"),
4974 ret
->match
= lang_vers_match_lang_c
;
4980 /* This is called for each set of variable names and match
4983 struct bfd_elf_version_tree
*
4984 lang_new_vers_node (globals
, locals
)
4985 struct bfd_elf_version_expr
*globals
;
4986 struct bfd_elf_version_expr
*locals
;
4988 struct bfd_elf_version_tree
*ret
;
4990 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
4994 ret
->globals
= globals
;
4995 ret
->locals
= locals
;
4997 ret
->name_indx
= (unsigned int) -1;
5002 /* This static variable keeps track of version indices. */
5004 static int version_index
;
5006 /* This is called when we know the name and dependencies of the
5010 lang_register_vers_node (name
, version
, deps
)
5012 struct bfd_elf_version_tree
*version
;
5013 struct bfd_elf_version_deps
*deps
;
5015 struct bfd_elf_version_tree
*t
, **pp
;
5016 struct bfd_elf_version_expr
*e1
;
5018 /* Make sure this node has a unique name. */
5019 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5020 if (strcmp (t
->name
, name
) == 0)
5021 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5023 /* Check the global and local match names, and make sure there
5024 aren't any duplicates. */
5026 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
5028 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5030 struct bfd_elf_version_expr
*e2
;
5032 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
5033 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5034 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5039 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
5041 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5043 struct bfd_elf_version_expr
*e2
;
5045 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
5046 if (strcmp (e1
->pattern
, e2
->pattern
) == 0)
5047 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5052 version
->deps
= deps
;
5053 version
->name
= name
;
5055 version
->vernum
= version_index
;
5057 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5062 /* This is called when we see a version dependency. */
5064 struct bfd_elf_version_deps
*
5065 lang_add_vers_depend (list
, name
)
5066 struct bfd_elf_version_deps
*list
;
5069 struct bfd_elf_version_deps
*ret
;
5070 struct bfd_elf_version_tree
*t
;
5072 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
5075 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5077 if (strcmp (t
->name
, name
) == 0)
5079 ret
->version_needed
= t
;
5084 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
5090 lang_do_version_exports_section ()
5092 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
5094 LANG_FOR_EACH_INPUT_STATEMENT (is
)
5096 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
5103 len
= bfd_section_size (is
->the_bfd
, sec
);
5104 contents
= xmalloc (len
);
5105 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
5106 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
5109 while (p
< contents
+ len
)
5111 greg
= lang_new_vers_regex (greg
, p
, NULL
);
5112 p
= strchr (p
, '\0') + 1;
5115 /* Do not free the contents, as we used them creating the regex. */
5117 /* Do not include this section in the link. */
5118 bfd_set_section_flags (is
->the_bfd
, sec
,
5119 bfd_get_section_flags (is
->the_bfd
, sec
) | SEC_EXCLUDE
);
5122 lreg
= lang_new_vers_regex (NULL
, "*", NULL
);
5123 lang_register_vers_node (command_line
.version_exports_section
,
5124 lang_new_vers_node (greg
, lreg
), NULL
);
5128 lang_add_unique (name
)
5131 struct unique_sections
*ent
;
5133 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
5134 if (strcmp (ent
->name
, name
) == 0)
5137 ent
= (struct unique_sections
*) xmalloc (sizeof *ent
);
5138 ent
->name
= xstrdup (name
);
5139 ent
->next
= unique_section_list
;
5140 unique_section_list
= ent
;