1 /* Linker command language support.
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
4 This file is part of GLD, the Gnu Linker.
6 GLD is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 1, or (at your option)
11 GLD is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GLD; see the file COPYING. If not, write to the Free
18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 #include "libiberty.h"
42 static lang_statement_union_type
*new_statement
PARAMS ((enum statement_enum
,
44 lang_statement_list_type
*));
48 static struct obstack stat_obstack
;
50 #define obstack_chunk_alloc xmalloc
51 #define obstack_chunk_free free
52 static CONST
char *startup_file
;
53 static lang_statement_list_type input_file_chain
;
54 static boolean placed_commons
= false;
55 static lang_output_section_statement_type
*default_common_section
;
56 static boolean map_option_f
;
57 static bfd_vma print_dot
;
58 static lang_input_statement_type
*first_file
;
59 static lang_statement_list_type lang_output_section_statement
;
60 static CONST
char *current_target
;
61 static CONST
char *output_target
;
62 static lang_statement_list_type statement_list
;
63 static struct lang_phdr
*lang_phdr_list
;
65 static void lang_for_each_statement_worker
66 PARAMS ((void (*func
) (lang_statement_union_type
*),
67 lang_statement_union_type
*s
));
68 static lang_input_statement_type
*new_afile
69 PARAMS ((const char *name
, lang_input_file_enum_type file_type
,
70 const char *target
, boolean add_to_list
));
71 static void init_os
PARAMS ((lang_output_section_statement_type
*s
));
72 static void exp_init_os
PARAMS ((etree_type
*));
73 static void section_already_linked
PARAMS ((bfd
*, asection
*, PTR
));
74 static boolean wildcardp
PARAMS ((const char *));
75 static void wild_section
PARAMS ((lang_wild_statement_type
*ptr
,
77 lang_input_statement_type
*file
,
78 lang_output_section_statement_type
*output
));
79 static lang_input_statement_type
*lookup_name
PARAMS ((const char *name
));
80 static void load_symbols
PARAMS ((lang_input_statement_type
*entry
,
81 lang_statement_list_type
*));
82 static void wild_file
PARAMS ((lang_wild_statement_type
*, const char *,
83 lang_input_statement_type
*,
84 lang_output_section_statement_type
*));
85 static void wild
PARAMS ((lang_wild_statement_type
*s
,
86 const char *section
, const char *file
,
88 lang_output_section_statement_type
*output
));
89 static bfd
*open_output
PARAMS ((const char *name
));
90 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*statement
));
91 static void open_input_bfds
92 PARAMS ((lang_statement_union_type
*statement
, boolean
));
93 static void lang_reasonable_defaults
PARAMS ((void));
94 static void lang_place_undefineds
PARAMS ((void));
95 static void map_input_to_output_sections
96 PARAMS ((lang_statement_union_type
*s
,
98 lang_output_section_statement_type
*output_section_statement
));
99 static void print_output_section_statement
100 PARAMS ((lang_output_section_statement_type
*output_section_statement
));
101 static void print_assignment
102 PARAMS ((lang_assignment_statement_type
*assignment
,
103 lang_output_section_statement_type
*output_section
));
104 static void print_input_statement
PARAMS ((lang_input_statement_type
*statm
));
105 static boolean print_one_symbol
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
106 static void print_input_section
PARAMS ((lang_input_section_type
*in
));
107 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*fill
));
108 static void print_data_statement
PARAMS ((lang_data_statement_type
*data
));
109 static void print_address_statement
PARAMS ((lang_address_statement_type
*));
110 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*reloc
));
111 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*s
));
112 static void print_wild_statement
113 PARAMS ((lang_wild_statement_type
*w
,
114 lang_output_section_statement_type
*os
));
115 static void print_group
116 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
117 static void print_statement
PARAMS ((lang_statement_union_type
*s
,
118 lang_output_section_statement_type
*os
));
119 static void print_statement_list
PARAMS ((lang_statement_union_type
*s
,
120 lang_output_section_statement_type
*os
));
121 static void print_statements
PARAMS ((void));
122 static bfd_vma insert_pad
PARAMS ((lang_statement_union_type
**this_ptr
,
123 fill_type fill
, unsigned int power
,
124 asection
*output_section_statement
,
126 static bfd_vma size_input_section
127 PARAMS ((lang_statement_union_type
**this_ptr
,
128 lang_output_section_statement_type
*output_section_statement
,
129 fill_type fill
, bfd_vma dot
, boolean relax
));
130 static void lang_finish
PARAMS ((void));
131 static void lang_check
PARAMS ((void));
132 static void lang_common
PARAMS ((void));
133 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
134 static void lang_place_orphans
PARAMS ((void));
135 static int topower
PARAMS ((int));
136 static void lang_set_startof
PARAMS ((void));
137 static void reset_memory_regions
PARAMS ((void));
138 static void lang_record_phdrs
PARAMS ((void));
141 lang_output_section_statement_type
*abs_output_section
;
142 lang_statement_list_type
*stat_ptr
= &statement_list
;
143 lang_statement_list_type file_chain
= { 0 };
144 const char *entry_symbol
= NULL
;
145 boolean entry_from_cmdline
;
146 boolean lang_has_input_file
= false;
147 boolean had_output_filename
= false;
148 boolean lang_float_flag
= false;
149 boolean delete_output_file_on_failure
= false;
150 struct lang_nocrossrefs
*nocrossref_list
;
152 etree_type
*base
; /* Relocation base - or null */
155 #if defined(__STDC__) || defined(ALMOST_STDC)
156 #define cat(a,b) a##b
158 #define cat(a,b) a/**/b
161 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
163 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
165 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
167 #define SECTION_NAME_MAP_LENGTH (16)
173 return obstack_alloc (&stat_obstack
, size
);
176 /*----------------------------------------------------------------------
177 lang_for_each_statement walks the parse tree and calls the provided
178 function for each node
182 lang_for_each_statement_worker (func
, s
)
183 void (*func
) PARAMS ((lang_statement_union_type
*));
184 lang_statement_union_type
*s
;
186 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
190 switch (s
->header
.type
)
192 case lang_constructors_statement_enum
:
193 lang_for_each_statement_worker (func
, constructor_list
.head
);
195 case lang_output_section_statement_enum
:
196 lang_for_each_statement_worker
198 s
->output_section_statement
.children
.head
);
200 case lang_wild_statement_enum
:
201 lang_for_each_statement_worker
203 s
->wild_statement
.children
.head
);
205 case lang_group_statement_enum
:
206 lang_for_each_statement_worker (func
,
207 s
->group_statement
.children
.head
);
209 case lang_data_statement_enum
:
210 case lang_reloc_statement_enum
:
211 case lang_object_symbols_statement_enum
:
212 case lang_output_statement_enum
:
213 case lang_target_statement_enum
:
214 case lang_input_section_enum
:
215 case lang_input_statement_enum
:
216 case lang_assignment_statement_enum
:
217 case lang_padding_statement_enum
:
218 case lang_address_statement_enum
:
219 case lang_fill_statement_enum
:
229 lang_for_each_statement (func
)
230 void (*func
) PARAMS ((lang_statement_union_type
*));
232 lang_for_each_statement_worker (func
,
233 statement_list
.head
);
236 /*----------------------------------------------------------------------*/
238 lang_list_init (list
)
239 lang_statement_list_type
*list
;
241 list
->head
= (lang_statement_union_type
*) NULL
;
242 list
->tail
= &list
->head
;
245 /*----------------------------------------------------------------------
247 build a new statement node for the parse tree
252 lang_statement_union_type
*
253 new_statement (type
, size
, list
)
254 enum statement_enum type
;
256 lang_statement_list_type
* list
;
258 lang_statement_union_type
*new = (lang_statement_union_type
*)
261 new->header
.type
= type
;
262 new->header
.next
= (lang_statement_union_type
*) NULL
;
263 lang_statement_append (list
, new, &new->header
.next
);
268 Build a new input file node for the language. There are several ways
269 in which we treat an input file, eg, we only look at symbols, or
270 prefix it with a -l etc.
272 We can be supplied with requests for input files more than once;
273 they may, for example be split over serveral lines like foo.o(.text)
274 foo.o(.data) etc, so when asked for a file we check that we havn't
275 got it already so we don't duplicate the bfd.
278 static lang_input_statement_type
*
279 new_afile (name
, file_type
, target
, add_to_list
)
281 lang_input_file_enum_type file_type
;
285 lang_input_statement_type
*p
;
288 p
= new_stat (lang_input_statement
, stat_ptr
);
291 p
= ((lang_input_statement_type
*)
292 stat_alloc (sizeof (lang_input_statement_type
)));
293 p
->header
.next
= NULL
;
296 lang_has_input_file
= true;
300 case lang_input_file_is_symbols_only_enum
:
302 p
->is_archive
= false;
304 p
->local_sym_name
= name
;
305 p
->just_syms_flag
= true;
306 p
->search_dirs_flag
= false;
308 case lang_input_file_is_fake_enum
:
310 p
->is_archive
= false;
312 p
->local_sym_name
= name
;
313 p
->just_syms_flag
= false;
314 p
->search_dirs_flag
= false;
316 case lang_input_file_is_l_enum
:
317 p
->is_archive
= true;
320 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
321 p
->just_syms_flag
= false;
322 p
->search_dirs_flag
= true;
324 case lang_input_file_is_marker_enum
:
326 p
->is_archive
= false;
328 p
->local_sym_name
= name
;
329 p
->just_syms_flag
= false;
330 p
->search_dirs_flag
= true;
332 case lang_input_file_is_search_file_enum
:
334 p
->is_archive
= false;
336 p
->local_sym_name
= name
;
337 p
->just_syms_flag
= false;
338 p
->search_dirs_flag
= true;
340 case lang_input_file_is_file_enum
:
342 p
->is_archive
= false;
344 p
->local_sym_name
= name
;
345 p
->just_syms_flag
= false;
346 p
->search_dirs_flag
= false;
351 p
->the_bfd
= (bfd
*) NULL
;
352 p
->asymbols
= (asymbol
**) NULL
;
353 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
354 p
->next
= (lang_statement_union_type
*) NULL
;
356 p
->dynamic
= config
.dynamic_link
;
357 p
->whole_archive
= whole_archive
;
359 lang_statement_append (&input_file_chain
,
360 (lang_statement_union_type
*) p
,
365 lang_input_statement_type
*
366 lang_add_input_file (name
, file_type
, target
)
368 lang_input_file_enum_type file_type
;
371 lang_has_input_file
= true;
372 return new_afile (name
, file_type
, target
, true);
375 /* Build enough state so that the parser can build its tree */
379 obstack_begin (&stat_obstack
, 1000);
381 stat_ptr
= &statement_list
;
383 lang_list_init (stat_ptr
);
385 lang_list_init (&input_file_chain
);
386 lang_list_init (&lang_output_section_statement
);
387 lang_list_init (&file_chain
);
388 first_file
= lang_add_input_file ((char *) NULL
,
389 lang_input_file_is_marker_enum
,
391 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
393 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
397 /*----------------------------------------------------------------------
398 A region is an area of memory declared with the
399 MEMORY { name:org=exp, len=exp ... }
402 We maintain a list of all the regions here
404 If no regions are specified in the script, then the default is used
405 which is created when looked up to be the entire data space
408 static lang_memory_region_type
*lang_memory_region_list
;
409 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
411 lang_memory_region_type
*
412 lang_memory_region_lookup (name
)
413 CONST
char *CONST name
;
416 lang_memory_region_type
*p
= lang_memory_region_list
;
418 for (p
= lang_memory_region_list
;
419 p
!= (lang_memory_region_type
*) NULL
;
422 if (strcmp (p
->name
, name
) == 0)
429 /* This code used to always use the first region in the list as the
430 default region. I changed it to instead use a region
431 encompassing all of memory as the default region. This permits
432 NOLOAD sections to work reasonably without requiring a region.
433 People should specify what region they mean, if they really want
435 if (strcmp (name
, "*default*") == 0)
437 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
439 return lang_memory_region_list
;
445 lang_memory_region_type
*new =
446 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
448 new->name
= buystring (name
);
449 new->next
= (lang_memory_region_type
*) NULL
;
451 *lang_memory_region_list_tail
= new;
452 lang_memory_region_list_tail
= &new->next
;
454 new->length
= ~(bfd_size_type
)0;
456 new->had_full_message
= false;
463 lang_output_section_statement_type
*
464 lang_output_section_find (name
)
465 CONST
char *CONST name
;
467 lang_statement_union_type
*u
;
468 lang_output_section_statement_type
*lookup
;
470 for (u
= lang_output_section_statement
.head
;
471 u
!= (lang_statement_union_type
*) NULL
;
474 lookup
= &u
->output_section_statement
;
475 if (strcmp (name
, lookup
->name
) == 0)
480 return (lang_output_section_statement_type
*) NULL
;
483 lang_output_section_statement_type
*
484 lang_output_section_statement_lookup (name
)
485 CONST
char *CONST name
;
487 lang_output_section_statement_type
*lookup
;
489 lookup
= lang_output_section_find (name
);
490 if (lookup
== (lang_output_section_statement_type
*) NULL
)
493 lookup
= (lang_output_section_statement_type
*)
494 new_stat (lang_output_section_statement
, stat_ptr
);
495 lookup
->region
= (lang_memory_region_type
*) NULL
;
497 lookup
->block_value
= 1;
500 lookup
->next
= (lang_statement_union_type
*) NULL
;
501 lookup
->bfd_section
= (asection
*) NULL
;
502 lookup
->processed
= false;
503 lookup
->sectype
= normal_section
;
504 lookup
->addr_tree
= (etree_type
*) NULL
;
505 lang_list_init (&lookup
->children
);
507 lookup
->memspec
= (CONST
char *) NULL
;
509 lookup
->subsection_alignment
= -1;
510 lookup
->section_alignment
= -1;
511 lookup
->load_base
= (union etree_union
*) NULL
;
512 lookup
->phdrs
= NULL
;
514 lang_statement_append (&lang_output_section_statement
,
515 (lang_statement_union_type
*) lookup
,
524 lang_memory_region_type
*m
;
526 minfo ("\nMemory Configuration\n\n");
527 fprintf (config
.map_file
, "%-16s %-18s %-18s\n",
528 "Name", "Origin", "Length");
530 for (m
= lang_memory_region_list
;
531 m
!= (lang_memory_region_type
*) NULL
;
537 fprintf (config
.map_file
, "%-16s ", m
->name
);
539 sprintf_vma (buf
, m
->origin
);
540 minfo ("0x%s ", buf
);
548 minfo ("0x%V\n", m
->length
);
551 fprintf (config
.map_file
, "\nLinker script and memory map\n\n");
556 /* Initialize an output section. */
560 lang_output_section_statement_type
*s
;
562 section_userdata_type
*new;
564 if (s
->bfd_section
!= NULL
)
567 if (strcmp (s
->name
, DISCARD_SECTION_NAME
) == 0)
568 einfo ("%P%F: Illegal use of `%s' section", DISCARD_SECTION_NAME
);
570 new = ((section_userdata_type
*)
571 stat_alloc (sizeof (section_userdata_type
)));
573 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
574 if (s
->bfd_section
== (asection
*) NULL
)
575 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
576 if (s
->bfd_section
== (asection
*) NULL
)
578 einfo ("%P%F: output format %s cannot represent section called %s\n",
579 output_bfd
->xvec
->name
, s
->name
);
581 s
->bfd_section
->output_section
= s
->bfd_section
;
583 /* We initialize an output sections output offset to minus its own */
584 /* vma to allow us to output a section through itself */
585 s
->bfd_section
->output_offset
= 0;
586 get_userdata (s
->bfd_section
) = (PTR
) new;
588 /* If there is a base address, make sure that any sections it might
589 mention are initialized. */
590 if (s
->addr_tree
!= NULL
)
591 exp_init_os (s
->addr_tree
);
594 /* Make sure that all output sections mentioned in an expression are
601 switch (exp
->type
.node_class
)
604 exp_init_os (exp
->assign
.src
);
608 exp_init_os (exp
->binary
.lhs
);
609 exp_init_os (exp
->binary
.rhs
);
613 exp_init_os (exp
->trinary
.cond
);
614 exp_init_os (exp
->trinary
.lhs
);
615 exp_init_os (exp
->trinary
.rhs
);
619 exp_init_os (exp
->unary
.child
);
623 switch (exp
->type
.node_code
)
629 lang_output_section_statement_type
*os
;
631 os
= lang_output_section_find (exp
->name
.name
);
632 if (os
!= NULL
&& os
->bfd_section
== NULL
)
643 /* Sections marked with the SEC_LINK_ONCE flag should only be linked
644 once into the output. This routine checks each sections, and
645 arranges to discard it if a section of the same name has already
646 been linked. This code assumes that all relevant sections have the
647 SEC_LINK_ONCE flag set; that is, it does not depend solely upon the
648 section name. This is called via bfd_map_over_sections. */
652 section_already_linked (abfd
, sec
, data
)
657 lang_input_statement_type
*entry
= (lang_input_statement_type
*) data
;
660 struct sec_link_once
*next
;
663 static struct sec_link_once
*sec_link_once_list
;
666 struct sec_link_once
*l
;
668 /* If we are only reading symbols from this object, then we want to
669 discard all sections. */
670 if (entry
->just_syms_flag
)
672 sec
->output_section
= bfd_abs_section_ptr
;
673 sec
->output_offset
= sec
->vma
;
677 flags
= bfd_get_section_flags (abfd
, sec
);
679 if ((flags
& SEC_LINK_ONCE
) == 0)
682 name
= bfd_get_section_name (abfd
, sec
);
684 for (l
= sec_link_once_list
; l
!= NULL
; l
= l
->next
)
686 if (strcmp (name
, bfd_get_section_name (l
->sec
->owner
, l
->sec
)) == 0)
688 /* The section has already been linked. See if we should
690 switch (flags
& SEC_LINK_DUPLICATES
)
695 case SEC_LINK_DUPLICATES_DISCARD
:
698 case SEC_LINK_DUPLICATES_ONE_ONLY
:
699 einfo ("%P: %B: warning: ignoring duplicate section `%s'\n",
703 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
704 /* FIXME: We should really dig out the contents of both
705 sections and memcmp them. The COFF/PE spec says that
706 the Microsoft linker does not implement this
707 correctly, so I'm not going to bother doing it
710 case SEC_LINK_DUPLICATES_SAME_SIZE
:
711 if (bfd_section_size (abfd
, sec
)
712 != bfd_section_size (l
->sec
->owner
, l
->sec
))
713 einfo ("%P: %B: warning: duplicate section `%s' has different size\n",
718 /* Set the output_section field so that wild_doit does not
719 create a lang_input_section structure for this section. */
720 sec
->output_section
= bfd_abs_section_ptr
;
726 /* This is the first section with this name. Record it. */
728 l
= (struct sec_link_once
*) xmalloc (sizeof *l
);
730 l
->next
= sec_link_once_list
;
731 sec_link_once_list
= l
;
734 /* The wild routines.
736 These expand statements like *(.text) and foo.o to a list of
737 explicit actions, like foo.o(.text), bar.o(.text) and
738 foo.o(.text, .data). */
740 /* Return true if the PATTERN argument is a wildcard pattern.
741 Although backslashes are treated specially if a pattern contains
742 wildcards, we do not consider the mere presence of a backslash to
743 be enough to cause the the pattern to be treated as a wildcard.
744 That lets us handle DOS filenames more naturally. */
752 for (s
= pattern
; *s
!= '\0'; ++s
)
760 /* Add SECTION to the output section OUTPUT. Do this by creating a
761 lang_input_section statement which is placed at PTR. FILE is the
762 input file which holds SECTION. */
765 wild_doit (ptr
, section
, output
, file
)
766 lang_statement_list_type
*ptr
;
768 lang_output_section_statement_type
*output
;
769 lang_input_statement_type
*file
;
774 flags
= bfd_get_section_flags (section
->owner
, section
);
778 /* If we are doing a final link, discard sections marked with
780 if (! link_info
.relocateable
781 && (flags
& SEC_EXCLUDE
) != 0)
784 /* Discard input sections which are assigned to a section named
785 DISCARD_SECTION_NAME. */
786 if (strcmp (output
->name
, DISCARD_SECTION_NAME
) == 0)
789 /* Discard debugging sections if we are stripping debugging
791 if ((link_info
.strip
== strip_debugger
|| link_info
.strip
== strip_all
)
792 && (flags
& SEC_DEBUGGING
) != 0)
797 if (section
->output_section
== NULL
)
799 /* This prevents future calls from assigning this section. */
800 section
->output_section
= bfd_abs_section_ptr
;
805 if (section
->output_section
== NULL
)
807 lang_input_section_type
*new;
809 if (output
->bfd_section
== NULL
)
812 /* Add a section reference to the list */
813 new = new_stat (lang_input_section
, ptr
);
815 new->section
= section
;
817 section
->output_section
= output
->bfd_section
;
819 /* We don't copy the SEC_NEVER_LOAD flag from an input section
820 to an output section, because we want to be able to include a
821 SEC_NEVER_LOAD section in the middle of an otherwise loaded
822 section (I don't know why we want to do this, but we do).
823 build_link_order in ldwrite.c handles this case by turning
824 the embedded SEC_NEVER_LOAD section into a fill.
826 If final link, don't copy the SEC_LINK_ONCE flags, they've already
827 been processed. One reason to do this is that on pe format targets,
828 .text$foo sections go into .text and it's odd to see .text with
829 SEC_LINK_ONCE set. */
831 section
->output_section
->flags
|=
832 section
->flags
& (flagword
) (~ (SEC_NEVER_LOAD
833 | (! link_info
.relocateable
834 ? SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
837 switch (output
->sectype
)
844 case overlay_section
:
845 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
848 output
->bfd_section
->flags
&= ~SEC_LOAD
;
849 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
853 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
854 output
->bfd_section
->alignment_power
= section
->alignment_power
;
856 /* If supplied an aligment, then force it. */
857 if (output
->section_alignment
!= -1)
858 output
->bfd_section
->alignment_power
= output
->section_alignment
;
862 /* Expand a wild statement for a particular FILE. SECTION may be
863 NULL, in which case it is a wild card. */
866 wild_section (ptr
, section
, file
, output
)
867 lang_wild_statement_type
*ptr
;
869 lang_input_statement_type
*file
;
870 lang_output_section_statement_type
*output
;
872 if (file
->just_syms_flag
== false)
874 register asection
*s
;
880 wildcard
= wildcardp (section
);
882 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
886 /* Attach all sections named SECTION. If SECTION is NULL,
887 then attach all sections.
889 Previously, if SECTION was NULL, this code did not call
890 wild_doit if the SEC_IS_COMMON flag was set for the
891 section. I did not understand that, and I took it out.
900 name
= bfd_get_section_name (file
->the_bfd
, s
);
902 match
= fnmatch (section
, name
, 0) == 0 ? true : false;
904 match
= strcmp (section
, name
) == 0 ? true : false;
907 wild_doit (&ptr
->children
, s
, output
, file
);
912 /* This is passed a file name which must have been seen already and
913 added to the statement tree. We will see if it has been opened
914 already and had its symbols read. If not then we'll read it. */
916 static lang_input_statement_type
*
920 lang_input_statement_type
*search
;
922 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
923 search
!= (lang_input_statement_type
*) NULL
;
924 search
= (lang_input_statement_type
*) search
->next_real_file
)
926 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
928 if (search
->filename
!= (char *) NULL
929 && name
!= (char *) NULL
930 && strcmp (search
->filename
, name
) == 0)
934 if (search
== (lang_input_statement_type
*) NULL
)
935 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
938 /* If we have already added this file, or this file is not real
939 (FIXME: can that ever actually happen?) or the name is NULL
940 (FIXME: can that ever actually happen?) don't add this file. */
943 || search
->filename
== (const char *) NULL
)
946 load_symbols (search
, (lang_statement_list_type
*) NULL
);
951 /* Get the symbols for an input file. */
954 load_symbols (entry
, place
)
955 lang_input_statement_type
*entry
;
956 lang_statement_list_type
*place
;
963 ldfile_open_file (entry
);
965 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
966 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
969 lang_statement_list_type
*hold
;
971 err
= bfd_get_error ();
972 if (err
== bfd_error_file_ambiguously_recognized
)
976 einfo ("%B: file not recognized: %E\n", entry
->the_bfd
);
977 einfo ("%B: matching formats:", entry
->the_bfd
);
978 for (p
= matching
; *p
!= NULL
; p
++)
982 else if (err
!= bfd_error_file_not_recognized
984 einfo ("%F%B: file not recognized: %E\n", entry
->the_bfd
);
986 bfd_close (entry
->the_bfd
);
987 entry
->the_bfd
= NULL
;
989 /* See if the emulation has some special knowledge. */
991 if (ldemul_unrecognized_file (entry
))
994 /* Try to interpret the file as a linker script. */
996 ldfile_open_command_file (entry
->filename
);
1001 ldfile_assumed_script
= true;
1002 parser_input
= input_script
;
1004 ldfile_assumed_script
= false;
1011 /* We don't call ldlang_add_file for an archive. Instead, the
1012 add_symbols entry point will call ldlang_add_file, via the
1013 add_archive_element callback, for each element of the archive
1015 switch (bfd_get_format (entry
->the_bfd
))
1021 ldlang_add_file (entry
);
1022 if (trace_files
|| trace_file_tries
)
1023 info_msg ("%I\n", entry
);
1027 if (entry
->whole_archive
)
1029 bfd
*member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1031 while (member
!= NULL
)
1033 if (! bfd_check_format (member
, bfd_object
))
1034 einfo ("%F%B: object %B in archive is not object\n",
1035 entry
->the_bfd
, member
);
1036 if (! ((*link_info
.callbacks
->add_archive_element
)
1037 (&link_info
, member
, "--whole-archive")))
1039 if (! bfd_link_add_symbols (member
, &link_info
))
1040 einfo ("%F%B: could not read symbols: %E\n", member
);
1041 member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1045 entry
->loaded
= true;
1051 if (! bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1052 einfo ("%F%B: could not read symbols: %E\n", entry
->the_bfd
);
1054 entry
->loaded
= true;
1057 /* Handle a wild statement for a single file F. */
1060 wild_file (s
, section
, f
, output
)
1061 lang_wild_statement_type
*s
;
1062 const char *section
;
1063 lang_input_statement_type
*f
;
1064 lang_output_section_statement_type
*output
;
1066 if (f
->the_bfd
== NULL
1067 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
1068 wild_section (s
, section
, f
, output
);
1073 /* This is an archive file. We must map each member of the
1074 archive separately. */
1075 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
1076 while (member
!= NULL
)
1078 /* When lookup_name is called, it will call the add_symbols
1079 entry point for the archive. For each element of the
1080 archive which is included, BFD will call ldlang_add_file,
1081 which will set the usrdata field of the member to the
1082 lang_input_statement. */
1083 if (member
->usrdata
!= NULL
)
1085 wild_section (s
, section
,
1086 (lang_input_statement_type
*) member
->usrdata
,
1090 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
1095 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1096 indicating that it is a wildcard. Separate lang_input_section
1097 statements are created for each part of the expansion; they are
1098 added after the wild statement S. OUTPUT is the output section. */
1101 wild (s
, section
, file
, target
, output
)
1102 lang_wild_statement_type
*s
;
1103 const char *section
;
1106 lang_output_section_statement_type
*output
;
1108 lang_input_statement_type
*f
;
1110 if (file
== (char *) NULL
)
1112 /* Perform the iteration over all files in the list */
1113 for (f
= (lang_input_statement_type
*) file_chain
.head
;
1114 f
!= (lang_input_statement_type
*) NULL
;
1115 f
= (lang_input_statement_type
*) f
->next
)
1117 wild_file (s
, section
, f
, output
);
1120 else if (wildcardp (file
))
1122 for (f
= (lang_input_statement_type
*) file_chain
.head
;
1123 f
!= (lang_input_statement_type
*) NULL
;
1124 f
= (lang_input_statement_type
*) f
->next
)
1126 if (fnmatch (file
, f
->filename
, FNM_FILE_NAME
) == 0)
1127 wild_file (s
, section
, f
, output
);
1132 /* Perform the iteration over a single file */
1133 f
= lookup_name (file
);
1134 wild_file (s
, section
, f
, output
);
1137 if (section
!= (char *) NULL
1138 && strcmp (section
, "COMMON") == 0
1139 && default_common_section
== NULL
)
1141 /* Remember the section that common is going to in case we later
1142 get something which doesn't know where to put it. */
1143 default_common_section
= output
;
1147 /* Open the output file. */
1155 if (output_target
== (char *) NULL
)
1157 if (current_target
!= (char *) NULL
)
1158 output_target
= current_target
;
1160 output_target
= default_target
;
1162 output
= bfd_openw (name
, output_target
);
1164 if (output
== (bfd
*) NULL
)
1166 if (bfd_get_error () == bfd_error_invalid_target
)
1168 einfo ("%P%F: target %s not found\n", output_target
);
1170 einfo ("%P%F: cannot open output file %s: %E\n", name
);
1173 delete_output_file_on_failure
= true;
1175 /* output->flags |= D_PAGED;*/
1177 if (! bfd_set_format (output
, bfd_object
))
1178 einfo ("%P%F:%s: can not make object file: %E\n", name
);
1179 if (! bfd_set_arch_mach (output
,
1180 ldfile_output_architecture
,
1181 ldfile_output_machine
))
1182 einfo ("%P%F:%s: can not set architecture: %E\n", name
);
1184 link_info
.hash
= bfd_link_hash_table_create (output
);
1185 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1186 einfo ("%P%F: can not create link hash table: %E\n");
1188 bfd_set_gp_size (output
, g_switch_value
);
1196 ldlang_open_output (statement
)
1197 lang_statement_union_type
* statement
;
1199 switch (statement
->header
.type
)
1201 case lang_output_statement_enum
:
1202 ASSERT (output_bfd
== (bfd
*) NULL
);
1203 output_bfd
= open_output (statement
->output_statement
.name
);
1204 ldemul_set_output_arch ();
1205 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1206 output_bfd
->flags
|= D_PAGED
;
1208 output_bfd
->flags
&= ~D_PAGED
;
1209 if (config
.text_read_only
)
1210 output_bfd
->flags
|= WP_TEXT
;
1212 output_bfd
->flags
&= ~WP_TEXT
;
1213 if (link_info
.traditional_format
)
1214 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1216 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1219 case lang_target_statement_enum
:
1220 current_target
= statement
->target_statement
.target
;
1227 /* Open all the input files. */
1230 open_input_bfds (s
, force
)
1231 lang_statement_union_type
*s
;
1234 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1236 switch (s
->header
.type
)
1238 case lang_constructors_statement_enum
:
1239 open_input_bfds (constructor_list
.head
, force
);
1241 case lang_output_section_statement_enum
:
1242 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1244 case lang_wild_statement_enum
:
1245 /* Maybe we should load the file's symbols */
1246 if (s
->wild_statement
.filename
1247 && ! wildcardp (s
->wild_statement
.filename
))
1248 (void) lookup_name (s
->wild_statement
.filename
);
1249 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1251 case lang_group_statement_enum
:
1253 struct bfd_link_hash_entry
*undefs
;
1255 /* We must continually search the entries in the group
1256 until no new symbols are added to the list of undefined
1261 undefs
= link_info
.hash
->undefs_tail
;
1262 open_input_bfds (s
->group_statement
.children
.head
, true);
1264 while (undefs
!= link_info
.hash
->undefs_tail
);
1267 case lang_target_statement_enum
:
1268 current_target
= s
->target_statement
.target
;
1270 case lang_input_statement_enum
:
1271 if (s
->input_statement
.real
== true)
1273 lang_statement_list_type add
;
1275 s
->input_statement
.target
= current_target
;
1277 /* If we are being called from within a group, and this
1278 is an archive which has already been searched, then
1279 force it to be researched. */
1281 && s
->input_statement
.loaded
1282 && bfd_check_format (s
->input_statement
.the_bfd
,
1284 s
->input_statement
.loaded
= false;
1286 lang_list_init (&add
);
1288 load_symbols (&s
->input_statement
, &add
);
1290 if (add
.head
!= NULL
)
1292 *add
.tail
= s
->next
;
1303 /* If there are [COMMONS] statements, put a wild one into the bss section */
1306 lang_reasonable_defaults ()
1309 lang_output_section_statement_lookup (".text");
1310 lang_output_section_statement_lookup (".data");
1312 default_common_section
=
1313 lang_output_section_statement_lookup (".bss");
1316 if (placed_commons
== false)
1318 lang_wild_statement_type
*new =
1319 new_stat (lang_wild_statement
,
1320 &default_common_section
->children
);
1322 new->section_name
= "COMMON";
1323 new->filename
= (char *) NULL
;
1324 lang_list_init (&new->children
);
1331 Add the supplied name to the symbol table as an undefined reference.
1332 Remove items from the chain as we open input bfds
1334 typedef struct ldlang_undef_chain_list
1336 struct ldlang_undef_chain_list
*next
;
1338 } ldlang_undef_chain_list_type
;
1340 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
1343 ldlang_add_undef (name
)
1344 CONST
char *CONST name
;
1346 ldlang_undef_chain_list_type
*new =
1347 ((ldlang_undef_chain_list_type
*)
1348 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
1350 new->next
= ldlang_undef_chain_list_head
;
1351 ldlang_undef_chain_list_head
= new;
1353 new->name
= buystring (name
);
1356 /* Run through the list of undefineds created above and place them
1357 into the linker hash table as undefined symbols belonging to the
1361 lang_place_undefineds ()
1363 ldlang_undef_chain_list_type
*ptr
;
1365 for (ptr
= ldlang_undef_chain_list_head
;
1366 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
1369 struct bfd_link_hash_entry
*h
;
1371 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
1372 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1373 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
1374 if (h
->type
== bfd_link_hash_new
)
1376 h
->type
= bfd_link_hash_undefined
;
1377 h
->u
.undef
.abfd
= NULL
;
1378 bfd_link_add_undef (link_info
.hash
, h
);
1383 /* Open input files and attatch to output sections */
1385 map_input_to_output_sections (s
, target
, output_section_statement
)
1386 lang_statement_union_type
* s
;
1388 lang_output_section_statement_type
* output_section_statement
;
1390 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1392 switch (s
->header
.type
)
1396 case lang_wild_statement_enum
:
1397 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1398 s
->wild_statement
.filename
, target
,
1399 output_section_statement
);
1402 case lang_constructors_statement_enum
:
1403 map_input_to_output_sections (constructor_list
.head
,
1405 output_section_statement
);
1407 case lang_output_section_statement_enum
:
1408 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1410 &s
->output_section_statement
);
1412 case lang_output_statement_enum
:
1414 case lang_target_statement_enum
:
1415 target
= s
->target_statement
.target
;
1417 case lang_group_statement_enum
:
1418 map_input_to_output_sections (s
->group_statement
.children
.head
,
1420 output_section_statement
);
1422 case lang_fill_statement_enum
:
1423 case lang_input_section_enum
:
1424 case lang_object_symbols_statement_enum
:
1425 case lang_data_statement_enum
:
1426 case lang_reloc_statement_enum
:
1427 case lang_padding_statement_enum
:
1428 case lang_input_statement_enum
:
1429 if (output_section_statement
!= NULL
1430 && output_section_statement
->bfd_section
== NULL
)
1431 init_os (output_section_statement
);
1433 case lang_assignment_statement_enum
:
1434 if (output_section_statement
!= NULL
1435 && output_section_statement
->bfd_section
== NULL
)
1436 init_os (output_section_statement
);
1438 /* Make sure that any sections mentioned in the assignment
1440 exp_init_os (s
->assignment_statement
.exp
);
1442 case lang_afile_asection_pair_statement_enum
:
1445 case lang_address_statement_enum
:
1446 /* Mark the specified section with the supplied address */
1448 lang_output_section_statement_type
*os
=
1449 lang_output_section_statement_lookup
1450 (s
->address_statement
.section_name
);
1452 if (os
->bfd_section
== NULL
)
1454 os
->addr_tree
= s
->address_statement
.address
;
1462 print_output_section_statement (output_section_statement
)
1463 lang_output_section_statement_type
* output_section_statement
;
1465 asection
*section
= output_section_statement
->bfd_section
;
1468 if (output_section_statement
!= abs_output_section
)
1470 minfo ("\n%s", output_section_statement
->name
);
1472 if (section
!= NULL
)
1474 print_dot
= section
->vma
;
1476 len
= strlen (output_section_statement
->name
);
1477 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
1482 while (len
< SECTION_NAME_MAP_LENGTH
)
1488 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
1490 if (output_section_statement
->load_base
!= NULL
)
1494 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
1495 "load base", lang_final_phase_enum
);
1496 minfo (" load address 0x%V", addr
);
1503 print_statement_list (output_section_statement
->children
.head
,
1504 output_section_statement
);
1508 print_assignment (assignment
, output_section
)
1509 lang_assignment_statement_type
* assignment
;
1510 lang_output_section_statement_type
* output_section
;
1513 etree_value_type result
;
1515 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1518 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
1519 lang_final_phase_enum
, print_dot
, &print_dot
);
1521 minfo ("0x%V", result
.value
+ result
.section
->bfd_section
->vma
);
1532 exp_print_tree (assignment
->exp
);
1538 print_input_statement (statm
)
1539 lang_input_statement_type
* statm
;
1541 if (statm
->filename
!= (char *) NULL
)
1543 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1547 /* Print all symbols defined in a particular section. This is called
1548 via bfd_link_hash_traverse. */
1551 print_one_symbol (hash_entry
, ptr
)
1552 struct bfd_link_hash_entry
*hash_entry
;
1555 asection
*sec
= (asection
*) ptr
;
1557 if ((hash_entry
->type
== bfd_link_hash_defined
1558 || hash_entry
->type
== bfd_link_hash_defweak
)
1559 && sec
== hash_entry
->u
.def
.section
)
1563 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1566 (hash_entry
->u
.def
.value
1567 + hash_entry
->u
.def
.section
->output_offset
1568 + hash_entry
->u
.def
.section
->output_section
->vma
));
1570 minfo (" %T\n", hash_entry
->root
.string
);
1576 /* Print information about an input section to the map file. */
1579 print_input_section (in
)
1580 lang_input_section_type
* in
;
1582 asection
*i
= in
->section
;
1583 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
1589 minfo ("%s", i
->name
);
1591 if (i
->output_section
!= NULL
)
1595 len
= 1 + strlen (i
->name
);
1596 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
1601 while (len
< SECTION_NAME_MAP_LENGTH
)
1607 minfo ("0x%V %W %B\n",
1608 i
->output_section
->vma
+ i
->output_offset
, size
,
1611 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
1613 len
= SECTION_NAME_MAP_LENGTH
+ 3;
1625 minfo ("%W (size before relaxing)\n", i
->_raw_size
);
1628 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
1630 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
;
1636 print_fill_statement (fill
)
1637 lang_fill_statement_type
* fill
;
1639 fprintf (config
.map_file
, " FILL mask 0x%x\n", fill
->fill
);
1643 print_data_statement (data
)
1644 lang_data_statement_type
* data
;
1651 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1654 addr
= data
->output_vma
;
1655 if (data
->output_section
!= NULL
)
1656 addr
+= data
->output_section
->vma
;
1684 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
1686 if (data
->exp
->type
.node_class
!= etree_value
)
1689 exp_print_tree (data
->exp
);
1694 print_dot
= addr
+ size
;
1697 /* Print an address statement. These are generated by options like
1701 print_address_statement (address
)
1702 lang_address_statement_type
*address
;
1704 minfo ("Address of section %s set to ", address
->section_name
);
1705 exp_print_tree (address
->address
);
1709 /* Print a reloc statement. */
1712 print_reloc_statement (reloc
)
1713 lang_reloc_statement_type
*reloc
;
1719 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1722 addr
= reloc
->output_vma
;
1723 if (reloc
->output_section
!= NULL
)
1724 addr
+= reloc
->output_section
->vma
;
1726 size
= bfd_get_reloc_size (reloc
->howto
);
1728 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
1730 if (reloc
->name
!= NULL
)
1731 minfo ("%s+", reloc
->name
);
1733 minfo ("%s+", reloc
->section
->name
);
1735 exp_print_tree (reloc
->addend_exp
);
1739 print_dot
= addr
+ size
;
1743 print_padding_statement (s
)
1744 lang_padding_statement_type
*s
;
1751 len
= sizeof " *fill*" - 1;
1752 while (len
< SECTION_NAME_MAP_LENGTH
)
1758 addr
= s
->output_offset
;
1759 if (s
->output_section
!= NULL
)
1760 addr
+= s
->output_section
->vma
;
1761 minfo ("0x%V %W", addr
, s
->size
);
1764 minfo (" %u", s
->fill
);
1768 print_dot
= addr
+ s
->size
;
1772 print_wild_statement (w
, os
)
1773 lang_wild_statement_type
* w
;
1774 lang_output_section_statement_type
* os
;
1778 if (w
->filename
!= NULL
)
1779 minfo ("%s", w
->filename
);
1783 if (w
->section_name
!= NULL
)
1784 minfo ("(%s)", w
->section_name
);
1790 print_statement_list (w
->children
.head
, os
);
1793 /* Print a group statement. */
1797 lang_group_statement_type
*s
;
1798 lang_output_section_statement_type
*os
;
1800 fprintf (config
.map_file
, "START GROUP\n");
1801 print_statement_list (s
->children
.head
, os
);
1802 fprintf (config
.map_file
, "END GROUP\n");
1805 /* Print the list of statements in S.
1806 This can be called for any statement type. */
1809 print_statement_list (s
, os
)
1810 lang_statement_union_type
*s
;
1811 lang_output_section_statement_type
*os
;
1815 print_statement (s
, os
);
1820 /* Print the first statement in statement list S.
1821 This can be called for any statement type. */
1824 print_statement (s
, os
)
1825 lang_statement_union_type
*s
;
1826 lang_output_section_statement_type
*os
;
1828 switch (s
->header
.type
)
1831 fprintf (config
.map_file
, "Fail with %d\n", s
->header
.type
);
1834 case lang_constructors_statement_enum
:
1835 if (constructor_list
.head
!= NULL
)
1837 minfo (" CONSTRUCTORS\n");
1838 print_statement_list (constructor_list
.head
, os
);
1841 case lang_wild_statement_enum
:
1842 print_wild_statement (&s
->wild_statement
, os
);
1844 case lang_address_statement_enum
:
1845 print_address_statement (&s
->address_statement
);
1847 case lang_object_symbols_statement_enum
:
1848 minfo (" CREATE_OBJECT_SYMBOLS\n");
1850 case lang_fill_statement_enum
:
1851 print_fill_statement (&s
->fill_statement
);
1853 case lang_data_statement_enum
:
1854 print_data_statement (&s
->data_statement
);
1856 case lang_reloc_statement_enum
:
1857 print_reloc_statement (&s
->reloc_statement
);
1859 case lang_input_section_enum
:
1860 print_input_section (&s
->input_section
);
1862 case lang_padding_statement_enum
:
1863 print_padding_statement (&s
->padding_statement
);
1865 case lang_output_section_statement_enum
:
1866 print_output_section_statement (&s
->output_section_statement
);
1868 case lang_assignment_statement_enum
:
1869 print_assignment (&s
->assignment_statement
, os
);
1871 case lang_target_statement_enum
:
1872 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1874 case lang_output_statement_enum
:
1875 minfo ("OUTPUT(%s", s
->output_statement
.name
);
1876 if (output_target
!= NULL
)
1877 minfo (" %s", output_target
);
1880 case lang_input_statement_enum
:
1881 print_input_statement (&s
->input_statement
);
1883 case lang_group_statement_enum
:
1884 print_group (&s
->group_statement
, os
);
1886 case lang_afile_asection_pair_statement_enum
:
1895 print_statement_list (statement_list
.head
, abs_output_section
);
1898 /* Print the first N statements in statement list S to STDERR.
1899 If N == 0, nothing is printed.
1900 If N < 0, the entire list is printed.
1901 Intended to be called from GDB. */
1904 dprint_statement (s
, n
)
1905 lang_statement_union_type
* s
;
1908 FILE *map_save
= config
.map_file
;
1910 config
.map_file
= stderr
;
1913 print_statement_list (s
, abs_output_section
);
1916 while (s
&& --n
>= 0)
1918 print_statement (s
, abs_output_section
);
1923 config
.map_file
= map_save
;
1927 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
1928 lang_statement_union_type
** this_ptr
;
1931 asection
* output_section_statement
;
1934 /* Align this section first to the
1935 input sections requirement, then
1936 to the output section's requirement.
1937 If this alignment is > than any seen before,
1938 then record it too. Perform the alignment by
1939 inserting a magic 'padding' statement.
1942 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
1944 if (alignment_needed
!= 0)
1946 lang_statement_union_type
*new =
1947 ((lang_statement_union_type
*)
1948 stat_alloc (sizeof (lang_padding_statement_type
)));
1950 /* Link into existing chain */
1951 new->header
.next
= *this_ptr
;
1953 new->header
.type
= lang_padding_statement_enum
;
1954 new->padding_statement
.output_section
= output_section_statement
;
1955 new->padding_statement
.output_offset
=
1956 dot
- output_section_statement
->vma
;
1957 new->padding_statement
.fill
= fill
;
1958 new->padding_statement
.size
= alignment_needed
;
1962 /* Remember the most restrictive alignment */
1963 if (power
> output_section_statement
->alignment_power
)
1965 output_section_statement
->alignment_power
= power
;
1967 output_section_statement
->_raw_size
+= alignment_needed
;
1968 return alignment_needed
+ dot
;
1972 /* Work out how much this section will move the dot point */
1974 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
1975 lang_statement_union_type
** this_ptr
;
1976 lang_output_section_statement_type
* output_section_statement
;
1981 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1982 asection
*i
= is
->section
;
1984 if (is
->ifile
->just_syms_flag
== false)
1986 if (output_section_statement
->subsection_alignment
!= -1)
1987 i
->alignment_power
=
1988 output_section_statement
->subsection_alignment
;
1990 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
1991 output_section_statement
->bfd_section
, dot
);
1993 /* Remember where in the output section this input section goes */
1995 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1997 /* Mark how big the output section must be to contain this now
1999 if (i
->_cooked_size
!= 0)
2000 dot
+= i
->_cooked_size
;
2002 dot
+= i
->_raw_size
;
2003 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
2007 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2013 /* This variable indicates whether bfd_relax_section should be called
2016 static boolean relax_again
;
2018 /* Set the sizes for all the output sections. */
2021 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2022 lang_statement_union_type
* s
;
2023 lang_output_section_statement_type
* output_section_statement
;
2024 lang_statement_union_type
** prev
;
2029 /* Size up the sections from their constituent parts */
2030 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2032 switch (s
->header
.type
)
2035 case lang_output_section_statement_enum
:
2038 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
2040 if (os
->bfd_section
== NULL
)
2042 /* This section was never actually created. */
2046 /* If this is a COFF shared library section, use the size and
2047 address from the input section. FIXME: This is COFF
2048 specific; it would be cleaner if there were some other way
2049 to do this, but nothing simple comes to mind. */
2050 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2054 if (os
->children
.head
== NULL
2055 || os
->children
.head
->next
!= NULL
2056 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2057 einfo ("%P%X: Internal error on COFF shared library section %s\n",
2060 input
= os
->children
.head
->input_section
.section
;
2061 bfd_set_section_vma (os
->bfd_section
->owner
,
2063 bfd_section_vma (input
->owner
, input
));
2064 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2068 if (bfd_is_abs_section (os
->bfd_section
))
2070 /* No matter what happens, an abs section starts at zero */
2071 ASSERT (os
->bfd_section
->vma
== 0);
2075 if (os
->addr_tree
== (etree_type
*) NULL
)
2077 /* No address specified for this section, get one
2078 from the region specification
2080 if (os
->region
== (lang_memory_region_type
*) NULL
)
2082 os
->region
= lang_memory_region_lookup ("*default*");
2084 dot
= os
->region
->current
;
2085 if (os
->section_alignment
== -1)
2090 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
2091 if (dot
!= olddot
&& config
.warn_section_align
)
2092 einfo ("%P: warning: changing start of section %s by %u bytes\n",
2093 os
->name
, (unsigned int) (dot
- olddot
));
2100 r
= exp_fold_tree (os
->addr_tree
,
2102 lang_allocating_phase_enum
,
2104 if (r
.valid
== false)
2106 einfo ("%F%S: non constant address expression for section %s\n",
2109 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2111 /* The section starts here */
2112 /* First, align to what the section needs */
2114 if (os
->section_alignment
!= -1)
2115 dot
= align_power (dot
, os
->section_alignment
);
2117 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2119 os
->bfd_section
->output_offset
= 0;
2122 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
2123 os
->fill
, dot
, relax
);
2124 /* Ignore the size of the input sections, use the vma and size to */
2127 after
= ALIGN_N (os
->bfd_section
->vma
+
2128 os
->bfd_section
->_raw_size
,
2129 /* The coercion here is important, see ld.h. */
2130 (bfd_vma
) os
->block_value
);
2132 if (bfd_is_abs_section (os
->bfd_section
))
2133 ASSERT (after
== os
->bfd_section
->vma
);
2135 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
2136 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
2137 os
->processed
= true;
2139 /* Replace into region ? */
2140 if (os
->region
!= (lang_memory_region_type
*) NULL
)
2142 os
->region
->current
= dot
;
2143 /* Make sure this isn't silly. */
2144 if (os
->region
->current
< os
->region
->origin
2145 || (os
->region
->current
- os
->region
->origin
2146 > os
->region
->length
))
2148 if (os
->addr_tree
!= (etree_type
*) NULL
)
2150 einfo ("%X%P: address 0x%v of %B section %s is not within region %s\n",
2151 os
->region
->current
,
2152 os
->bfd_section
->owner
,
2153 os
->bfd_section
->name
,
2158 einfo ("%X%P: region %s is full (%B section %s)\n",
2160 os
->bfd_section
->owner
,
2161 os
->bfd_section
->name
);
2163 /* Reset the region pointer. */
2164 os
->region
->current
= os
->region
->origin
;
2170 case lang_constructors_statement_enum
:
2171 dot
= lang_size_sections (constructor_list
.head
,
2172 output_section_statement
,
2173 &s
->wild_statement
.children
.head
,
2178 case lang_data_statement_enum
:
2180 unsigned int size
= 0;
2182 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
2183 s
->data_statement
.output_section
=
2184 output_section_statement
->bfd_section
;
2186 switch (s
->data_statement
.type
)
2204 output_section_statement
->bfd_section
->_raw_size
+= size
;
2205 /* The output section gets contents, and then we inspect for
2206 any flags set in the input script which override any ALLOC */
2207 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
2208 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
)) {
2209 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
| SEC_LOAD
;
2214 case lang_reloc_statement_enum
:
2218 s
->reloc_statement
.output_vma
=
2219 dot
- output_section_statement
->bfd_section
->vma
;
2220 s
->reloc_statement
.output_section
=
2221 output_section_statement
->bfd_section
;
2222 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
2224 output_section_statement
->bfd_section
->_raw_size
+= size
;
2228 case lang_wild_statement_enum
:
2230 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
2231 output_section_statement
,
2232 &s
->wild_statement
.children
.head
,
2238 case lang_object_symbols_statement_enum
:
2239 link_info
.create_object_symbols_section
=
2240 output_section_statement
->bfd_section
;
2242 case lang_output_statement_enum
:
2243 case lang_target_statement_enum
:
2245 case lang_input_section_enum
:
2249 i
= (*prev
)->input_section
.section
;
2252 if (i
->_cooked_size
== 0)
2253 i
->_cooked_size
= i
->_raw_size
;
2259 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
2260 einfo ("%P%F: can't relax section: %E\n");
2264 dot
= size_input_section (prev
,
2265 output_section_statement
,
2266 output_section_statement
->fill
,
2270 case lang_input_statement_enum
:
2272 case lang_fill_statement_enum
:
2273 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
2275 fill
= s
->fill_statement
.fill
;
2277 case lang_assignment_statement_enum
:
2279 bfd_vma newdot
= dot
;
2281 exp_fold_tree (s
->assignment_statement
.exp
,
2282 output_section_statement
,
2283 lang_allocating_phase_enum
,
2287 if (newdot
!= dot
&& !relax
)
2289 /* The assignment changed dot. Insert a pad. */
2290 if (output_section_statement
== abs_output_section
)
2292 /* If we don't have an output section, then just adjust
2293 the default memory address. */
2294 lang_memory_region_lookup ("*default*")->current
= newdot
;
2298 lang_statement_union_type
*new =
2299 ((lang_statement_union_type
*)
2300 stat_alloc (sizeof (lang_padding_statement_type
)));
2302 /* Link into existing chain */
2303 new->header
.next
= *prev
;
2305 new->header
.type
= lang_padding_statement_enum
;
2306 new->padding_statement
.output_section
=
2307 output_section_statement
->bfd_section
;
2308 new->padding_statement
.output_offset
=
2309 dot
- output_section_statement
->bfd_section
->vma
;
2310 new->padding_statement
.fill
= fill
;
2311 new->padding_statement
.size
= newdot
- dot
;
2312 output_section_statement
->bfd_section
->_raw_size
+=
2313 new->padding_statement
.size
;
2321 case lang_padding_statement_enum
:
2322 /* If we are relaxing, and this is not the first pass, some
2323 padding statements may have been inserted during previous
2324 passes. We may have to move the padding statement to a new
2325 location if dot has a different value at this point in this
2326 pass than it did at this point in the previous pass. */
2327 s
->padding_statement
.output_offset
=
2328 dot
- output_section_statement
->bfd_section
->vma
;
2329 dot
+= s
->padding_statement
.size
;
2330 output_section_statement
->bfd_section
->_raw_size
+=
2331 s
->padding_statement
.size
;
2334 case lang_group_statement_enum
:
2335 dot
= lang_size_sections (s
->group_statement
.children
.head
,
2336 output_section_statement
,
2337 &s
->group_statement
.children
.head
,
2345 /* This can only get here when relaxing is turned on */
2347 case lang_address_statement_enum
:
2350 prev
= &s
->header
.next
;
2356 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
2357 lang_statement_union_type
* s
;
2358 lang_output_section_statement_type
* output_section_statement
;
2362 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2364 switch (s
->header
.type
)
2366 case lang_constructors_statement_enum
:
2367 dot
= lang_do_assignments (constructor_list
.head
,
2368 output_section_statement
,
2373 case lang_output_section_statement_enum
:
2375 lang_output_section_statement_type
*os
=
2376 &(s
->output_section_statement
);
2378 if (os
->bfd_section
!= NULL
)
2380 dot
= os
->bfd_section
->vma
;
2381 (void) lang_do_assignments (os
->children
.head
, os
,
2383 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
2387 /* If nothing has been placed into the output section then
2388 it won't have a bfd_section. */
2389 if (os
->bfd_section
)
2391 os
->bfd_section
->lma
2392 = exp_get_abs_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
2397 case lang_wild_statement_enum
:
2399 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
2400 output_section_statement
,
2405 case lang_object_symbols_statement_enum
:
2406 case lang_output_statement_enum
:
2407 case lang_target_statement_enum
:
2409 case lang_common_statement_enum
:
2412 case lang_data_statement_enum
:
2414 etree_value_type value
;
2416 value
= exp_fold_tree (s
->data_statement
.exp
,
2418 lang_final_phase_enum
, dot
, &dot
);
2419 s
->data_statement
.value
= value
.value
;
2420 if (value
.valid
== false)
2421 einfo ("%F%P: invalid data statement\n");
2423 switch (s
->data_statement
.type
)
2441 case lang_reloc_statement_enum
:
2443 etree_value_type value
;
2445 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
2447 lang_final_phase_enum
, dot
, &dot
);
2448 s
->reloc_statement
.addend_value
= value
.value
;
2449 if (value
.valid
== false)
2450 einfo ("%F%P: invalid reloc statement\n");
2452 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
);
2455 case lang_input_section_enum
:
2457 asection
*in
= s
->input_section
.section
;
2459 if (in
->_cooked_size
!= 0)
2460 dot
+= in
->_cooked_size
;
2462 dot
+= in
->_raw_size
;
2466 case lang_input_statement_enum
:
2468 case lang_fill_statement_enum
:
2469 fill
= s
->fill_statement
.fill
;
2471 case lang_assignment_statement_enum
:
2473 exp_fold_tree (s
->assignment_statement
.exp
,
2474 output_section_statement
,
2475 lang_final_phase_enum
,
2481 case lang_padding_statement_enum
:
2482 dot
+= s
->padding_statement
.size
;
2485 case lang_group_statement_enum
:
2486 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
2487 output_section_statement
,
2495 case lang_address_statement_enum
:
2503 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
2504 operator .startof. (section_name), it produces an undefined symbol
2505 .startof.section_name. Similarly, when it sees
2506 .sizeof. (section_name), it produces an undefined symbol
2507 .sizeof.section_name. For all the output sections, we look for
2508 such symbols, and set them to the correct value. */
2515 if (link_info
.relocateable
)
2518 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2520 const char *secname
;
2522 struct bfd_link_hash_entry
*h
;
2524 secname
= bfd_get_section_name (output_bfd
, s
);
2525 buf
= xmalloc (10 + strlen (secname
));
2527 sprintf (buf
, ".startof.%s", secname
);
2528 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
2529 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
2531 h
->type
= bfd_link_hash_defined
;
2532 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
2533 h
->u
.def
.section
= bfd_abs_section_ptr
;
2536 sprintf (buf
, ".sizeof.%s", secname
);
2537 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
2538 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
2540 h
->type
= bfd_link_hash_defined
;
2541 if (s
->_cooked_size
!= 0)
2542 h
->u
.def
.value
= s
->_cooked_size
;
2544 h
->u
.def
.value
= s
->_raw_size
;
2545 h
->u
.def
.section
= bfd_abs_section_ptr
;
2555 struct bfd_link_hash_entry
*h
;
2558 if (link_info
.relocateable
|| link_info
.shared
)
2563 if (entry_symbol
== (char *) NULL
)
2565 /* No entry has been specified. Look for start, but don't warn
2566 if we don't find it. */
2567 entry_symbol
= "start";
2571 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
2572 if (h
!= (struct bfd_link_hash_entry
*) NULL
2573 && (h
->type
== bfd_link_hash_defined
2574 || h
->type
== bfd_link_hash_defweak
)
2575 && h
->u
.def
.section
->output_section
!= NULL
)
2579 val
= (h
->u
.def
.value
2580 + bfd_get_section_vma (output_bfd
,
2581 h
->u
.def
.section
->output_section
)
2582 + h
->u
.def
.section
->output_offset
);
2583 if (! bfd_set_start_address (output_bfd
, val
))
2584 einfo ("%P%F:%s: can't set start address\n", entry_symbol
);
2590 /* Can't find the entry symbol. Use the first address in the
2592 ts
= bfd_get_section_by_name (output_bfd
, ".text");
2593 if (ts
!= (asection
*) NULL
)
2596 einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
2597 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
2598 if (! bfd_set_start_address (output_bfd
,
2599 bfd_get_section_vma (output_bfd
, ts
)))
2600 einfo ("%P%F: can't set start address\n");
2605 einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2611 /* Check that the architecture of all the input files is compatible
2612 with the output file. Also call the backend to let it do any
2613 other checking that is needed. */
2618 lang_statement_union_type
*file
;
2620 CONST bfd_arch_info_type
*compatible
;
2622 for (file
= file_chain
.head
;
2623 file
!= (lang_statement_union_type
*) NULL
;
2624 file
= file
->input_statement
.next
)
2626 input_bfd
= file
->input_statement
.the_bfd
;
2627 compatible
= bfd_arch_get_compatible (input_bfd
,
2629 if (compatible
== NULL
)
2630 einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2631 bfd_printable_name (input_bfd
), input_bfd
,
2632 bfd_printable_name (output_bfd
));
2634 else if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
2636 einfo ("%E%X: failed to merge target specific data of file %B\n", input_bfd
);
2641 /* Look through all the global common symbols and attach them to the
2642 correct section. The -sort-common command line switch may be used
2643 to roughly sort the entries by size. */
2648 if (link_info
.relocateable
2649 && ! command_line
.force_common_definition
)
2652 if (! config
.sort_common
)
2653 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
2658 for (power
= 4; power
>= 0; power
--)
2659 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
2664 /* Place one common symbol in the correct section. */
2667 lang_one_common (h
, info
)
2668 struct bfd_link_hash_entry
*h
;
2671 unsigned int power_of_two
;
2675 if (h
->type
!= bfd_link_hash_common
)
2679 power_of_two
= h
->u
.c
.p
->alignment_power
;
2681 if (config
.sort_common
2682 && power_of_two
< (unsigned int) *(int *) info
)
2685 section
= h
->u
.c
.p
->section
;
2687 /* Increase the size of the section. */
2688 section
->_raw_size
= ALIGN_N (section
->_raw_size
,
2689 (bfd_size_type
) (1 << power_of_two
));
2691 /* Adjust the alignment if necessary. */
2692 if (power_of_two
> section
->alignment_power
)
2693 section
->alignment_power
= power_of_two
;
2695 /* Change the symbol from common to defined. */
2696 h
->type
= bfd_link_hash_defined
;
2697 h
->u
.def
.section
= section
;
2698 h
->u
.def
.value
= section
->_raw_size
;
2700 /* Increase the size of the section. */
2701 section
->_raw_size
+= size
;
2703 /* Make sure the section is allocated in memory, and make sure that
2704 it is no longer a common section. */
2705 section
->flags
|= SEC_ALLOC
;
2706 section
->flags
&= ~ SEC_IS_COMMON
;
2708 if (config
.map_file
!= NULL
)
2710 static boolean header_printed
;
2715 if (! header_printed
)
2717 minfo ("\nAllocating common symbols\n");
2718 minfo ("Common symbol size file\n\n");
2719 header_printed
= true;
2722 name
= demangle (h
->root
.string
);
2724 len
= strlen (name
);
2739 if (size
<= 0xffffffff)
2740 sprintf (buf
, "%lx", (unsigned long) size
);
2742 sprintf_vma (buf
, size
);
2752 minfo ("%B\n", section
->owner
);
2759 run through the input files and ensure that every input
2760 section has somewhere to go. If one is found without
2761 a destination then create an input request and place it
2762 into the statement tree.
2766 lang_place_orphans ()
2768 lang_input_statement_type
*file
;
2770 for (file
= (lang_input_statement_type
*) file_chain
.head
;
2771 file
!= (lang_input_statement_type
*) NULL
;
2772 file
= (lang_input_statement_type
*) file
->next
)
2776 for (s
= file
->the_bfd
->sections
;
2777 s
!= (asection
*) NULL
;
2780 if (s
->output_section
== (asection
*) NULL
)
2782 /* This section of the file is not attatched, root
2783 around for a sensible place for it to go */
2785 if (file
->just_syms_flag
)
2787 /* We are only retrieving symbol values from this
2788 file. We want the symbols to act as though the
2789 values in the file are absolute. */
2790 s
->output_section
= bfd_abs_section_ptr
;
2791 s
->output_offset
= s
->vma
;
2793 else if (strcmp (s
->name
, "COMMON") == 0)
2795 /* This is a lonely common section which must have
2796 come from an archive. We attach to the section
2797 with the wildcard. */
2798 if (! link_info
.relocateable
2799 || command_line
.force_common_definition
)
2801 if (default_common_section
== NULL
)
2804 /* This message happens when using the
2805 svr3.ifile linker script, so I have
2807 info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2809 default_common_section
=
2810 lang_output_section_statement_lookup (".bss");
2813 wild_doit (&default_common_section
->children
, s
,
2814 default_common_section
, file
);
2817 else if (ldemul_place_orphan (file
, s
))
2821 lang_output_section_statement_type
*os
=
2822 lang_output_section_statement_lookup (s
->name
);
2824 wild_doit (&os
->children
, s
, os
, file
);
2833 lang_set_flags (ptr
, flags
)
2837 boolean state
= false;
2852 /* ptr->flag_read = state; */
2855 /* ptr->flag_write = state; */
2858 /* ptr->flag_executable= state;*/
2862 /* ptr->flag_loadable= state;*/
2865 einfo ("%P%F: invalid syntax in flags\n");
2872 /* Call a function on each input file. This function will be called
2873 on an archive, but not on the elements. */
2876 lang_for_each_input_file (func
)
2877 void (*func
) PARAMS ((lang_input_statement_type
*));
2879 lang_input_statement_type
*f
;
2881 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
2883 f
= (lang_input_statement_type
*) f
->next_real_file
)
2887 /* Call a function on each file. The function will be called on all
2888 the elements of an archive which are included in the link, but will
2889 not be called on the archive file itself. */
2892 lang_for_each_file (func
)
2893 void (*func
) PARAMS ((lang_input_statement_type
*));
2895 lang_input_statement_type
*f
;
2897 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2898 f
!= (lang_input_statement_type
*) NULL
;
2899 f
= (lang_input_statement_type
*) f
->next
)
2910 lang_for_each_input_section (func
)
2911 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
2913 lang_input_statement_type
*f
;
2915 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2916 f
!= (lang_input_statement_type
*) NULL
;
2917 f
= (lang_input_statement_type
*) f
->next
)
2921 for (s
= f
->the_bfd
->sections
;
2922 s
!= (asection
*) NULL
;
2925 func (f
->the_bfd
, s
);
2933 ldlang_add_file (entry
)
2934 lang_input_statement_type
* entry
;
2938 lang_statement_append (&file_chain
,
2939 (lang_statement_union_type
*) entry
,
2942 /* The BFD linker needs to have a list of all input BFDs involved in
2944 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
2945 ASSERT (entry
->the_bfd
!= output_bfd
);
2946 for (pp
= &link_info
.input_bfds
;
2947 *pp
!= (bfd
*) NULL
;
2948 pp
= &(*pp
)->link_next
)
2950 *pp
= entry
->the_bfd
;
2951 entry
->the_bfd
->usrdata
= (PTR
) entry
;
2952 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
2954 /* Look through the sections and check for any which should not be
2955 included in the link. We need to do this now, so that we can
2956 notice when the backend linker tries to report multiple
2957 definition errors for symbols which are in sections we aren't
2958 going to link. FIXME: It might be better to entirely ignore
2959 symbols which are defined in sections which are going to be
2960 discarded. This would require modifying the backend linker for
2961 each backend which might set the SEC_LINK_ONCE flag. If we do
2962 this, we should probably handle SEC_EXCLUDE in the same way. */
2964 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
2968 lang_add_output (name
, from_script
)
2972 /* Make -o on command line override OUTPUT in script. */
2973 if (had_output_filename
== false || !from_script
)
2975 output_filename
= name
;
2976 had_output_filename
= true;
2981 static lang_output_section_statement_type
*current_section
;
2993 for (l
= 0; l
< 32; l
++)
2995 if (i
>= (unsigned int) x
)
3004 lang_enter_output_section_statement (output_section_statement_name
,
3005 address_exp
, sectype
, block_value
,
3006 align
, subalign
, ebase
)
3007 const char *output_section_statement_name
;
3008 etree_type
* address_exp
;
3009 enum section_type sectype
;
3010 bfd_vma block_value
;
3012 etree_type
*subalign
;
3015 lang_output_section_statement_type
*os
;
3019 lang_output_section_statement_lookup (output_section_statement_name
);
3023 /* Add this statement to tree */
3024 /* add_statement(lang_output_section_statement_enum,
3025 output_section_statement);*/
3026 /* Make next things chain into subchain of this */
3028 if (os
->addr_tree
==
3029 (etree_type
*) NULL
)
3034 os
->sectype
= sectype
;
3035 if (sectype
!= noload_section
)
3036 os
->flags
= SEC_NO_FLAGS
;
3038 os
->flags
= SEC_NEVER_LOAD
;
3039 os
->block_value
= block_value
? block_value
: 1;
3040 stat_ptr
= &os
->children
;
3042 os
->subsection_alignment
= topower(
3043 exp_get_value_int(subalign
, -1,
3044 "subsection alignment",
3046 os
->section_alignment
= topower(
3047 exp_get_value_int(align
, -1,
3048 "section alignment", 0));
3050 os
->load_base
= ebase
;
3057 lang_output_statement_type
*new =
3058 new_stat (lang_output_statement
, stat_ptr
);
3060 new->name
= output_filename
;
3063 /* Reset the current counters in the regions */
3065 reset_memory_regions ()
3067 lang_memory_region_type
*p
= lang_memory_region_list
;
3069 for (p
= lang_memory_region_list
;
3070 p
!= (lang_memory_region_type
*) NULL
;
3073 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
3074 p
->current
= p
->origin
;
3081 lang_reasonable_defaults ();
3082 current_target
= default_target
;
3084 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
3086 ldemul_create_output_section_statements ();
3088 /* Add to the hash table all undefineds on the command line */
3089 lang_place_undefineds ();
3091 /* Create a bfd for each input file */
3092 current_target
= default_target
;
3093 open_input_bfds (statement_list
.head
, false);
3095 ldemul_after_open ();
3097 /* Make sure that we're not mixing architectures. We call this
3098 after all the input files have been opened, but before we do any
3099 other processing, so that any operations merge_private_bfd_data
3100 does on the output file will be known during the rest of the
3104 /* Build all sets based on the information gathered from the input
3106 ldctor_build_sets ();
3108 /* Size up the common data */
3111 /* Run through the contours of the script and attach input sections
3112 to the correct output sections
3114 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
3115 (lang_output_section_statement_type
*) NULL
);
3118 /* Find any sections not attached explicitly and handle them */
3119 lang_place_orphans ();
3121 ldemul_before_allocation ();
3123 /* We must record the program headers before we try to fix the
3124 section positions, since they will affect SIZEOF_HEADERS. */
3125 lang_record_phdrs ();
3127 /* Now run around and relax if we can */
3128 if (command_line
.relax
)
3130 /* First time round is a trial run to get the 'worst case'
3131 addresses of the objects if there was no relaxing. */
3132 lang_size_sections (statement_list
.head
,
3134 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
3136 /* Keep relaxing until bfd_relax_section gives up. */
3139 reset_memory_regions ();
3141 relax_again
= false;
3143 /* Do all the assignments with our current guesses as to
3145 lang_do_assignments (statement_list
.head
,
3147 (fill_type
) 0, (bfd_vma
) 0);
3149 /* Perform another relax pass - this time we know where the
3150 globals are, so can make better guess. */
3151 lang_size_sections (statement_list
.head
,
3153 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
3155 while (relax_again
);
3159 /* Size up the sections. */
3160 lang_size_sections (statement_list
.head
,
3162 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
3165 /* See if anything special should be done now we know how big
3167 ldemul_after_allocation ();
3169 /* Fix any .startof. or .sizeof. symbols. */
3170 lang_set_startof ();
3172 /* Do all the assignments, now that we know the final restingplaces
3173 of all the symbols */
3175 lang_do_assignments (statement_list
.head
,
3177 (fill_type
) 0, (bfd_vma
) 0);
3185 /* EXPORTED TO YACC */
3188 lang_add_wild (section_name
, filename
)
3189 CONST
char *CONST section_name
;
3190 CONST
char *CONST filename
;
3192 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
3195 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
3197 placed_commons
= true;
3199 if (filename
!= (char *) NULL
)
3201 lang_has_input_file
= true;
3203 new->section_name
= section_name
;
3204 new->filename
= filename
;
3205 lang_list_init (&new->children
);
3209 lang_section_start (name
, address
)
3211 etree_type
* address
;
3213 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
3215 ad
->section_name
= name
;
3216 ad
->address
= address
;
3219 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
3220 because of a -e argument on the command line, or zero if this is
3221 called by ENTRY in a linker script. Command line arguments take
3224 /* WINDOWS_NT. When an entry point has been specified, we will also force
3225 this symbol to be defined by calling ldlang_add_undef (equivalent to
3226 having switch -u entry_name on the command line). The reason we do
3227 this is so that the user doesn't have to because they would have to use
3228 the -u switch if they were specifying an entry point other than
3229 _mainCRTStartup. Specifically, if creating a windows application, entry
3230 point _WinMainCRTStartup must be specified.
3231 What I have found for non console applications (entry not _mainCRTStartup)
3232 is that the .obj that contains mainCRTStartup is brought in since it is
3233 the first encountered in libc.lib and it has other symbols in it which will
3234 be pulled in by the link process. To avoid this, adding -u with the entry
3235 point name specified forces the correct .obj to be used. We can avoid
3236 making the user do this by always adding the entry point name as an
3237 undefined symbol. */
3240 lang_add_entry (name
, cmdline
)
3244 if (entry_symbol
== NULL
3246 || ! entry_from_cmdline
)
3248 entry_symbol
= name
;
3249 entry_from_cmdline
= cmdline
;
3252 /* don't do this yet. It seems to work (the executables run), but the
3253 image created is very different from what I was getting before indicating
3254 that something else is being pulled in. When everything else is working,
3255 then try to put this back in to see if it will do the right thing for
3256 other more complicated applications */
3257 ldlang_add_undef (name
);
3262 lang_add_target (name
)
3265 lang_target_statement_type
*new = new_stat (lang_target_statement
,
3281 map_option_f
= true;
3292 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
3299 lang_add_data (type
, exp
)
3301 union etree_union
*exp
;
3304 lang_data_statement_type
*new = new_stat (lang_data_statement
,
3312 /* Create a new reloc statement. RELOC is the BFD relocation type to
3313 generate. HOWTO is the corresponding howto structure (we could
3314 look this up, but the caller has already done so). SECTION is the
3315 section to generate a reloc against, or NAME is the name of the
3316 symbol to generate a reloc against. Exactly one of SECTION and
3317 NAME must be NULL. ADDEND is an expression for the addend. */
3320 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
3321 bfd_reloc_code_real_type reloc
;
3322 reloc_howto_type
*howto
;
3325 union etree_union
*addend
;
3327 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
3331 p
->section
= section
;
3333 p
->addend_exp
= addend
;
3335 p
->addend_value
= 0;
3336 p
->output_section
= NULL
;
3341 lang_add_assignment (exp
)
3344 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
3351 lang_add_attribute (attribute
)
3352 enum statement_enum attribute
;
3354 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
3361 if (startup_file
!= (char *) NULL
)
3363 einfo ("%P%Fmultiple STARTUP files\n");
3365 first_file
->filename
= name
;
3366 first_file
->local_sym_name
= name
;
3367 first_file
->real
= true;
3369 startup_file
= name
;
3376 lang_float_flag
= maybe
;
3380 lang_leave_output_section_statement (fill
, memspec
, phdrs
)
3382 const char *memspec
;
3383 struct lang_output_section_phdr_list
*phdrs
;
3385 current_section
->fill
= fill
;
3386 current_section
->region
= lang_memory_region_lookup (memspec
);
3387 current_section
->phdrs
= phdrs
;
3388 stat_ptr
= &statement_list
;
3392 Create an absolute symbol with the given name with the value of the
3393 address of first byte of the section named.
3395 If the symbol already exists, then do nothing.
3398 lang_abs_symbol_at_beginning_of (secname
, name
)
3399 const char *secname
;
3402 struct bfd_link_hash_entry
*h
;
3404 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
3405 if (h
== (struct bfd_link_hash_entry
*) NULL
)
3406 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
3408 if (h
->type
== bfd_link_hash_new
3409 || h
->type
== bfd_link_hash_undefined
)
3413 h
->type
= bfd_link_hash_defined
;
3415 sec
= bfd_get_section_by_name (output_bfd
, secname
);
3416 if (sec
== (asection
*) NULL
)
3419 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
3421 h
->u
.def
.section
= bfd_abs_section_ptr
;
3426 Create an absolute symbol with the given name with the value of the
3427 address of the first byte after the end of the section named.
3429 If the symbol already exists, then do nothing.
3432 lang_abs_symbol_at_end_of (secname
, name
)
3433 const char *secname
;
3436 struct bfd_link_hash_entry
*h
;
3438 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
3439 if (h
== (struct bfd_link_hash_entry
*) NULL
)
3440 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
3442 if (h
->type
== bfd_link_hash_new
3443 || h
->type
== bfd_link_hash_undefined
)
3447 h
->type
= bfd_link_hash_defined
;
3449 sec
= bfd_get_section_by_name (output_bfd
, secname
);
3450 if (sec
== (asection
*) NULL
)
3453 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
3454 + bfd_section_size (output_bfd
, sec
));
3456 h
->u
.def
.section
= bfd_abs_section_ptr
;
3461 lang_statement_append (list
, element
, field
)
3462 lang_statement_list_type
* list
;
3463 lang_statement_union_type
* element
;
3464 lang_statement_union_type
** field
;
3466 *(list
->tail
) = element
;
3470 /* Set the output format type. -oformat overrides scripts. */
3473 lang_add_output_format (format
, big
, little
, from_script
)
3479 if (output_target
== NULL
|| !from_script
)
3481 if (command_line
.endian
== ENDIAN_BIG
3484 else if (command_line
.endian
== ENDIAN_LITTLE
3488 output_target
= format
;
3492 /* Enter a group. This creates a new lang_group_statement, and sets
3493 stat_ptr to build new statements within the group. */
3498 lang_group_statement_type
*g
;
3500 g
= new_stat (lang_group_statement
, stat_ptr
);
3501 lang_list_init (&g
->children
);
3502 stat_ptr
= &g
->children
;
3505 /* Leave a group. This just resets stat_ptr to start writing to the
3506 regular list of statements again. Note that this will not work if
3507 groups can occur inside anything else which can adjust stat_ptr,
3508 but currently they can't. */
3513 stat_ptr
= &statement_list
;
3516 /* Add a new program header. This is called for each entry in a PHDRS
3517 command in a linker script. */
3520 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
3528 struct lang_phdr
*n
, **pp
;
3530 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
3533 n
->type
= exp_get_value_int (type
, 0, "program header type",
3534 lang_final_phase_enum
);
3535 n
->filehdr
= filehdr
;
3540 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
3545 /* Record the program header information in the output BFD. FIXME: We
3546 should not be calling an ELF specific function here. */
3549 lang_record_phdrs ()
3553 struct lang_output_section_phdr_list
*last
;
3554 struct lang_phdr
*l
;
3555 lang_statement_union_type
*u
;
3558 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
3560 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
3567 for (u
= lang_output_section_statement
.head
;
3569 u
= u
->output_section_statement
.next
)
3571 lang_output_section_statement_type
*os
;
3572 struct lang_output_section_phdr_list
*pl
;
3574 os
= &u
->output_section_statement
;
3581 if (os
->sectype
== noload_section
3582 || os
->bfd_section
== NULL
3583 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
3588 if (os
->bfd_section
== NULL
)
3591 for (; pl
!= NULL
; pl
= pl
->next
)
3593 if (strcmp (pl
->name
, l
->name
) == 0)
3598 secs
= ((asection
**)
3599 xrealloc (secs
, alc
* sizeof (asection
*)));
3601 secs
[c
] = os
->bfd_section
;
3608 if (l
->flags
== NULL
)
3611 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
3612 lang_final_phase_enum
);
3617 at
= exp_get_vma (l
->at
, 0, "phdr load address",
3618 lang_final_phase_enum
);
3620 if (! bfd_record_phdr (output_bfd
, l
->type
,
3621 l
->flags
== NULL
? false : true,
3623 l
->at
== NULL
? false : true,
3624 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
3625 einfo ("%F%P: bfd_record_phdr failed: %E\n");
3630 /* Make sure all the phdr assignments succeeded. */
3631 for (u
= lang_output_section_statement
.head
;
3633 u
= u
->output_section_statement
.next
)
3635 struct lang_output_section_phdr_list
*pl
;
3637 if (u
->output_section_statement
.bfd_section
== NULL
)
3640 for (pl
= u
->output_section_statement
.phdrs
;
3643 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
3644 einfo ("%X%P: section `%s' assigned to non-existent phdr `%s'\n",
3645 u
->output_section_statement
.name
, pl
->name
);
3649 /* Record a list of sections which may not be cross referenced. */
3652 lang_add_nocrossref (l
)
3653 struct lang_nocrossref
*l
;
3655 struct lang_nocrossrefs
*n
;
3657 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
3658 n
->next
= nocrossref_list
;
3660 nocrossref_list
= n
;
3662 /* Set notice_all so that we get informed about all symbols. */
3663 link_info
.notice_all
= true;
3666 /* Overlay handling. We handle overlays with some static variables. */
3668 /* The overlay virtual address. */
3669 static etree_type
*overlay_vma
;
3671 /* The overlay load address. */
3672 static etree_type
*overlay_lma
;
3674 /* Whether nocrossrefs is set for this overlay. */
3675 static int overlay_nocrossrefs
;
3677 /* An expression for the maximum section size seen so far. */
3678 static etree_type
*overlay_max
;
3680 /* A list of all the sections in this overlay. */
3684 struct overlay_list
*next
;
3685 lang_output_section_statement_type
*os
;
3688 static struct overlay_list
*overlay_list
;
3690 /* Start handling an overlay. */
3693 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
3694 etree_type
*vma_expr
;
3695 etree_type
*lma_expr
;
3698 /* The grammar should prevent nested overlays from occurring. */
3699 ASSERT (overlay_vma
== NULL
3700 && overlay_lma
== NULL
3701 && overlay_list
== NULL
3702 && overlay_max
== NULL
);
3704 overlay_vma
= vma_expr
;
3705 overlay_lma
= lma_expr
;
3706 overlay_nocrossrefs
= nocrossrefs
;
3709 /* Start a section in an overlay. We handle this by calling
3710 lang_enter_output_section_statement with the correct VMA and LMA. */
3713 lang_enter_overlay_section (name
)
3716 struct overlay_list
*n
;
3719 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
3720 0, 0, 0, overlay_lma
);
3722 /* If this is the first section, then base the VMA and LMA of future
3723 sections on this one. This will work correctly even if `.' is
3724 used in the addresses. */
3725 if (overlay_list
== NULL
)
3727 overlay_vma
= exp_nameop (ADDR
, name
);
3728 overlay_lma
= exp_nameop (LOADADDR
, name
);
3731 /* Remember the section. */
3732 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
3733 n
->os
= current_section
;
3734 n
->next
= overlay_list
;
3737 size
= exp_nameop (SIZEOF
, name
);
3739 /* Adjust the LMA for the next section. */
3740 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
3742 /* Arrange to work out the maximum section end address. */
3743 if (overlay_max
== NULL
)
3746 overlay_max
= exp_binop (MAX
, overlay_max
, size
);
3749 /* Finish a section in an overlay. There isn't any special to do
3753 lang_leave_overlay_section (fill
, phdrs
)
3755 struct lang_output_section_phdr_list
*phdrs
;
3762 name
= current_section
->name
;
3764 lang_leave_output_section_statement (fill
, "*default*", phdrs
);
3766 /* Define the magic symbols. */
3768 clean
= xmalloc (strlen (name
) + 1);
3770 for (s1
= name
; *s1
!= '\0'; s1
++)
3771 if (isalnum (*s1
) || *s1
== '_')
3775 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
3776 sprintf (buf
, "__load_start_%s", clean
);
3777 lang_add_assignment (exp_assop ('=', buf
,
3778 exp_nameop (LOADADDR
, name
)));
3780 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
3781 sprintf (buf
, "__load_stop_%s", clean
);
3782 lang_add_assignment (exp_assop ('=', buf
,
3784 exp_nameop (LOADADDR
, name
),
3785 exp_nameop (SIZEOF
, name
))));
3790 /* Finish an overlay. If there are any overlay wide settings, this
3791 looks through all the sections in the overlay and sets them. */
3794 lang_leave_overlay (fill
, memspec
, phdrs
)
3796 const char *memspec
;
3797 struct lang_output_section_phdr_list
*phdrs
;
3799 lang_memory_region_type
*region
;
3800 struct overlay_list
*l
;
3801 struct lang_nocrossref
*nocrossref
;
3803 if (memspec
== NULL
)
3806 region
= lang_memory_region_lookup (memspec
);
3813 struct overlay_list
*next
;
3815 if (fill
!= 0 && l
->os
->fill
== 0)
3817 if (region
!= NULL
&& l
->os
->region
== NULL
)
3818 l
->os
->region
= region
;
3819 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
3820 l
->os
->phdrs
= phdrs
;
3822 if (overlay_nocrossrefs
)
3824 struct lang_nocrossref
*nc
;
3826 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
3827 nc
->name
= l
->os
->name
;
3828 nc
->next
= nocrossref
;
3837 if (nocrossref
!= NULL
)
3838 lang_add_nocrossref (nocrossref
);
3840 /* Update . for the end of the overlay. */
3841 lang_add_assignment (exp_assop ('=', ".",
3842 exp_binop ('+', overlay_vma
, overlay_max
)));
3846 overlay_nocrossrefs
= 0;
3847 overlay_list
= NULL
;
3851 /* Version handling. This is only useful for ELF. */
3853 /* This global variable holds the version tree that we build. */
3855 struct bfd_elf_version_tree
*lang_elf_version_info
;
3857 /* This is called for each variable name or match expression. */
3859 struct bfd_elf_version_expr
*
3860 lang_new_vers_regex (orig
, new)
3861 struct bfd_elf_version_expr
*orig
;
3864 struct bfd_elf_version_expr
*ret
;
3866 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
3872 /* This is called for each set of variable names and match
3875 struct bfd_elf_version_tree
*
3876 lang_new_vers_node (globals
, locals
)
3877 struct bfd_elf_version_expr
*globals
;
3878 struct bfd_elf_version_expr
*locals
;
3880 struct bfd_elf_version_tree
*ret
;
3882 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
3886 ret
->globals
= globals
;
3887 ret
->locals
= locals
;
3889 ret
->name_indx
= (unsigned int) -1;
3894 /* This static variable keeps track of version indices. */
3896 static int version_index
;
3898 /* This is called when we know the name and dependencies of the
3902 lang_register_vers_node (name
, version
, deps
)
3904 struct bfd_elf_version_tree
*version
;
3905 struct bfd_elf_version_deps
*deps
;
3907 struct bfd_elf_version_tree
*t
, **pp
;
3908 struct bfd_elf_version_expr
*e1
;
3910 /* Make sure this node has a unique name. */
3911 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
3912 if (strcmp (t
->name
, name
) == 0)
3913 einfo ("%X%P: duplicate version tag `%s'\n", name
);
3915 /* Check the global and local match names, and make sure there
3916 aren't any duplicates. */
3918 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
3920 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
3922 struct bfd_elf_version_expr
*e2
;
3924 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
3925 if (strcmp (e1
->match
, e2
->match
) == 0)
3926 einfo ("%X%P: duplicate expression `%s' in version information\n",
3929 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
3930 if (strcmp (e1
->match
, e2
->match
) == 0)
3931 einfo ("%X%P: duplicate expression `%s' in version information\n",
3936 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
3938 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
3940 struct bfd_elf_version_expr
*e2
;
3942 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
3943 if (strcmp (e1
->match
, e2
->match
) == 0)
3944 einfo ("%X%P: duplicate expression `%s' in version information\n",
3947 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
3948 if (strcmp (e1
->match
, e2
->match
) == 0)
3949 einfo ("%X%P: duplicate expression `%s' in version information\n",
3954 version
->deps
= deps
;
3955 version
->name
= name
;
3957 version
->vernum
= version_index
;
3959 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
3964 /* This is called when we see a version dependency. */
3966 struct bfd_elf_version_deps
*
3967 lang_add_vers_depend (list
, name
)
3968 struct bfd_elf_version_deps
*list
;
3971 struct bfd_elf_version_deps
*ret
;
3972 struct bfd_elf_version_tree
*t
;
3974 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
3977 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
3979 if (strcmp (t
->name
, name
) == 0)
3981 ret
->version_needed
= t
;
3986 einfo ("%X%P: unable to find version dependency `%s'\n", name
);