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"
26 #include "safe-ctype.h"
45 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
48 /* Locals variables. */
49 static struct obstack stat_obstack
;
50 static struct obstack map_obstack
;
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
54 static const char *startup_file
;
55 static lang_statement_list_type input_file_chain
;
56 static bfd_boolean placed_commons
= FALSE
;
57 static lang_output_section_statement_type
*default_common_section
;
58 static bfd_boolean map_option_f
;
59 static bfd_vma print_dot
;
60 static lang_input_statement_type
*first_file
;
61 static const char *current_target
;
62 static const char *output_target
;
63 static lang_statement_list_type statement_list
;
64 static struct lang_phdr
*lang_phdr_list
;
65 static struct bfd_hash_table lang_definedness_table
;
67 /* Forward declarations. */
68 static void exp_init_os (etree_type
*);
69 static void init_map_userdata (bfd
*, asection
*, void *);
70 static lang_input_statement_type
*lookup_name (const char *);
71 static bfd_boolean
load_symbols (lang_input_statement_type
*,
72 lang_statement_list_type
*);
73 static struct bfd_hash_entry
*lang_definedness_newfunc
74 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
75 static void insert_undefined (const char *);
76 static void print_all_symbols (asection
*);
77 static bfd_boolean
sort_def_symbol (struct bfd_link_hash_entry
*, void *);
78 static void print_statement (lang_statement_union_type
*,
79 lang_output_section_statement_type
*);
80 static void print_statement_list (lang_statement_union_type
*,
81 lang_output_section_statement_type
*);
82 static void print_statements (void);
83 static bfd_boolean
lang_one_common (struct bfd_link_hash_entry
*, void *);
84 static void lang_record_phdrs (void);
85 static void lang_do_version_exports_section (void);
87 typedef void (*callback_t
) (lang_wild_statement_type
*, struct wildcard_list
*,
88 asection
*, lang_input_statement_type
*, void *);
90 /* Exported variables. */
91 lang_output_section_statement_type
*abs_output_section
;
92 lang_statement_list_type lang_output_section_statement
;
93 lang_statement_list_type
*stat_ptr
= &statement_list
;
94 lang_statement_list_type file_chain
= { NULL
, NULL
};
95 struct bfd_sym_chain entry_symbol
= { NULL
, NULL
};
96 const char *entry_section
= ".text";
97 bfd_boolean entry_from_cmdline
;
98 bfd_boolean lang_has_input_file
= FALSE
;
99 bfd_boolean had_output_filename
= FALSE
;
100 bfd_boolean lang_float_flag
= FALSE
;
101 bfd_boolean delete_output_file_on_failure
= FALSE
;
102 struct lang_nocrossrefs
*nocrossref_list
;
103 struct unique_sections
*unique_section_list
;
104 static bfd_boolean ldlang_sysrooted_script
= FALSE
;
105 int lang_statement_iteration
= 0;
107 etree_type
*base
; /* Relocation base - or null */
109 /* Return TRUE if the PATTERN argument is a wildcard pattern.
110 Although backslashes are treated specially if a pattern contains
111 wildcards, we do not consider the mere presence of a backslash to
112 be enough to cause the pattern to be treated as a wildcard.
113 That lets us handle DOS filenames more naturally. */
114 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
116 #define new_stat(x, y) \
117 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
119 #define outside_section_address(q) \
120 ((q)->output_offset + (q)->output_section->vma)
122 #define outside_symbol_address(q) \
123 ((q)->value + outside_section_address (q->section))
125 #define SECTION_NAME_MAP_LENGTH (16)
128 stat_alloc (size_t size
)
130 return obstack_alloc (&stat_obstack
, size
);
134 unique_section_p (const asection
*sec
)
136 struct unique_sections
*unam
;
139 if (link_info
.relocatable
140 && sec
->owner
!= NULL
141 && bfd_is_group_section (sec
->owner
, sec
))
145 for (unam
= unique_section_list
; unam
; unam
= unam
->next
)
146 if (wildcardp (unam
->name
)
147 ? fnmatch (unam
->name
, secnam
, 0) == 0
148 : strcmp (unam
->name
, secnam
) == 0)
156 /* Generic traversal routines for finding matching sections. */
159 walk_wild_section (lang_wild_statement_type
*ptr
,
160 lang_input_statement_type
*file
,
166 if (file
->just_syms_flag
)
169 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
171 struct wildcard_list
*sec
;
173 sec
= ptr
->section_list
;
175 (*callback
) (ptr
, sec
, s
, file
, data
);
179 bfd_boolean skip
= FALSE
;
180 struct name_list
*list_tmp
;
182 /* Don't process sections from files which were
184 for (list_tmp
= sec
->spec
.exclude_name_list
;
186 list_tmp
= list_tmp
->next
)
188 if (wildcardp (list_tmp
->name
))
189 skip
= fnmatch (list_tmp
->name
, file
->filename
, 0) == 0;
191 skip
= strcmp (list_tmp
->name
, file
->filename
) == 0;
193 /* If this file is part of an archive, and the archive is
194 excluded, exclude this file. */
195 if (! skip
&& file
->the_bfd
!= NULL
196 && file
->the_bfd
->my_archive
!= NULL
197 && file
->the_bfd
->my_archive
->filename
!= NULL
)
199 if (wildcardp (list_tmp
->name
))
200 skip
= fnmatch (list_tmp
->name
,
201 file
->the_bfd
->my_archive
->filename
,
204 skip
= strcmp (list_tmp
->name
,
205 file
->the_bfd
->my_archive
->filename
) == 0;
212 if (!skip
&& sec
->spec
.name
!= NULL
)
214 const char *sname
= bfd_get_section_name (file
->the_bfd
, s
);
216 if (wildcardp (sec
->spec
.name
))
217 skip
= fnmatch (sec
->spec
.name
, sname
, 0) != 0;
219 skip
= strcmp (sec
->spec
.name
, sname
) != 0;
223 (*callback
) (ptr
, sec
, s
, file
, data
);
230 /* Handle a wild statement for a single file F. */
233 walk_wild_file (lang_wild_statement_type
*s
,
234 lang_input_statement_type
*f
,
238 if (f
->the_bfd
== NULL
239 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
240 walk_wild_section (s
, f
, callback
, data
);
245 /* This is an archive file. We must map each member of the
246 archive separately. */
247 member
= bfd_openr_next_archived_file (f
->the_bfd
, NULL
);
248 while (member
!= NULL
)
250 /* When lookup_name is called, it will call the add_symbols
251 entry point for the archive. For each element of the
252 archive which is included, BFD will call ldlang_add_file,
253 which will set the usrdata field of the member to the
254 lang_input_statement. */
255 if (member
->usrdata
!= NULL
)
257 walk_wild_section (s
, member
->usrdata
, callback
, data
);
260 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
266 walk_wild (lang_wild_statement_type
*s
, callback_t callback
, void *data
)
268 const char *file_spec
= s
->filename
;
270 if (file_spec
== NULL
)
272 /* Perform the iteration over all files in the list. */
273 LANG_FOR_EACH_INPUT_STATEMENT (f
)
275 walk_wild_file (s
, f
, callback
, data
);
278 else if (wildcardp (file_spec
))
280 LANG_FOR_EACH_INPUT_STATEMENT (f
)
282 if (fnmatch (file_spec
, f
->filename
, FNM_FILE_NAME
) == 0)
283 walk_wild_file (s
, f
, callback
, data
);
288 lang_input_statement_type
*f
;
290 /* Perform the iteration over a single file. */
291 f
= lookup_name (file_spec
);
293 walk_wild_file (s
, f
, callback
, data
);
297 /* lang_for_each_statement walks the parse tree and calls the provided
298 function for each node. */
301 lang_for_each_statement_worker (void (*func
) (lang_statement_union_type
*),
302 lang_statement_union_type
*s
)
304 for (; s
!= NULL
; s
= s
->header
.next
)
308 switch (s
->header
.type
)
310 case lang_constructors_statement_enum
:
311 lang_for_each_statement_worker (func
, constructor_list
.head
);
313 case lang_output_section_statement_enum
:
314 lang_for_each_statement_worker
315 (func
, s
->output_section_statement
.children
.head
);
317 case lang_wild_statement_enum
:
318 lang_for_each_statement_worker (func
,
319 s
->wild_statement
.children
.head
);
321 case lang_group_statement_enum
:
322 lang_for_each_statement_worker (func
,
323 s
->group_statement
.children
.head
);
325 case lang_data_statement_enum
:
326 case lang_reloc_statement_enum
:
327 case lang_object_symbols_statement_enum
:
328 case lang_output_statement_enum
:
329 case lang_target_statement_enum
:
330 case lang_input_section_enum
:
331 case lang_input_statement_enum
:
332 case lang_assignment_statement_enum
:
333 case lang_padding_statement_enum
:
334 case lang_address_statement_enum
:
335 case lang_fill_statement_enum
:
345 lang_for_each_statement (void (*func
) (lang_statement_union_type
*))
347 lang_for_each_statement_worker (func
, statement_list
.head
);
350 /*----------------------------------------------------------------------*/
353 lang_list_init (lang_statement_list_type
*list
)
356 list
->tail
= &list
->head
;
359 /* Build a new statement node for the parse tree. */
361 static lang_statement_union_type
*
362 new_statement (enum statement_enum type
,
364 lang_statement_list_type
*list
)
366 lang_statement_union_type
*new;
368 new = stat_alloc (size
);
369 new->header
.type
= type
;
370 new->header
.next
= NULL
;
371 lang_statement_append (list
, new, &new->header
.next
);
375 /* Build a new input file node for the language. There are several
376 ways in which we treat an input file, eg, we only look at symbols,
377 or prefix it with a -l etc.
379 We can be supplied with requests for input files more than once;
380 they may, for example be split over several lines like foo.o(.text)
381 foo.o(.data) etc, so when asked for a file we check that we haven't
382 got it already so we don't duplicate the bfd. */
384 static lang_input_statement_type
*
385 new_afile (const char *name
,
386 lang_input_file_enum_type file_type
,
388 bfd_boolean add_to_list
)
390 lang_input_statement_type
*p
;
393 p
= new_stat (lang_input_statement
, stat_ptr
);
396 p
= stat_alloc (sizeof (lang_input_statement_type
));
397 p
->header
.next
= NULL
;
400 lang_has_input_file
= TRUE
;
402 p
->sysrooted
= FALSE
;
405 case lang_input_file_is_symbols_only_enum
:
407 p
->is_archive
= FALSE
;
409 p
->local_sym_name
= name
;
410 p
->just_syms_flag
= TRUE
;
411 p
->search_dirs_flag
= FALSE
;
413 case lang_input_file_is_fake_enum
:
415 p
->is_archive
= FALSE
;
417 p
->local_sym_name
= name
;
418 p
->just_syms_flag
= FALSE
;
419 p
->search_dirs_flag
= FALSE
;
421 case lang_input_file_is_l_enum
:
422 p
->is_archive
= TRUE
;
425 p
->local_sym_name
= concat ("-l", name
, NULL
);
426 p
->just_syms_flag
= FALSE
;
427 p
->search_dirs_flag
= TRUE
;
429 case lang_input_file_is_marker_enum
:
431 p
->is_archive
= FALSE
;
433 p
->local_sym_name
= name
;
434 p
->just_syms_flag
= FALSE
;
435 p
->search_dirs_flag
= TRUE
;
437 case lang_input_file_is_search_file_enum
:
438 p
->sysrooted
= ldlang_sysrooted_script
;
440 p
->is_archive
= FALSE
;
442 p
->local_sym_name
= name
;
443 p
->just_syms_flag
= FALSE
;
444 p
->search_dirs_flag
= TRUE
;
446 case lang_input_file_is_file_enum
:
448 p
->is_archive
= FALSE
;
450 p
->local_sym_name
= name
;
451 p
->just_syms_flag
= FALSE
;
452 p
->search_dirs_flag
= FALSE
;
459 p
->next_real_file
= NULL
;
462 p
->dynamic
= config
.dynamic_link
;
463 p
->add_needed
= add_needed
;
464 p
->as_needed
= as_needed
;
465 p
->whole_archive
= whole_archive
;
467 lang_statement_append (&input_file_chain
,
468 (lang_statement_union_type
*) p
,
473 lang_input_statement_type
*
474 lang_add_input_file (const char *name
,
475 lang_input_file_enum_type file_type
,
478 lang_has_input_file
= TRUE
;
479 return new_afile (name
, file_type
, target
, TRUE
);
482 /* Build enough state so that the parser can build its tree. */
487 obstack_begin (&stat_obstack
, 1000);
489 stat_ptr
= &statement_list
;
491 lang_list_init (stat_ptr
);
493 lang_list_init (&input_file_chain
);
494 lang_list_init (&lang_output_section_statement
);
495 lang_list_init (&file_chain
);
496 first_file
= lang_add_input_file (NULL
, lang_input_file_is_marker_enum
,
499 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
501 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
503 /* The value "3" is ad-hoc, somewhat related to the expected number of
504 DEFINED expressions in a linker script. For most default linker
505 scripts, there are none. Why a hash table then? Well, it's somewhat
506 simpler to re-use working machinery than using a linked list in terms
507 of code-complexity here in ld, besides the initialization which just
508 looks like other code here. */
509 if (!bfd_hash_table_init_n (&lang_definedness_table
,
510 lang_definedness_newfunc
, 3))
511 einfo (_("%P%F: out of memory during initialization"));
513 /* Callers of exp_fold_tree need to increment this. */
514 lang_statement_iteration
= 0;
517 /*----------------------------------------------------------------------
518 A region is an area of memory declared with the
519 MEMORY { name:org=exp, len=exp ... }
522 We maintain a list of all the regions here.
524 If no regions are specified in the script, then the default is used
525 which is created when looked up to be the entire data space.
527 If create is true we are creating a region inside a MEMORY block.
528 In this case it is probably an error to create a region that has
529 already been created. If we are not inside a MEMORY block it is
530 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
531 and so we issue a warning. */
533 static lang_memory_region_type
*lang_memory_region_list
;
534 static lang_memory_region_type
**lang_memory_region_list_tail
535 = &lang_memory_region_list
;
537 lang_memory_region_type
*
538 lang_memory_region_lookup (const char *const name
, bfd_boolean create
)
540 lang_memory_region_type
*p
;
541 lang_memory_region_type
*new;
543 /* NAME is NULL for LMA memspecs if no region was specified. */
547 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
548 if (strcmp (p
->name
, name
) == 0)
551 einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
557 /* This code used to always use the first region in the list as the
558 default region. I changed it to instead use a region
559 encompassing all of memory as the default region. This permits
560 NOLOAD sections to work reasonably without requiring a region.
561 People should specify what region they mean, if they really want
563 if (strcmp (name
, DEFAULT_MEMORY_REGION
) == 0)
565 if (lang_memory_region_list
!= NULL
)
566 return lang_memory_region_list
;
570 if (!create
&& strcmp (name
, DEFAULT_MEMORY_REGION
))
571 einfo (_("%P:%S: warning: memory region %s not declared\n"), name
);
573 new = stat_alloc (sizeof (lang_memory_region_type
));
575 new->name
= xstrdup (name
);
578 *lang_memory_region_list_tail
= new;
579 lang_memory_region_list_tail
= &new->next
;
583 new->length
= ~(bfd_size_type
) 0;
585 new->had_full_message
= FALSE
;
590 static lang_memory_region_type
*
591 lang_memory_default (asection
*section
)
593 lang_memory_region_type
*p
;
595 flagword sec_flags
= section
->flags
;
597 /* Override SEC_DATA to mean a writable section. */
598 if ((sec_flags
& (SEC_ALLOC
| SEC_READONLY
| SEC_CODE
)) == SEC_ALLOC
)
599 sec_flags
|= SEC_DATA
;
601 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
603 if ((p
->flags
& sec_flags
) != 0
604 && (p
->not_flags
& sec_flags
) == 0)
609 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION
, FALSE
);
612 static lang_output_section_statement_type
*
613 lang_output_section_find_1 (const char *const name
, int constraint
)
615 lang_output_section_statement_type
*lookup
;
617 for (lookup
= &lang_output_section_statement
.head
->output_section_statement
;
619 lookup
= lookup
->next
)
621 if (strcmp (name
, lookup
->name
) == 0
622 && lookup
->constraint
!= -1
623 && (constraint
== 0 || constraint
== lookup
->constraint
))
629 lang_output_section_statement_type
*
630 lang_output_section_find (const char *const name
)
632 return lang_output_section_find_1 (name
, 0);
635 static lang_output_section_statement_type
*
636 lang_output_section_statement_lookup_1 (const char *const name
, int constraint
)
638 lang_output_section_statement_type
*lookup
;
640 lookup
= lang_output_section_find_1 (name
, constraint
);
643 lookup
= new_stat (lang_output_section_statement
, stat_ptr
);
644 lookup
->region
= NULL
;
645 lookup
->lma_region
= NULL
;
647 lookup
->block_value
= 1;
651 lookup
->bfd_section
= NULL
;
652 lookup
->processed
= 0;
653 lookup
->constraint
= constraint
;
654 lookup
->sectype
= normal_section
;
655 lookup
->addr_tree
= NULL
;
656 lang_list_init (&lookup
->children
);
658 lookup
->memspec
= NULL
;
660 lookup
->subsection_alignment
= -1;
661 lookup
->section_alignment
= -1;
662 lookup
->load_base
= NULL
;
663 lookup
->update_dot_tree
= NULL
;
664 lookup
->phdrs
= NULL
;
666 lang_statement_append (&lang_output_section_statement
,
667 (lang_statement_union_type
*) lookup
,
668 (lang_statement_union_type
**) &lookup
->next
);
673 lang_output_section_statement_type
*
674 lang_output_section_statement_lookup (const char *const name
)
676 return lang_output_section_statement_lookup_1 (name
, 0);
679 /* A variant of lang_output_section_find used by place_orphan.
680 Returns the output statement that should precede a new output
681 statement for SEC. If an exact match is found on certain flags,
684 lang_output_section_statement_type
*
685 lang_output_section_find_by_flags (const asection
*sec
,
686 lang_output_section_statement_type
**exact
)
688 lang_output_section_statement_type
*first
, *look
, *found
;
691 /* We know the first statement on this list is *ABS*. May as well
693 first
= &lang_output_section_statement
.head
->output_section_statement
;
696 /* First try for an exact match. */
698 for (look
= first
; look
; look
= look
->next
)
701 if (look
->bfd_section
!= NULL
)
702 flags
= look
->bfd_section
->flags
;
704 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
705 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
714 if (sec
->flags
& SEC_CODE
)
716 /* Try for a rw code section. */
717 for (look
= first
; look
; look
= look
->next
)
720 if (look
->bfd_section
!= NULL
)
721 flags
= look
->bfd_section
->flags
;
723 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
724 | SEC_CODE
| SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
730 if (sec
->flags
& (SEC_READONLY
| SEC_THREAD_LOCAL
))
732 /* .rodata can go after .text, .sdata2 after .rodata. */
733 for (look
= first
; look
; look
= look
->next
)
736 if (look
->bfd_section
!= NULL
)
737 flags
= look
->bfd_section
->flags
;
739 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
741 && !(look
->flags
& (SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
747 if (sec
->flags
& SEC_SMALL_DATA
)
749 /* .sdata goes after .data, .sbss after .sdata. */
750 for (look
= first
; look
; look
= look
->next
)
753 if (look
->bfd_section
!= NULL
)
754 flags
= look
->bfd_section
->flags
;
756 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
758 || ((look
->flags
& SEC_SMALL_DATA
)
759 && !(sec
->flags
& SEC_HAS_CONTENTS
)))
765 if (sec
->flags
& SEC_HAS_CONTENTS
)
767 /* .data goes after .rodata. */
768 for (look
= first
; look
; look
= look
->next
)
771 if (look
->bfd_section
!= NULL
)
772 flags
= look
->bfd_section
->flags
;
774 if (!(flags
& (SEC_HAS_CONTENTS
| SEC_ALLOC
| SEC_LOAD
775 | SEC_SMALL_DATA
| SEC_THREAD_LOCAL
)))
781 /* .bss goes last. */
782 for (look
= first
; look
; look
= look
->next
)
785 if (look
->bfd_section
!= NULL
)
786 flags
= look
->bfd_section
->flags
;
788 if (!(flags
& SEC_ALLOC
))
795 /* Find the last output section before given output statement.
796 Used by place_orphan. */
799 output_prev_sec_find (lang_output_section_statement_type
*os
)
801 asection
*s
= (asection
*) NULL
;
802 lang_output_section_statement_type
*lookup
;
804 for (lookup
= &lang_output_section_statement
.head
->output_section_statement
;
806 lookup
= lookup
->next
)
808 if (lookup
->constraint
== -1)
813 if (lookup
->bfd_section
!= NULL
&& lookup
->bfd_section
->owner
!= NULL
)
814 s
= lookup
->bfd_section
;
820 lang_output_section_statement_type
*
821 lang_insert_orphan (lang_input_statement_type
*file
,
824 lang_output_section_statement_type
*after
,
825 struct orphan_save
*place
,
827 lang_statement_list_type
*add_child
)
829 lang_statement_list_type
*old
;
830 lang_statement_list_type add
;
832 etree_type
*load_base
;
833 lang_output_section_statement_type
*os
;
834 lang_output_section_statement_type
**os_tail
;
836 /* Start building a list of statements for this section.
837 First save the current statement pointer. */
840 /* If we have found an appropriate place for the output section
841 statements for this orphan, add them to our own private list,
842 inserting them later into the global statement list. */
846 lang_list_init (stat_ptr
);
850 if (config
.build_constructors
)
852 /* If the name of the section is representable in C, then create
853 symbols to mark the start and the end of the section. */
854 for (ps
= secname
; *ps
!= '\0'; ps
++)
855 if (! ISALNUM ((unsigned char) *ps
) && *ps
!= '_')
862 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__start_" + 1);
863 symname
[0] = bfd_get_symbol_leading_char (output_bfd
);
864 sprintf (symname
+ (symname
[0] != 0), "__start_%s", secname
);
865 e_align
= exp_unop (ALIGN_K
,
866 exp_intop ((bfd_vma
) 1 << s
->alignment_power
));
867 lang_add_assignment (exp_assop ('=', ".", e_align
));
868 lang_add_assignment (exp_assop ('=', symname
,
869 exp_nameop (NAME
, ".")));
873 if (link_info
.relocatable
|| (s
->flags
& (SEC_LOAD
| SEC_ALLOC
)) == 0)
874 address
= exp_intop (0);
877 if (after
!= NULL
&& after
->load_base
!= NULL
)
879 etree_type
*lma_from_vma
;
880 lma_from_vma
= exp_binop ('-', after
->load_base
,
881 exp_nameop (ADDR
, after
->name
));
882 load_base
= exp_binop ('+', lma_from_vma
,
883 exp_nameop (ADDR
, secname
));
886 os_tail
= ((lang_output_section_statement_type
**)
887 lang_output_section_statement
.tail
);
888 os
= lang_enter_output_section_statement (secname
, address
, 0, NULL
, NULL
,
891 if (add_child
== NULL
)
892 add_child
= &os
->children
;
893 lang_add_section (add_child
, s
, os
, file
);
895 lang_leave_output_section_statement (0, "*default*", NULL
, NULL
);
897 if (config
.build_constructors
&& *ps
== '\0')
901 /* lang_leave_ouput_section_statement resets stat_ptr.
902 Put stat_ptr back where we want it. */
906 symname
= (char *) xmalloc (ps
- secname
+ sizeof "__stop_" + 1);
907 symname
[0] = bfd_get_symbol_leading_char (output_bfd
);
908 sprintf (symname
+ (symname
[0] != 0), "__stop_%s", secname
);
909 lang_add_assignment (exp_assop ('=', symname
,
910 exp_nameop (NAME
, ".")));
913 /* Restore the global list pointer. */
917 if (after
!= NULL
&& os
->bfd_section
!= NULL
)
919 asection
*snew
, **pps
;
921 snew
= os
->bfd_section
;
923 /* Shuffle the bfd section list to make the output file look
924 neater. This is really only cosmetic. */
925 if (place
->section
== NULL
926 && after
!= (&lang_output_section_statement
.head
927 ->output_section_statement
))
929 asection
*bfd_section
= after
->bfd_section
;
931 /* If the output statement hasn't been used to place any input
932 sections (and thus doesn't have an output bfd_section),
933 look for the closest prior output statement having an
935 if (bfd_section
== NULL
)
936 bfd_section
= output_prev_sec_find (after
);
938 if (bfd_section
!= NULL
&& bfd_section
!= snew
)
939 place
->section
= &bfd_section
->next
;
942 if (place
->section
== NULL
)
943 place
->section
= &output_bfd
->sections
;
945 /* Unlink the section. */
946 for (pps
= &output_bfd
->sections
; *pps
!= snew
; pps
= &(*pps
)->next
)
948 bfd_section_list_remove (output_bfd
, pps
);
950 /* Now tack it back on in the right place. */
951 bfd_section_list_insert (output_bfd
, place
->section
, snew
);
953 /* Save the end of this list. Further ophans of this type will
954 follow the one we've just added. */
955 place
->section
= &snew
->next
;
957 /* The following is non-cosmetic. We try to put the output
958 statements in some sort of reasonable order here, because they
959 determine the final load addresses of the orphan sections.
960 In addition, placing output statements in the wrong order may
961 require extra segments. For instance, given a typical
962 situation of all read-only sections placed in one segment and
963 following that a segment containing all the read-write
964 sections, we wouldn't want to place an orphan read/write
965 section before or amongst the read-only ones. */
966 if (add
.head
!= NULL
)
968 lang_output_section_statement_type
*newly_added_os
;
970 if (place
->stmt
== NULL
)
972 lang_statement_union_type
**where
;
973 lang_statement_union_type
**assign
= NULL
;
975 /* Look for a suitable place for the new statement list.
976 The idea is to skip over anything that might be inside
977 a SECTIONS {} statement in a script, before we find
978 another output_section_statement. Assignments to "dot"
979 before an output section statement are assumed to
981 for (where
= &after
->header
.next
;
983 where
= &(*where
)->header
.next
)
985 switch ((*where
)->header
.type
)
987 case lang_assignment_statement_enum
:
990 lang_assignment_statement_type
*ass
;
991 ass
= &(*where
)->assignment_statement
;
992 if (ass
->exp
->type
.node_class
!= etree_assert
993 && ass
->exp
->assign
.dst
[0] == '.'
994 && ass
->exp
->assign
.dst
[1] == 0)
998 case lang_wild_statement_enum
:
999 case lang_input_section_enum
:
1000 case lang_object_symbols_statement_enum
:
1001 case lang_fill_statement_enum
:
1002 case lang_data_statement_enum
:
1003 case lang_reloc_statement_enum
:
1004 case lang_padding_statement_enum
:
1005 case lang_constructors_statement_enum
:
1008 case lang_output_section_statement_enum
:
1011 case lang_input_statement_enum
:
1012 case lang_address_statement_enum
:
1013 case lang_target_statement_enum
:
1014 case lang_output_statement_enum
:
1015 case lang_group_statement_enum
:
1016 case lang_afile_asection_pair_statement_enum
:
1025 place
->os_tail
= &after
->next
;
1029 /* Put it after the last orphan statement we added. */
1030 *add
.tail
= *place
->stmt
;
1031 *place
->stmt
= add
.head
;
1034 /* Fix the global list pointer if we happened to tack our
1035 new list at the tail. */
1036 if (*old
->tail
== add
.head
)
1037 old
->tail
= add
.tail
;
1039 /* Save the end of this list. */
1040 place
->stmt
= add
.tail
;
1042 /* Do the same for the list of output section statements. */
1043 newly_added_os
= *os_tail
;
1045 newly_added_os
->next
= *place
->os_tail
;
1046 *place
->os_tail
= newly_added_os
;
1047 place
->os_tail
= &newly_added_os
->next
;
1049 /* Fixing the global list pointer here is a little different.
1050 We added to the list in lang_enter_output_section_statement,
1051 trimmed off the new output_section_statment above when
1052 assigning *os_tail = NULL, but possibly added it back in
1053 the same place when assigning *place->os_tail. */
1054 if (*os_tail
== NULL
)
1055 lang_output_section_statement
.tail
1056 = (lang_statement_union_type
**) os_tail
;
1063 lang_map_flags (flagword flag
)
1065 if (flag
& SEC_ALLOC
)
1068 if (flag
& SEC_CODE
)
1071 if (flag
& SEC_READONLY
)
1074 if (flag
& SEC_DATA
)
1077 if (flag
& SEC_LOAD
)
1084 lang_memory_region_type
*m
;
1087 minfo (_("\nMemory Configuration\n\n"));
1088 fprintf (config
.map_file
, "%-16s %-18s %-18s %s\n",
1089 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1091 for (m
= lang_memory_region_list
; m
!= NULL
; m
= m
->next
)
1096 fprintf (config
.map_file
, "%-16s ", m
->name
);
1098 sprintf_vma (buf
, m
->origin
);
1099 minfo ("0x%s ", buf
);
1107 minfo ("0x%V", m
->length
);
1108 if (m
->flags
|| m
->not_flags
)
1116 lang_map_flags (m
->flags
);
1122 lang_map_flags (m
->not_flags
);
1129 fprintf (config
.map_file
, _("\nLinker script and memory map\n\n"));
1131 if (! command_line
.reduce_memory_overheads
)
1133 obstack_begin (&map_obstack
, 1000);
1134 for (p
= link_info
.input_bfds
; p
!= (bfd
*) NULL
; p
= p
->link_next
)
1135 bfd_map_over_sections (p
, init_map_userdata
, 0);
1136 bfd_link_hash_traverse (link_info
.hash
, sort_def_symbol
, 0);
1138 print_statements ();
1142 init_map_userdata (abfd
, sec
, data
)
1143 bfd
*abfd ATTRIBUTE_UNUSED
;
1145 void *data ATTRIBUTE_UNUSED
;
1147 fat_section_userdata_type
*new_data
1148 = ((fat_section_userdata_type
*) (stat_alloc
1149 (sizeof (fat_section_userdata_type
))));
1151 ASSERT (get_userdata (sec
) == NULL
);
1152 get_userdata (sec
) = new_data
;
1153 new_data
->map_symbol_def_tail
= &new_data
->map_symbol_def_head
;
1157 sort_def_symbol (hash_entry
, info
)
1158 struct bfd_link_hash_entry
*hash_entry
;
1159 void *info ATTRIBUTE_UNUSED
;
1161 if (hash_entry
->type
== bfd_link_hash_defined
1162 || hash_entry
->type
== bfd_link_hash_defweak
)
1164 struct fat_user_section_struct
*ud
;
1165 struct map_symbol_def
*def
;
1167 ud
= get_userdata (hash_entry
->u
.def
.section
);
1170 /* ??? What do we have to do to initialize this beforehand? */
1171 /* The first time we get here is bfd_abs_section... */
1172 init_map_userdata (0, hash_entry
->u
.def
.section
, 0);
1173 ud
= get_userdata (hash_entry
->u
.def
.section
);
1175 else if (!ud
->map_symbol_def_tail
)
1176 ud
->map_symbol_def_tail
= &ud
->map_symbol_def_head
;
1178 def
= obstack_alloc (&map_obstack
, sizeof *def
);
1179 def
->entry
= hash_entry
;
1180 *(ud
->map_symbol_def_tail
) = def
;
1181 ud
->map_symbol_def_tail
= &def
->next
;
1186 /* Initialize an output section. */
1189 init_os (lang_output_section_statement_type
*s
)
1191 lean_section_userdata_type
*new;
1193 if (s
->bfd_section
!= NULL
)
1196 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
1197 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME
);
1199 new = stat_alloc (SECTION_USERDATA_SIZE
);
1200 memset (new, 0, SECTION_USERDATA_SIZE
);
1202 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
1203 if (s
->bfd_section
== NULL
)
1204 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
1205 if (s
->bfd_section
== NULL
)
1207 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
1208 output_bfd
->xvec
->name
, s
->name
);
1210 s
->bfd_section
->output_section
= s
->bfd_section
;
1212 /* We initialize an output sections output offset to minus its own
1213 vma to allow us to output a section through itself. */
1214 s
->bfd_section
->output_offset
= 0;
1215 get_userdata (s
->bfd_section
) = new;
1217 /* If there is a base address, make sure that any sections it might
1218 mention are initialized. */
1219 if (s
->addr_tree
!= NULL
)
1220 exp_init_os (s
->addr_tree
);
1222 if (s
->load_base
!= NULL
)
1223 exp_init_os (s
->load_base
);
1226 /* Make sure that all output sections mentioned in an expression are
1230 exp_init_os (etree_type
*exp
)
1232 switch (exp
->type
.node_class
)
1235 exp_init_os (exp
->assign
.src
);
1239 exp_init_os (exp
->binary
.lhs
);
1240 exp_init_os (exp
->binary
.rhs
);
1244 exp_init_os (exp
->trinary
.cond
);
1245 exp_init_os (exp
->trinary
.lhs
);
1246 exp_init_os (exp
->trinary
.rhs
);
1250 exp_init_os (exp
->assert_s
.child
);
1254 exp_init_os (exp
->unary
.child
);
1258 switch (exp
->type
.node_code
)
1264 lang_output_section_statement_type
*os
;
1266 os
= lang_output_section_find (exp
->name
.name
);
1267 if (os
!= NULL
&& os
->bfd_section
== NULL
)
1279 section_already_linked (bfd
*abfd
, asection
*sec
, void *data
)
1281 lang_input_statement_type
*entry
= data
;
1283 /* If we are only reading symbols from this object, then we want to
1284 discard all sections. */
1285 if (entry
->just_syms_flag
)
1287 bfd_link_just_syms (sec
, &link_info
);
1291 bfd_section_already_linked (abfd
, sec
);
1294 /* The wild routines.
1296 These expand statements like *(.text) and foo.o to a list of
1297 explicit actions, like foo.o(.text), bar.o(.text) and
1298 foo.o(.text, .data). */
1300 /* Add SECTION to the output section OUTPUT. Do this by creating a
1301 lang_input_section statement which is placed at PTR. FILE is the
1302 input file which holds SECTION. */
1305 lang_add_section (lang_statement_list_type
*ptr
,
1307 lang_output_section_statement_type
*output
,
1308 lang_input_statement_type
*file
)
1310 flagword flags
= section
->flags
;
1311 bfd_boolean discard
;
1313 /* Discard sections marked with SEC_EXCLUDE. */
1314 discard
= (flags
& SEC_EXCLUDE
) != 0;
1316 /* Discard input sections which are assigned to a section named
1317 DISCARD_SECTION_NAME. */
1318 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
1321 /* Discard debugging sections if we are stripping debugging
1323 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
1324 && (flags
& SEC_DEBUGGING
) != 0)
1329 if (section
->output_section
== NULL
)
1331 /* This prevents future calls from assigning this section. */
1332 section
->output_section
= bfd_abs_section_ptr
;
1337 if (section
->output_section
== NULL
)
1340 lang_input_section_type
*new;
1343 if (output
->bfd_section
== NULL
)
1346 first
= ! output
->bfd_section
->linker_has_input
;
1347 output
->bfd_section
->linker_has_input
= 1;
1349 /* Add a section reference to the list. */
1350 new = new_stat (lang_input_section
, ptr
);
1352 new->section
= section
;
1354 section
->output_section
= output
->bfd_section
;
1356 flags
= section
->flags
;
1358 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1359 to an output section, because we want to be able to include a
1360 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1361 section (I don't know why we want to do this, but we do).
1362 build_link_order in ldwrite.c handles this case by turning
1363 the embedded SEC_NEVER_LOAD section into a fill. */
1365 flags
&= ~ SEC_NEVER_LOAD
;
1367 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1368 already been processed. One reason to do this is that on pe
1369 format targets, .text$foo sections go into .text and it's odd
1370 to see .text with SEC_LINK_ONCE set. */
1372 if (! link_info
.relocatable
)
1373 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
1375 /* If this is not the first input section, and the SEC_READONLY
1376 flag is not currently set, then don't set it just because the
1377 input section has it set. */
1379 if (! first
&& (output
->bfd_section
->flags
& SEC_READONLY
) == 0)
1380 flags
&= ~ SEC_READONLY
;
1382 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1384 && ((output
->bfd_section
->flags
& (SEC_MERGE
| SEC_STRINGS
))
1385 != (flags
& (SEC_MERGE
| SEC_STRINGS
))
1386 || ((flags
& SEC_MERGE
)
1387 && output
->bfd_section
->entsize
!= section
->entsize
)))
1389 output
->bfd_section
->flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1390 flags
&= ~ (SEC_MERGE
| SEC_STRINGS
);
1393 output
->bfd_section
->flags
|= flags
;
1395 if (flags
& SEC_MERGE
)
1396 output
->bfd_section
->entsize
= section
->entsize
;
1398 /* If SEC_READONLY is not set in the input section, then clear
1399 it from the output section. */
1400 if ((section
->flags
& SEC_READONLY
) == 0)
1401 output
->bfd_section
->flags
&= ~SEC_READONLY
;
1403 switch (output
->sectype
)
1405 case normal_section
:
1410 case overlay_section
:
1411 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
1413 case noload_section
:
1414 output
->bfd_section
->flags
&= ~SEC_LOAD
;
1415 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
1419 /* Copy over SEC_SMALL_DATA. */
1420 if (section
->flags
& SEC_SMALL_DATA
)
1421 output
->bfd_section
->flags
|= SEC_SMALL_DATA
;
1423 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
1424 output
->bfd_section
->alignment_power
= section
->alignment_power
;
1426 /* If supplied an alignment, then force it. */
1427 if (output
->section_alignment
!= -1)
1428 output
->bfd_section
->alignment_power
= output
->section_alignment
;
1430 if (section
->flags
& SEC_BLOCK
)
1432 output
->bfd_section
->flags
|= SEC_BLOCK
;
1433 /* FIXME: This value should really be obtained from the bfd... */
1434 output
->block_value
= 128;
1439 /* Compare sections ASEC and BSEC according to SORT. */
1442 compare_section (sort_type sort
, asection
*asec
, asection
*bsec
)
1451 case by_alignment_name
:
1452 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
1453 - bfd_section_alignment (asec
->owner
, asec
));
1459 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
1460 bfd_get_section_name (bsec
->owner
, bsec
));
1463 case by_name_alignment
:
1464 ret
= strcmp (bfd_get_section_name (asec
->owner
, asec
),
1465 bfd_get_section_name (bsec
->owner
, bsec
));
1471 ret
= (bfd_section_alignment (bsec
->owner
, bsec
)
1472 - bfd_section_alignment (asec
->owner
, asec
));
1479 /* Handle wildcard sorting. This returns the lang_input_section which
1480 should follow the one we are going to create for SECTION and FILE,
1481 based on the sorting requirements of WILD. It returns NULL if the
1482 new section should just go at the end of the current list. */
1484 static lang_statement_union_type
*
1485 wild_sort (lang_wild_statement_type
*wild
,
1486 struct wildcard_list
*sec
,
1487 lang_input_statement_type
*file
,
1490 const char *section_name
;
1491 lang_statement_union_type
*l
;
1493 if (!wild
->filenames_sorted
1494 && (sec
== NULL
|| sec
->spec
.sorted
== none
))
1497 section_name
= bfd_get_section_name (file
->the_bfd
, section
);
1498 for (l
= wild
->children
.head
; l
!= NULL
; l
= l
->header
.next
)
1500 lang_input_section_type
*ls
;
1502 if (l
->header
.type
!= lang_input_section_enum
)
1504 ls
= &l
->input_section
;
1506 /* Sorting by filename takes precedence over sorting by section
1509 if (wild
->filenames_sorted
)
1511 const char *fn
, *ln
;
1515 /* The PE support for the .idata section as generated by
1516 dlltool assumes that files will be sorted by the name of
1517 the archive and then the name of the file within the
1520 if (file
->the_bfd
!= NULL
1521 && bfd_my_archive (file
->the_bfd
) != NULL
)
1523 fn
= bfd_get_filename (bfd_my_archive (file
->the_bfd
));
1528 fn
= file
->filename
;
1532 if (ls
->ifile
->the_bfd
!= NULL
1533 && bfd_my_archive (ls
->ifile
->the_bfd
) != NULL
)
1535 ln
= bfd_get_filename (bfd_my_archive (ls
->ifile
->the_bfd
));
1540 ln
= ls
->ifile
->filename
;
1544 i
= strcmp (fn
, ln
);
1553 fn
= file
->filename
;
1555 ln
= ls
->ifile
->filename
;
1557 i
= strcmp (fn
, ln
);
1565 /* Here either the files are not sorted by name, or we are
1566 looking at the sections for this file. */
1568 if (sec
!= NULL
&& sec
->spec
.sorted
!= none
)
1570 if (compare_section (sec
->spec
.sorted
, section
,
1579 /* Expand a wild statement for a particular FILE. SECTION may be
1580 NULL, in which case it is a wild card. */
1583 output_section_callback (lang_wild_statement_type
*ptr
,
1584 struct wildcard_list
*sec
,
1586 lang_input_statement_type
*file
,
1589 lang_statement_union_type
*before
;
1591 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1592 if (unique_section_p (section
))
1595 before
= wild_sort (ptr
, sec
, file
, section
);
1597 /* Here BEFORE points to the lang_input_section which
1598 should follow the one we are about to add. If BEFORE
1599 is NULL, then the section should just go at the end
1600 of the current list. */
1603 lang_add_section (&ptr
->children
, section
,
1604 (lang_output_section_statement_type
*) output
,
1608 lang_statement_list_type list
;
1609 lang_statement_union_type
**pp
;
1611 lang_list_init (&list
);
1612 lang_add_section (&list
, section
,
1613 (lang_output_section_statement_type
*) output
,
1616 /* If we are discarding the section, LIST.HEAD will
1618 if (list
.head
!= NULL
)
1620 ASSERT (list
.head
->header
.next
== NULL
);
1622 for (pp
= &ptr
->children
.head
;
1624 pp
= &(*pp
)->header
.next
)
1625 ASSERT (*pp
!= NULL
);
1627 list
.head
->header
.next
= *pp
;
1633 /* Check if all sections in a wild statement for a particular FILE
1637 check_section_callback (lang_wild_statement_type
*ptr ATTRIBUTE_UNUSED
,
1638 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
1640 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
1643 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1644 if (unique_section_p (section
))
1647 if (section
->output_section
== NULL
&& (section
->flags
& SEC_READONLY
) == 0)
1648 ((lang_output_section_statement_type
*) data
)->all_input_readonly
= FALSE
;
1651 /* This is passed a file name which must have been seen already and
1652 added to the statement tree. We will see if it has been opened
1653 already and had its symbols read. If not then we'll read it. */
1655 static lang_input_statement_type
*
1656 lookup_name (const char *name
)
1658 lang_input_statement_type
*search
;
1660 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
1662 search
= (lang_input_statement_type
*) search
->next_real_file
)
1664 /* Use the local_sym_name as the name of the file that has
1665 already been loaded as filename might have been transformed
1666 via the search directory lookup mechanism. */
1667 const char * filename
= search
->local_sym_name
;
1669 if (filename
== NULL
&& name
== NULL
)
1671 if (filename
!= NULL
1673 && strcmp (filename
, name
) == 0)
1678 search
= new_afile (name
, lang_input_file_is_search_file_enum
,
1679 default_target
, FALSE
);
1681 /* If we have already added this file, or this file is not real
1682 (FIXME: can that ever actually happen?) or the name is NULL
1683 (FIXME: can that ever actually happen?) don't add this file. */
1686 || search
->filename
== NULL
)
1689 if (! load_symbols (search
, NULL
))
1695 /* Save LIST as a list of libraries whose symbols should not be exported. */
1700 struct excluded_lib
*next
;
1702 static struct excluded_lib
*excluded_libs
;
1705 add_excluded_libs (const char *list
)
1707 const char *p
= list
, *end
;
1711 struct excluded_lib
*entry
;
1712 end
= strpbrk (p
, ",:");
1714 end
= p
+ strlen (p
);
1715 entry
= xmalloc (sizeof (*entry
));
1716 entry
->next
= excluded_libs
;
1717 entry
->name
= xmalloc (end
- p
+ 1);
1718 memcpy (entry
->name
, p
, end
- p
);
1719 entry
->name
[end
- p
] = '\0';
1720 excluded_libs
= entry
;
1728 check_excluded_libs (bfd
*abfd
)
1730 struct excluded_lib
*lib
= excluded_libs
;
1734 int len
= strlen (lib
->name
);
1735 const char *filename
= lbasename (abfd
->filename
);
1737 if (strcmp (lib
->name
, "ALL") == 0)
1739 abfd
->no_export
= TRUE
;
1743 if (strncmp (lib
->name
, filename
, len
) == 0
1744 && (filename
[len
] == '\0'
1745 || (filename
[len
] == '.' && filename
[len
+ 1] == 'a'
1746 && filename
[len
+ 2] == '\0')))
1748 abfd
->no_export
= TRUE
;
1756 /* Get the symbols for an input file. */
1759 load_symbols (lang_input_statement_type
*entry
,
1760 lang_statement_list_type
*place
)
1767 ldfile_open_file (entry
);
1769 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
1770 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
1773 lang_statement_list_type
*hold
;
1774 bfd_boolean bad_load
= TRUE
;
1775 bfd_boolean save_ldlang_sysrooted_script
;
1777 err
= bfd_get_error ();
1779 /* See if the emulation has some special knowledge. */
1780 if (ldemul_unrecognized_file (entry
))
1783 if (err
== bfd_error_file_ambiguously_recognized
)
1787 einfo (_("%B: file not recognized: %E\n"), entry
->the_bfd
);
1788 einfo (_("%B: matching formats:"), entry
->the_bfd
);
1789 for (p
= matching
; *p
!= NULL
; p
++)
1793 else if (err
!= bfd_error_file_not_recognized
1795 einfo (_("%F%B: file not recognized: %E\n"), entry
->the_bfd
);
1799 bfd_close (entry
->the_bfd
);
1800 entry
->the_bfd
= NULL
;
1802 /* Try to interpret the file as a linker script. */
1803 ldfile_open_command_file (entry
->filename
);
1807 save_ldlang_sysrooted_script
= ldlang_sysrooted_script
;
1808 ldlang_sysrooted_script
= entry
->sysrooted
;
1810 ldfile_assumed_script
= TRUE
;
1811 parser_input
= input_script
;
1813 ldfile_assumed_script
= FALSE
;
1815 ldlang_sysrooted_script
= save_ldlang_sysrooted_script
;
1821 if (ldemul_recognized_file (entry
))
1824 /* We don't call ldlang_add_file for an archive. Instead, the
1825 add_symbols entry point will call ldlang_add_file, via the
1826 add_archive_element callback, for each element of the archive
1828 switch (bfd_get_format (entry
->the_bfd
))
1834 ldlang_add_file (entry
);
1835 if (trace_files
|| trace_file_tries
)
1836 info_msg ("%I\n", entry
);
1840 check_excluded_libs (entry
->the_bfd
);
1842 if (entry
->whole_archive
)
1845 bfd_boolean loaded
= TRUE
;
1849 member
= bfd_openr_next_archived_file (entry
->the_bfd
, member
);
1854 if (! bfd_check_format (member
, bfd_object
))
1856 einfo (_("%F%B: member %B in archive is not an object\n"),
1857 entry
->the_bfd
, member
);
1861 if (! ((*link_info
.callbacks
->add_archive_element
)
1862 (&link_info
, member
, "--whole-archive")))
1865 if (! bfd_link_add_symbols (member
, &link_info
))
1867 einfo (_("%F%B: could not read symbols: %E\n"), member
);
1872 entry
->loaded
= loaded
;
1878 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1879 entry
->loaded
= TRUE
;
1881 einfo (_("%F%B: could not read symbols: %E\n"), entry
->the_bfd
);
1883 return entry
->loaded
;
1886 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1887 may be NULL, indicating that it is a wildcard. Separate
1888 lang_input_section statements are created for each part of the
1889 expansion; they are added after the wild statement S. OUTPUT is
1890 the output section. */
1893 wild (lang_wild_statement_type
*s
,
1894 const char *target ATTRIBUTE_UNUSED
,
1895 lang_output_section_statement_type
*output
)
1897 struct wildcard_list
*sec
;
1899 walk_wild (s
, output_section_callback
, output
);
1901 for (sec
= s
->section_list
; sec
!= NULL
; sec
= sec
->next
)
1903 if (default_common_section
!= NULL
)
1905 if (sec
->spec
.name
!= NULL
&& strcmp (sec
->spec
.name
, "COMMON") == 0)
1907 /* Remember the section that common is going to in case we
1908 later get something which doesn't know where to put it. */
1909 default_common_section
= output
;
1914 /* Return TRUE iff target is the sought target. */
1917 get_target (const bfd_target
*target
, void *data
)
1919 const char *sought
= data
;
1921 return strcmp (target
->name
, sought
) == 0;
1924 /* Like strcpy() but convert to lower case as well. */
1927 stricpy (char *dest
, char *src
)
1931 while ((c
= *src
++) != 0)
1932 *dest
++ = TOLOWER (c
);
1937 /* Remove the first occurrence of needle (if any) in haystack
1941 strcut (char *haystack
, char *needle
)
1943 haystack
= strstr (haystack
, needle
);
1949 for (src
= haystack
+ strlen (needle
); *src
;)
1950 *haystack
++ = *src
++;
1956 /* Compare two target format name strings.
1957 Return a value indicating how "similar" they are. */
1960 name_compare (char *first
, char *second
)
1966 copy1
= xmalloc (strlen (first
) + 1);
1967 copy2
= xmalloc (strlen (second
) + 1);
1969 /* Convert the names to lower case. */
1970 stricpy (copy1
, first
);
1971 stricpy (copy2
, second
);
1973 /* Remove size and endian strings from the name. */
1974 strcut (copy1
, "big");
1975 strcut (copy1
, "little");
1976 strcut (copy2
, "big");
1977 strcut (copy2
, "little");
1979 /* Return a value based on how many characters match,
1980 starting from the beginning. If both strings are
1981 the same then return 10 * their length. */
1982 for (result
= 0; copy1
[result
] == copy2
[result
]; result
++)
1983 if (copy1
[result
] == 0)
1995 /* Set by closest_target_match() below. */
1996 static const bfd_target
*winner
;
1998 /* Scan all the valid bfd targets looking for one that has the endianness
1999 requirement that was specified on the command line, and is the nearest
2000 match to the original output target. */
2003 closest_target_match (const bfd_target
*target
, void *data
)
2005 const bfd_target
*original
= data
;
2007 if (command_line
.endian
== ENDIAN_BIG
2008 && target
->byteorder
!= BFD_ENDIAN_BIG
)
2011 if (command_line
.endian
== ENDIAN_LITTLE
2012 && target
->byteorder
!= BFD_ENDIAN_LITTLE
)
2015 /* Must be the same flavour. */
2016 if (target
->flavour
!= original
->flavour
)
2019 /* If we have not found a potential winner yet, then record this one. */
2026 /* Oh dear, we now have two potential candidates for a successful match.
2027 Compare their names and choose the better one. */
2028 if (name_compare (target
->name
, original
->name
)
2029 > name_compare (winner
->name
, original
->name
))
2032 /* Keep on searching until wqe have checked them all. */
2036 /* Return the BFD target format of the first input file. */
2039 get_first_input_target (void)
2041 char *target
= NULL
;
2043 LANG_FOR_EACH_INPUT_STATEMENT (s
)
2045 if (s
->header
.type
== lang_input_statement_enum
2048 ldfile_open_file (s
);
2050 if (s
->the_bfd
!= NULL
2051 && bfd_check_format (s
->the_bfd
, bfd_object
))
2053 target
= bfd_get_target (s
->the_bfd
);
2065 lang_get_output_target (void)
2069 /* Has the user told us which output format to use? */
2070 if (output_target
!= NULL
)
2071 return output_target
;
2073 /* No - has the current target been set to something other than
2075 if (current_target
!= default_target
)
2076 return current_target
;
2078 /* No - can we determine the format of the first input file? */
2079 target
= get_first_input_target ();
2083 /* Failed - use the default output target. */
2084 return default_target
;
2087 /* Open the output file. */
2090 open_output (const char *name
)
2094 output_target
= lang_get_output_target ();
2096 /* Has the user requested a particular endianness on the command
2098 if (command_line
.endian
!= ENDIAN_UNSET
)
2100 const bfd_target
*target
;
2101 enum bfd_endian desired_endian
;
2103 /* Get the chosen target. */
2104 target
= bfd_search_for_target (get_target
, (void *) output_target
);
2106 /* If the target is not supported, we cannot do anything. */
2109 if (command_line
.endian
== ENDIAN_BIG
)
2110 desired_endian
= BFD_ENDIAN_BIG
;
2112 desired_endian
= BFD_ENDIAN_LITTLE
;
2114 /* See if the target has the wrong endianness. This should
2115 not happen if the linker script has provided big and
2116 little endian alternatives, but some scrips don't do
2118 if (target
->byteorder
!= desired_endian
)
2120 /* If it does, then see if the target provides
2121 an alternative with the correct endianness. */
2122 if (target
->alternative_target
!= NULL
2123 && (target
->alternative_target
->byteorder
== desired_endian
))
2124 output_target
= target
->alternative_target
->name
;
2127 /* Try to find a target as similar as possible to
2128 the default target, but which has the desired
2129 endian characteristic. */
2130 bfd_search_for_target (closest_target_match
,
2133 /* Oh dear - we could not find any targets that
2134 satisfy our requirements. */
2136 einfo (_("%P: warning: could not find any targets"
2137 " that match endianness requirement\n"));
2139 output_target
= winner
->name
;
2145 output
= bfd_openw (name
, output_target
);
2149 if (bfd_get_error () == bfd_error_invalid_target
)
2150 einfo (_("%P%F: target %s not found\n"), output_target
);
2152 einfo (_("%P%F: cannot open output file %s: %E\n"), name
);
2155 delete_output_file_on_failure
= TRUE
;
2158 output
->flags
|= D_PAGED
;
2161 if (! bfd_set_format (output
, bfd_object
))
2162 einfo (_("%P%F:%s: can not make object file: %E\n"), name
);
2163 if (! bfd_set_arch_mach (output
,
2164 ldfile_output_architecture
,
2165 ldfile_output_machine
))
2166 einfo (_("%P%F:%s: can not set architecture: %E\n"), name
);
2168 link_info
.hash
= bfd_link_hash_table_create (output
);
2169 if (link_info
.hash
== NULL
)
2170 einfo (_("%P%F: can not create link hash table: %E\n"));
2172 bfd_set_gp_size (output
, g_switch_value
);
2177 ldlang_open_output (lang_statement_union_type
*statement
)
2179 switch (statement
->header
.type
)
2181 case lang_output_statement_enum
:
2182 ASSERT (output_bfd
== NULL
);
2183 output_bfd
= open_output (statement
->output_statement
.name
);
2184 ldemul_set_output_arch ();
2185 if (config
.magic_demand_paged
&& !link_info
.relocatable
)
2186 output_bfd
->flags
|= D_PAGED
;
2188 output_bfd
->flags
&= ~D_PAGED
;
2189 if (config
.text_read_only
)
2190 output_bfd
->flags
|= WP_TEXT
;
2192 output_bfd
->flags
&= ~WP_TEXT
;
2193 if (link_info
.traditional_format
)
2194 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
2196 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
2199 case lang_target_statement_enum
:
2200 current_target
= statement
->target_statement
.target
;
2207 /* Convert between addresses in bytes and sizes in octets.
2208 For currently supported targets, octets_per_byte is always a power
2209 of two, so we can use shifts. */
2210 #define TO_ADDR(X) ((X) >> opb_shift)
2211 #define TO_SIZE(X) ((X) << opb_shift)
2213 /* Support the above. */
2214 static unsigned int opb_shift
= 0;
2219 unsigned x
= bfd_arch_mach_octets_per_byte (ldfile_output_architecture
,
2220 ldfile_output_machine
);
2223 while ((x
& 1) == 0)
2231 /* Open all the input files. */
2234 open_input_bfds (lang_statement_union_type
*s
, bfd_boolean force
)
2236 for (; s
!= NULL
; s
= s
->header
.next
)
2238 switch (s
->header
.type
)
2240 case lang_constructors_statement_enum
:
2241 open_input_bfds (constructor_list
.head
, force
);
2243 case lang_output_section_statement_enum
:
2244 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
2246 case lang_wild_statement_enum
:
2247 /* Maybe we should load the file's symbols. */
2248 if (s
->wild_statement
.filename
2249 && ! wildcardp (s
->wild_statement
.filename
))
2250 lookup_name (s
->wild_statement
.filename
);
2251 open_input_bfds (s
->wild_statement
.children
.head
, force
);
2253 case lang_group_statement_enum
:
2255 struct bfd_link_hash_entry
*undefs
;
2257 /* We must continually search the entries in the group
2258 until no new symbols are added to the list of undefined
2263 undefs
= link_info
.hash
->undefs_tail
;
2264 open_input_bfds (s
->group_statement
.children
.head
, TRUE
);
2266 while (undefs
!= link_info
.hash
->undefs_tail
);
2269 case lang_target_statement_enum
:
2270 current_target
= s
->target_statement
.target
;
2272 case lang_input_statement_enum
:
2273 if (s
->input_statement
.real
)
2275 lang_statement_list_type add
;
2277 s
->input_statement
.target
= current_target
;
2279 /* If we are being called from within a group, and this
2280 is an archive which has already been searched, then
2281 force it to be researched unless the whole archive
2282 has been loaded already. */
2284 && !s
->input_statement
.whole_archive
2285 && s
->input_statement
.loaded
2286 && bfd_check_format (s
->input_statement
.the_bfd
,
2288 s
->input_statement
.loaded
= FALSE
;
2290 lang_list_init (&add
);
2292 if (! load_symbols (&s
->input_statement
, &add
))
2293 config
.make_executable
= FALSE
;
2295 if (add
.head
!= NULL
)
2297 *add
.tail
= s
->header
.next
;
2298 s
->header
.next
= add
.head
;
2308 /* If there are [COMMONS] statements, put a wild one into the bss
2312 lang_reasonable_defaults (void)
2315 lang_output_section_statement_lookup (".text");
2316 lang_output_section_statement_lookup (".data");
2318 default_common_section
= lang_output_section_statement_lookup (".bss");
2320 if (!placed_commons
)
2322 lang_wild_statement_type
*new =
2323 new_stat (lang_wild_statement
,
2324 &default_common_section
->children
);
2326 new->section_name
= "COMMON";
2327 new->filename
= NULL
;
2328 lang_list_init (&new->children
);
2333 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
2336 lang_track_definedness (const char *name
)
2338 if (bfd_hash_lookup (&lang_definedness_table
, name
, TRUE
, FALSE
) == NULL
)
2339 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name
);
2342 /* New-function for the definedness hash table. */
2344 static struct bfd_hash_entry
*
2345 lang_definedness_newfunc (struct bfd_hash_entry
*entry
,
2346 struct bfd_hash_table
*table ATTRIBUTE_UNUSED
,
2347 const char *name ATTRIBUTE_UNUSED
)
2349 struct lang_definedness_hash_entry
*ret
2350 = (struct lang_definedness_hash_entry
*) entry
;
2353 ret
= (struct lang_definedness_hash_entry
*)
2354 bfd_hash_allocate (table
, sizeof (struct lang_definedness_hash_entry
));
2357 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name
);
2359 ret
->iteration
= -1;
2363 /* Return the iteration when the definition of NAME was last updated. A
2364 value of -1 means that the symbol is not defined in the linker script
2365 or the command line, but may be defined in the linker symbol table. */
2368 lang_symbol_definition_iteration (const char *name
)
2370 struct lang_definedness_hash_entry
*defentry
2371 = (struct lang_definedness_hash_entry
*)
2372 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
2374 /* We've already created this one on the presence of DEFINED in the
2375 script, so it can't be NULL unless something is borked elsewhere in
2377 if (defentry
== NULL
)
2380 return defentry
->iteration
;
2383 /* Update the definedness state of NAME. */
2386 lang_update_definedness (const char *name
, struct bfd_link_hash_entry
*h
)
2388 struct lang_definedness_hash_entry
*defentry
2389 = (struct lang_definedness_hash_entry
*)
2390 bfd_hash_lookup (&lang_definedness_table
, name
, FALSE
, FALSE
);
2392 /* We don't keep track of symbols not tested with DEFINED. */
2393 if (defentry
== NULL
)
2396 /* If the symbol was already defined, and not from an earlier statement
2397 iteration, don't update the definedness iteration, because that'd
2398 make the symbol seem defined in the linker script at this point, and
2399 it wasn't; it was defined in some object. If we do anyway, DEFINED
2400 would start to yield false before this point and the construct "sym =
2401 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
2403 if (h
->type
!= bfd_link_hash_undefined
2404 && h
->type
!= bfd_link_hash_common
2405 && h
->type
!= bfd_link_hash_new
2406 && defentry
->iteration
== -1)
2409 defentry
->iteration
= lang_statement_iteration
;
2412 /* Add the supplied name to the symbol table as an undefined reference.
2413 This is a two step process as the symbol table doesn't even exist at
2414 the time the ld command line is processed. First we put the name
2415 on a list, then, once the output file has been opened, transfer the
2416 name to the symbol table. */
2418 typedef struct bfd_sym_chain ldlang_undef_chain_list_type
;
2420 #define ldlang_undef_chain_list_head entry_symbol.next
2423 ldlang_add_undef (const char *const name
)
2425 ldlang_undef_chain_list_type
*new =
2426 stat_alloc (sizeof (ldlang_undef_chain_list_type
));
2428 new->next
= ldlang_undef_chain_list_head
;
2429 ldlang_undef_chain_list_head
= new;
2431 new->name
= xstrdup (name
);
2433 if (output_bfd
!= NULL
)
2434 insert_undefined (new->name
);
2437 /* Insert NAME as undefined in the symbol table. */
2440 insert_undefined (const char *name
)
2442 struct bfd_link_hash_entry
*h
;
2444 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, FALSE
, TRUE
);
2446 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2447 if (h
->type
== bfd_link_hash_new
)
2449 h
->type
= bfd_link_hash_undefined
;
2450 h
->u
.undef
.abfd
= NULL
;
2451 bfd_link_add_undef (link_info
.hash
, h
);
2455 /* Run through the list of undefineds created above and place them
2456 into the linker hash table as undefined symbols belonging to the
2460 lang_place_undefineds (void)
2462 ldlang_undef_chain_list_type
*ptr
;
2464 for (ptr
= ldlang_undef_chain_list_head
; ptr
!= NULL
; ptr
= ptr
->next
)
2465 insert_undefined (ptr
->name
);
2468 /* Check for all readonly or some readwrite sections. */
2471 check_input_sections
2472 (lang_statement_union_type
*s
,
2473 lang_output_section_statement_type
*output_section_statement
)
2475 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->header
.next
)
2477 switch (s
->header
.type
)
2479 case lang_wild_statement_enum
:
2480 walk_wild (&s
->wild_statement
, check_section_callback
,
2481 output_section_statement
);
2482 if (! output_section_statement
->all_input_readonly
)
2485 case lang_constructors_statement_enum
:
2486 check_input_sections (constructor_list
.head
,
2487 output_section_statement
);
2488 if (! output_section_statement
->all_input_readonly
)
2491 case lang_group_statement_enum
:
2492 check_input_sections (s
->group_statement
.children
.head
,
2493 output_section_statement
);
2494 if (! output_section_statement
->all_input_readonly
)
2503 /* Update wildcard statements if needed. */
2506 update_wild_statements (lang_statement_union_type
*s
)
2508 struct wildcard_list
*sec
;
2510 switch (sort_section
)
2520 for (; s
!= NULL
; s
= s
->header
.next
)
2522 switch (s
->header
.type
)
2527 case lang_wild_statement_enum
:
2528 sec
= s
->wild_statement
.section_list
;
2531 switch (sec
->spec
.sorted
)
2534 sec
->spec
.sorted
= sort_section
;
2537 if (sort_section
== by_alignment
)
2538 sec
->spec
.sorted
= by_name_alignment
;
2541 if (sort_section
== by_name
)
2542 sec
->spec
.sorted
= by_alignment_name
;
2550 case lang_constructors_statement_enum
:
2551 update_wild_statements (constructor_list
.head
);
2554 case lang_output_section_statement_enum
:
2555 update_wild_statements
2556 (s
->output_section_statement
.children
.head
);
2559 case lang_group_statement_enum
:
2560 update_wild_statements (s
->group_statement
.children
.head
);
2568 /* Open input files and attach to output sections. */
2571 map_input_to_output_sections
2572 (lang_statement_union_type
*s
, const char *target
,
2573 lang_output_section_statement_type
*os
)
2575 for (; s
!= NULL
; s
= s
->header
.next
)
2577 switch (s
->header
.type
)
2579 case lang_wild_statement_enum
:
2580 wild (&s
->wild_statement
, target
, os
);
2582 case lang_constructors_statement_enum
:
2583 map_input_to_output_sections (constructor_list
.head
,
2587 case lang_output_section_statement_enum
:
2588 if (s
->output_section_statement
.constraint
)
2590 if (s
->output_section_statement
.constraint
== -1)
2592 s
->output_section_statement
.all_input_readonly
= TRUE
;
2593 check_input_sections (s
->output_section_statement
.children
.head
,
2594 &s
->output_section_statement
);
2595 if ((s
->output_section_statement
.all_input_readonly
2596 && s
->output_section_statement
.constraint
== ONLY_IF_RW
)
2597 || (!s
->output_section_statement
.all_input_readonly
2598 && s
->output_section_statement
.constraint
== ONLY_IF_RO
))
2600 s
->output_section_statement
.constraint
= -1;
2605 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
2607 &s
->output_section_statement
);
2609 case lang_output_statement_enum
:
2611 case lang_target_statement_enum
:
2612 target
= s
->target_statement
.target
;
2614 case lang_group_statement_enum
:
2615 map_input_to_output_sections (s
->group_statement
.children
.head
,
2619 case lang_data_statement_enum
:
2620 /* Make sure that any sections mentioned in the expression
2622 exp_init_os (s
->data_statement
.exp
);
2623 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2625 /* The output section gets contents, and then we inspect for
2626 any flags set in the input script which override any ALLOC. */
2627 os
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
2628 if (!(os
->flags
& SEC_NEVER_LOAD
))
2629 os
->bfd_section
->flags
|= SEC_ALLOC
| SEC_LOAD
;
2631 case lang_fill_statement_enum
:
2632 case lang_input_section_enum
:
2633 case lang_object_symbols_statement_enum
:
2634 case lang_reloc_statement_enum
:
2635 case lang_padding_statement_enum
:
2636 case lang_input_statement_enum
:
2637 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2640 case lang_assignment_statement_enum
:
2641 if (os
!= NULL
&& os
->bfd_section
== NULL
)
2644 /* Make sure that any sections mentioned in the assignment
2646 exp_init_os (s
->assignment_statement
.exp
);
2648 case lang_afile_asection_pair_statement_enum
:
2651 case lang_address_statement_enum
:
2652 /* Mark the specified section with the supplied address. */
2654 lang_output_section_statement_type
*aos
2655 = (lang_output_section_statement_lookup
2656 (s
->address_statement
.section_name
));
2658 if (aos
->bfd_section
== NULL
)
2660 aos
->addr_tree
= s
->address_statement
.address
;
2667 /* An output section might have been removed after its statement was
2668 added. For example, ldemul_before_allocation can remove dynamic
2669 sections if they turn out to be not needed. Clean them up here. */
2672 strip_excluded_output_sections (void)
2674 lang_output_section_statement_type
*os
;
2676 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
2682 if (os
->constraint
== -1)
2684 s
= os
->bfd_section
;
2685 if (s
!= NULL
&& (s
->flags
& SEC_EXCLUDE
) != 0)
2689 os
->bfd_section
= NULL
;
2691 for (p
= &output_bfd
->sections
; *p
; p
= &(*p
)->next
)
2694 bfd_section_list_remove (output_bfd
, p
);
2695 output_bfd
->section_count
--;
2703 print_output_section_statement
2704 (lang_output_section_statement_type
*output_section_statement
)
2706 asection
*section
= output_section_statement
->bfd_section
;
2709 if (output_section_statement
!= abs_output_section
)
2711 minfo ("\n%s", output_section_statement
->name
);
2713 if (section
!= NULL
)
2715 print_dot
= section
->vma
;
2717 len
= strlen (output_section_statement
->name
);
2718 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2723 while (len
< SECTION_NAME_MAP_LENGTH
)
2729 minfo ("0x%V %W", section
->vma
, section
->size
);
2731 if (output_section_statement
->load_base
!= NULL
)
2735 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
2736 "load base", lang_final_phase_enum
);
2737 minfo (_(" load address 0x%V"), addr
);
2744 print_statement_list (output_section_statement
->children
.head
,
2745 output_section_statement
);
2749 print_assignment (lang_assignment_statement_type
*assignment
,
2750 lang_output_section_statement_type
*output_section
)
2755 etree_value_type result
;
2757 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2760 if (assignment
->exp
->type
.node_class
== etree_assert
)
2763 tree
= assignment
->exp
->assert_s
.child
;
2767 const char *dst
= assignment
->exp
->assign
.dst
;
2768 is_dot
= dst
[0] == '.' && dst
[1] == 0;
2769 tree
= assignment
->exp
->assign
.src
;
2772 result
= exp_fold_tree (tree
, output_section
, lang_final_phase_enum
,
2773 print_dot
, &print_dot
);
2778 value
= result
.value
+ result
.section
->bfd_section
->vma
;
2780 minfo ("0x%V", value
);
2793 exp_print_tree (assignment
->exp
);
2798 print_input_statement (lang_input_statement_type
*statm
)
2800 if (statm
->filename
!= NULL
)
2802 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
2806 /* Print all symbols defined in a particular section. This is called
2807 via bfd_link_hash_traverse, or by print_all_symbols. */
2810 print_one_symbol (struct bfd_link_hash_entry
*hash_entry
, void *ptr
)
2812 asection
*sec
= ptr
;
2814 if ((hash_entry
->type
== bfd_link_hash_defined
2815 || hash_entry
->type
== bfd_link_hash_defweak
)
2816 && sec
== hash_entry
->u
.def
.section
)
2820 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2823 (hash_entry
->u
.def
.value
2824 + hash_entry
->u
.def
.section
->output_offset
2825 + hash_entry
->u
.def
.section
->output_section
->vma
));
2827 minfo (" %T\n", hash_entry
->root
.string
);
2834 print_all_symbols (sec
)
2837 struct fat_user_section_struct
*ud
= get_userdata (sec
);
2838 struct map_symbol_def
*def
;
2843 *ud
->map_symbol_def_tail
= 0;
2844 for (def
= ud
->map_symbol_def_head
; def
; def
= def
->next
)
2845 print_one_symbol (def
->entry
, sec
);
2848 /* Print information about an input section to the map file. */
2851 print_input_section (lang_input_section_type
*in
)
2853 asection
*i
= in
->section
;
2854 bfd_size_type size
= i
->size
;
2863 minfo ("%s", i
->name
);
2865 len
= 1 + strlen (i
->name
);
2866 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
2871 while (len
< SECTION_NAME_MAP_LENGTH
)
2877 if (i
->output_section
!= NULL
&& (i
->flags
& SEC_EXCLUDE
) == 0)
2878 addr
= i
->output_section
->vma
+ i
->output_offset
;
2885 minfo ("0x%V %W %B\n", addr
, TO_ADDR (size
), i
->owner
);
2887 if (size
!= i
->rawsize
&& i
->rawsize
!= 0)
2889 len
= SECTION_NAME_MAP_LENGTH
+ 3;
2901 minfo (_("%W (size before relaxing)\n"), i
->rawsize
);
2904 if (i
->output_section
!= NULL
&& (i
->flags
& SEC_EXCLUDE
) == 0)
2906 if (command_line
.reduce_memory_overheads
)
2907 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, i
);
2909 print_all_symbols (i
);
2911 print_dot
= addr
+ TO_ADDR (size
);
2917 print_fill_statement (lang_fill_statement_type
*fill
)
2921 fputs (" FILL mask 0x", config
.map_file
);
2922 for (p
= fill
->fill
->data
, size
= fill
->fill
->size
; size
!= 0; p
++, size
--)
2923 fprintf (config
.map_file
, "%02x", *p
);
2924 fputs ("\n", config
.map_file
);
2928 print_data_statement (lang_data_statement_type
*data
)
2936 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
2939 addr
= data
->output_vma
;
2940 if (data
->output_section
!= NULL
)
2941 addr
+= data
->output_section
->vma
;
2969 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
2971 if (data
->exp
->type
.node_class
!= etree_value
)
2974 exp_print_tree (data
->exp
);
2979 print_dot
= addr
+ TO_ADDR (size
);
2982 /* Print an address statement. These are generated by options like
2986 print_address_statement (lang_address_statement_type
*address
)
2988 minfo (_("Address of section %s set to "), address
->section_name
);
2989 exp_print_tree (address
->address
);
2993 /* Print a reloc statement. */
2996 print_reloc_statement (lang_reloc_statement_type
*reloc
)
3003 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
3006 addr
= reloc
->output_vma
;
3007 if (reloc
->output_section
!= NULL
)
3008 addr
+= reloc
->output_section
->vma
;
3010 size
= bfd_get_reloc_size (reloc
->howto
);
3012 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
3014 if (reloc
->name
!= NULL
)
3015 minfo ("%s+", reloc
->name
);
3017 minfo ("%s+", reloc
->section
->name
);
3019 exp_print_tree (reloc
->addend_exp
);
3023 print_dot
= addr
+ TO_ADDR (size
);
3027 print_padding_statement (lang_padding_statement_type
*s
)
3035 len
= sizeof " *fill*" - 1;
3036 while (len
< SECTION_NAME_MAP_LENGTH
)
3042 addr
= s
->output_offset
;
3043 if (s
->output_section
!= NULL
)
3044 addr
+= s
->output_section
->vma
;
3045 minfo ("0x%V %W ", addr
, (bfd_vma
) s
->size
);
3047 if (s
->fill
->size
!= 0)
3051 for (p
= s
->fill
->data
, size
= s
->fill
->size
; size
!= 0; p
++, size
--)
3052 fprintf (config
.map_file
, "%02x", *p
);
3057 print_dot
= addr
+ TO_ADDR (s
->size
);
3061 print_wild_statement (lang_wild_statement_type
*w
,
3062 lang_output_section_statement_type
*os
)
3064 struct wildcard_list
*sec
;
3068 if (w
->filenames_sorted
)
3070 if (w
->filename
!= NULL
)
3071 minfo ("%s", w
->filename
);
3074 if (w
->filenames_sorted
)
3078 for (sec
= w
->section_list
; sec
; sec
= sec
->next
)
3080 if (sec
->spec
.sorted
)
3082 if (sec
->spec
.exclude_name_list
!= NULL
)
3085 minfo ("EXCLUDE_FILE(%s", sec
->spec
.exclude_name_list
->name
);
3086 for (tmp
= sec
->spec
.exclude_name_list
->next
; tmp
; tmp
= tmp
->next
)
3087 minfo (" %s", tmp
->name
);
3090 if (sec
->spec
.name
!= NULL
)
3091 minfo ("%s", sec
->spec
.name
);
3094 if (sec
->spec
.sorted
)
3103 print_statement_list (w
->children
.head
, os
);
3106 /* Print a group statement. */
3109 print_group (lang_group_statement_type
*s
,
3110 lang_output_section_statement_type
*os
)
3112 fprintf (config
.map_file
, "START GROUP\n");
3113 print_statement_list (s
->children
.head
, os
);
3114 fprintf (config
.map_file
, "END GROUP\n");
3117 /* Print the list of statements in S.
3118 This can be called for any statement type. */
3121 print_statement_list (lang_statement_union_type
*s
,
3122 lang_output_section_statement_type
*os
)
3126 print_statement (s
, os
);
3131 /* Print the first statement in statement list S.
3132 This can be called for any statement type. */
3135 print_statement (lang_statement_union_type
*s
,
3136 lang_output_section_statement_type
*os
)
3138 switch (s
->header
.type
)
3141 fprintf (config
.map_file
, _("Fail with %d\n"), s
->header
.type
);
3144 case lang_constructors_statement_enum
:
3145 if (constructor_list
.head
!= NULL
)
3147 if (constructors_sorted
)
3148 minfo (" SORT (CONSTRUCTORS)\n");
3150 minfo (" CONSTRUCTORS\n");
3151 print_statement_list (constructor_list
.head
, os
);
3154 case lang_wild_statement_enum
:
3155 print_wild_statement (&s
->wild_statement
, os
);
3157 case lang_address_statement_enum
:
3158 print_address_statement (&s
->address_statement
);
3160 case lang_object_symbols_statement_enum
:
3161 minfo (" CREATE_OBJECT_SYMBOLS\n");
3163 case lang_fill_statement_enum
:
3164 print_fill_statement (&s
->fill_statement
);
3166 case lang_data_statement_enum
:
3167 print_data_statement (&s
->data_statement
);
3169 case lang_reloc_statement_enum
:
3170 print_reloc_statement (&s
->reloc_statement
);
3172 case lang_input_section_enum
:
3173 print_input_section (&s
->input_section
);
3175 case lang_padding_statement_enum
:
3176 print_padding_statement (&s
->padding_statement
);
3178 case lang_output_section_statement_enum
:
3179 print_output_section_statement (&s
->output_section_statement
);
3181 case lang_assignment_statement_enum
:
3182 print_assignment (&s
->assignment_statement
, os
);
3184 case lang_target_statement_enum
:
3185 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
3187 case lang_output_statement_enum
:
3188 minfo ("OUTPUT(%s", s
->output_statement
.name
);
3189 if (output_target
!= NULL
)
3190 minfo (" %s", output_target
);
3193 case lang_input_statement_enum
:
3194 print_input_statement (&s
->input_statement
);
3196 case lang_group_statement_enum
:
3197 print_group (&s
->group_statement
, os
);
3199 case lang_afile_asection_pair_statement_enum
:
3206 print_statements (void)
3208 print_statement_list (statement_list
.head
, abs_output_section
);
3211 /* Print the first N statements in statement list S to STDERR.
3212 If N == 0, nothing is printed.
3213 If N < 0, the entire list is printed.
3214 Intended to be called from GDB. */
3217 dprint_statement (lang_statement_union_type
*s
, int n
)
3219 FILE *map_save
= config
.map_file
;
3221 config
.map_file
= stderr
;
3224 print_statement_list (s
, abs_output_section
);
3227 while (s
&& --n
>= 0)
3229 print_statement (s
, abs_output_section
);
3234 config
.map_file
= map_save
;
3238 insert_pad (lang_statement_union_type
**ptr
,
3240 unsigned int alignment_needed
,
3241 asection
*output_section
,
3244 static fill_type zero_fill
= { 1, { 0 } };
3245 lang_statement_union_type
*pad
;
3247 pad
= ((lang_statement_union_type
*)
3248 ((char *) ptr
- offsetof (lang_statement_union_type
, header
.next
)));
3249 if (ptr
!= &statement_list
.head
3250 && pad
->header
.type
== lang_padding_statement_enum
3251 && pad
->padding_statement
.output_section
== output_section
)
3253 /* Use the existing pad statement. The above test on output
3254 section is probably redundant, but it doesn't hurt to check. */
3258 /* Make a new padding statement, linked into existing chain. */
3259 pad
= stat_alloc (sizeof (lang_padding_statement_type
));
3260 pad
->header
.next
= *ptr
;
3262 pad
->header
.type
= lang_padding_statement_enum
;
3263 pad
->padding_statement
.output_section
= output_section
;
3266 pad
->padding_statement
.fill
= fill
;
3268 pad
->padding_statement
.output_offset
= dot
- output_section
->vma
;
3269 pad
->padding_statement
.size
= alignment_needed
;
3270 output_section
->size
+= alignment_needed
;
3273 /* Work out how much this section will move the dot point. */
3277 (lang_statement_union_type
**this_ptr
,
3278 lang_output_section_statement_type
*output_section_statement
,
3282 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
3283 asection
*i
= is
->section
;
3285 if (!is
->ifile
->just_syms_flag
&& (i
->flags
& SEC_EXCLUDE
) == 0)
3287 unsigned int alignment_needed
;
3290 /* Align this section first to the input sections requirement,
3291 then to the output section's requirement. If this alignment
3292 is greater than any seen before, then record it too. Perform
3293 the alignment by inserting a magic 'padding' statement. */
3295 if (output_section_statement
->subsection_alignment
!= -1)
3296 i
->alignment_power
= output_section_statement
->subsection_alignment
;
3298 o
= output_section_statement
->bfd_section
;
3299 if (o
->alignment_power
< i
->alignment_power
)
3300 o
->alignment_power
= i
->alignment_power
;
3302 alignment_needed
= align_power (dot
, i
->alignment_power
) - dot
;
3304 if (alignment_needed
!= 0)
3306 insert_pad (this_ptr
, fill
, TO_SIZE (alignment_needed
), o
, dot
);
3307 dot
+= alignment_needed
;
3310 /* Remember where in the output section this input section goes. */
3312 i
->output_offset
= dot
- o
->vma
;
3314 /* Mark how big the output section must be to contain this now. */
3315 dot
+= TO_ADDR (i
->size
);
3316 o
->size
= TO_SIZE (dot
- o
->vma
);
3320 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
3326 #define IGNORE_SECTION(s) \
3327 ((s->flags & SEC_NEVER_LOAD) != 0 \
3328 || (s->flags & SEC_ALLOC) == 0 \
3329 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
3330 && (s->flags & SEC_LOAD) == 0) \
3333 /* Check to see if any allocated sections overlap with other allocated
3334 sections. This can happen if a linker script specifies the output
3335 section addresses of the two sections. */
3338 lang_check_section_addresses (void)
3342 /* Scan all sections in the output list. */
3343 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
3347 /* Ignore sections which are not loaded or which have no contents. */
3348 if (IGNORE_SECTION (s
))
3351 /* Once we reach section 's' stop our seach. This prevents two
3352 warning messages from being produced, one for 'section A overlaps
3353 section B' and one for 'section B overlaps section A'. */
3354 for (os
= output_bfd
->sections
; os
!= s
; os
= os
->next
)
3361 /* Only consider loadable sections with real contents. */
3362 if (IGNORE_SECTION (os
))
3365 /* We must check the sections' LMA addresses not their
3366 VMA addresses because overlay sections can have
3367 overlapping VMAs but they must have distinct LMAs. */
3368 s_start
= bfd_section_lma (output_bfd
, s
);
3369 os_start
= bfd_section_lma (output_bfd
, os
);
3370 s_end
= s_start
+ TO_ADDR (s
->size
) - 1;
3371 os_end
= os_start
+ TO_ADDR (os
->size
) - 1;
3373 /* Look for an overlap. */
3374 if ((s_end
< os_start
) || (s_start
> os_end
))
3378 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
3379 s
->name
, s_start
, s_end
, os
->name
, os_start
, os_end
);
3381 /* Once we have found one overlap for this section,
3382 stop looking for others. */
3388 /* Make sure the new address is within the region. We explicitly permit the
3389 current address to be at the exact end of the region when the address is
3390 non-zero, in case the region is at the end of addressable memory and the
3391 calculation wraps around. */
3394 os_region_check (lang_output_section_statement_type
*os
,
3395 lang_memory_region_type
*region
,
3399 if ((region
->current
< region
->origin
3400 || (region
->current
- region
->origin
> region
->length
))
3401 && ((region
->current
!= region
->origin
+ region
->length
)
3406 einfo (_("%X%P: address 0x%v of %B section %s"
3407 " is not within region %s\n"),
3409 os
->bfd_section
->owner
,
3410 os
->bfd_section
->name
,
3415 einfo (_("%X%P: region %s is full (%B section %s)\n"),
3417 os
->bfd_section
->owner
,
3418 os
->bfd_section
->name
);
3420 /* Reset the region pointer. */
3421 region
->current
= region
->origin
;
3425 /* Set the sizes for all the output sections. */
3428 lang_size_sections_1
3429 (lang_statement_union_type
*s
,
3430 lang_output_section_statement_type
*output_section_statement
,
3431 lang_statement_union_type
**prev
,
3435 bfd_boolean check_regions
)
3437 /* Size up the sections from their constituent parts. */
3438 for (; s
!= NULL
; s
= s
->header
.next
)
3440 switch (s
->header
.type
)
3442 case lang_output_section_statement_enum
:
3445 lang_output_section_statement_type
*os
;
3447 os
= &s
->output_section_statement
;
3448 if (os
->bfd_section
== NULL
)
3449 /* This section was never actually created. */
3452 /* If this is a COFF shared library section, use the size and
3453 address from the input section. FIXME: This is COFF
3454 specific; it would be cleaner if there were some other way
3455 to do this, but nothing simple comes to mind. */
3456 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
3460 if (os
->children
.head
== NULL
3461 || os
->children
.head
->header
.next
!= NULL
3462 || (os
->children
.head
->header
.type
3463 != lang_input_section_enum
))
3464 einfo (_("%P%X: Internal error on COFF shared library"
3465 " section %s\n"), os
->name
);
3467 input
= os
->children
.head
->input_section
.section
;
3468 bfd_set_section_vma (os
->bfd_section
->owner
,
3470 bfd_section_vma (input
->owner
, input
));
3471 os
->bfd_section
->size
= input
->size
;
3475 if (bfd_is_abs_section (os
->bfd_section
))
3477 /* No matter what happens, an abs section starts at zero. */
3478 ASSERT (os
->bfd_section
->vma
== 0);
3482 if (os
->addr_tree
== NULL
)
3484 /* No address specified for this section, get one
3485 from the region specification. */
3486 if (os
->region
== NULL
3487 || ((os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))
3488 && os
->region
->name
[0] == '*'
3489 && strcmp (os
->region
->name
,
3490 DEFAULT_MEMORY_REGION
) == 0))
3492 os
->region
= lang_memory_default (os
->bfd_section
);
3495 /* If a loadable section is using the default memory
3496 region, and some non default memory regions were
3497 defined, issue an error message. */
3498 if (!IGNORE_SECTION (os
->bfd_section
)
3499 && ! link_info
.relocatable
3501 && strcmp (os
->region
->name
,
3502 DEFAULT_MEMORY_REGION
) == 0
3503 && lang_memory_region_list
!= NULL
3504 && (strcmp (lang_memory_region_list
->name
,
3505 DEFAULT_MEMORY_REGION
) != 0
3506 || lang_memory_region_list
->next
!= NULL
))
3508 /* By default this is an error rather than just a
3509 warning because if we allocate the section to the
3510 default memory region we can end up creating an
3511 excessively large binary, or even seg faulting when
3512 attempting to perform a negative seek. See
3513 sources.redhat.com/ml/binutils/2003-04/msg00423.html
3514 for an example of this. This behaviour can be
3515 overridden by the using the --no-check-sections
3517 if (command_line
.check_section_addresses
)
3518 einfo (_("%P%F: error: no memory region specified"
3519 " for loadable section `%s'\n"),
3520 bfd_get_section_name (output_bfd
,
3523 einfo (_("%P: warning: no memory region specified"
3524 " for loadable section `%s'\n"),
3525 bfd_get_section_name (output_bfd
,
3529 dot
= os
->region
->current
;
3531 if (os
->section_alignment
== -1)
3536 dot
= align_power (dot
,
3537 os
->bfd_section
->alignment_power
);
3539 if (dot
!= olddot
&& config
.warn_section_align
)
3540 einfo (_("%P: warning: changing start of section"
3541 " %s by %u bytes\n"),
3542 os
->name
, (unsigned int) (dot
- olddot
));
3550 r
= exp_fold_tree (os
->addr_tree
,
3552 lang_allocating_phase_enum
,
3557 einfo (_("%F%S: non constant or forward reference"
3558 " address expression for section %s\n"),
3561 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
3564 /* The section starts here.
3565 First, align to what the section needs. */
3567 if (os
->section_alignment
!= -1)
3568 dot
= align_power (dot
, os
->section_alignment
);
3570 bfd_set_section_vma (0, os
->bfd_section
, dot
);
3572 os
->bfd_section
->output_offset
= 0;
3575 lang_size_sections_1 (os
->children
.head
, os
, &os
->children
.head
,
3576 os
->fill
, dot
, relax
, check_regions
);
3578 /* Put the section within the requested block size, or
3579 align at the block boundary. */
3580 after
= ((os
->bfd_section
->vma
3581 + TO_ADDR (os
->bfd_section
->size
)
3582 + os
->block_value
- 1)
3583 & - (bfd_vma
) os
->block_value
);
3585 if (bfd_is_abs_section (os
->bfd_section
))
3586 ASSERT (after
== os
->bfd_section
->vma
);
3588 os
->bfd_section
->size
3589 = TO_SIZE (after
- os
->bfd_section
->vma
);
3591 dot
= os
->bfd_section
->vma
;
3592 /* .tbss sections effectively have zero size. */
3593 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
3594 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
3595 || link_info
.relocatable
)
3596 dot
+= TO_ADDR (os
->bfd_section
->size
);
3600 if (os
->update_dot_tree
!= 0)
3601 exp_fold_tree (os
->update_dot_tree
, abs_output_section
,
3602 lang_allocating_phase_enum
, dot
, &dot
);
3604 /* Update dot in the region ?
3605 We only do this if the section is going to be allocated,
3606 since unallocated sections do not contribute to the region's
3607 overall size in memory.
3609 If the SEC_NEVER_LOAD bit is not set, it will affect the
3610 addresses of sections after it. We have to update
3612 if (os
->region
!= NULL
3613 && ((os
->bfd_section
->flags
& SEC_NEVER_LOAD
) == 0
3614 || (os
->bfd_section
->flags
& (SEC_ALLOC
| SEC_LOAD
))))
3616 os
->region
->current
= dot
;
3619 /* Make sure the new address is within the region. */
3620 os_region_check (os
, os
->region
, os
->addr_tree
,
3621 os
->bfd_section
->vma
);
3623 /* If there's no load address specified, use the run
3624 region as the load region. */
3625 if (os
->lma_region
== NULL
&& os
->load_base
== NULL
)
3626 os
->lma_region
= os
->region
;
3628 if (os
->lma_region
!= NULL
&& os
->lma_region
!= os
->region
)
3630 /* Set load_base, which will be handled later. */
3631 os
->load_base
= exp_intop (os
->lma_region
->current
);
3632 os
->lma_region
->current
+=
3633 TO_ADDR (os
->bfd_section
->size
);
3635 os_region_check (os
, os
->lma_region
, NULL
,
3636 os
->bfd_section
->lma
);
3642 case lang_constructors_statement_enum
:
3643 dot
= lang_size_sections_1 (constructor_list
.head
,
3644 output_section_statement
,
3645 &s
->wild_statement
.children
.head
,
3646 fill
, dot
, relax
, check_regions
);
3649 case lang_data_statement_enum
:
3651 unsigned int size
= 0;
3653 s
->data_statement
.output_vma
=
3654 dot
- output_section_statement
->bfd_section
->vma
;
3655 s
->data_statement
.output_section
=
3656 output_section_statement
->bfd_section
;
3658 /* We might refer to provided symbols in the expression, and
3659 need to mark them as needed. */
3660 exp_fold_tree (s
->data_statement
.exp
, abs_output_section
,
3661 lang_allocating_phase_enum
, dot
, &dot
);
3663 switch (s
->data_statement
.type
)
3681 if (size
< TO_SIZE ((unsigned) 1))
3682 size
= TO_SIZE ((unsigned) 1);
3683 dot
+= TO_ADDR (size
);
3684 output_section_statement
->bfd_section
->size
+= size
;
3688 case lang_reloc_statement_enum
:
3692 s
->reloc_statement
.output_vma
=
3693 dot
- output_section_statement
->bfd_section
->vma
;
3694 s
->reloc_statement
.output_section
=
3695 output_section_statement
->bfd_section
;
3696 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
3697 dot
+= TO_ADDR (size
);
3698 output_section_statement
->bfd_section
->size
+= size
;
3702 case lang_wild_statement_enum
:
3704 dot
= lang_size_sections_1 (s
->wild_statement
.children
.head
,
3705 output_section_statement
,
3706 &s
->wild_statement
.children
.head
,
3707 fill
, dot
, relax
, check_regions
);
3711 case lang_object_symbols_statement_enum
:
3712 link_info
.create_object_symbols_section
=
3713 output_section_statement
->bfd_section
;
3715 case lang_output_statement_enum
:
3716 case lang_target_statement_enum
:
3718 case lang_input_section_enum
:
3722 i
= (*prev
)->input_section
.section
;
3727 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
3728 einfo (_("%P%F: can't relax section: %E\n"));
3732 dot
= size_input_section (prev
, output_section_statement
,
3733 output_section_statement
->fill
, dot
);
3736 case lang_input_statement_enum
:
3738 case lang_fill_statement_enum
:
3739 s
->fill_statement
.output_section
=
3740 output_section_statement
->bfd_section
;
3742 fill
= s
->fill_statement
.fill
;
3744 case lang_assignment_statement_enum
:
3746 bfd_vma newdot
= dot
;
3748 exp_fold_tree (s
->assignment_statement
.exp
,
3749 output_section_statement
,
3750 lang_allocating_phase_enum
,
3756 if (output_section_statement
== abs_output_section
)
3758 /* If we don't have an output section, then just adjust
3759 the default memory address. */
3760 lang_memory_region_lookup (DEFAULT_MEMORY_REGION
,
3761 FALSE
)->current
= newdot
;
3765 /* Insert a pad after this statement. We can't
3766 put the pad before when relaxing, in case the
3767 assignment references dot. */
3768 insert_pad (&s
->header
.next
, fill
, TO_SIZE (newdot
- dot
),
3769 output_section_statement
->bfd_section
, dot
);
3771 /* Don't neuter the pad below when relaxing. */
3775 /* If dot is advanced, this implies that the section should
3776 have space allocated to it, unless the user has explicitly
3777 stated that the section should never be loaded. */
3778 if (!(output_section_statement
->flags
3779 & (SEC_NEVER_LOAD
| SEC_ALLOC
)))
3780 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
;
3787 case lang_padding_statement_enum
:
3788 /* If this is the first time lang_size_sections is called,
3789 we won't have any padding statements. If this is the
3790 second or later passes when relaxing, we should allow
3791 padding to shrink. If padding is needed on this pass, it
3792 will be added back in. */
3793 s
->padding_statement
.size
= 0;
3795 /* Make sure output_offset is valid. If relaxation shrinks
3796 the section and this pad isn't needed, it's possible to
3797 have output_offset larger than the final size of the
3798 section. bfd_set_section_contents will complain even for
3799 a pad size of zero. */
3800 s
->padding_statement
.output_offset
3801 = dot
- output_section_statement
->bfd_section
->vma
;
3804 case lang_group_statement_enum
:
3805 dot
= lang_size_sections_1 (s
->group_statement
.children
.head
,
3806 output_section_statement
,
3807 &s
->group_statement
.children
.head
,
3808 fill
, dot
, relax
, check_regions
);
3815 /* We can only get here when relaxing is turned on. */
3816 case lang_address_statement_enum
:
3819 prev
= &s
->header
.next
;
3826 (lang_statement_union_type
*s
,
3827 lang_output_section_statement_type
*output_section_statement
,
3828 lang_statement_union_type
**prev
,
3832 bfd_boolean check_regions
)
3836 /* Callers of exp_fold_tree need to increment this. */
3837 lang_statement_iteration
++;
3839 exp_data_seg
.phase
= exp_dataseg_none
;
3840 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
3841 dot
, relax
, check_regions
);
3842 if (exp_data_seg
.phase
== exp_dataseg_end_seen
3843 && link_info
.relro
&& exp_data_seg
.relro_end
)
3845 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
3846 to put exp_data_seg.relro on a (common) page boundary. */
3847 bfd_vma old_base
, relro_end
;
3849 exp_data_seg
.phase
= exp_dataseg_relro_adjust
;
3850 old_base
= exp_data_seg
.base
;
3851 exp_data_seg
.base
+= (-exp_data_seg
.relro_end
3852 & (exp_data_seg
.pagesize
- 1));
3853 /* Compute the expected PT_GNU_RELRO segment end. */
3854 relro_end
= (exp_data_seg
.relro_end
+ exp_data_seg
.pagesize
- 1)
3855 & (exp_data_seg
.pagesize
- 1);
3856 result
= lang_size_sections_1 (s
, output_section_statement
, prev
, fill
,
3857 dot
, relax
, check_regions
);
3858 if (exp_data_seg
.relro_end
> relro_end
)
3860 /* The alignment of sections between DATA_SEGMENT_ALIGN
3861 and DATA_SEGMENT_RELRO_END caused huge padding to be
3862 inserted at DATA_SEGMENT_RELRO_END. Try some other base. */
3864 unsigned int max_alignment_power
= 0;
3866 /* Find maximum alignment power of sections between
3867 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
3868 for (sec
= output_bfd
->sections
; sec
; sec
= sec
->next
)
3869 if (sec
->vma
>= exp_data_seg
.base
3870 && sec
->vma
< exp_data_seg
.relro_end
3871 && sec
->alignment_power
> max_alignment_power
)
3872 max_alignment_power
= sec
->alignment_power
;
3874 if (((bfd_vma
) 1 << max_alignment_power
) < exp_data_seg
.pagesize
)
3876 if (exp_data_seg
.base
- (1 << max_alignment_power
)
3878 exp_data_seg
.base
+= exp_data_seg
.pagesize
;
3879 exp_data_seg
.base
-= (1 << max_alignment_power
);
3880 result
= lang_size_sections_1 (s
, output_section_statement
,
3881 prev
, fill
, dot
, relax
,
3885 link_info
.relro_start
= exp_data_seg
.base
;
3886 link_info
.relro_end
= exp_data_seg
.relro_end
;
3888 else if (exp_data_seg
.phase
== exp_dataseg_end_seen
)
3890 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3891 a page could be saved in the data segment. */
3892 bfd_vma first
, last
;
3894 first
= -exp_data_seg
.base
& (exp_data_seg
.pagesize
- 1);
3895 last
= exp_data_seg
.end
& (exp_data_seg
.pagesize
- 1);
3897 && ((exp_data_seg
.base
& ~(exp_data_seg
.pagesize
- 1))
3898 != (exp_data_seg
.end
& ~(exp_data_seg
.pagesize
- 1)))
3899 && first
+ last
<= exp_data_seg
.pagesize
)
3901 exp_data_seg
.phase
= exp_dataseg_adjust
;
3902 lang_statement_iteration
++;
3903 result
= lang_size_sections_1 (s
, output_section_statement
, prev
,
3904 fill
, dot
, relax
, check_regions
);
3911 /* Worker function for lang_do_assignments. Recursiveness goes here. */
3914 lang_do_assignments_1
3915 (lang_statement_union_type
*s
,
3916 lang_output_section_statement_type
*output_section_statement
,
3920 for (; s
!= NULL
; s
= s
->header
.next
)
3922 switch (s
->header
.type
)
3924 case lang_constructors_statement_enum
:
3925 dot
= lang_do_assignments_1 (constructor_list
.head
,
3926 output_section_statement
,
3931 case lang_output_section_statement_enum
:
3933 lang_output_section_statement_type
*os
;
3935 os
= &(s
->output_section_statement
);
3936 if (os
->bfd_section
!= NULL
)
3938 dot
= os
->bfd_section
->vma
;
3939 lang_do_assignments_1 (os
->children
.head
, os
, os
->fill
, dot
);
3940 /* .tbss sections effectively have zero size. */
3941 if ((os
->bfd_section
->flags
& SEC_HAS_CONTENTS
) != 0
3942 || (os
->bfd_section
->flags
& SEC_THREAD_LOCAL
) == 0
3943 || link_info
.relocatable
)
3944 dot
+= TO_ADDR (os
->bfd_section
->size
);
3948 /* If nothing has been placed into the output section then
3949 it won't have a bfd_section. */
3950 if (os
->bfd_section
)
3952 os
->bfd_section
->lma
3953 = exp_get_abs_int (os
->load_base
, 0, "load base",
3954 lang_final_phase_enum
);
3959 case lang_wild_statement_enum
:
3961 dot
= lang_do_assignments_1 (s
->wild_statement
.children
.head
,
3962 output_section_statement
,
3967 case lang_object_symbols_statement_enum
:
3968 case lang_output_statement_enum
:
3969 case lang_target_statement_enum
:
3971 case lang_common_statement_enum
:
3974 case lang_data_statement_enum
:
3976 etree_value_type value
;
3978 value
= exp_fold_tree (s
->data_statement
.exp
,
3980 lang_final_phase_enum
, dot
, &dot
);
3982 einfo (_("%F%P: invalid data statement\n"));
3983 s
->data_statement
.value
3984 = value
.value
+ value
.section
->bfd_section
->vma
;
3988 switch (s
->data_statement
.type
)
4006 if (size
< TO_SIZE ((unsigned) 1))
4007 size
= TO_SIZE ((unsigned) 1);
4008 dot
+= TO_ADDR (size
);
4012 case lang_reloc_statement_enum
:
4014 etree_value_type value
;
4016 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
4018 lang_final_phase_enum
, dot
, &dot
);
4019 s
->reloc_statement
.addend_value
= value
.value
;
4021 einfo (_("%F%P: invalid reloc statement\n"));
4023 dot
+= TO_ADDR (bfd_get_reloc_size (s
->reloc_statement
.howto
));
4026 case lang_input_section_enum
:
4028 asection
*in
= s
->input_section
.section
;
4030 if ((in
->flags
& SEC_EXCLUDE
) == 0)
4031 dot
+= TO_ADDR (in
->size
);
4035 case lang_input_statement_enum
:
4037 case lang_fill_statement_enum
:
4038 fill
= s
->fill_statement
.fill
;
4040 case lang_assignment_statement_enum
:
4042 exp_fold_tree (s
->assignment_statement
.exp
,
4043 output_section_statement
,
4044 lang_final_phase_enum
,
4050 case lang_padding_statement_enum
:
4051 dot
+= TO_ADDR (s
->padding_statement
.size
);
4054 case lang_group_statement_enum
:
4055 dot
= lang_do_assignments_1 (s
->group_statement
.children
.head
,
4056 output_section_statement
,
4064 case lang_address_statement_enum
:
4074 (lang_statement_union_type
*s
,
4075 lang_output_section_statement_type
*output_section_statement
,
4079 /* Callers of exp_fold_tree need to increment this. */
4080 lang_statement_iteration
++;
4081 lang_do_assignments_1 (s
, output_section_statement
, fill
, dot
);
4084 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
4085 operator .startof. (section_name), it produces an undefined symbol
4086 .startof.section_name. Similarly, when it sees
4087 .sizeof. (section_name), it produces an undefined symbol
4088 .sizeof.section_name. For all the output sections, we look for
4089 such symbols, and set them to the correct value. */
4092 lang_set_startof (void)
4096 if (link_info
.relocatable
)
4099 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4101 const char *secname
;
4103 struct bfd_link_hash_entry
*h
;
4105 secname
= bfd_get_section_name (output_bfd
, s
);
4106 buf
= xmalloc (10 + strlen (secname
));
4108 sprintf (buf
, ".startof.%s", secname
);
4109 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
4110 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
4112 h
->type
= bfd_link_hash_defined
;
4113 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
4114 h
->u
.def
.section
= bfd_abs_section_ptr
;
4117 sprintf (buf
, ".sizeof.%s", secname
);
4118 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, FALSE
, FALSE
, TRUE
);
4119 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
4121 h
->type
= bfd_link_hash_defined
;
4122 h
->u
.def
.value
= TO_ADDR (s
->size
);
4123 h
->u
.def
.section
= bfd_abs_section_ptr
;
4133 struct bfd_link_hash_entry
*h
;
4136 if (link_info
.relocatable
|| link_info
.shared
)
4141 if (entry_symbol
.name
== NULL
)
4143 /* No entry has been specified. Look for start, but don't warn
4144 if we don't find it. */
4145 entry_symbol
.name
= "start";
4149 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
.name
,
4150 FALSE
, FALSE
, TRUE
);
4152 && (h
->type
== bfd_link_hash_defined
4153 || h
->type
== bfd_link_hash_defweak
)
4154 && h
->u
.def
.section
->output_section
!= NULL
)
4158 val
= (h
->u
.def
.value
4159 + bfd_get_section_vma (output_bfd
,
4160 h
->u
.def
.section
->output_section
)
4161 + h
->u
.def
.section
->output_offset
);
4162 if (! bfd_set_start_address (output_bfd
, val
))
4163 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol
.name
);
4170 /* We couldn't find the entry symbol. Try parsing it as a
4172 val
= bfd_scan_vma (entry_symbol
.name
, &send
, 0);
4175 if (! bfd_set_start_address (output_bfd
, val
))
4176 einfo (_("%P%F: can't set start address\n"));
4182 /* Can't find the entry symbol, and it's not a number. Use
4183 the first address in the text section. */
4184 ts
= bfd_get_section_by_name (output_bfd
, entry_section
);
4188 einfo (_("%P: warning: cannot find entry symbol %s;"
4189 " defaulting to %V\n"),
4191 bfd_get_section_vma (output_bfd
, ts
));
4192 if (! bfd_set_start_address (output_bfd
,
4193 bfd_get_section_vma (output_bfd
,
4195 einfo (_("%P%F: can't set start address\n"));
4200 einfo (_("%P: warning: cannot find entry symbol %s;"
4201 " not setting start address\n"),
4207 /* Don't bfd_hash_table_free (&lang_definedness_table);
4208 map file output may result in a call of lang_track_definedness. */
4211 /* This is a small function used when we want to ignore errors from
4215 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED
, ...)
4217 /* Don't do anything. */
4220 /* Check that the architecture of all the input files is compatible
4221 with the output file. Also call the backend to let it do any
4222 other checking that is needed. */
4227 lang_statement_union_type
*file
;
4229 const bfd_arch_info_type
*compatible
;
4231 for (file
= file_chain
.head
; file
!= NULL
; file
= file
->input_statement
.next
)
4233 input_bfd
= file
->input_statement
.the_bfd
;
4235 = bfd_arch_get_compatible (input_bfd
, output_bfd
,
4236 command_line
.accept_unknown_input_arch
);
4238 /* In general it is not possible to perform a relocatable
4239 link between differing object formats when the input
4240 file has relocations, because the relocations in the
4241 input format may not have equivalent representations in
4242 the output format (and besides BFD does not translate
4243 relocs for other link purposes than a final link). */
4244 if ((link_info
.relocatable
|| link_info
.emitrelocations
)
4245 && (compatible
== NULL
4246 || bfd_get_flavour (input_bfd
) != bfd_get_flavour (output_bfd
))
4247 && (bfd_get_file_flags (input_bfd
) & HAS_RELOC
) != 0)
4249 einfo (_("%P%F: Relocatable linking with relocations from"
4250 " format %s (%B) to format %s (%B) is not supported\n"),
4251 bfd_get_target (input_bfd
), input_bfd
,
4252 bfd_get_target (output_bfd
), output_bfd
);
4253 /* einfo with %F exits. */
4256 if (compatible
== NULL
)
4258 if (command_line
.warn_mismatch
)
4259 einfo (_("%P: warning: %s architecture of input file `%B'"
4260 " is incompatible with %s output\n"),
4261 bfd_printable_name (input_bfd
), input_bfd
,
4262 bfd_printable_name (output_bfd
));
4264 else if (bfd_count_sections (input_bfd
))
4266 /* If the input bfd has no contents, it shouldn't set the
4267 private data of the output bfd. */
4269 bfd_error_handler_type pfn
= NULL
;
4271 /* If we aren't supposed to warn about mismatched input
4272 files, temporarily set the BFD error handler to a
4273 function which will do nothing. We still want to call
4274 bfd_merge_private_bfd_data, since it may set up
4275 information which is needed in the output file. */
4276 if (! command_line
.warn_mismatch
)
4277 pfn
= bfd_set_error_handler (ignore_bfd_errors
);
4278 if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
4280 if (command_line
.warn_mismatch
)
4281 einfo (_("%P%X: failed to merge target specific data"
4282 " of file %B\n"), input_bfd
);
4284 if (! command_line
.warn_mismatch
)
4285 bfd_set_error_handler (pfn
);
4290 /* Look through all the global common symbols and attach them to the
4291 correct section. The -sort-common command line switch may be used
4292 to roughly sort the entries by size. */
4297 if (command_line
.inhibit_common_definition
)
4299 if (link_info
.relocatable
4300 && ! command_line
.force_common_definition
)
4303 if (! config
.sort_common
)
4304 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, NULL
);
4309 for (power
= 4; power
>= 0; power
--)
4310 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, &power
);
4314 /* Place one common symbol in the correct section. */
4317 lang_one_common (struct bfd_link_hash_entry
*h
, void *info
)
4319 unsigned int power_of_two
;
4323 if (h
->type
!= bfd_link_hash_common
)
4327 power_of_two
= h
->u
.c
.p
->alignment_power
;
4329 if (config
.sort_common
4330 && power_of_two
< (unsigned int) *(int *) info
)
4333 section
= h
->u
.c
.p
->section
;
4335 /* Increase the size of the section to align the common sym. */
4336 section
->size
+= ((bfd_vma
) 1 << (power_of_two
+ opb_shift
)) - 1;
4337 section
->size
&= (- (bfd_vma
) 1 << (power_of_two
+ opb_shift
));
4339 /* Adjust the alignment if necessary. */
4340 if (power_of_two
> section
->alignment_power
)
4341 section
->alignment_power
= power_of_two
;
4343 /* Change the symbol from common to defined. */
4344 h
->type
= bfd_link_hash_defined
;
4345 h
->u
.def
.section
= section
;
4346 h
->u
.def
.value
= section
->size
;
4348 /* Increase the size of the section. */
4349 section
->size
+= size
;
4351 /* Make sure the section is allocated in memory, and make sure that
4352 it is no longer a common section. */
4353 section
->flags
|= SEC_ALLOC
;
4354 section
->flags
&= ~SEC_IS_COMMON
;
4356 if (config
.map_file
!= NULL
)
4358 static bfd_boolean header_printed
;
4363 if (! header_printed
)
4365 minfo (_("\nAllocating common symbols\n"));
4366 minfo (_("Common symbol size file\n\n"));
4367 header_printed
= TRUE
;
4370 name
= demangle (h
->root
.string
);
4372 len
= strlen (name
);
4387 if (size
<= 0xffffffff)
4388 sprintf (buf
, "%lx", (unsigned long) size
);
4390 sprintf_vma (buf
, size
);
4400 minfo ("%B\n", section
->owner
);
4406 /* Run through the input files and ensure that every input section has
4407 somewhere to go. If one is found without a destination then create
4408 an input request and place it into the statement tree. */
4411 lang_place_orphans (void)
4413 LANG_FOR_EACH_INPUT_STATEMENT (file
)
4417 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
4419 if (s
->output_section
== NULL
)
4421 /* This section of the file is not attached, root
4422 around for a sensible place for it to go. */
4424 if (file
->just_syms_flag
)
4427 if ((s
->flags
& SEC_EXCLUDE
) != 0)
4428 s
->output_section
= bfd_abs_section_ptr
;
4429 else if (strcmp (s
->name
, "COMMON") == 0)
4431 /* This is a lonely common section which must have
4432 come from an archive. We attach to the section
4433 with the wildcard. */
4434 if (! link_info
.relocatable
4435 || command_line
.force_common_definition
)
4437 if (default_common_section
== NULL
)
4440 /* This message happens when using the
4441 svr3.ifile linker script, so I have
4443 info_msg (_("%P: no [COMMON] command,"
4444 " defaulting to .bss\n"));
4446 default_common_section
=
4447 lang_output_section_statement_lookup (".bss");
4450 lang_add_section (&default_common_section
->children
, s
,
4451 default_common_section
, file
);
4454 else if (ldemul_place_orphan (file
, s
))
4458 lang_output_section_statement_type
*os
;
4460 os
= lang_output_section_statement_lookup (s
->name
);
4461 lang_add_section (&os
->children
, s
, os
, file
);
4469 lang_set_flags (lang_memory_region_type
*ptr
, const char *flags
, int invert
)
4471 flagword
*ptr_flags
;
4473 ptr_flags
= invert
? &ptr
->not_flags
: &ptr
->flags
;
4479 *ptr_flags
|= SEC_ALLOC
;
4483 *ptr_flags
|= SEC_READONLY
;
4487 *ptr_flags
|= SEC_DATA
;
4491 *ptr_flags
|= SEC_CODE
;
4496 *ptr_flags
|= SEC_LOAD
;
4500 einfo (_("%P%F: invalid syntax in flags\n"));
4507 /* Call a function on each input file. This function will be called
4508 on an archive, but not on the elements. */
4511 lang_for_each_input_file (void (*func
) (lang_input_statement_type
*))
4513 lang_input_statement_type
*f
;
4515 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
4517 f
= (lang_input_statement_type
*) f
->next_real_file
)
4521 /* Call a function on each file. The function will be called on all
4522 the elements of an archive which are included in the link, but will
4523 not be called on the archive file itself. */
4526 lang_for_each_file (void (*func
) (lang_input_statement_type
*))
4528 LANG_FOR_EACH_INPUT_STATEMENT (f
)
4535 ldlang_add_file (lang_input_statement_type
*entry
)
4539 lang_statement_append (&file_chain
,
4540 (lang_statement_union_type
*) entry
,
4543 /* The BFD linker needs to have a list of all input BFDs involved in
4545 ASSERT (entry
->the_bfd
->link_next
== NULL
);
4546 ASSERT (entry
->the_bfd
!= output_bfd
);
4547 for (pp
= &link_info
.input_bfds
; *pp
!= NULL
; pp
= &(*pp
)->link_next
)
4549 *pp
= entry
->the_bfd
;
4550 entry
->the_bfd
->usrdata
= entry
;
4551 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
4553 /* Look through the sections and check for any which should not be
4554 included in the link. We need to do this now, so that we can
4555 notice when the backend linker tries to report multiple
4556 definition errors for symbols which are in sections we aren't
4557 going to link. FIXME: It might be better to entirely ignore
4558 symbols which are defined in sections which are going to be
4559 discarded. This would require modifying the backend linker for
4560 each backend which might set the SEC_LINK_ONCE flag. If we do
4561 this, we should probably handle SEC_EXCLUDE in the same way. */
4563 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, entry
);
4567 lang_add_output (const char *name
, int from_script
)
4569 /* Make -o on command line override OUTPUT in script. */
4570 if (!had_output_filename
|| !from_script
)
4572 output_filename
= name
;
4573 had_output_filename
= TRUE
;
4577 static lang_output_section_statement_type
*current_section
;
4588 for (l
= 0; l
< 32; l
++)
4590 if (i
>= (unsigned int) x
)
4598 lang_output_section_statement_type
*
4599 lang_enter_output_section_statement (const char *output_section_statement_name
,
4600 etree_type
*address_exp
,
4601 enum section_type sectype
,
4603 etree_type
*subalign
,
4607 lang_output_section_statement_type
*os
;
4611 lang_output_section_statement_lookup_1 (output_section_statement_name
,
4614 /* Add this statement to tree. */
4616 add_statement (lang_output_section_statement_enum
,
4617 output_section_statement
);
4619 /* Make next things chain into subchain of this. */
4621 if (os
->addr_tree
== NULL
)
4623 os
->addr_tree
= address_exp
;
4625 os
->sectype
= sectype
;
4626 if (sectype
!= noload_section
)
4627 os
->flags
= SEC_NO_FLAGS
;
4629 os
->flags
= SEC_NEVER_LOAD
;
4630 os
->block_value
= 1;
4631 stat_ptr
= &os
->children
;
4633 os
->subsection_alignment
=
4634 topower (exp_get_value_int (subalign
, -1, "subsection alignment", 0));
4635 os
->section_alignment
=
4636 topower (exp_get_value_int (align
, -1, "section alignment", 0));
4638 os
->load_base
= ebase
;
4645 lang_output_statement_type
*new =
4646 new_stat (lang_output_statement
, stat_ptr
);
4648 new->name
= output_filename
;
4651 /* Reset the current counters in the regions. */
4654 lang_reset_memory_regions (void)
4656 lang_memory_region_type
*p
= lang_memory_region_list
;
4659 for (p
= lang_memory_region_list
; p
!= NULL
; p
= p
->next
)
4661 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
4662 p
->current
= p
->origin
;
4665 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
4667 /* Save the last size for possible use by bfd_relax_section. */
4668 o
->rawsize
= o
->size
;
4673 /* Worker for lang_gc_sections_1. */
4676 gc_section_callback (lang_wild_statement_type
*ptr
,
4677 struct wildcard_list
*sec ATTRIBUTE_UNUSED
,
4679 lang_input_statement_type
*file ATTRIBUTE_UNUSED
,
4680 void *data ATTRIBUTE_UNUSED
)
4682 /* If the wild pattern was marked KEEP, the member sections
4683 should be as well. */
4684 if (ptr
->keep_sections
)
4685 section
->flags
|= SEC_KEEP
;
4688 /* Iterate over sections marking them against GC. */
4691 lang_gc_sections_1 (lang_statement_union_type
*s
)
4693 for (; s
!= NULL
; s
= s
->header
.next
)
4695 switch (s
->header
.type
)
4697 case lang_wild_statement_enum
:
4698 walk_wild (&s
->wild_statement
, gc_section_callback
, NULL
);
4700 case lang_constructors_statement_enum
:
4701 lang_gc_sections_1 (constructor_list
.head
);
4703 case lang_output_section_statement_enum
:
4704 lang_gc_sections_1 (s
->output_section_statement
.children
.head
);
4706 case lang_group_statement_enum
:
4707 lang_gc_sections_1 (s
->group_statement
.children
.head
);
4716 lang_gc_sections (void)
4718 struct bfd_link_hash_entry
*h
;
4719 ldlang_undef_chain_list_type
*ulist
;
4721 /* Keep all sections so marked in the link script. */
4723 lang_gc_sections_1 (statement_list
.head
);
4725 /* Keep all sections containing symbols undefined on the command-line,
4726 and the section containing the entry symbol. */
4728 for (ulist
= link_info
.gc_sym_list
; ulist
; ulist
= ulist
->next
)
4730 h
= bfd_link_hash_lookup (link_info
.hash
, ulist
->name
,
4731 FALSE
, FALSE
, FALSE
);
4734 && (h
->type
== bfd_link_hash_defined
4735 || h
->type
== bfd_link_hash_defweak
)
4736 && ! bfd_is_abs_section (h
->u
.def
.section
))
4738 h
->u
.def
.section
->flags
|= SEC_KEEP
;
4742 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
4743 the special case of debug info. (See bfd/stabs.c)
4744 Twiddle the flag here, to simplify later linker code. */
4745 if (link_info
.relocatable
)
4747 LANG_FOR_EACH_INPUT_STATEMENT (f
)
4750 for (sec
= f
->the_bfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4751 if ((sec
->flags
& SEC_DEBUGGING
) == 0)
4752 sec
->flags
&= ~SEC_EXCLUDE
;
4756 if (command_line
.gc_sections
)
4757 bfd_gc_sections (output_bfd
, &link_info
);
4763 lang_reasonable_defaults ();
4764 current_target
= default_target
;
4766 /* Open the output file. */
4767 lang_for_each_statement (ldlang_open_output
);
4770 ldemul_create_output_section_statements ();
4772 /* Add to the hash table all undefineds on the command line. */
4773 lang_place_undefineds ();
4775 if (!bfd_section_already_linked_table_init ())
4776 einfo (_("%P%F: Failed to create hash table\n"));
4778 /* Create a bfd for each input file. */
4779 current_target
= default_target
;
4780 open_input_bfds (statement_list
.head
, FALSE
);
4782 link_info
.gc_sym_list
= &entry_symbol
;
4783 if (entry_symbol
.name
== NULL
)
4784 link_info
.gc_sym_list
= ldlang_undef_chain_list_head
;
4786 ldemul_after_open ();
4788 bfd_section_already_linked_table_free ();
4790 /* Make sure that we're not mixing architectures. We call this
4791 after all the input files have been opened, but before we do any
4792 other processing, so that any operations merge_private_bfd_data
4793 does on the output file will be known during the rest of the
4797 /* Handle .exports instead of a version script if we're told to do so. */
4798 if (command_line
.version_exports_section
)
4799 lang_do_version_exports_section ();
4801 /* Build all sets based on the information gathered from the input
4803 ldctor_build_sets ();
4805 /* Remove unreferenced sections if asked to. */
4806 lang_gc_sections ();
4808 /* Size up the common data. */
4811 /* Update wild statements. */
4812 update_wild_statements (statement_list
.head
);
4814 /* Run through the contours of the script and attach input sections
4815 to the correct output sections. */
4816 map_input_to_output_sections (statement_list
.head
, NULL
, NULL
);
4818 /* Find any sections not attached explicitly and handle them. */
4819 lang_place_orphans ();
4821 if (! link_info
.relocatable
)
4825 /* Merge SEC_MERGE sections. This has to be done after GC of
4826 sections, so that GCed sections are not merged, but before
4827 assigning dynamic symbols, since removing whole input sections
4829 bfd_merge_sections (output_bfd
, &link_info
);
4831 /* Look for a text section and set the readonly attribute in it. */
4832 found
= bfd_get_section_by_name (output_bfd
, ".text");
4836 if (config
.text_read_only
)
4837 found
->flags
|= SEC_READONLY
;
4839 found
->flags
&= ~SEC_READONLY
;
4843 /* Do anything special before sizing sections. This is where ELF
4844 and other back-ends size dynamic sections. */
4845 ldemul_before_allocation ();
4847 if (!link_info
.relocatable
)
4848 strip_excluded_output_sections ();
4850 /* We must record the program headers before we try to fix the
4851 section positions, since they will affect SIZEOF_HEADERS. */
4852 lang_record_phdrs ();
4854 /* Size up the sections. */
4855 lang_size_sections (statement_list
.head
, abs_output_section
,
4856 &statement_list
.head
, 0, 0, NULL
,
4857 command_line
.relax
? FALSE
: TRUE
);
4859 /* Now run around and relax if we can. */
4860 if (command_line
.relax
)
4862 /* Keep relaxing until bfd_relax_section gives up. */
4863 bfd_boolean relax_again
;
4867 relax_again
= FALSE
;
4869 /* Note: pe-dll.c does something like this also. If you find
4870 you need to change this code, you probably need to change
4871 pe-dll.c also. DJ */
4873 /* Do all the assignments with our current guesses as to
4875 lang_do_assignments (statement_list
.head
, abs_output_section
,
4878 /* We must do this after lang_do_assignments, because it uses
4880 lang_reset_memory_regions ();
4882 /* Perform another relax pass - this time we know where the
4883 globals are, so can make a better guess. */
4884 lang_size_sections (statement_list
.head
, abs_output_section
,
4885 &statement_list
.head
, 0, 0, &relax_again
, FALSE
);
4887 /* If the normal relax is done and the relax finalize pass
4888 is not performed yet, we perform another relax pass. */
4889 if (!relax_again
&& link_info
.need_relax_finalize
)
4891 link_info
.need_relax_finalize
= FALSE
;
4895 while (relax_again
);
4897 /* Final extra sizing to report errors. */
4898 lang_do_assignments (statement_list
.head
, abs_output_section
, NULL
, 0);
4899 lang_reset_memory_regions ();
4900 lang_size_sections (statement_list
.head
, abs_output_section
,
4901 &statement_list
.head
, 0, 0, NULL
, TRUE
);
4904 /* See if anything special should be done now we know how big
4906 ldemul_after_allocation ();
4908 /* Fix any .startof. or .sizeof. symbols. */
4909 lang_set_startof ();
4911 /* Do all the assignments, now that we know the final resting places
4912 of all the symbols. */
4914 lang_do_assignments (statement_list
.head
, abs_output_section
, NULL
, 0);
4916 /* Make sure that the section addresses make sense. */
4917 if (! link_info
.relocatable
4918 && command_line
.check_section_addresses
)
4919 lang_check_section_addresses ();
4927 /* EXPORTED TO YACC */
4930 lang_add_wild (struct wildcard_spec
*filespec
,
4931 struct wildcard_list
*section_list
,
4932 bfd_boolean keep_sections
)
4934 struct wildcard_list
*curr
, *next
;
4935 lang_wild_statement_type
*new;
4937 /* Reverse the list as the parser puts it back to front. */
4938 for (curr
= section_list
, section_list
= NULL
;
4940 section_list
= curr
, curr
= next
)
4942 if (curr
->spec
.name
!= NULL
&& strcmp (curr
->spec
.name
, "COMMON") == 0)
4943 placed_commons
= TRUE
;
4946 curr
->next
= section_list
;
4949 if (filespec
!= NULL
&& filespec
->name
!= NULL
)
4951 if (strcmp (filespec
->name
, "*") == 0)
4952 filespec
->name
= NULL
;
4953 else if (! wildcardp (filespec
->name
))
4954 lang_has_input_file
= TRUE
;
4957 new = new_stat (lang_wild_statement
, stat_ptr
);
4958 new->filename
= NULL
;
4959 new->filenames_sorted
= FALSE
;
4960 if (filespec
!= NULL
)
4962 new->filename
= filespec
->name
;
4963 new->filenames_sorted
= filespec
->sorted
== by_name
;
4965 new->section_list
= section_list
;
4966 new->keep_sections
= keep_sections
;
4967 lang_list_init (&new->children
);
4971 lang_section_start (const char *name
, etree_type
*address
)
4973 lang_address_statement_type
*ad
;
4975 ad
= new_stat (lang_address_statement
, stat_ptr
);
4976 ad
->section_name
= name
;
4977 ad
->address
= address
;
4980 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4981 because of a -e argument on the command line, or zero if this is
4982 called by ENTRY in a linker script. Command line arguments take
4986 lang_add_entry (const char *name
, bfd_boolean cmdline
)
4988 if (entry_symbol
.name
== NULL
4990 || ! entry_from_cmdline
)
4992 entry_symbol
.name
= name
;
4993 entry_from_cmdline
= cmdline
;
4998 lang_add_target (const char *name
)
5000 lang_target_statement_type
*new = new_stat (lang_target_statement
,
5008 lang_add_map (const char *name
)
5015 map_option_f
= TRUE
;
5023 lang_add_fill (fill_type
*fill
)
5025 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
5032 lang_add_data (int type
, union etree_union
*exp
)
5035 lang_data_statement_type
*new = new_stat (lang_data_statement
,
5043 /* Create a new reloc statement. RELOC is the BFD relocation type to
5044 generate. HOWTO is the corresponding howto structure (we could
5045 look this up, but the caller has already done so). SECTION is the
5046 section to generate a reloc against, or NAME is the name of the
5047 symbol to generate a reloc against. Exactly one of SECTION and
5048 NAME must be NULL. ADDEND is an expression for the addend. */
5051 lang_add_reloc (bfd_reloc_code_real_type reloc
,
5052 reloc_howto_type
*howto
,
5055 union etree_union
*addend
)
5057 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
5061 p
->section
= section
;
5063 p
->addend_exp
= addend
;
5065 p
->addend_value
= 0;
5066 p
->output_section
= NULL
;
5070 lang_assignment_statement_type
*
5071 lang_add_assignment (etree_type
*exp
)
5073 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
5081 lang_add_attribute (enum statement_enum attribute
)
5083 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
5087 lang_startup (const char *name
)
5089 if (startup_file
!= NULL
)
5091 einfo (_("%P%Fmultiple STARTUP files\n"));
5093 first_file
->filename
= name
;
5094 first_file
->local_sym_name
= name
;
5095 first_file
->real
= TRUE
;
5097 startup_file
= name
;
5101 lang_float (bfd_boolean maybe
)
5103 lang_float_flag
= maybe
;
5107 /* Work out the load- and run-time regions from a script statement, and
5108 store them in *LMA_REGION and *REGION respectively.
5110 MEMSPEC is the name of the run-time region, or the value of
5111 DEFAULT_MEMORY_REGION if the statement didn't specify one.
5112 LMA_MEMSPEC is the name of the load-time region, or null if the
5113 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
5114 had an explicit load address.
5116 It is an error to specify both a load region and a load address. */
5119 lang_get_regions (lang_memory_region_type
**region
,
5120 lang_memory_region_type
**lma_region
,
5121 const char *memspec
,
5122 const char *lma_memspec
,
5123 bfd_boolean have_lma
,
5124 bfd_boolean have_vma
)
5126 *lma_region
= lang_memory_region_lookup (lma_memspec
, FALSE
);
5128 /* If no runtime region or VMA has been specified, but the load region
5129 has been specified, then use the load region for the runtime region
5131 if (lma_memspec
!= NULL
5133 && strcmp (memspec
, DEFAULT_MEMORY_REGION
) == 0)
5134 *region
= *lma_region
;
5136 *region
= lang_memory_region_lookup (memspec
, FALSE
);
5138 if (have_lma
&& lma_memspec
!= 0)
5139 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
5143 lang_leave_output_section_statement (fill_type
*fill
, const char *memspec
,
5144 lang_output_section_phdr_list
*phdrs
,
5145 const char *lma_memspec
)
5147 lang_get_regions (¤t_section
->region
,
5148 ¤t_section
->lma_region
,
5149 memspec
, lma_memspec
,
5150 current_section
->load_base
!= NULL
,
5151 current_section
->addr_tree
!= NULL
);
5152 current_section
->fill
= fill
;
5153 current_section
->phdrs
= phdrs
;
5154 stat_ptr
= &statement_list
;
5157 /* Create an absolute symbol with the given name with the value of the
5158 address of first byte of the section named.
5160 If the symbol already exists, then do nothing. */
5163 lang_abs_symbol_at_beginning_of (const char *secname
, const char *name
)
5165 struct bfd_link_hash_entry
*h
;
5167 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
5169 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
5171 if (h
->type
== bfd_link_hash_new
5172 || h
->type
== bfd_link_hash_undefined
)
5176 h
->type
= bfd_link_hash_defined
;
5178 sec
= bfd_get_section_by_name (output_bfd
, secname
);
5182 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
5184 h
->u
.def
.section
= bfd_abs_section_ptr
;
5188 /* Create an absolute symbol with the given name with the value of the
5189 address of the first byte after the end of the section named.
5191 If the symbol already exists, then do nothing. */
5194 lang_abs_symbol_at_end_of (const char *secname
, const char *name
)
5196 struct bfd_link_hash_entry
*h
;
5198 h
= bfd_link_hash_lookup (link_info
.hash
, name
, TRUE
, TRUE
, TRUE
);
5200 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
5202 if (h
->type
== bfd_link_hash_new
5203 || h
->type
== bfd_link_hash_undefined
)
5207 h
->type
= bfd_link_hash_defined
;
5209 sec
= bfd_get_section_by_name (output_bfd
, secname
);
5213 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
5214 + TO_ADDR (sec
->size
));
5216 h
->u
.def
.section
= bfd_abs_section_ptr
;
5221 lang_statement_append (lang_statement_list_type
*list
,
5222 lang_statement_union_type
*element
,
5223 lang_statement_union_type
**field
)
5225 *(list
->tail
) = element
;
5229 /* Set the output format type. -oformat overrides scripts. */
5232 lang_add_output_format (const char *format
,
5237 if (output_target
== NULL
|| !from_script
)
5239 if (command_line
.endian
== ENDIAN_BIG
5242 else if (command_line
.endian
== ENDIAN_LITTLE
5246 output_target
= format
;
5250 /* Enter a group. This creates a new lang_group_statement, and sets
5251 stat_ptr to build new statements within the group. */
5254 lang_enter_group (void)
5256 lang_group_statement_type
*g
;
5258 g
= new_stat (lang_group_statement
, stat_ptr
);
5259 lang_list_init (&g
->children
);
5260 stat_ptr
= &g
->children
;
5263 /* Leave a group. This just resets stat_ptr to start writing to the
5264 regular list of statements again. Note that this will not work if
5265 groups can occur inside anything else which can adjust stat_ptr,
5266 but currently they can't. */
5269 lang_leave_group (void)
5271 stat_ptr
= &statement_list
;
5274 /* Add a new program header. This is called for each entry in a PHDRS
5275 command in a linker script. */
5278 lang_new_phdr (const char *name
,
5280 bfd_boolean filehdr
,
5285 struct lang_phdr
*n
, **pp
;
5287 n
= stat_alloc (sizeof (struct lang_phdr
));
5290 n
->type
= exp_get_value_int (type
, 0, "program header type",
5291 lang_final_phase_enum
);
5292 n
->filehdr
= filehdr
;
5297 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
5302 /* Record the program header information in the output BFD. FIXME: We
5303 should not be calling an ELF specific function here. */
5306 lang_record_phdrs (void)
5310 lang_output_section_phdr_list
*last
;
5311 struct lang_phdr
*l
;
5312 lang_output_section_statement_type
*os
;
5315 secs
= xmalloc (alc
* sizeof (asection
*));
5317 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
5324 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
5328 lang_output_section_phdr_list
*pl
;
5330 if (os
->constraint
== -1)
5338 if (os
->sectype
== noload_section
5339 || os
->bfd_section
== NULL
5340 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
5345 if (os
->bfd_section
== NULL
)
5348 for (; pl
!= NULL
; pl
= pl
->next
)
5350 if (strcmp (pl
->name
, l
->name
) == 0)
5355 secs
= xrealloc (secs
, alc
* sizeof (asection
*));
5357 secs
[c
] = os
->bfd_section
;
5364 if (l
->flags
== NULL
)
5367 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
5368 lang_final_phase_enum
);
5373 at
= exp_get_vma (l
->at
, 0, "phdr load address",
5374 lang_final_phase_enum
);
5376 if (! bfd_record_phdr (output_bfd
, l
->type
,
5377 l
->flags
!= NULL
, flags
, l
->at
!= NULL
,
5378 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
5379 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
5384 /* Make sure all the phdr assignments succeeded. */
5385 for (os
= &lang_output_section_statement
.head
->output_section_statement
;
5389 lang_output_section_phdr_list
*pl
;
5391 if (os
->constraint
== -1
5392 || os
->bfd_section
== NULL
)
5395 for (pl
= os
->phdrs
;
5398 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
5399 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
5400 os
->name
, pl
->name
);
5404 /* Record a list of sections which may not be cross referenced. */
5407 lang_add_nocrossref (lang_nocrossref_type
*l
)
5409 struct lang_nocrossrefs
*n
;
5411 n
= xmalloc (sizeof *n
);
5412 n
->next
= nocrossref_list
;
5414 nocrossref_list
= n
;
5416 /* Set notice_all so that we get informed about all symbols. */
5417 link_info
.notice_all
= TRUE
;
5420 /* Overlay handling. We handle overlays with some static variables. */
5422 /* The overlay virtual address. */
5423 static etree_type
*overlay_vma
;
5424 /* And subsection alignment. */
5425 static etree_type
*overlay_subalign
;
5427 /* An expression for the maximum section size seen so far. */
5428 static etree_type
*overlay_max
;
5430 /* A list of all the sections in this overlay. */
5432 struct overlay_list
{
5433 struct overlay_list
*next
;
5434 lang_output_section_statement_type
*os
;
5437 static struct overlay_list
*overlay_list
;
5439 /* Start handling an overlay. */
5442 lang_enter_overlay (etree_type
*vma_expr
, etree_type
*subalign
)
5444 /* The grammar should prevent nested overlays from occurring. */
5445 ASSERT (overlay_vma
== NULL
5446 && overlay_subalign
== NULL
5447 && overlay_max
== NULL
);
5449 overlay_vma
= vma_expr
;
5450 overlay_subalign
= subalign
;
5453 /* Start a section in an overlay. We handle this by calling
5454 lang_enter_output_section_statement with the correct VMA.
5455 lang_leave_overlay sets up the LMA and memory regions. */
5458 lang_enter_overlay_section (const char *name
)
5460 struct overlay_list
*n
;
5463 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
5464 0, overlay_subalign
, 0, 0);
5466 /* If this is the first section, then base the VMA of future
5467 sections on this one. This will work correctly even if `.' is
5468 used in the addresses. */
5469 if (overlay_list
== NULL
)
5470 overlay_vma
= exp_nameop (ADDR
, name
);
5472 /* Remember the section. */
5473 n
= xmalloc (sizeof *n
);
5474 n
->os
= current_section
;
5475 n
->next
= overlay_list
;
5478 size
= exp_nameop (SIZEOF
, name
);
5480 /* Arrange to work out the maximum section end address. */
5481 if (overlay_max
== NULL
)
5484 overlay_max
= exp_binop (MAX_K
, overlay_max
, size
);
5487 /* Finish a section in an overlay. There isn't any special to do
5491 lang_leave_overlay_section (fill_type
*fill
,
5492 lang_output_section_phdr_list
*phdrs
)
5499 name
= current_section
->name
;
5501 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
5502 region and that no load-time region has been specified. It doesn't
5503 really matter what we say here, since lang_leave_overlay will
5505 lang_leave_output_section_statement (fill
, DEFAULT_MEMORY_REGION
, phdrs
, 0);
5507 /* Define the magic symbols. */
5509 clean
= xmalloc (strlen (name
) + 1);
5511 for (s1
= name
; *s1
!= '\0'; s1
++)
5512 if (ISALNUM (*s1
) || *s1
== '_')
5516 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
5517 sprintf (buf
, "__load_start_%s", clean
);
5518 lang_add_assignment (exp_assop ('=', buf
,
5519 exp_nameop (LOADADDR
, name
)));
5521 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
5522 sprintf (buf
, "__load_stop_%s", clean
);
5523 lang_add_assignment (exp_assop ('=', buf
,
5525 exp_nameop (LOADADDR
, name
),
5526 exp_nameop (SIZEOF
, name
))));
5531 /* Finish an overlay. If there are any overlay wide settings, this
5532 looks through all the sections in the overlay and sets them. */
5535 lang_leave_overlay (etree_type
*lma_expr
,
5538 const char *memspec
,
5539 lang_output_section_phdr_list
*phdrs
,
5540 const char *lma_memspec
)
5542 lang_memory_region_type
*region
;
5543 lang_memory_region_type
*lma_region
;
5544 struct overlay_list
*l
;
5545 lang_nocrossref_type
*nocrossref
;
5547 lang_get_regions (®ion
, &lma_region
,
5548 memspec
, lma_memspec
,
5549 lma_expr
!= NULL
, FALSE
);
5553 /* After setting the size of the last section, set '.' to end of the
5555 if (overlay_list
!= NULL
)
5556 overlay_list
->os
->update_dot_tree
5557 = exp_assop ('=', ".", exp_binop ('+', overlay_vma
, overlay_max
));
5562 struct overlay_list
*next
;
5564 if (fill
!= NULL
&& l
->os
->fill
== NULL
)
5567 l
->os
->region
= region
;
5568 l
->os
->lma_region
= lma_region
;
5570 /* The first section has the load address specified in the
5571 OVERLAY statement. The rest are worked out from that.
5572 The base address is not needed (and should be null) if
5573 an LMA region was specified. */
5575 l
->os
->load_base
= lma_expr
;
5576 else if (lma_region
== 0)
5577 l
->os
->load_base
= exp_binop ('+',
5578 exp_nameop (LOADADDR
, l
->next
->os
->name
),
5579 exp_nameop (SIZEOF
, l
->next
->os
->name
));
5581 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
5582 l
->os
->phdrs
= phdrs
;
5586 lang_nocrossref_type
*nc
;
5588 nc
= xmalloc (sizeof *nc
);
5589 nc
->name
= l
->os
->name
;
5590 nc
->next
= nocrossref
;
5599 if (nocrossref
!= NULL
)
5600 lang_add_nocrossref (nocrossref
);
5603 overlay_list
= NULL
;
5607 /* Version handling. This is only useful for ELF. */
5609 /* This global variable holds the version tree that we build. */
5611 struct bfd_elf_version_tree
*lang_elf_version_info
;
5613 /* If PREV is NULL, return first version pattern matching particular symbol.
5614 If PREV is non-NULL, return first version pattern matching particular
5615 symbol after PREV (previously returned by lang_vers_match). */
5617 static struct bfd_elf_version_expr
*
5618 lang_vers_match (struct bfd_elf_version_expr_head
*head
,
5619 struct bfd_elf_version_expr
*prev
,
5622 const char *cxx_sym
= sym
;
5623 const char *java_sym
= sym
;
5624 struct bfd_elf_version_expr
*expr
= NULL
;
5626 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
5628 cxx_sym
= cplus_demangle (sym
, DMGL_PARAMS
| DMGL_ANSI
);
5632 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
5634 java_sym
= cplus_demangle (sym
, DMGL_JAVA
);
5639 if (head
->htab
&& (prev
== NULL
|| prev
->symbol
))
5641 struct bfd_elf_version_expr e
;
5643 switch (prev
? prev
->mask
: 0)
5646 if (head
->mask
& BFD_ELF_VERSION_C_TYPE
)
5649 expr
= htab_find (head
->htab
, &e
);
5650 while (expr
&& strcmp (expr
->symbol
, sym
) == 0)
5651 if (expr
->mask
== BFD_ELF_VERSION_C_TYPE
)
5657 case BFD_ELF_VERSION_C_TYPE
:
5658 if (head
->mask
& BFD_ELF_VERSION_CXX_TYPE
)
5661 expr
= htab_find (head
->htab
, &e
);
5662 while (expr
&& strcmp (expr
->symbol
, cxx_sym
) == 0)
5663 if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
5669 case BFD_ELF_VERSION_CXX_TYPE
:
5670 if (head
->mask
& BFD_ELF_VERSION_JAVA_TYPE
)
5672 e
.symbol
= java_sym
;
5673 expr
= htab_find (head
->htab
, &e
);
5674 while (expr
&& strcmp (expr
->symbol
, java_sym
) == 0)
5675 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
5686 /* Finally, try the wildcards. */
5687 if (prev
== NULL
|| prev
->symbol
)
5688 expr
= head
->remaining
;
5695 if (expr
->pattern
[0] == '*' && expr
->pattern
[1] == '\0')
5698 if (expr
->mask
== BFD_ELF_VERSION_JAVA_TYPE
)
5700 else if (expr
->mask
== BFD_ELF_VERSION_CXX_TYPE
)
5704 if (fnmatch (expr
->pattern
, s
, 0) == 0)
5711 free ((char *) cxx_sym
);
5712 if (java_sym
!= sym
)
5713 free ((char *) java_sym
);
5717 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
5718 return a string pointing to the symbol name. */
5721 realsymbol (const char *pattern
)
5724 bfd_boolean changed
= FALSE
, backslash
= FALSE
;
5725 char *s
, *symbol
= xmalloc (strlen (pattern
) + 1);
5727 for (p
= pattern
, s
= symbol
; *p
!= '\0'; ++p
)
5729 /* It is a glob pattern only if there is no preceding
5731 if (! backslash
&& (*p
== '?' || *p
== '*' || *p
== '['))
5739 /* Remove the preceding backslash. */
5746 backslash
= *p
== '\\';
5761 /* This is called for each variable name or match expression. */
5763 struct bfd_elf_version_expr
*
5764 lang_new_vers_pattern (struct bfd_elf_version_expr
*orig
,
5768 struct bfd_elf_version_expr
*ret
;
5770 ret
= xmalloc (sizeof *ret
);
5775 ret
->symbol
= realsymbol (new);
5777 if (lang
== NULL
|| strcasecmp (lang
, "C") == 0)
5778 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
5779 else if (strcasecmp (lang
, "C++") == 0)
5780 ret
->mask
= BFD_ELF_VERSION_CXX_TYPE
;
5781 else if (strcasecmp (lang
, "Java") == 0)
5782 ret
->mask
= BFD_ELF_VERSION_JAVA_TYPE
;
5785 einfo (_("%X%P: unknown language `%s' in version information\n"),
5787 ret
->mask
= BFD_ELF_VERSION_C_TYPE
;
5790 return ldemul_new_vers_pattern (ret
);
5793 /* This is called for each set of variable names and match
5796 struct bfd_elf_version_tree
*
5797 lang_new_vers_node (struct bfd_elf_version_expr
*globals
,
5798 struct bfd_elf_version_expr
*locals
)
5800 struct bfd_elf_version_tree
*ret
;
5802 ret
= xcalloc (1, sizeof *ret
);
5803 ret
->globals
.list
= globals
;
5804 ret
->locals
.list
= locals
;
5805 ret
->match
= lang_vers_match
;
5806 ret
->name_indx
= (unsigned int) -1;
5810 /* This static variable keeps track of version indices. */
5812 static int version_index
;
5815 version_expr_head_hash (const void *p
)
5817 const struct bfd_elf_version_expr
*e
= p
;
5819 return htab_hash_string (e
->symbol
);
5823 version_expr_head_eq (const void *p1
, const void *p2
)
5825 const struct bfd_elf_version_expr
*e1
= p1
;
5826 const struct bfd_elf_version_expr
*e2
= p2
;
5828 return strcmp (e1
->symbol
, e2
->symbol
) == 0;
5832 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head
*head
)
5835 struct bfd_elf_version_expr
*e
, *next
;
5836 struct bfd_elf_version_expr
**list_loc
, **remaining_loc
;
5838 for (e
= head
->list
; e
; e
= e
->next
)
5842 head
->mask
|= e
->mask
;
5847 head
->htab
= htab_create (count
* 2, version_expr_head_hash
,
5848 version_expr_head_eq
, NULL
);
5849 list_loc
= &head
->list
;
5850 remaining_loc
= &head
->remaining
;
5851 for (e
= head
->list
; e
; e
= next
)
5857 remaining_loc
= &e
->next
;
5861 void **loc
= htab_find_slot (head
->htab
, e
, INSERT
);
5865 struct bfd_elf_version_expr
*e1
, *last
;
5871 if (e1
->mask
== e
->mask
)
5879 while (e1
&& strcmp (e1
->symbol
, e
->symbol
) == 0);
5883 /* This is a duplicate. */
5884 /* FIXME: Memory leak. Sometimes pattern is not
5885 xmalloced alone, but in larger chunk of memory. */
5886 /* free (e->symbol); */
5891 e
->next
= last
->next
;
5899 list_loc
= &e
->next
;
5903 *remaining_loc
= NULL
;
5904 *list_loc
= head
->remaining
;
5907 head
->remaining
= head
->list
;
5910 /* This is called when we know the name and dependencies of the
5914 lang_register_vers_node (const char *name
,
5915 struct bfd_elf_version_tree
*version
,
5916 struct bfd_elf_version_deps
*deps
)
5918 struct bfd_elf_version_tree
*t
, **pp
;
5919 struct bfd_elf_version_expr
*e1
;
5924 if ((name
[0] == '\0' && lang_elf_version_info
!= NULL
)
5925 || (lang_elf_version_info
&& lang_elf_version_info
->name
[0] == '\0'))
5927 einfo (_("%X%P: anonymous version tag cannot be combined"
5928 " with other version tags\n"));
5933 /* Make sure this node has a unique name. */
5934 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5935 if (strcmp (t
->name
, name
) == 0)
5936 einfo (_("%X%P: duplicate version tag `%s'\n"), name
);
5938 lang_finalize_version_expr_head (&version
->globals
);
5939 lang_finalize_version_expr_head (&version
->locals
);
5941 /* Check the global and local match names, and make sure there
5942 aren't any duplicates. */
5944 for (e1
= version
->globals
.list
; e1
!= NULL
; e1
= e1
->next
)
5946 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5948 struct bfd_elf_version_expr
*e2
;
5950 if (t
->locals
.htab
&& e1
->symbol
)
5952 e2
= htab_find (t
->locals
.htab
, e1
);
5953 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
5955 if (e1
->mask
== e2
->mask
)
5956 einfo (_("%X%P: duplicate expression `%s'"
5957 " in version information\n"), e1
->symbol
);
5961 else if (!e1
->symbol
)
5962 for (e2
= t
->locals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
5963 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
5964 && e1
->mask
== e2
->mask
)
5965 einfo (_("%X%P: duplicate expression `%s'"
5966 " in version information\n"), e1
->pattern
);
5970 for (e1
= version
->locals
.list
; e1
!= NULL
; e1
= e1
->next
)
5972 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
5974 struct bfd_elf_version_expr
*e2
;
5976 if (t
->globals
.htab
&& e1
->symbol
)
5978 e2
= htab_find (t
->globals
.htab
, e1
);
5979 while (e2
&& strcmp (e1
->symbol
, e2
->symbol
) == 0)
5981 if (e1
->mask
== e2
->mask
)
5982 einfo (_("%X%P: duplicate expression `%s'"
5983 " in version information\n"),
5988 else if (!e1
->symbol
)
5989 for (e2
= t
->globals
.remaining
; e2
!= NULL
; e2
= e2
->next
)
5990 if (strcmp (e1
->pattern
, e2
->pattern
) == 0
5991 && e1
->mask
== e2
->mask
)
5992 einfo (_("%X%P: duplicate expression `%s'"
5993 " in version information\n"), e1
->pattern
);
5997 version
->deps
= deps
;
5998 version
->name
= name
;
5999 if (name
[0] != '\0')
6002 version
->vernum
= version_index
;
6005 version
->vernum
= 0;
6007 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
6012 /* This is called when we see a version dependency. */
6014 struct bfd_elf_version_deps
*
6015 lang_add_vers_depend (struct bfd_elf_version_deps
*list
, const char *name
)
6017 struct bfd_elf_version_deps
*ret
;
6018 struct bfd_elf_version_tree
*t
;
6020 ret
= xmalloc (sizeof *ret
);
6023 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
6025 if (strcmp (t
->name
, name
) == 0)
6027 ret
->version_needed
= t
;
6032 einfo (_("%X%P: unable to find version dependency `%s'\n"), name
);
6038 lang_do_version_exports_section (void)
6040 struct bfd_elf_version_expr
*greg
= NULL
, *lreg
;
6042 LANG_FOR_EACH_INPUT_STATEMENT (is
)
6044 asection
*sec
= bfd_get_section_by_name (is
->the_bfd
, ".exports");
6052 contents
= xmalloc (len
);
6053 if (!bfd_get_section_contents (is
->the_bfd
, sec
, contents
, 0, len
))
6054 einfo (_("%X%P: unable to read .exports section contents\n"), sec
);
6057 while (p
< contents
+ len
)
6059 greg
= lang_new_vers_pattern (greg
, p
, NULL
);
6060 p
= strchr (p
, '\0') + 1;
6063 /* Do not free the contents, as we used them creating the regex. */
6065 /* Do not include this section in the link. */
6066 sec
->flags
|= SEC_EXCLUDE
;
6069 lreg
= lang_new_vers_pattern (NULL
, "*", NULL
);
6070 lang_register_vers_node (command_line
.version_exports_section
,
6071 lang_new_vers_node (greg
, lreg
), NULL
);
6075 lang_add_unique (const char *name
)
6077 struct unique_sections
*ent
;
6079 for (ent
= unique_section_list
; ent
; ent
= ent
->next
)
6080 if (strcmp (ent
->name
, name
) == 0)
6083 ent
= xmalloc (sizeof *ent
);
6084 ent
->name
= xstrdup (name
);
6085 ent
->next
= unique_section_list
;
6086 unique_section_list
= ent
;