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
;
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
)
808 lang_input_section_type
*new;
811 if (output
->bfd_section
== NULL
)
819 /* Add a section reference to the list */
820 new = new_stat (lang_input_section
, ptr
);
822 new->section
= section
;
824 section
->output_section
= output
->bfd_section
;
826 flags
= section
->flags
;
828 /* We don't copy the SEC_NEVER_LOAD flag from an input section
829 to an output section, because we want to be able to include a
830 SEC_NEVER_LOAD section in the middle of an otherwise loaded
831 section (I don't know why we want to do this, but we do).
832 build_link_order in ldwrite.c handles this case by turning
833 the embedded SEC_NEVER_LOAD section into a fill. */
835 flags
&= ~ SEC_NEVER_LOAD
;
837 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
838 already been processed. One reason to do this is that on pe
839 format targets, .text$foo sections go into .text and it's odd
840 to see .text with SEC_LINK_ONCE set. */
842 if (! link_info
.relocateable
)
843 flags
&= ~ (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
);
845 /* If this is not the first input section, and the SEC_READONLY
846 flag is not currently set, then don't set it just because the
847 input section has it set. */
849 if (! first
&& (section
->output_section
->flags
& SEC_READONLY
) == 0)
850 flags
&= ~ SEC_READONLY
;
852 section
->output_section
->flags
|= flags
;
854 /* If SEC_READONLY is not set in the input section, then clear
855 it from the output section. */
856 if ((section
->flags
& SEC_READONLY
) == 0)
857 section
->output_section
->flags
&= ~SEC_READONLY
;
859 switch (output
->sectype
)
866 case overlay_section
:
867 output
->bfd_section
->flags
&= ~SEC_ALLOC
;
870 output
->bfd_section
->flags
&= ~SEC_LOAD
;
871 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
875 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
876 output
->bfd_section
->alignment_power
= section
->alignment_power
;
878 /* If supplied an aligment, then force it. */
879 if (output
->section_alignment
!= -1)
880 output
->bfd_section
->alignment_power
= output
->section_alignment
;
884 /* Expand a wild statement for a particular FILE. SECTION may be
885 NULL, in which case it is a wild card. */
888 wild_section (ptr
, section
, file
, output
)
889 lang_wild_statement_type
*ptr
;
891 lang_input_statement_type
*file
;
892 lang_output_section_statement_type
*output
;
894 if (file
->just_syms_flag
== false)
896 register asection
*s
;
902 wildcard
= wildcardp (section
);
904 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
908 /* Attach all sections named SECTION. If SECTION is NULL,
909 then attach all sections.
911 Previously, if SECTION was NULL, this code did not call
912 wild_doit if the SEC_IS_COMMON flag was set for the
913 section. I did not understand that, and I took it out.
922 name
= bfd_get_section_name (file
->the_bfd
, s
);
924 match
= fnmatch (section
, name
, 0) == 0 ? true : false;
926 match
= strcmp (section
, name
) == 0 ? true : false;
929 wild_doit (&ptr
->children
, s
, output
, file
);
934 /* This is passed a file name which must have been seen already and
935 added to the statement tree. We will see if it has been opened
936 already and had its symbols read. If not then we'll read it. */
938 static lang_input_statement_type
*
942 lang_input_statement_type
*search
;
944 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
945 search
!= (lang_input_statement_type
*) NULL
;
946 search
= (lang_input_statement_type
*) search
->next_real_file
)
948 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
950 if (search
->filename
!= (char *) NULL
951 && name
!= (char *) NULL
952 && strcmp (search
->filename
, name
) == 0)
956 if (search
== (lang_input_statement_type
*) NULL
)
957 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
960 /* If we have already added this file, or this file is not real
961 (FIXME: can that ever actually happen?) or the name is NULL
962 (FIXME: can that ever actually happen?) don't add this file. */
965 || search
->filename
== (const char *) NULL
)
968 load_symbols (search
, (lang_statement_list_type
*) NULL
);
973 /* Get the symbols for an input file. */
976 load_symbols (entry
, place
)
977 lang_input_statement_type
*entry
;
978 lang_statement_list_type
*place
;
985 ldfile_open_file (entry
);
987 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
988 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
991 lang_statement_list_type
*hold
;
993 err
= bfd_get_error ();
994 if (err
== bfd_error_file_ambiguously_recognized
)
998 einfo ("%B: file not recognized: %E\n", entry
->the_bfd
);
999 einfo ("%B: matching formats:", entry
->the_bfd
);
1000 for (p
= matching
; *p
!= NULL
; p
++)
1004 else if (err
!= bfd_error_file_not_recognized
1006 einfo ("%F%B: file not recognized: %E\n", entry
->the_bfd
);
1008 bfd_close (entry
->the_bfd
);
1009 entry
->the_bfd
= NULL
;
1011 /* See if the emulation has some special knowledge. */
1013 if (ldemul_unrecognized_file (entry
))
1016 /* Try to interpret the file as a linker script. */
1018 ldfile_open_command_file (entry
->filename
);
1023 ldfile_assumed_script
= true;
1024 parser_input
= input_script
;
1026 ldfile_assumed_script
= false;
1033 /* We don't call ldlang_add_file for an archive. Instead, the
1034 add_symbols entry point will call ldlang_add_file, via the
1035 add_archive_element callback, for each element of the archive
1037 switch (bfd_get_format (entry
->the_bfd
))
1043 ldlang_add_file (entry
);
1044 if (trace_files
|| trace_file_tries
)
1045 info_msg ("%I\n", entry
);
1049 if (entry
->whole_archive
)
1051 bfd
*member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1053 while (member
!= NULL
)
1055 if (! bfd_check_format (member
, bfd_object
))
1056 einfo ("%F%B: object %B in archive is not object\n",
1057 entry
->the_bfd
, member
);
1058 if (! ((*link_info
.callbacks
->add_archive_element
)
1059 (&link_info
, member
, "--whole-archive")))
1061 if (! bfd_link_add_symbols (member
, &link_info
))
1062 einfo ("%F%B: could not read symbols: %E\n", member
);
1063 member
= bfd_openr_next_archived_file (entry
->the_bfd
,
1067 entry
->loaded
= true;
1073 if (! bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
1074 einfo ("%F%B: could not read symbols: %E\n", entry
->the_bfd
);
1076 entry
->loaded
= true;
1079 /* Handle a wild statement for a single file F. */
1082 wild_file (s
, section
, f
, output
)
1083 lang_wild_statement_type
*s
;
1084 const char *section
;
1085 lang_input_statement_type
*f
;
1086 lang_output_section_statement_type
*output
;
1088 if (f
->the_bfd
== NULL
1089 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
1090 wild_section (s
, section
, f
, output
);
1095 /* This is an archive file. We must map each member of the
1096 archive separately. */
1097 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
1098 while (member
!= NULL
)
1100 /* When lookup_name is called, it will call the add_symbols
1101 entry point for the archive. For each element of the
1102 archive which is included, BFD will call ldlang_add_file,
1103 which will set the usrdata field of the member to the
1104 lang_input_statement. */
1105 if (member
->usrdata
!= NULL
)
1107 wild_section (s
, section
,
1108 (lang_input_statement_type
*) member
->usrdata
,
1112 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
1117 /* Handle a wild statement. SECTION or FILE or both may be NULL,
1118 indicating that it is a wildcard. Separate lang_input_section
1119 statements are created for each part of the expansion; they are
1120 added after the wild statement S. OUTPUT is the output section. */
1123 wild (s
, section
, file
, target
, output
)
1124 lang_wild_statement_type
*s
;
1125 const char *section
;
1128 lang_output_section_statement_type
*output
;
1130 lang_input_statement_type
*f
;
1132 if (file
== (char *) NULL
)
1134 /* Perform the iteration over all files in the list */
1135 for (f
= (lang_input_statement_type
*) file_chain
.head
;
1136 f
!= (lang_input_statement_type
*) NULL
;
1137 f
= (lang_input_statement_type
*) f
->next
)
1139 wild_file (s
, section
, f
, output
);
1142 else if (wildcardp (file
))
1144 for (f
= (lang_input_statement_type
*) file_chain
.head
;
1145 f
!= (lang_input_statement_type
*) NULL
;
1146 f
= (lang_input_statement_type
*) f
->next
)
1148 if (fnmatch (file
, f
->filename
, FNM_FILE_NAME
) == 0)
1149 wild_file (s
, section
, f
, output
);
1154 /* Perform the iteration over a single file */
1155 f
= lookup_name (file
);
1156 wild_file (s
, section
, f
, output
);
1159 if (section
!= (char *) NULL
1160 && strcmp (section
, "COMMON") == 0
1161 && default_common_section
== NULL
)
1163 /* Remember the section that common is going to in case we later
1164 get something which doesn't know where to put it. */
1165 default_common_section
= output
;
1169 /* Open the output file. */
1177 if (output_target
== (char *) NULL
)
1179 if (current_target
!= (char *) NULL
)
1180 output_target
= current_target
;
1182 output_target
= default_target
;
1184 output
= bfd_openw (name
, output_target
);
1186 if (output
== (bfd
*) NULL
)
1188 if (bfd_get_error () == bfd_error_invalid_target
)
1190 einfo ("%P%F: target %s not found\n", output_target
);
1192 einfo ("%P%F: cannot open output file %s: %E\n", name
);
1195 delete_output_file_on_failure
= true;
1197 /* output->flags |= D_PAGED;*/
1199 if (! bfd_set_format (output
, bfd_object
))
1200 einfo ("%P%F:%s: can not make object file: %E\n", name
);
1201 if (! bfd_set_arch_mach (output
,
1202 ldfile_output_architecture
,
1203 ldfile_output_machine
))
1204 einfo ("%P%F:%s: can not set architecture: %E\n", name
);
1206 link_info
.hash
= bfd_link_hash_table_create (output
);
1207 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
1208 einfo ("%P%F: can not create link hash table: %E\n");
1210 bfd_set_gp_size (output
, g_switch_value
);
1218 ldlang_open_output (statement
)
1219 lang_statement_union_type
* statement
;
1221 switch (statement
->header
.type
)
1223 case lang_output_statement_enum
:
1224 ASSERT (output_bfd
== (bfd
*) NULL
);
1225 output_bfd
= open_output (statement
->output_statement
.name
);
1226 ldemul_set_output_arch ();
1227 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
1228 output_bfd
->flags
|= D_PAGED
;
1230 output_bfd
->flags
&= ~D_PAGED
;
1231 if (config
.text_read_only
)
1232 output_bfd
->flags
|= WP_TEXT
;
1234 output_bfd
->flags
&= ~WP_TEXT
;
1235 if (link_info
.traditional_format
)
1236 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
1238 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
1241 case lang_target_statement_enum
:
1242 current_target
= statement
->target_statement
.target
;
1249 /* Open all the input files. */
1252 open_input_bfds (s
, force
)
1253 lang_statement_union_type
*s
;
1256 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1258 switch (s
->header
.type
)
1260 case lang_constructors_statement_enum
:
1261 open_input_bfds (constructor_list
.head
, force
);
1263 case lang_output_section_statement_enum
:
1264 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1266 case lang_wild_statement_enum
:
1267 /* Maybe we should load the file's symbols */
1268 if (s
->wild_statement
.filename
1269 && ! wildcardp (s
->wild_statement
.filename
))
1270 (void) lookup_name (s
->wild_statement
.filename
);
1271 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1273 case lang_group_statement_enum
:
1275 struct bfd_link_hash_entry
*undefs
;
1277 /* We must continually search the entries in the group
1278 until no new symbols are added to the list of undefined
1283 undefs
= link_info
.hash
->undefs_tail
;
1284 open_input_bfds (s
->group_statement
.children
.head
, true);
1286 while (undefs
!= link_info
.hash
->undefs_tail
);
1289 case lang_target_statement_enum
:
1290 current_target
= s
->target_statement
.target
;
1292 case lang_input_statement_enum
:
1293 if (s
->input_statement
.real
== true)
1295 lang_statement_list_type add
;
1297 s
->input_statement
.target
= current_target
;
1299 /* If we are being called from within a group, and this
1300 is an archive which has already been searched, then
1301 force it to be researched. */
1303 && s
->input_statement
.loaded
1304 && bfd_check_format (s
->input_statement
.the_bfd
,
1306 s
->input_statement
.loaded
= false;
1308 lang_list_init (&add
);
1310 load_symbols (&s
->input_statement
, &add
);
1312 if (add
.head
!= NULL
)
1314 *add
.tail
= s
->next
;
1325 /* If there are [COMMONS] statements, put a wild one into the bss section */
1328 lang_reasonable_defaults ()
1331 lang_output_section_statement_lookup (".text");
1332 lang_output_section_statement_lookup (".data");
1334 default_common_section
=
1335 lang_output_section_statement_lookup (".bss");
1338 if (placed_commons
== false)
1340 lang_wild_statement_type
*new =
1341 new_stat (lang_wild_statement
,
1342 &default_common_section
->children
);
1344 new->section_name
= "COMMON";
1345 new->filename
= (char *) NULL
;
1346 lang_list_init (&new->children
);
1353 Add the supplied name to the symbol table as an undefined reference.
1354 Remove items from the chain as we open input bfds
1356 typedef struct ldlang_undef_chain_list
1358 struct ldlang_undef_chain_list
*next
;
1360 } ldlang_undef_chain_list_type
;
1362 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
1365 ldlang_add_undef (name
)
1366 CONST
char *CONST name
;
1368 ldlang_undef_chain_list_type
*new =
1369 ((ldlang_undef_chain_list_type
*)
1370 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
1372 new->next
= ldlang_undef_chain_list_head
;
1373 ldlang_undef_chain_list_head
= new;
1375 new->name
= buystring (name
);
1378 /* Run through the list of undefineds created above and place them
1379 into the linker hash table as undefined symbols belonging to the
1383 lang_place_undefineds ()
1385 ldlang_undef_chain_list_type
*ptr
;
1387 for (ptr
= ldlang_undef_chain_list_head
;
1388 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
1391 struct bfd_link_hash_entry
*h
;
1393 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
1394 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1395 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
1396 if (h
->type
== bfd_link_hash_new
)
1398 h
->type
= bfd_link_hash_undefined
;
1399 h
->u
.undef
.abfd
= NULL
;
1400 bfd_link_add_undef (link_info
.hash
, h
);
1405 /* Open input files and attatch to output sections */
1407 map_input_to_output_sections (s
, target
, output_section_statement
)
1408 lang_statement_union_type
* s
;
1410 lang_output_section_statement_type
* output_section_statement
;
1412 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1414 switch (s
->header
.type
)
1418 case lang_wild_statement_enum
:
1419 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1420 s
->wild_statement
.filename
, target
,
1421 output_section_statement
);
1424 case lang_constructors_statement_enum
:
1425 map_input_to_output_sections (constructor_list
.head
,
1427 output_section_statement
);
1429 case lang_output_section_statement_enum
:
1430 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1432 &s
->output_section_statement
);
1434 case lang_output_statement_enum
:
1436 case lang_target_statement_enum
:
1437 target
= s
->target_statement
.target
;
1439 case lang_group_statement_enum
:
1440 map_input_to_output_sections (s
->group_statement
.children
.head
,
1442 output_section_statement
);
1444 case lang_fill_statement_enum
:
1445 case lang_input_section_enum
:
1446 case lang_object_symbols_statement_enum
:
1447 case lang_data_statement_enum
:
1448 case lang_reloc_statement_enum
:
1449 case lang_padding_statement_enum
:
1450 case lang_input_statement_enum
:
1451 if (output_section_statement
!= NULL
1452 && output_section_statement
->bfd_section
== NULL
)
1453 init_os (output_section_statement
);
1455 case lang_assignment_statement_enum
:
1456 if (output_section_statement
!= NULL
1457 && output_section_statement
->bfd_section
== NULL
)
1458 init_os (output_section_statement
);
1460 /* Make sure that any sections mentioned in the assignment
1462 exp_init_os (s
->assignment_statement
.exp
);
1464 case lang_afile_asection_pair_statement_enum
:
1467 case lang_address_statement_enum
:
1468 /* Mark the specified section with the supplied address */
1470 lang_output_section_statement_type
*os
=
1471 lang_output_section_statement_lookup
1472 (s
->address_statement
.section_name
);
1474 if (os
->bfd_section
== NULL
)
1476 os
->addr_tree
= s
->address_statement
.address
;
1484 print_output_section_statement (output_section_statement
)
1485 lang_output_section_statement_type
* output_section_statement
;
1487 asection
*section
= output_section_statement
->bfd_section
;
1490 if (output_section_statement
!= abs_output_section
)
1492 minfo ("\n%s", output_section_statement
->name
);
1494 if (section
!= NULL
)
1496 print_dot
= section
->vma
;
1498 len
= strlen (output_section_statement
->name
);
1499 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
1504 while (len
< SECTION_NAME_MAP_LENGTH
)
1510 minfo ("0x%V %W", section
->vma
, section
->_raw_size
);
1512 if (output_section_statement
->load_base
!= NULL
)
1516 addr
= exp_get_abs_int (output_section_statement
->load_base
, 0,
1517 "load base", lang_final_phase_enum
);
1518 minfo (" load address 0x%V", addr
);
1525 print_statement_list (output_section_statement
->children
.head
,
1526 output_section_statement
);
1530 print_assignment (assignment
, output_section
)
1531 lang_assignment_statement_type
* assignment
;
1532 lang_output_section_statement_type
* output_section
;
1535 etree_value_type result
;
1537 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1540 result
= exp_fold_tree (assignment
->exp
->assign
.src
, output_section
,
1541 lang_final_phase_enum
, print_dot
, &print_dot
);
1543 minfo ("0x%V", result
.value
+ result
.section
->bfd_section
->vma
);
1554 exp_print_tree (assignment
->exp
);
1560 print_input_statement (statm
)
1561 lang_input_statement_type
* statm
;
1563 if (statm
->filename
!= (char *) NULL
)
1565 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1569 /* Print all symbols defined in a particular section. This is called
1570 via bfd_link_hash_traverse. */
1573 print_one_symbol (hash_entry
, ptr
)
1574 struct bfd_link_hash_entry
*hash_entry
;
1577 asection
*sec
= (asection
*) ptr
;
1579 if ((hash_entry
->type
== bfd_link_hash_defined
1580 || hash_entry
->type
== bfd_link_hash_defweak
)
1581 && sec
== hash_entry
->u
.def
.section
)
1585 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1588 (hash_entry
->u
.def
.value
1589 + hash_entry
->u
.def
.section
->output_offset
1590 + hash_entry
->u
.def
.section
->output_section
->vma
));
1592 minfo (" %T\n", hash_entry
->root
.string
);
1598 /* Print information about an input section to the map file. */
1601 print_input_section (in
)
1602 lang_input_section_type
* in
;
1604 asection
*i
= in
->section
;
1605 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
1611 minfo ("%s", i
->name
);
1613 if (i
->output_section
!= NULL
)
1617 len
= 1 + strlen (i
->name
);
1618 if (len
>= SECTION_NAME_MAP_LENGTH
- 1)
1623 while (len
< SECTION_NAME_MAP_LENGTH
)
1629 minfo ("0x%V %W %B\n",
1630 i
->output_section
->vma
+ i
->output_offset
, size
,
1633 if (i
->_cooked_size
!= 0 && i
->_cooked_size
!= i
->_raw_size
)
1635 len
= SECTION_NAME_MAP_LENGTH
+ 3;
1647 minfo ("%W (size before relaxing)\n", i
->_raw_size
);
1650 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
1652 print_dot
= i
->output_section
->vma
+ i
->output_offset
+ size
;
1658 print_fill_statement (fill
)
1659 lang_fill_statement_type
* fill
;
1661 fprintf (config
.map_file
, " FILL mask 0x%x\n", fill
->fill
);
1665 print_data_statement (data
)
1666 lang_data_statement_type
* data
;
1673 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1676 addr
= data
->output_vma
;
1677 if (data
->output_section
!= NULL
)
1678 addr
+= data
->output_section
->vma
;
1706 minfo ("0x%V %W %s 0x%v", addr
, size
, name
, data
->value
);
1708 if (data
->exp
->type
.node_class
!= etree_value
)
1711 exp_print_tree (data
->exp
);
1716 print_dot
= addr
+ size
;
1719 /* Print an address statement. These are generated by options like
1723 print_address_statement (address
)
1724 lang_address_statement_type
*address
;
1726 minfo ("Address of section %s set to ", address
->section_name
);
1727 exp_print_tree (address
->address
);
1731 /* Print a reloc statement. */
1734 print_reloc_statement (reloc
)
1735 lang_reloc_statement_type
*reloc
;
1741 for (i
= 0; i
< SECTION_NAME_MAP_LENGTH
; i
++)
1744 addr
= reloc
->output_vma
;
1745 if (reloc
->output_section
!= NULL
)
1746 addr
+= reloc
->output_section
->vma
;
1748 size
= bfd_get_reloc_size (reloc
->howto
);
1750 minfo ("0x%V %W RELOC %s ", addr
, size
, reloc
->howto
->name
);
1752 if (reloc
->name
!= NULL
)
1753 minfo ("%s+", reloc
->name
);
1755 minfo ("%s+", reloc
->section
->name
);
1757 exp_print_tree (reloc
->addend_exp
);
1761 print_dot
= addr
+ size
;
1765 print_padding_statement (s
)
1766 lang_padding_statement_type
*s
;
1773 len
= sizeof " *fill*" - 1;
1774 while (len
< SECTION_NAME_MAP_LENGTH
)
1780 addr
= s
->output_offset
;
1781 if (s
->output_section
!= NULL
)
1782 addr
+= s
->output_section
->vma
;
1783 minfo ("0x%V %W", addr
, s
->size
);
1786 minfo (" %u", s
->fill
);
1790 print_dot
= addr
+ s
->size
;
1794 print_wild_statement (w
, os
)
1795 lang_wild_statement_type
* w
;
1796 lang_output_section_statement_type
* os
;
1800 if (w
->filename
!= NULL
)
1801 minfo ("%s", w
->filename
);
1805 if (w
->section_name
!= NULL
)
1806 minfo ("(%s)", w
->section_name
);
1812 print_statement_list (w
->children
.head
, os
);
1815 /* Print a group statement. */
1819 lang_group_statement_type
*s
;
1820 lang_output_section_statement_type
*os
;
1822 fprintf (config
.map_file
, "START GROUP\n");
1823 print_statement_list (s
->children
.head
, os
);
1824 fprintf (config
.map_file
, "END GROUP\n");
1827 /* Print the list of statements in S.
1828 This can be called for any statement type. */
1831 print_statement_list (s
, os
)
1832 lang_statement_union_type
*s
;
1833 lang_output_section_statement_type
*os
;
1837 print_statement (s
, os
);
1842 /* Print the first statement in statement list S.
1843 This can be called for any statement type. */
1846 print_statement (s
, os
)
1847 lang_statement_union_type
*s
;
1848 lang_output_section_statement_type
*os
;
1850 switch (s
->header
.type
)
1853 fprintf (config
.map_file
, "Fail with %d\n", s
->header
.type
);
1856 case lang_constructors_statement_enum
:
1857 if (constructor_list
.head
!= NULL
)
1859 minfo (" CONSTRUCTORS\n");
1860 print_statement_list (constructor_list
.head
, os
);
1863 case lang_wild_statement_enum
:
1864 print_wild_statement (&s
->wild_statement
, os
);
1866 case lang_address_statement_enum
:
1867 print_address_statement (&s
->address_statement
);
1869 case lang_object_symbols_statement_enum
:
1870 minfo (" CREATE_OBJECT_SYMBOLS\n");
1872 case lang_fill_statement_enum
:
1873 print_fill_statement (&s
->fill_statement
);
1875 case lang_data_statement_enum
:
1876 print_data_statement (&s
->data_statement
);
1878 case lang_reloc_statement_enum
:
1879 print_reloc_statement (&s
->reloc_statement
);
1881 case lang_input_section_enum
:
1882 print_input_section (&s
->input_section
);
1884 case lang_padding_statement_enum
:
1885 print_padding_statement (&s
->padding_statement
);
1887 case lang_output_section_statement_enum
:
1888 print_output_section_statement (&s
->output_section_statement
);
1890 case lang_assignment_statement_enum
:
1891 print_assignment (&s
->assignment_statement
, os
);
1893 case lang_target_statement_enum
:
1894 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1896 case lang_output_statement_enum
:
1897 minfo ("OUTPUT(%s", s
->output_statement
.name
);
1898 if (output_target
!= NULL
)
1899 minfo (" %s", output_target
);
1902 case lang_input_statement_enum
:
1903 print_input_statement (&s
->input_statement
);
1905 case lang_group_statement_enum
:
1906 print_group (&s
->group_statement
, os
);
1908 case lang_afile_asection_pair_statement_enum
:
1917 print_statement_list (statement_list
.head
, abs_output_section
);
1920 /* Print the first N statements in statement list S to STDERR.
1921 If N == 0, nothing is printed.
1922 If N < 0, the entire list is printed.
1923 Intended to be called from GDB. */
1926 dprint_statement (s
, n
)
1927 lang_statement_union_type
* s
;
1930 FILE *map_save
= config
.map_file
;
1932 config
.map_file
= stderr
;
1935 print_statement_list (s
, abs_output_section
);
1938 while (s
&& --n
>= 0)
1940 print_statement (s
, abs_output_section
);
1945 config
.map_file
= map_save
;
1949 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
1950 lang_statement_union_type
** this_ptr
;
1953 asection
* output_section_statement
;
1956 /* Align this section first to the
1957 input sections requirement, then
1958 to the output section's requirement.
1959 If this alignment is > than any seen before,
1960 then record it too. Perform the alignment by
1961 inserting a magic 'padding' statement.
1964 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
1966 if (alignment_needed
!= 0)
1968 lang_statement_union_type
*new =
1969 ((lang_statement_union_type
*)
1970 stat_alloc (sizeof (lang_padding_statement_type
)));
1972 /* Link into existing chain */
1973 new->header
.next
= *this_ptr
;
1975 new->header
.type
= lang_padding_statement_enum
;
1976 new->padding_statement
.output_section
= output_section_statement
;
1977 new->padding_statement
.output_offset
=
1978 dot
- output_section_statement
->vma
;
1979 new->padding_statement
.fill
= fill
;
1980 new->padding_statement
.size
= alignment_needed
;
1984 /* Remember the most restrictive alignment */
1985 if (power
> output_section_statement
->alignment_power
)
1987 output_section_statement
->alignment_power
= power
;
1989 output_section_statement
->_raw_size
+= alignment_needed
;
1990 return alignment_needed
+ dot
;
1994 /* Work out how much this section will move the dot point */
1996 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
1997 lang_statement_union_type
** this_ptr
;
1998 lang_output_section_statement_type
* output_section_statement
;
2003 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
2004 asection
*i
= is
->section
;
2006 if (is
->ifile
->just_syms_flag
== false)
2008 if (output_section_statement
->subsection_alignment
!= -1)
2009 i
->alignment_power
=
2010 output_section_statement
->subsection_alignment
;
2012 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
2013 output_section_statement
->bfd_section
, dot
);
2015 /* Remember where in the output section this input section goes */
2017 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
2019 /* Mark how big the output section must be to contain this now
2021 if (i
->_cooked_size
!= 0)
2022 dot
+= i
->_cooked_size
;
2024 dot
+= i
->_raw_size
;
2025 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
2029 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
2035 /* This variable indicates whether bfd_relax_section should be called
2038 static boolean relax_again
;
2040 /* Set the sizes for all the output sections. */
2043 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
2044 lang_statement_union_type
* s
;
2045 lang_output_section_statement_type
* output_section_statement
;
2046 lang_statement_union_type
** prev
;
2051 /* Size up the sections from their constituent parts */
2052 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2054 switch (s
->header
.type
)
2057 case lang_output_section_statement_enum
:
2060 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
2062 if (os
->bfd_section
== NULL
)
2064 /* This section was never actually created. */
2068 /* If this is a COFF shared library section, use the size and
2069 address from the input section. FIXME: This is COFF
2070 specific; it would be cleaner if there were some other way
2071 to do this, but nothing simple comes to mind. */
2072 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
2076 if (os
->children
.head
== NULL
2077 || os
->children
.head
->next
!= NULL
2078 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
2079 einfo ("%P%X: Internal error on COFF shared library section %s\n",
2082 input
= os
->children
.head
->input_section
.section
;
2083 bfd_set_section_vma (os
->bfd_section
->owner
,
2085 bfd_section_vma (input
->owner
, input
));
2086 os
->bfd_section
->_raw_size
= input
->_raw_size
;
2090 if (bfd_is_abs_section (os
->bfd_section
))
2092 /* No matter what happens, an abs section starts at zero */
2093 ASSERT (os
->bfd_section
->vma
== 0);
2097 if (os
->addr_tree
== (etree_type
*) NULL
)
2099 /* No address specified for this section, get one
2100 from the region specification
2102 if (os
->region
== (lang_memory_region_type
*) NULL
)
2104 os
->region
= lang_memory_region_lookup ("*default*");
2106 dot
= os
->region
->current
;
2107 if (os
->section_alignment
== -1)
2112 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
2113 if (dot
!= olddot
&& config
.warn_section_align
)
2114 einfo ("%P: warning: changing start of section %s by %u bytes\n",
2115 os
->name
, (unsigned int) (dot
- olddot
));
2122 r
= exp_fold_tree (os
->addr_tree
,
2124 lang_allocating_phase_enum
,
2126 if (r
.valid
== false)
2128 einfo ("%F%S: non constant address expression for section %s\n",
2131 dot
= r
.value
+ r
.section
->bfd_section
->vma
;
2133 /* The section starts here */
2134 /* First, align to what the section needs */
2136 if (os
->section_alignment
!= -1)
2137 dot
= align_power (dot
, os
->section_alignment
);
2139 bfd_set_section_vma (0, os
->bfd_section
, dot
);
2141 os
->bfd_section
->output_offset
= 0;
2144 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
2145 os
->fill
, dot
, relax
);
2146 /* Ignore the size of the input sections, use the vma and size to */
2149 after
= ALIGN_N (os
->bfd_section
->vma
+
2150 os
->bfd_section
->_raw_size
,
2151 /* The coercion here is important, see ld.h. */
2152 (bfd_vma
) os
->block_value
);
2154 if (bfd_is_abs_section (os
->bfd_section
))
2155 ASSERT (after
== os
->bfd_section
->vma
);
2157 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
2158 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
2159 os
->processed
= true;
2161 /* Replace into region ? */
2162 if (os
->region
!= (lang_memory_region_type
*) NULL
)
2164 os
->region
->current
= dot
;
2165 /* Make sure this isn't silly. */
2166 if (os
->region
->current
< os
->region
->origin
2167 || (os
->region
->current
- os
->region
->origin
2168 > os
->region
->length
))
2170 if (os
->addr_tree
!= (etree_type
*) NULL
)
2172 einfo ("%X%P: address 0x%v of %B section %s is not within region %s\n",
2173 os
->region
->current
,
2174 os
->bfd_section
->owner
,
2175 os
->bfd_section
->name
,
2180 einfo ("%X%P: region %s is full (%B section %s)\n",
2182 os
->bfd_section
->owner
,
2183 os
->bfd_section
->name
);
2185 /* Reset the region pointer. */
2186 os
->region
->current
= os
->region
->origin
;
2192 case lang_constructors_statement_enum
:
2193 dot
= lang_size_sections (constructor_list
.head
,
2194 output_section_statement
,
2195 &s
->wild_statement
.children
.head
,
2200 case lang_data_statement_enum
:
2202 unsigned int size
= 0;
2204 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
2205 s
->data_statement
.output_section
=
2206 output_section_statement
->bfd_section
;
2208 switch (s
->data_statement
.type
)
2226 output_section_statement
->bfd_section
->_raw_size
+= size
;
2227 /* The output section gets contents, and then we inspect for
2228 any flags set in the input script which override any ALLOC */
2229 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
2230 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
)) {
2231 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
| SEC_LOAD
;
2236 case lang_reloc_statement_enum
:
2240 s
->reloc_statement
.output_vma
=
2241 dot
- output_section_statement
->bfd_section
->vma
;
2242 s
->reloc_statement
.output_section
=
2243 output_section_statement
->bfd_section
;
2244 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
2246 output_section_statement
->bfd_section
->_raw_size
+= size
;
2250 case lang_wild_statement_enum
:
2252 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
2253 output_section_statement
,
2254 &s
->wild_statement
.children
.head
,
2260 case lang_object_symbols_statement_enum
:
2261 link_info
.create_object_symbols_section
=
2262 output_section_statement
->bfd_section
;
2264 case lang_output_statement_enum
:
2265 case lang_target_statement_enum
:
2267 case lang_input_section_enum
:
2271 i
= (*prev
)->input_section
.section
;
2274 if (i
->_cooked_size
== 0)
2275 i
->_cooked_size
= i
->_raw_size
;
2281 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
2282 einfo ("%P%F: can't relax section: %E\n");
2286 dot
= size_input_section (prev
,
2287 output_section_statement
,
2288 output_section_statement
->fill
,
2292 case lang_input_statement_enum
:
2294 case lang_fill_statement_enum
:
2295 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
2297 fill
= s
->fill_statement
.fill
;
2299 case lang_assignment_statement_enum
:
2301 bfd_vma newdot
= dot
;
2303 exp_fold_tree (s
->assignment_statement
.exp
,
2304 output_section_statement
,
2305 lang_allocating_phase_enum
,
2309 if (newdot
!= dot
&& !relax
)
2311 /* The assignment changed dot. Insert a pad. */
2312 if (output_section_statement
== abs_output_section
)
2314 /* If we don't have an output section, then just adjust
2315 the default memory address. */
2316 lang_memory_region_lookup ("*default*")->current
= newdot
;
2320 lang_statement_union_type
*new =
2321 ((lang_statement_union_type
*)
2322 stat_alloc (sizeof (lang_padding_statement_type
)));
2324 /* Link into existing chain */
2325 new->header
.next
= *prev
;
2327 new->header
.type
= lang_padding_statement_enum
;
2328 new->padding_statement
.output_section
=
2329 output_section_statement
->bfd_section
;
2330 new->padding_statement
.output_offset
=
2331 dot
- output_section_statement
->bfd_section
->vma
;
2332 new->padding_statement
.fill
= fill
;
2333 new->padding_statement
.size
= newdot
- dot
;
2334 output_section_statement
->bfd_section
->_raw_size
+=
2335 new->padding_statement
.size
;
2343 case lang_padding_statement_enum
:
2344 /* If we are relaxing, and this is not the first pass, some
2345 padding statements may have been inserted during previous
2346 passes. We may have to move the padding statement to a new
2347 location if dot has a different value at this point in this
2348 pass than it did at this point in the previous pass. */
2349 s
->padding_statement
.output_offset
=
2350 dot
- output_section_statement
->bfd_section
->vma
;
2351 dot
+= s
->padding_statement
.size
;
2352 output_section_statement
->bfd_section
->_raw_size
+=
2353 s
->padding_statement
.size
;
2356 case lang_group_statement_enum
:
2357 dot
= lang_size_sections (s
->group_statement
.children
.head
,
2358 output_section_statement
,
2359 &s
->group_statement
.children
.head
,
2367 /* This can only get here when relaxing is turned on */
2369 case lang_address_statement_enum
:
2372 prev
= &s
->header
.next
;
2378 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
2379 lang_statement_union_type
* s
;
2380 lang_output_section_statement_type
* output_section_statement
;
2384 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2386 switch (s
->header
.type
)
2388 case lang_constructors_statement_enum
:
2389 dot
= lang_do_assignments (constructor_list
.head
,
2390 output_section_statement
,
2395 case lang_output_section_statement_enum
:
2397 lang_output_section_statement_type
*os
=
2398 &(s
->output_section_statement
);
2400 if (os
->bfd_section
!= NULL
)
2402 dot
= os
->bfd_section
->vma
;
2403 (void) lang_do_assignments (os
->children
.head
, os
,
2405 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
2409 /* If nothing has been placed into the output section then
2410 it won't have a bfd_section. */
2411 if (os
->bfd_section
)
2413 os
->bfd_section
->lma
2414 = exp_get_abs_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
2419 case lang_wild_statement_enum
:
2421 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
2422 output_section_statement
,
2427 case lang_object_symbols_statement_enum
:
2428 case lang_output_statement_enum
:
2429 case lang_target_statement_enum
:
2431 case lang_common_statement_enum
:
2434 case lang_data_statement_enum
:
2436 etree_value_type value
;
2438 value
= exp_fold_tree (s
->data_statement
.exp
,
2440 lang_final_phase_enum
, dot
, &dot
);
2441 s
->data_statement
.value
= value
.value
;
2442 if (value
.valid
== false)
2443 einfo ("%F%P: invalid data statement\n");
2445 switch (s
->data_statement
.type
)
2463 case lang_reloc_statement_enum
:
2465 etree_value_type value
;
2467 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
2469 lang_final_phase_enum
, dot
, &dot
);
2470 s
->reloc_statement
.addend_value
= value
.value
;
2471 if (value
.valid
== false)
2472 einfo ("%F%P: invalid reloc statement\n");
2474 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
);
2477 case lang_input_section_enum
:
2479 asection
*in
= s
->input_section
.section
;
2481 if (in
->_cooked_size
!= 0)
2482 dot
+= in
->_cooked_size
;
2484 dot
+= in
->_raw_size
;
2488 case lang_input_statement_enum
:
2490 case lang_fill_statement_enum
:
2491 fill
= s
->fill_statement
.fill
;
2493 case lang_assignment_statement_enum
:
2495 exp_fold_tree (s
->assignment_statement
.exp
,
2496 output_section_statement
,
2497 lang_final_phase_enum
,
2503 case lang_padding_statement_enum
:
2504 dot
+= s
->padding_statement
.size
;
2507 case lang_group_statement_enum
:
2508 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
2509 output_section_statement
,
2517 case lang_address_statement_enum
:
2525 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
2526 operator .startof. (section_name), it produces an undefined symbol
2527 .startof.section_name. Similarly, when it sees
2528 .sizeof. (section_name), it produces an undefined symbol
2529 .sizeof.section_name. For all the output sections, we look for
2530 such symbols, and set them to the correct value. */
2537 if (link_info
.relocateable
)
2540 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2542 const char *secname
;
2544 struct bfd_link_hash_entry
*h
;
2546 secname
= bfd_get_section_name (output_bfd
, s
);
2547 buf
= xmalloc (10 + strlen (secname
));
2549 sprintf (buf
, ".startof.%s", secname
);
2550 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
2551 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
2553 h
->type
= bfd_link_hash_defined
;
2554 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
2555 h
->u
.def
.section
= bfd_abs_section_ptr
;
2558 sprintf (buf
, ".sizeof.%s", secname
);
2559 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
2560 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
2562 h
->type
= bfd_link_hash_defined
;
2563 if (s
->_cooked_size
!= 0)
2564 h
->u
.def
.value
= s
->_cooked_size
;
2566 h
->u
.def
.value
= s
->_raw_size
;
2567 h
->u
.def
.section
= bfd_abs_section_ptr
;
2577 struct bfd_link_hash_entry
*h
;
2580 if (link_info
.relocateable
|| link_info
.shared
)
2585 if (entry_symbol
== (char *) NULL
)
2587 /* No entry has been specified. Look for start, but don't warn
2588 if we don't find it. */
2589 entry_symbol
= "start";
2593 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
2594 if (h
!= (struct bfd_link_hash_entry
*) NULL
2595 && (h
->type
== bfd_link_hash_defined
2596 || h
->type
== bfd_link_hash_defweak
)
2597 && h
->u
.def
.section
->output_section
!= NULL
)
2601 val
= (h
->u
.def
.value
2602 + bfd_get_section_vma (output_bfd
,
2603 h
->u
.def
.section
->output_section
)
2604 + h
->u
.def
.section
->output_offset
);
2605 if (! bfd_set_start_address (output_bfd
, val
))
2606 einfo ("%P%F:%s: can't set start address\n", entry_symbol
);
2612 /* Can't find the entry symbol. Use the first address in the
2614 ts
= bfd_get_section_by_name (output_bfd
, ".text");
2615 if (ts
!= (asection
*) NULL
)
2618 einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
2619 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
2620 if (! bfd_set_start_address (output_bfd
,
2621 bfd_get_section_vma (output_bfd
, ts
)))
2622 einfo ("%P%F: can't set start address\n");
2627 einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2633 /* Check that the architecture of all the input files is compatible
2634 with the output file. Also call the backend to let it do any
2635 other checking that is needed. */
2640 lang_statement_union_type
*file
;
2642 CONST bfd_arch_info_type
*compatible
;
2644 for (file
= file_chain
.head
;
2645 file
!= (lang_statement_union_type
*) NULL
;
2646 file
= file
->input_statement
.next
)
2648 input_bfd
= file
->input_statement
.the_bfd
;
2649 compatible
= bfd_arch_get_compatible (input_bfd
,
2651 if (compatible
== NULL
)
2652 einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2653 bfd_printable_name (input_bfd
), input_bfd
,
2654 bfd_printable_name (output_bfd
));
2656 else if (! bfd_merge_private_bfd_data (input_bfd
, output_bfd
))
2658 einfo ("%E%X: failed to merge target specific data of file %B\n", input_bfd
);
2663 /* Look through all the global common symbols and attach them to the
2664 correct section. The -sort-common command line switch may be used
2665 to roughly sort the entries by size. */
2670 if (link_info
.relocateable
2671 && ! command_line
.force_common_definition
)
2674 if (! config
.sort_common
)
2675 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
2680 for (power
= 4; power
>= 0; power
--)
2681 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
2686 /* Place one common symbol in the correct section. */
2689 lang_one_common (h
, info
)
2690 struct bfd_link_hash_entry
*h
;
2693 unsigned int power_of_two
;
2697 if (h
->type
!= bfd_link_hash_common
)
2701 power_of_two
= h
->u
.c
.p
->alignment_power
;
2703 if (config
.sort_common
2704 && power_of_two
< (unsigned int) *(int *) info
)
2707 section
= h
->u
.c
.p
->section
;
2709 /* Increase the size of the section. */
2710 section
->_raw_size
= ALIGN_N (section
->_raw_size
,
2711 (bfd_size_type
) (1 << power_of_two
));
2713 /* Adjust the alignment if necessary. */
2714 if (power_of_two
> section
->alignment_power
)
2715 section
->alignment_power
= power_of_two
;
2717 /* Change the symbol from common to defined. */
2718 h
->type
= bfd_link_hash_defined
;
2719 h
->u
.def
.section
= section
;
2720 h
->u
.def
.value
= section
->_raw_size
;
2722 /* Increase the size of the section. */
2723 section
->_raw_size
+= size
;
2725 /* Make sure the section is allocated in memory, and make sure that
2726 it is no longer a common section. */
2727 section
->flags
|= SEC_ALLOC
;
2728 section
->flags
&= ~ SEC_IS_COMMON
;
2730 if (config
.map_file
!= NULL
)
2732 static boolean header_printed
;
2737 if (! header_printed
)
2739 minfo ("\nAllocating common symbols\n");
2740 minfo ("Common symbol size file\n\n");
2741 header_printed
= true;
2744 name
= demangle (h
->root
.string
);
2746 len
= strlen (name
);
2761 if (size
<= 0xffffffff)
2762 sprintf (buf
, "%lx", (unsigned long) size
);
2764 sprintf_vma (buf
, size
);
2774 minfo ("%B\n", section
->owner
);
2781 run through the input files and ensure that every input
2782 section has somewhere to go. If one is found without
2783 a destination then create an input request and place it
2784 into the statement tree.
2788 lang_place_orphans ()
2790 lang_input_statement_type
*file
;
2792 for (file
= (lang_input_statement_type
*) file_chain
.head
;
2793 file
!= (lang_input_statement_type
*) NULL
;
2794 file
= (lang_input_statement_type
*) file
->next
)
2798 for (s
= file
->the_bfd
->sections
;
2799 s
!= (asection
*) NULL
;
2802 if (s
->output_section
== (asection
*) NULL
)
2804 /* This section of the file is not attatched, root
2805 around for a sensible place for it to go */
2807 if (file
->just_syms_flag
)
2809 /* We are only retrieving symbol values from this
2810 file. We want the symbols to act as though the
2811 values in the file are absolute. */
2812 s
->output_section
= bfd_abs_section_ptr
;
2813 s
->output_offset
= s
->vma
;
2815 else if (strcmp (s
->name
, "COMMON") == 0)
2817 /* This is a lonely common section which must have
2818 come from an archive. We attach to the section
2819 with the wildcard. */
2820 if (! link_info
.relocateable
2821 || command_line
.force_common_definition
)
2823 if (default_common_section
== NULL
)
2826 /* This message happens when using the
2827 svr3.ifile linker script, so I have
2829 info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2831 default_common_section
=
2832 lang_output_section_statement_lookup (".bss");
2835 wild_doit (&default_common_section
->children
, s
,
2836 default_common_section
, file
);
2839 else if (ldemul_place_orphan (file
, s
))
2843 lang_output_section_statement_type
*os
=
2844 lang_output_section_statement_lookup (s
->name
);
2846 wild_doit (&os
->children
, s
, os
, file
);
2855 lang_set_flags (ptr
, flags
)
2859 boolean state
= false;
2874 /* ptr->flag_read = state; */
2877 /* ptr->flag_write = state; */
2880 /* ptr->flag_executable= state;*/
2884 /* ptr->flag_loadable= state;*/
2887 einfo ("%P%F: invalid syntax in flags\n");
2894 /* Call a function on each input file. This function will be called
2895 on an archive, but not on the elements. */
2898 lang_for_each_input_file (func
)
2899 void (*func
) PARAMS ((lang_input_statement_type
*));
2901 lang_input_statement_type
*f
;
2903 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
2905 f
= (lang_input_statement_type
*) f
->next_real_file
)
2909 /* Call a function on each file. The function will be called on all
2910 the elements of an archive which are included in the link, but will
2911 not be called on the archive file itself. */
2914 lang_for_each_file (func
)
2915 void (*func
) PARAMS ((lang_input_statement_type
*));
2917 lang_input_statement_type
*f
;
2919 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2920 f
!= (lang_input_statement_type
*) NULL
;
2921 f
= (lang_input_statement_type
*) f
->next
)
2932 lang_for_each_input_section (func
)
2933 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
2935 lang_input_statement_type
*f
;
2937 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2938 f
!= (lang_input_statement_type
*) NULL
;
2939 f
= (lang_input_statement_type
*) f
->next
)
2943 for (s
= f
->the_bfd
->sections
;
2944 s
!= (asection
*) NULL
;
2947 func (f
->the_bfd
, s
);
2955 ldlang_add_file (entry
)
2956 lang_input_statement_type
* entry
;
2960 lang_statement_append (&file_chain
,
2961 (lang_statement_union_type
*) entry
,
2964 /* The BFD linker needs to have a list of all input BFDs involved in
2966 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
2967 ASSERT (entry
->the_bfd
!= output_bfd
);
2968 for (pp
= &link_info
.input_bfds
;
2969 *pp
!= (bfd
*) NULL
;
2970 pp
= &(*pp
)->link_next
)
2972 *pp
= entry
->the_bfd
;
2973 entry
->the_bfd
->usrdata
= (PTR
) entry
;
2974 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
2976 /* Look through the sections and check for any which should not be
2977 included in the link. We need to do this now, so that we can
2978 notice when the backend linker tries to report multiple
2979 definition errors for symbols which are in sections we aren't
2980 going to link. FIXME: It might be better to entirely ignore
2981 symbols which are defined in sections which are going to be
2982 discarded. This would require modifying the backend linker for
2983 each backend which might set the SEC_LINK_ONCE flag. If we do
2984 this, we should probably handle SEC_EXCLUDE in the same way. */
2986 bfd_map_over_sections (entry
->the_bfd
, section_already_linked
, (PTR
) entry
);
2990 lang_add_output (name
, from_script
)
2994 /* Make -o on command line override OUTPUT in script. */
2995 if (had_output_filename
== false || !from_script
)
2997 output_filename
= name
;
2998 had_output_filename
= true;
3003 static lang_output_section_statement_type
*current_section
;
3015 for (l
= 0; l
< 32; l
++)
3017 if (i
>= (unsigned int) x
)
3026 lang_enter_output_section_statement (output_section_statement_name
,
3027 address_exp
, sectype
, block_value
,
3028 align
, subalign
, ebase
)
3029 const char *output_section_statement_name
;
3030 etree_type
* address_exp
;
3031 enum section_type sectype
;
3032 bfd_vma block_value
;
3034 etree_type
*subalign
;
3037 lang_output_section_statement_type
*os
;
3041 lang_output_section_statement_lookup (output_section_statement_name
);
3045 /* Add this statement to tree */
3046 /* add_statement(lang_output_section_statement_enum,
3047 output_section_statement);*/
3048 /* Make next things chain into subchain of this */
3050 if (os
->addr_tree
==
3051 (etree_type
*) NULL
)
3056 os
->sectype
= sectype
;
3057 if (sectype
!= noload_section
)
3058 os
->flags
= SEC_NO_FLAGS
;
3060 os
->flags
= SEC_NEVER_LOAD
;
3061 os
->block_value
= block_value
? block_value
: 1;
3062 stat_ptr
= &os
->children
;
3064 os
->subsection_alignment
= topower(
3065 exp_get_value_int(subalign
, -1,
3066 "subsection alignment",
3068 os
->section_alignment
= topower(
3069 exp_get_value_int(align
, -1,
3070 "section alignment", 0));
3072 os
->load_base
= ebase
;
3079 lang_output_statement_type
*new =
3080 new_stat (lang_output_statement
, stat_ptr
);
3082 new->name
= output_filename
;
3085 /* Reset the current counters in the regions */
3087 reset_memory_regions ()
3089 lang_memory_region_type
*p
= lang_memory_region_list
;
3091 for (p
= lang_memory_region_list
;
3092 p
!= (lang_memory_region_type
*) NULL
;
3095 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
3096 p
->current
= p
->origin
;
3103 lang_reasonable_defaults ();
3104 current_target
= default_target
;
3106 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
3108 ldemul_create_output_section_statements ();
3110 /* Add to the hash table all undefineds on the command line */
3111 lang_place_undefineds ();
3113 /* Create a bfd for each input file */
3114 current_target
= default_target
;
3115 open_input_bfds (statement_list
.head
, false);
3117 ldemul_after_open ();
3119 /* Make sure that we're not mixing architectures. We call this
3120 after all the input files have been opened, but before we do any
3121 other processing, so that any operations merge_private_bfd_data
3122 does on the output file will be known during the rest of the
3126 /* Build all sets based on the information gathered from the input
3128 ldctor_build_sets ();
3130 /* Size up the common data */
3133 /* Run through the contours of the script and attach input sections
3134 to the correct output sections
3136 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
3137 (lang_output_section_statement_type
*) NULL
);
3140 /* Find any sections not attached explicitly and handle them */
3141 lang_place_orphans ();
3143 ldemul_before_allocation ();
3145 /* We must record the program headers before we try to fix the
3146 section positions, since they will affect SIZEOF_HEADERS. */
3147 lang_record_phdrs ();
3149 /* Now run around and relax if we can */
3150 if (command_line
.relax
)
3152 /* First time round is a trial run to get the 'worst case'
3153 addresses of the objects if there was no relaxing. */
3154 lang_size_sections (statement_list
.head
,
3156 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
3158 /* Keep relaxing until bfd_relax_section gives up. */
3161 reset_memory_regions ();
3163 relax_again
= false;
3165 /* Do all the assignments with our current guesses as to
3167 lang_do_assignments (statement_list
.head
,
3169 (fill_type
) 0, (bfd_vma
) 0);
3171 /* Perform another relax pass - this time we know where the
3172 globals are, so can make better guess. */
3173 lang_size_sections (statement_list
.head
,
3175 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
3177 while (relax_again
);
3181 /* Size up the sections. */
3182 lang_size_sections (statement_list
.head
,
3184 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
3187 /* See if anything special should be done now we know how big
3189 ldemul_after_allocation ();
3191 /* Fix any .startof. or .sizeof. symbols. */
3192 lang_set_startof ();
3194 /* Do all the assignments, now that we know the final restingplaces
3195 of all the symbols */
3197 lang_do_assignments (statement_list
.head
,
3199 (fill_type
) 0, (bfd_vma
) 0);
3207 /* EXPORTED TO YACC */
3210 lang_add_wild (section_name
, filename
)
3211 CONST
char *CONST section_name
;
3212 CONST
char *CONST filename
;
3214 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
3217 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
3219 placed_commons
= true;
3221 if (filename
!= (char *) NULL
)
3223 lang_has_input_file
= true;
3225 new->section_name
= section_name
;
3226 new->filename
= filename
;
3227 lang_list_init (&new->children
);
3231 lang_section_start (name
, address
)
3233 etree_type
* address
;
3235 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
3237 ad
->section_name
= name
;
3238 ad
->address
= address
;
3241 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
3242 because of a -e argument on the command line, or zero if this is
3243 called by ENTRY in a linker script. Command line arguments take
3246 /* WINDOWS_NT. When an entry point has been specified, we will also force
3247 this symbol to be defined by calling ldlang_add_undef (equivalent to
3248 having switch -u entry_name on the command line). The reason we do
3249 this is so that the user doesn't have to because they would have to use
3250 the -u switch if they were specifying an entry point other than
3251 _mainCRTStartup. Specifically, if creating a windows application, entry
3252 point _WinMainCRTStartup must be specified.
3253 What I have found for non console applications (entry not _mainCRTStartup)
3254 is that the .obj that contains mainCRTStartup is brought in since it is
3255 the first encountered in libc.lib and it has other symbols in it which will
3256 be pulled in by the link process. To avoid this, adding -u with the entry
3257 point name specified forces the correct .obj to be used. We can avoid
3258 making the user do this by always adding the entry point name as an
3259 undefined symbol. */
3262 lang_add_entry (name
, cmdline
)
3266 if (entry_symbol
== NULL
3268 || ! entry_from_cmdline
)
3270 entry_symbol
= name
;
3271 entry_from_cmdline
= cmdline
;
3274 /* don't do this yet. It seems to work (the executables run), but the
3275 image created is very different from what I was getting before indicating
3276 that something else is being pulled in. When everything else is working,
3277 then try to put this back in to see if it will do the right thing for
3278 other more complicated applications */
3279 ldlang_add_undef (name
);
3284 lang_add_target (name
)
3287 lang_target_statement_type
*new = new_stat (lang_target_statement
,
3303 map_option_f
= true;
3314 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
3321 lang_add_data (type
, exp
)
3323 union etree_union
*exp
;
3326 lang_data_statement_type
*new = new_stat (lang_data_statement
,
3334 /* Create a new reloc statement. RELOC is the BFD relocation type to
3335 generate. HOWTO is the corresponding howto structure (we could
3336 look this up, but the caller has already done so). SECTION is the
3337 section to generate a reloc against, or NAME is the name of the
3338 symbol to generate a reloc against. Exactly one of SECTION and
3339 NAME must be NULL. ADDEND is an expression for the addend. */
3342 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
3343 bfd_reloc_code_real_type reloc
;
3344 reloc_howto_type
*howto
;
3347 union etree_union
*addend
;
3349 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
3353 p
->section
= section
;
3355 p
->addend_exp
= addend
;
3357 p
->addend_value
= 0;
3358 p
->output_section
= NULL
;
3363 lang_add_assignment (exp
)
3366 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
3373 lang_add_attribute (attribute
)
3374 enum statement_enum attribute
;
3376 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
3383 if (startup_file
!= (char *) NULL
)
3385 einfo ("%P%Fmultiple STARTUP files\n");
3387 first_file
->filename
= name
;
3388 first_file
->local_sym_name
= name
;
3389 first_file
->real
= true;
3391 startup_file
= name
;
3398 lang_float_flag
= maybe
;
3402 lang_leave_output_section_statement (fill
, memspec
, phdrs
)
3404 const char *memspec
;
3405 struct lang_output_section_phdr_list
*phdrs
;
3407 current_section
->fill
= fill
;
3408 current_section
->region
= lang_memory_region_lookup (memspec
);
3409 current_section
->phdrs
= phdrs
;
3410 stat_ptr
= &statement_list
;
3414 Create an absolute symbol with the given name with the value of the
3415 address of first byte of the section named.
3417 If the symbol already exists, then do nothing.
3420 lang_abs_symbol_at_beginning_of (secname
, name
)
3421 const char *secname
;
3424 struct bfd_link_hash_entry
*h
;
3426 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
3427 if (h
== (struct bfd_link_hash_entry
*) NULL
)
3428 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
3430 if (h
->type
== bfd_link_hash_new
3431 || h
->type
== bfd_link_hash_undefined
)
3435 h
->type
= bfd_link_hash_defined
;
3437 sec
= bfd_get_section_by_name (output_bfd
, secname
);
3438 if (sec
== (asection
*) NULL
)
3441 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
3443 h
->u
.def
.section
= bfd_abs_section_ptr
;
3448 Create an absolute symbol with the given name with the value of the
3449 address of the first byte after the end of the section named.
3451 If the symbol already exists, then do nothing.
3454 lang_abs_symbol_at_end_of (secname
, name
)
3455 const char *secname
;
3458 struct bfd_link_hash_entry
*h
;
3460 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
3461 if (h
== (struct bfd_link_hash_entry
*) NULL
)
3462 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
3464 if (h
->type
== bfd_link_hash_new
3465 || h
->type
== bfd_link_hash_undefined
)
3469 h
->type
= bfd_link_hash_defined
;
3471 sec
= bfd_get_section_by_name (output_bfd
, secname
);
3472 if (sec
== (asection
*) NULL
)
3475 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
3476 + bfd_section_size (output_bfd
, sec
));
3478 h
->u
.def
.section
= bfd_abs_section_ptr
;
3483 lang_statement_append (list
, element
, field
)
3484 lang_statement_list_type
* list
;
3485 lang_statement_union_type
* element
;
3486 lang_statement_union_type
** field
;
3488 *(list
->tail
) = element
;
3492 /* Set the output format type. -oformat overrides scripts. */
3495 lang_add_output_format (format
, big
, little
, from_script
)
3501 if (output_target
== NULL
|| !from_script
)
3503 if (command_line
.endian
== ENDIAN_BIG
3506 else if (command_line
.endian
== ENDIAN_LITTLE
3510 output_target
= format
;
3514 /* Enter a group. This creates a new lang_group_statement, and sets
3515 stat_ptr to build new statements within the group. */
3520 lang_group_statement_type
*g
;
3522 g
= new_stat (lang_group_statement
, stat_ptr
);
3523 lang_list_init (&g
->children
);
3524 stat_ptr
= &g
->children
;
3527 /* Leave a group. This just resets stat_ptr to start writing to the
3528 regular list of statements again. Note that this will not work if
3529 groups can occur inside anything else which can adjust stat_ptr,
3530 but currently they can't. */
3535 stat_ptr
= &statement_list
;
3538 /* Add a new program header. This is called for each entry in a PHDRS
3539 command in a linker script. */
3542 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
3550 struct lang_phdr
*n
, **pp
;
3552 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
3555 n
->type
= exp_get_value_int (type
, 0, "program header type",
3556 lang_final_phase_enum
);
3557 n
->filehdr
= filehdr
;
3562 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
3567 /* Record the program header information in the output BFD. FIXME: We
3568 should not be calling an ELF specific function here. */
3571 lang_record_phdrs ()
3575 struct lang_output_section_phdr_list
*last
;
3576 struct lang_phdr
*l
;
3577 lang_statement_union_type
*u
;
3580 secs
= (asection
**) xmalloc (alc
* sizeof (asection
*));
3582 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
3589 for (u
= lang_output_section_statement
.head
;
3591 u
= u
->output_section_statement
.next
)
3593 lang_output_section_statement_type
*os
;
3594 struct lang_output_section_phdr_list
*pl
;
3596 os
= &u
->output_section_statement
;
3603 if (os
->sectype
== noload_section
3604 || os
->bfd_section
== NULL
3605 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
3610 if (os
->bfd_section
== NULL
)
3613 for (; pl
!= NULL
; pl
= pl
->next
)
3615 if (strcmp (pl
->name
, l
->name
) == 0)
3620 secs
= ((asection
**)
3621 xrealloc (secs
, alc
* sizeof (asection
*)));
3623 secs
[c
] = os
->bfd_section
;
3630 if (l
->flags
== NULL
)
3633 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
3634 lang_final_phase_enum
);
3639 at
= exp_get_vma (l
->at
, 0, "phdr load address",
3640 lang_final_phase_enum
);
3642 if (! bfd_record_phdr (output_bfd
, l
->type
,
3643 l
->flags
== NULL
? false : true,
3645 l
->at
== NULL
? false : true,
3646 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
3647 einfo ("%F%P: bfd_record_phdr failed: %E\n");
3652 /* Make sure all the phdr assignments succeeded. */
3653 for (u
= lang_output_section_statement
.head
;
3655 u
= u
->output_section_statement
.next
)
3657 struct lang_output_section_phdr_list
*pl
;
3659 if (u
->output_section_statement
.bfd_section
== NULL
)
3662 for (pl
= u
->output_section_statement
.phdrs
;
3665 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
3666 einfo ("%X%P: section `%s' assigned to non-existent phdr `%s'\n",
3667 u
->output_section_statement
.name
, pl
->name
);
3671 /* Record a list of sections which may not be cross referenced. */
3674 lang_add_nocrossref (l
)
3675 struct lang_nocrossref
*l
;
3677 struct lang_nocrossrefs
*n
;
3679 n
= (struct lang_nocrossrefs
*) xmalloc (sizeof *n
);
3680 n
->next
= nocrossref_list
;
3682 nocrossref_list
= n
;
3684 /* Set notice_all so that we get informed about all symbols. */
3685 link_info
.notice_all
= true;
3688 /* Overlay handling. We handle overlays with some static variables. */
3690 /* The overlay virtual address. */
3691 static etree_type
*overlay_vma
;
3693 /* The overlay load address. */
3694 static etree_type
*overlay_lma
;
3696 /* Whether nocrossrefs is set for this overlay. */
3697 static int overlay_nocrossrefs
;
3699 /* An expression for the maximum section size seen so far. */
3700 static etree_type
*overlay_max
;
3702 /* A list of all the sections in this overlay. */
3706 struct overlay_list
*next
;
3707 lang_output_section_statement_type
*os
;
3710 static struct overlay_list
*overlay_list
;
3712 /* Start handling an overlay. */
3715 lang_enter_overlay (vma_expr
, lma_expr
, nocrossrefs
)
3716 etree_type
*vma_expr
;
3717 etree_type
*lma_expr
;
3720 /* The grammar should prevent nested overlays from occurring. */
3721 ASSERT (overlay_vma
== NULL
3722 && overlay_lma
== NULL
3723 && overlay_list
== NULL
3724 && overlay_max
== NULL
);
3726 overlay_vma
= vma_expr
;
3727 overlay_lma
= lma_expr
;
3728 overlay_nocrossrefs
= nocrossrefs
;
3731 /* Start a section in an overlay. We handle this by calling
3732 lang_enter_output_section_statement with the correct VMA and LMA. */
3735 lang_enter_overlay_section (name
)
3738 struct overlay_list
*n
;
3741 lang_enter_output_section_statement (name
, overlay_vma
, normal_section
,
3742 0, 0, 0, overlay_lma
);
3744 /* If this is the first section, then base the VMA and LMA of future
3745 sections on this one. This will work correctly even if `.' is
3746 used in the addresses. */
3747 if (overlay_list
== NULL
)
3749 overlay_vma
= exp_nameop (ADDR
, name
);
3750 overlay_lma
= exp_nameop (LOADADDR
, name
);
3753 /* Remember the section. */
3754 n
= (struct overlay_list
*) xmalloc (sizeof *n
);
3755 n
->os
= current_section
;
3756 n
->next
= overlay_list
;
3759 size
= exp_nameop (SIZEOF
, name
);
3761 /* Adjust the LMA for the next section. */
3762 overlay_lma
= exp_binop ('+', overlay_lma
, size
);
3764 /* Arrange to work out the maximum section end address. */
3765 if (overlay_max
== NULL
)
3768 overlay_max
= exp_binop (MAX
, overlay_max
, size
);
3771 /* Finish a section in an overlay. There isn't any special to do
3775 lang_leave_overlay_section (fill
, phdrs
)
3777 struct lang_output_section_phdr_list
*phdrs
;
3784 name
= current_section
->name
;
3786 lang_leave_output_section_statement (fill
, "*default*", phdrs
);
3788 /* Define the magic symbols. */
3790 clean
= xmalloc (strlen (name
) + 1);
3792 for (s1
= name
; *s1
!= '\0'; s1
++)
3793 if (isalnum (*s1
) || *s1
== '_')
3797 buf
= xmalloc (strlen (clean
) + sizeof "__load_start_");
3798 sprintf (buf
, "__load_start_%s", clean
);
3799 lang_add_assignment (exp_assop ('=', buf
,
3800 exp_nameop (LOADADDR
, name
)));
3802 buf
= xmalloc (strlen (clean
) + sizeof "__load_stop_");
3803 sprintf (buf
, "__load_stop_%s", clean
);
3804 lang_add_assignment (exp_assop ('=', buf
,
3806 exp_nameop (LOADADDR
, name
),
3807 exp_nameop (SIZEOF
, name
))));
3812 /* Finish an overlay. If there are any overlay wide settings, this
3813 looks through all the sections in the overlay and sets them. */
3816 lang_leave_overlay (fill
, memspec
, phdrs
)
3818 const char *memspec
;
3819 struct lang_output_section_phdr_list
*phdrs
;
3821 lang_memory_region_type
*region
;
3822 struct overlay_list
*l
;
3823 struct lang_nocrossref
*nocrossref
;
3825 if (memspec
== NULL
)
3828 region
= lang_memory_region_lookup (memspec
);
3835 struct overlay_list
*next
;
3837 if (fill
!= 0 && l
->os
->fill
== 0)
3839 if (region
!= NULL
&& l
->os
->region
== NULL
)
3840 l
->os
->region
= region
;
3841 if (phdrs
!= NULL
&& l
->os
->phdrs
== NULL
)
3842 l
->os
->phdrs
= phdrs
;
3844 if (overlay_nocrossrefs
)
3846 struct lang_nocrossref
*nc
;
3848 nc
= (struct lang_nocrossref
*) xmalloc (sizeof *nc
);
3849 nc
->name
= l
->os
->name
;
3850 nc
->next
= nocrossref
;
3859 if (nocrossref
!= NULL
)
3860 lang_add_nocrossref (nocrossref
);
3862 /* Update . for the end of the overlay. */
3863 lang_add_assignment (exp_assop ('=', ".",
3864 exp_binop ('+', overlay_vma
, overlay_max
)));
3868 overlay_nocrossrefs
= 0;
3869 overlay_list
= NULL
;
3873 /* Version handling. This is only useful for ELF. */
3875 /* This global variable holds the version tree that we build. */
3877 struct bfd_elf_version_tree
*lang_elf_version_info
;
3879 /* This is called for each variable name or match expression. */
3881 struct bfd_elf_version_expr
*
3882 lang_new_vers_regex (orig
, new)
3883 struct bfd_elf_version_expr
*orig
;
3886 struct bfd_elf_version_expr
*ret
;
3888 ret
= (struct bfd_elf_version_expr
*) xmalloc (sizeof *ret
);
3894 /* This is called for each set of variable names and match
3897 struct bfd_elf_version_tree
*
3898 lang_new_vers_node (globals
, locals
)
3899 struct bfd_elf_version_expr
*globals
;
3900 struct bfd_elf_version_expr
*locals
;
3902 struct bfd_elf_version_tree
*ret
;
3904 ret
= (struct bfd_elf_version_tree
*) xmalloc (sizeof *ret
);
3908 ret
->globals
= globals
;
3909 ret
->locals
= locals
;
3911 ret
->name_indx
= (unsigned int) -1;
3916 /* This static variable keeps track of version indices. */
3918 static int version_index
;
3920 /* This is called when we know the name and dependencies of the
3924 lang_register_vers_node (name
, version
, deps
)
3926 struct bfd_elf_version_tree
*version
;
3927 struct bfd_elf_version_deps
*deps
;
3929 struct bfd_elf_version_tree
*t
, **pp
;
3930 struct bfd_elf_version_expr
*e1
;
3932 /* Make sure this node has a unique name. */
3933 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
3934 if (strcmp (t
->name
, name
) == 0)
3935 einfo ("%X%P: duplicate version tag `%s'\n", name
);
3937 /* Check the global and local match names, and make sure there
3938 aren't any duplicates. */
3940 for (e1
= version
->globals
; e1
!= NULL
; e1
= e1
->next
)
3942 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
3944 struct bfd_elf_version_expr
*e2
;
3946 for (e2
= t
->locals
; e2
!= NULL
; e2
= e2
->next
)
3947 if (strcmp (e1
->match
, e2
->match
) == 0)
3948 einfo ("%X%P: duplicate expression `%s' in version information\n",
3953 for (e1
= version
->locals
; e1
!= NULL
; e1
= e1
->next
)
3955 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
3957 struct bfd_elf_version_expr
*e2
;
3959 for (e2
= t
->globals
; e2
!= NULL
; e2
= e2
->next
)
3960 if (strcmp (e1
->match
, e2
->match
) == 0)
3961 einfo ("%X%P: duplicate expression `%s' in version information\n",
3966 version
->deps
= deps
;
3967 version
->name
= name
;
3969 version
->vernum
= version_index
;
3971 for (pp
= &lang_elf_version_info
; *pp
!= NULL
; pp
= &(*pp
)->next
)
3976 /* This is called when we see a version dependency. */
3978 struct bfd_elf_version_deps
*
3979 lang_add_vers_depend (list
, name
)
3980 struct bfd_elf_version_deps
*list
;
3983 struct bfd_elf_version_deps
*ret
;
3984 struct bfd_elf_version_tree
*t
;
3986 ret
= (struct bfd_elf_version_deps
*) xmalloc (sizeof *ret
);
3989 for (t
= lang_elf_version_info
; t
!= NULL
; t
= t
->next
)
3991 if (strcmp (t
->name
, name
) == 0)
3993 ret
->version_needed
= t
;
3998 einfo ("%X%P: unable to find version dependency `%s'\n", name
);