1 /* Linker command language support.
2 Copyright (C) 1991, 92, 93, 94 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
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
22 #include "libiberty.h"
37 static void print_statements
PARAMS ((void));
38 static void print_statement
PARAMS ((lang_statement_union_type
*,
39 lang_output_section_statement_type
*));
40 static lang_statement_union_type
*new_statement
PARAMS ((enum statement_enum
,
42 lang_statement_list_type
*));
46 static struct obstack stat_obstack
;
48 #define obstack_chunk_alloc xmalloc
49 #define obstack_chunk_free free
50 static CONST
char *startup_file
;
51 static lang_statement_list_type input_file_chain
;
52 static boolean placed_commons
= false;
53 static lang_output_section_statement_type
*default_common_section
;
54 static boolean map_option_f
;
55 static bfd_vma print_dot
;
56 static lang_input_statement_type
*first_file
;
57 static lang_statement_list_type lang_output_section_statement
;
58 static CONST
char *current_target
;
59 static CONST
char *output_target
;
60 static int longest_section_name
= 8;
61 static lang_statement_list_type statement_list
;
63 static void print_size
PARAMS ((size_t value
));
64 static void print_alignment
PARAMS ((unsigned int value
));
65 static void print_fill
PARAMS ((fill_type value
));
66 static void print_section
PARAMS ((const char *name
));
67 static void lang_for_each_statement_worker
68 PARAMS ((void (*func
) (lang_statement_union_type
*),
69 lang_statement_union_type
*s
));
70 static lang_input_statement_type
*new_afile
71 PARAMS ((const char *name
, lang_input_file_enum_type file_type
,
72 const char *target
, boolean add_to_list
));
73 static void print_flags
PARAMS ((int *ignore_flags
));
74 static void init_os
PARAMS ((lang_output_section_statement_type
*s
));
75 static void wild_doit
PARAMS ((lang_statement_list_type
*ptr
,
77 lang_output_section_statement_type
*output
,
78 lang_input_statement_type
*file
));
79 static void wild_section
PARAMS ((lang_wild_statement_type
*ptr
,
81 lang_input_statement_type
*file
,
82 lang_output_section_statement_type
*output
));
83 static lang_input_statement_type
*lookup_name
PARAMS ((const char *name
));
84 static void load_symbols
PARAMS ((lang_input_statement_type
*entry
));
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
PARAMS ((lang_statement_union_type
*statement
));
92 static void lang_reasonable_defaults
PARAMS ((void));
93 static void lang_place_undefineds
PARAMS ((void));
94 static void map_input_to_output_sections
95 PARAMS ((lang_statement_union_type
*s
,
97 lang_output_section_statement_type
*output_section_statement
));
98 static void print_output_section_statement
99 PARAMS ((lang_output_section_statement_type
*output_section_statement
));
100 static void print_assignment
101 PARAMS ((lang_assignment_statement_type
*assignment
,
102 lang_output_section_statement_type
*output_section
));
103 static void print_input_statement
PARAMS ((lang_input_statement_type
*statm
));
104 static void print_input_section
PARAMS ((lang_input_section_type
*in
));
105 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*fill
));
106 static void print_data_statement
PARAMS ((lang_data_statement_type
*data
));
107 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*reloc
));
108 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*s
));
109 static void print_wild_statement
110 PARAMS ((lang_wild_statement_type
*w
,
111 lang_output_section_statement_type
*os
));
112 static void print_statement
PARAMS ((lang_statement_union_type
*s
,
113 lang_output_section_statement_type
*os
));
114 static void print_statements
PARAMS ((void));
115 static bfd_vma insert_pad
PARAMS ((lang_statement_union_type
**this_ptr
,
116 fill_type fill
, unsigned int power
,
117 asection
*output_section_statement
,
119 static bfd_vma size_input_section
120 PARAMS ((lang_statement_union_type
**this_ptr
,
121 lang_output_section_statement_type
*output_section_statement
,
122 fill_type fill
, bfd_vma dot
, boolean relax
));
123 static bfd_vma lang_do_assignments
124 PARAMS ((lang_statement_union_type
* s
,
125 lang_output_section_statement_type
*output_section_statement
,
128 static void lang_finish
PARAMS ((void));
129 static void lang_check
PARAMS ((void));
130 static void lang_common
PARAMS ((void));
131 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
132 static void lang_place_orphans
PARAMS ((void));
133 static int topower
PARAMS ((int));
134 static void reset_memory_regions
PARAMS ((void));
137 lang_output_section_statement_type
*abs_output_section
;
138 lang_statement_list_type
*stat_ptr
= &statement_list
;
139 lang_statement_list_type file_chain
= { 0 };
140 static const char *entry_symbol
= 0;
141 boolean lang_has_input_file
= false;
142 boolean had_output_filename
= false;
143 boolean lang_float_flag
= false;
144 boolean delete_output_file_on_failure
= false;
146 etree_type
*base
; /* Relocation base - or null */
149 #if defined(__STDC__) || defined(ALMOST_STDC)
150 #define cat(a,b) a##b
152 #define cat(a,b) a/**/b
155 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
157 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
159 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
165 return obstack_alloc (&stat_obstack
, size
);
172 fprintf (config
.map_file
, "%5x", (unsigned) value
);
176 print_alignment (value
)
179 fprintf (config
.map_file
, "2**%1u", value
);
186 fprintf (config
.map_file
, "%04x", (unsigned) value
);
193 fprintf (config
.map_file
, "%*s", -longest_section_name
, name
);
196 /*----------------------------------------------------------------------
197 lang_for_each_statement walks the parse tree and calls the provided
198 function for each node
202 lang_for_each_statement_worker (func
, s
)
203 void (*func
) PARAMS ((lang_statement_union_type
*));
204 lang_statement_union_type
*s
;
206 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
210 switch (s
->header
.type
)
212 case lang_constructors_statement_enum
:
213 lang_for_each_statement_worker (func
, constructor_list
.head
);
215 case lang_output_section_statement_enum
:
216 lang_for_each_statement_worker
218 s
->output_section_statement
.children
.head
);
220 case lang_wild_statement_enum
:
221 lang_for_each_statement_worker
223 s
->wild_statement
.children
.head
);
225 case lang_data_statement_enum
:
226 case lang_reloc_statement_enum
:
227 case lang_object_symbols_statement_enum
:
228 case lang_output_statement_enum
:
229 case lang_target_statement_enum
:
230 case lang_input_section_enum
:
231 case lang_input_statement_enum
:
232 case lang_assignment_statement_enum
:
233 case lang_padding_statement_enum
:
234 case lang_address_statement_enum
:
244 lang_for_each_statement (func
)
245 void (*func
) PARAMS ((lang_statement_union_type
*));
247 lang_for_each_statement_worker (func
,
248 statement_list
.head
);
251 /*----------------------------------------------------------------------*/
253 lang_list_init (list
)
254 lang_statement_list_type
*list
;
256 list
->head
= (lang_statement_union_type
*) NULL
;
257 list
->tail
= &list
->head
;
260 /*----------------------------------------------------------------------
262 build a new statement node for the parse tree
267 lang_statement_union_type
*
268 new_statement (type
, size
, list
)
269 enum statement_enum type
;
271 lang_statement_list_type
* list
;
273 lang_statement_union_type
*new = (lang_statement_union_type
*)
276 new->header
.type
= type
;
277 new->header
.next
= (lang_statement_union_type
*) NULL
;
278 lang_statement_append (list
, new, &new->header
.next
);
283 Build a new input file node for the language. There are several ways
284 in which we treat an input file, eg, we only look at symbols, or
285 prefix it with a -l etc.
287 We can be supplied with requests for input files more than once;
288 they may, for example be split over serveral lines like foo.o(.text)
289 foo.o(.data) etc, so when asked for a file we check that we havn't
290 got it already so we don't duplicate the bfd.
293 static lang_input_statement_type
*
294 new_afile (name
, file_type
, target
, add_to_list
)
296 lang_input_file_enum_type file_type
;
300 lang_input_statement_type
*p
;
303 p
= new_stat (lang_input_statement
, stat_ptr
);
306 p
= ((lang_input_statement_type
*)
307 stat_alloc (sizeof (lang_input_statement_type
)));
308 p
->header
.next
= NULL
;
311 lang_has_input_file
= true;
313 p
->complained
= false;
316 case lang_input_file_is_symbols_only_enum
:
318 p
->is_archive
= false;
320 p
->local_sym_name
= name
;
321 p
->just_syms_flag
= true;
322 p
->search_dirs_flag
= false;
324 case lang_input_file_is_fake_enum
:
326 p
->is_archive
= false;
328 p
->local_sym_name
= name
;
329 p
->just_syms_flag
= false;
330 p
->search_dirs_flag
= false;
332 case lang_input_file_is_l_enum
:
333 p
->is_archive
= true;
336 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
337 p
->just_syms_flag
= false;
338 p
->search_dirs_flag
= true;
340 case lang_input_file_is_marker_enum
:
342 p
->is_archive
= false;
344 p
->local_sym_name
= name
;
345 p
->just_syms_flag
= false;
346 p
->search_dirs_flag
= true;
348 case lang_input_file_is_search_file_enum
:
350 p
->is_archive
= false;
352 p
->local_sym_name
= name
;
353 p
->just_syms_flag
= false;
354 p
->search_dirs_flag
= true;
356 case lang_input_file_is_file_enum
:
358 p
->is_archive
= false;
360 p
->local_sym_name
= name
;
361 p
->just_syms_flag
= false;
362 p
->search_dirs_flag
= false;
367 p
->the_bfd
= (bfd
*) NULL
;
368 p
->asymbols
= (asymbol
**) NULL
;
369 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
370 p
->next
= (lang_statement_union_type
*) NULL
;
372 p
->common_output_section
= (asection
*) NULL
;
374 lang_statement_append (&input_file_chain
,
375 (lang_statement_union_type
*) p
,
380 lang_input_statement_type
*
381 lang_add_input_file (name
, file_type
, target
)
383 lang_input_file_enum_type file_type
;
386 lang_has_input_file
= true;
387 return new_afile (name
, file_type
, target
, true);
390 /* Build enough state so that the parser can build its tree */
394 obstack_begin (&stat_obstack
, 1000);
396 stat_ptr
= &statement_list
;
398 lang_list_init (stat_ptr
);
400 lang_list_init (&input_file_chain
);
401 lang_list_init (&lang_output_section_statement
);
402 lang_list_init (&file_chain
);
403 first_file
= lang_add_input_file ((char *) NULL
,
404 lang_input_file_is_marker_enum
,
406 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
408 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
412 /*----------------------------------------------------------------------
413 A region is an area of memory declared with the
414 MEMORY { name:org=exp, len=exp ... }
417 We maintain a list of all the regions here
419 If no regions are specified in the script, then the default is used
420 which is created when looked up to be the entire data space
423 static lang_memory_region_type
*lang_memory_region_list
;
424 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
426 lang_memory_region_type
*
427 lang_memory_region_lookup (name
)
428 CONST
char *CONST name
;
431 lang_memory_region_type
*p
= lang_memory_region_list
;
433 for (p
= lang_memory_region_list
;
434 p
!= (lang_memory_region_type
*) NULL
;
437 if (strcmp (p
->name
, name
) == 0)
442 if (strcmp (name
, "*default*") == 0)
444 /* This is the default region, dig out first one on the list */
445 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
447 return lang_memory_region_list
;
451 lang_memory_region_type
*new =
452 (lang_memory_region_type
*) stat_alloc ((bfd_size_type
) (sizeof (lang_memory_region_type
)));
454 new->name
= buystring (name
);
455 new->next
= (lang_memory_region_type
*) NULL
;
457 *lang_memory_region_list_tail
= new;
458 lang_memory_region_list_tail
= &new->next
;
460 new->length
= ~(bfd_size_type
)0;
462 new->had_full_message
= false;
469 lang_output_section_statement_type
*
470 lang_output_section_find (name
)
471 CONST
char *CONST name
;
473 lang_statement_union_type
*u
;
474 lang_output_section_statement_type
*lookup
;
476 for (u
= lang_output_section_statement
.head
;
477 u
!= (lang_statement_union_type
*) NULL
;
480 lookup
= &u
->output_section_statement
;
481 if (strcmp (name
, lookup
->name
) == 0)
486 return (lang_output_section_statement_type
*) NULL
;
489 lang_output_section_statement_type
*
490 lang_output_section_statement_lookup (name
)
491 CONST
char *CONST name
;
493 lang_output_section_statement_type
*lookup
;
495 lookup
= lang_output_section_find (name
);
496 if (lookup
== (lang_output_section_statement_type
*) NULL
)
499 lookup
= (lang_output_section_statement_type
*)
500 new_stat (lang_output_section_statement
, stat_ptr
);
501 lookup
->region
= (lang_memory_region_type
*) NULL
;
503 lookup
->block_value
= 1;
506 lookup
->next
= (lang_statement_union_type
*) NULL
;
507 lookup
->bfd_section
= (asection
*) NULL
;
508 lookup
->processed
= false;
509 lookup
->loadable
= 1;
510 lookup
->addr_tree
= (etree_type
*) NULL
;
511 lang_list_init (&lookup
->children
);
513 lookup
->memspec
= (CONST
char *) NULL
;
515 lookup
->subsection_alignment
= -1;
516 lookup
->section_alignment
= -1;
517 lookup
->load_base
= (union etree_union
*) NULL
;
519 lang_statement_append (&lang_output_section_statement
,
520 (lang_statement_union_type
*) lookup
,
528 print_flags (ignore_flags
)
531 fprintf (config
.map_file
, "(");
533 if (flags
->flag_read
)
534 fprintf (outfile
, "R");
535 if (flags
->flag_write
)
536 fprintf (outfile
, "W");
537 if (flags
->flag_executable
)
538 fprintf (outfile
, "X");
539 if (flags
->flag_loadable
)
540 fprintf (outfile
, "L");
542 fprintf (config
.map_file
, ")");
548 lang_memory_region_type
*m
;
550 fprintf (config
.map_file
, "**MEMORY CONFIGURATION**\n\n");
552 fprintf (config
.map_file
, "name\t\torigin\t\tlength\t\tattributes\n");
554 fprintf (config
.map_file
,
555 "name\t\torigin length r_size c_size is attributes\n");
558 for (m
= lang_memory_region_list
;
559 m
!= (lang_memory_region_type
*) NULL
;
562 fprintf (config
.map_file
, "%-16s", m
->name
);
563 print_address (m
->origin
);
565 print_address ((bfd_vma
)m
->length
);
567 print_address ((bfd_vma
)m
->old_length
);
569 print_address (m
->current
- m
->origin
);
572 fprintf (config
.map_file
, " %2d%% ",
573 (int) ((m
->current
- m
->origin
) * 100 / m
->old_length
));
574 print_flags (&m
->flags
);
575 fprintf (config
.map_file
, "\n");
577 fprintf (config
.map_file
, "\n\n**LINK EDITOR MEMORY MAP**\n\n");
578 fprintf (config
.map_file
, "output input virtual\n");
579 fprintf (config
.map_file
, "section section address tsize\n\n");
590 lang_output_section_statement_type
* s
;
592 /* asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
593 section_userdata_type
*new =
594 (section_userdata_type
*)
595 stat_alloc ((bfd_size_type
) (sizeof (section_userdata_type
)));
597 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
598 if (s
->bfd_section
== (asection
*) NULL
)
599 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
600 if (s
->bfd_section
== (asection
*) NULL
)
602 einfo ("%P%F: output format %s cannot represent section called %s\n",
603 output_bfd
->xvec
->name
, s
->name
);
605 s
->bfd_section
->output_section
= s
->bfd_section
;
606 /* s->bfd_section->flags = s->flags;*/
608 /* We initialize an output sections output offset to minus its own */
609 /* vma to allow us to output a section through itself */
610 s
->bfd_section
->output_offset
= 0;
611 get_userdata (s
->bfd_section
) = (PTR
) new;
615 /***********************************************************************
618 These expand statements like *(.text) and foo.o to a list of
619 explicit actions, like foo.o(.text), bar.o(.text) and
622 The toplevel routine, wild, takes a statement, section, file and
623 target. If either the section or file is null it is taken to be the
624 wildcard. Seperate lang_input_section statements are created for
625 each part of the expanstion, and placed after the statement provided.
630 wild_doit (ptr
, section
, output
, file
)
631 lang_statement_list_type
* ptr
;
633 lang_output_section_statement_type
* output
;
634 lang_input_statement_type
* file
;
636 if (output
->bfd_section
== (asection
*) NULL
)
639 if (section
!= (asection
*) NULL
640 && section
->output_section
== (asection
*) NULL
)
642 /* Add a section reference to the list */
643 lang_input_section_type
*new = new_stat (lang_input_section
, ptr
);
645 new->section
= section
;
647 section
->output_section
= output
->bfd_section
;
649 /* We don't copy the SEC_NEVER_LOAD flag from an input section to
650 an output section, because we want to be able to include a
651 SEC_NEVER_LOAD section in the middle of an otherwise loaded
652 section (I don't know why we want to do this, but we do).
653 build_link_order in ldwrite.c handles this case by turning the
654 embedded SEC_NEVER_LOAD section into a fill. */
655 section
->output_section
->flags
|=
656 section
->flags
& (flagword
) (~ SEC_NEVER_LOAD
);
658 if (!output
->loadable
)
660 /* Turn off load flag */
661 output
->bfd_section
->flags
&= ~SEC_LOAD
;
662 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
664 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
666 output
->bfd_section
->alignment_power
= section
->alignment_power
;
668 /* If supplied an aligmnet, then force it */
669 if (output
->section_alignment
!= -1)
671 output
->bfd_section
->alignment_power
= output
->section_alignment
;
677 wild_section (ptr
, section
, file
, output
)
678 lang_wild_statement_type
* ptr
;
680 lang_input_statement_type
* file
;
681 lang_output_section_statement_type
* output
;
685 if (file
->just_syms_flag
== false)
687 if (section
== (char *) NULL
)
689 /* Do the creation to all sections in the file */
690 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
693 if ((s
->flags
& SEC_IS_COMMON
) == 0)
695 wild_doit (&ptr
->children
, s
, output
, file
);
701 /* Do the creation to the named section only */
702 s
= bfd_get_section_by_name (file
->the_bfd
, section
);
704 wild_doit (&ptr
->children
, s
, output
, file
);
709 /* passed a file name (which must have been seen already and added to
710 the statement tree. We will see if it has been opened already and
711 had its symbols read. If not then we'll read it.
713 Archives are pecuilar here. We may open them once, but if they do
714 not define anything we need at the time, they won't have all their
715 symbols read. If we need them later, we'll have to redo it.
717 static lang_input_statement_type
*
721 lang_input_statement_type
*search
;
723 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
724 search
!= (lang_input_statement_type
*) NULL
;
725 search
= (lang_input_statement_type
*) search
->next_real_file
)
727 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
729 if (search
->filename
!= (char *) NULL
730 && name
!= (char *) NULL
731 && strcmp (search
->filename
, name
) == 0)
735 if (search
== (lang_input_statement_type
*) NULL
)
736 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
739 /* If we have already added this file, or this file is not real
740 (FIXME: can that ever actually happen?) or the name is NULL
741 (FIXME: can that ever actually happen?) don't add this file. */
744 || search
->filename
== (const char *) NULL
)
747 load_symbols (search
);
752 /* Get the symbols for an input file. */
756 lang_input_statement_type
*entry
;
761 ldfile_open_file (entry
);
763 if (bfd_check_format (entry
->the_bfd
, bfd_object
))
765 ldlang_add_file (entry
);
766 if (trace_files
|| trace_file_tries
)
767 info_msg ("%I\n", entry
);
769 else if (bfd_check_format (entry
->the_bfd
, bfd_archive
))
771 /* There is nothing to do here; the add_symbols routine will
772 call ldlang_add_file (via the add_archive_element callback)
773 for each element of the archive which is used. */
776 einfo ("%F%B: file not recognized: %E\n", entry
->the_bfd
);
778 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
) == false)
779 einfo ("%F%B: could not read symbols: %E\n", entry
->the_bfd
);
781 entry
->loaded
= true;
785 wild (s
, section
, file
, target
, output
)
786 lang_wild_statement_type
* s
;
790 lang_output_section_statement_type
* output
;
792 lang_input_statement_type
*f
;
794 if (file
== (char *) NULL
)
796 /* Perform the iteration over all files in the list */
797 for (f
= (lang_input_statement_type
*) file_chain
.head
;
798 f
!= (lang_input_statement_type
*) NULL
;
799 f
= (lang_input_statement_type
*) f
->next
)
801 wild_section (s
, section
, f
, output
);
806 /* Perform the iteration over a single file */
807 wild_section (s
, section
, lookup_name (file
), output
);
809 if (section
!= (char *) NULL
810 && strcmp (section
, "COMMON") == 0
811 && default_common_section
== (lang_output_section_statement_type
*) NULL
)
813 /* Remember the section that common is going to incase we later
814 get something which doesn't know where to put it */
815 default_common_section
= output
;
820 read in all the files
829 if (output_target
== (char *) NULL
)
831 if (current_target
!= (char *) NULL
)
832 output_target
= current_target
;
834 output_target
= default_target
;
836 output
= bfd_openw (name
, output_target
);
838 if (output
== (bfd
*) NULL
)
840 if (bfd_get_error () == bfd_error_invalid_target
)
842 einfo ("%P%F: target %s not found\n", output_target
);
844 einfo ("%P%F: cannot open output file %s: %E\n", name
);
847 delete_output_file_on_failure
= 1;
849 /* output->flags |= D_PAGED;*/
851 if (! bfd_set_format (output
, bfd_object
))
852 einfo ("%P%F:%s: can not make object file: %E\n", name
);
853 if (! bfd_set_arch_mach (output
,
854 ldfile_output_architecture
,
855 ldfile_output_machine
))
856 einfo ("%P%F:%s: can not set architecture: %E\n", name
);
858 link_info
.hash
= bfd_link_hash_table_create (output
);
859 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
860 einfo ("%P%F: can not create link hash table: %E\n");
862 bfd_set_gp_size (output
, g_switch_value
);
870 ldlang_open_output (statement
)
871 lang_statement_union_type
* statement
;
873 switch (statement
->header
.type
)
875 case lang_output_statement_enum
:
876 ASSERT (output_bfd
== (bfd
*) NULL
);
877 output_bfd
= open_output (statement
->output_statement
.name
);
878 ldemul_set_output_arch ();
879 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
880 output_bfd
->flags
|= D_PAGED
;
882 output_bfd
->flags
&= ~D_PAGED
;
883 if (config
.text_read_only
)
884 output_bfd
->flags
|= WP_TEXT
;
886 output_bfd
->flags
&= ~WP_TEXT
;
887 if (config
.traditional_format
)
888 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
890 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
893 case lang_target_statement_enum
:
894 current_target
= statement
->target_statement
.target
;
902 open_input_bfds (statement
)
903 lang_statement_union_type
* statement
;
905 switch (statement
->header
.type
)
907 case lang_target_statement_enum
:
908 current_target
= statement
->target_statement
.target
;
910 case lang_wild_statement_enum
:
911 /* Maybe we should load the file's symbols */
912 if (statement
->wild_statement
.filename
)
914 (void) lookup_name (statement
->wild_statement
.filename
);
917 case lang_input_statement_enum
:
918 if (statement
->input_statement
.real
== true)
920 statement
->input_statement
.target
= current_target
;
921 load_symbols (&statement
->input_statement
);
929 /* If there are [COMMONS] statements, put a wild one into the bss section */
932 lang_reasonable_defaults ()
935 lang_output_section_statement_lookup (".text");
936 lang_output_section_statement_lookup (".data");
938 default_common_section
=
939 lang_output_section_statement_lookup (".bss");
942 if (placed_commons
== false)
944 lang_wild_statement_type
*new =
945 new_stat (lang_wild_statement
,
946 &default_common_section
->children
);
948 new->section_name
= "COMMON";
949 new->filename
= (char *) NULL
;
950 lang_list_init (&new->children
);
957 Add the supplied name to the symbol table as an undefined reference.
958 Remove items from the chain as we open input bfds
960 typedef struct ldlang_undef_chain_list
962 struct ldlang_undef_chain_list
*next
;
964 } ldlang_undef_chain_list_type
;
966 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
969 ldlang_add_undef (name
)
970 CONST
char *CONST name
;
972 ldlang_undef_chain_list_type
*new =
973 (ldlang_undef_chain_list_type
974 *) stat_alloc ((bfd_size_type
) (sizeof (ldlang_undef_chain_list_type
)));
976 new->next
= ldlang_undef_chain_list_head
;
977 ldlang_undef_chain_list_head
= new;
979 new->name
= buystring (name
);
982 /* Run through the list of undefineds created above and place them
983 into the linker hash table as undefined symbols belonging to the
987 lang_place_undefineds ()
989 ldlang_undef_chain_list_type
*ptr
;
991 for (ptr
= ldlang_undef_chain_list_head
;
992 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
995 struct bfd_link_hash_entry
*h
;
997 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
998 if (h
== (struct bfd_link_hash_entry
*) NULL
)
999 einfo ("%P%F: bfd_link_hash_lookup failed: %E");
1000 if (h
->type
== bfd_link_hash_new
)
1002 h
->type
= bfd_link_hash_undefined
;
1003 h
->u
.undef
.abfd
= NULL
;
1004 bfd_link_add_undef (link_info
.hash
, h
);
1009 /* Open input files and attatch to output sections */
1011 map_input_to_output_sections (s
, target
, output_section_statement
)
1012 lang_statement_union_type
* s
;
1014 lang_output_section_statement_type
* output_section_statement
;
1016 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1018 switch (s
->header
.type
)
1022 case lang_wild_statement_enum
:
1023 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1024 s
->wild_statement
.filename
, target
,
1025 output_section_statement
);
1028 case lang_constructors_statement_enum
:
1029 map_input_to_output_sections (constructor_list
.head
,
1031 output_section_statement
);
1033 case lang_output_section_statement_enum
:
1034 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1036 &s
->output_section_statement
);
1038 case lang_output_statement_enum
:
1040 case lang_target_statement_enum
:
1041 target
= s
->target_statement
.target
;
1043 case lang_fill_statement_enum
:
1044 case lang_input_section_enum
:
1045 case lang_object_symbols_statement_enum
:
1046 case lang_data_statement_enum
:
1047 case lang_reloc_statement_enum
:
1048 case lang_assignment_statement_enum
:
1049 case lang_padding_statement_enum
:
1050 case lang_input_statement_enum
:
1051 if (output_section_statement
!= NULL
1052 && output_section_statement
->bfd_section
== NULL
)
1053 init_os (output_section_statement
);
1055 case lang_afile_asection_pair_statement_enum
:
1058 case lang_address_statement_enum
:
1059 /* Mark the specified section with the supplied address */
1061 lang_output_section_statement_type
*os
=
1062 lang_output_section_statement_lookup
1063 (s
->address_statement
.section_name
);
1065 if (os
->bfd_section
== NULL
)
1067 os
->addr_tree
= s
->address_statement
.address
;
1075 print_output_section_statement (output_section_statement
)
1076 lang_output_section_statement_type
* output_section_statement
;
1078 asection
*section
= output_section_statement
->bfd_section
;
1081 print_section (output_section_statement
->name
);
1086 print_dot
= section
->vma
;
1090 print_address (section
->vma
);
1092 print_size (section
->_raw_size
);
1094 print_size(section
->_cooked_size
);
1096 print_alignment (section
->alignment_power
);
1099 fprintf (config
.map_file
, "%s flags", output_section_statement
->region
->name
);
1100 print_flags (stdout
, &output_section_statement
->flags
);
1102 if (section
->flags
& SEC_LOAD
)
1103 fprintf (config
.map_file
, "load ");
1104 if (section
->flags
& SEC_ALLOC
)
1105 fprintf (config
.map_file
, "alloc ");
1106 if (section
->flags
& SEC_RELOC
)
1107 fprintf (config
.map_file
, "reloc ");
1108 if (section
->flags
& SEC_HAS_CONTENTS
)
1109 fprintf (config
.map_file
, "contents ");
1114 fprintf (config
.map_file
, " (no attached output section)");
1117 if (output_section_statement
->load_base
)
1119 int b
= exp_get_value_int(output_section_statement
->load_base
,
1120 0, "output base", lang_final_phase_enum
);
1121 printf("Output address %08x\n", b
);
1123 if (output_section_statement
->section_alignment
>= 0
1124 || output_section_statement
->section_alignment
>= 0)
1126 printf("\t\t\t\t\tforced alignment ");
1127 if ( output_section_statement
->section_alignment
>= 0)
1129 printf("section 2**%d ",output_section_statement
->section_alignment
);
1131 if ( output_section_statement
->subsection_alignment
>= 0)
1133 printf("subsection 2**%d ",output_section_statement
->subsection_alignment
);
1138 print_statement (output_section_statement
->children
.head
,
1139 output_section_statement
);
1144 print_assignment (assignment
, output_section
)
1145 lang_assignment_statement_type
* assignment
;
1146 lang_output_section_statement_type
* output_section
;
1148 etree_value_type result
;
1154 print_address (print_dot
);
1156 result
= exp_fold_tree (assignment
->exp
->assign
.src
,
1158 lang_final_phase_enum
,
1164 print_address (result
.value
);
1168 fprintf (config
.map_file
, "*undefined*");
1171 exp_print_tree (assignment
->exp
);
1173 fprintf (config
.map_file
, "\n");
1177 print_input_statement (statm
)
1178 lang_input_statement_type
* statm
;
1180 if (statm
->filename
!= (char *) NULL
)
1182 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1186 /* Print all the defined symbols for the abfd provided by in the supplied
1191 print_one_symbol (hash_entry
, ptr
)
1192 struct bfd_link_hash_entry
*hash_entry
;
1195 asection
* sec
= (asection
*)ptr
;
1197 if (hash_entry
->type
== bfd_link_hash_defined
)
1199 if (sec
== hash_entry
->u
.def
.section
) {
1201 fprintf (config
.map_file
, " ");
1203 fprintf (config
.map_file
, " ");
1204 print_address (hash_entry
->u
.def
.value
+ outside_section_address (sec
));
1205 fprintf (config
.map_file
, " %s", hash_entry
->root
.string
);
1214 print_input_section (in
)
1215 lang_input_section_type
* in
;
1217 asection
*i
= in
->section
;
1218 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
1223 fprintf (config
.map_file
, " ");
1224 print_section (i
->name
);
1225 fprintf (config
.map_file
, " ");
1226 if (i
->output_section
)
1228 print_address (i
->output_section
->vma
+ i
->output_offset
);
1229 fprintf (config
.map_file
, " ");
1230 print_size (i
->_raw_size
);
1231 fprintf (config
.map_file
, " ");
1232 print_size(i
->_cooked_size
);
1233 fprintf (config
.map_file
, " ");
1234 print_alignment (i
->alignment_power
);
1235 fprintf (config
.map_file
, " ");
1239 bfd
*abfd
= in
->ifile
->the_bfd
;
1241 if (in
->ifile
->just_syms_flag
== true)
1243 fprintf (config
.map_file
, "symbols only ");
1246 fprintf (config
.map_file
, " %s ", abfd
->xvec
->name
);
1247 if (abfd
->my_archive
!= (bfd
*) NULL
)
1249 fprintf (config
.map_file
, "[%s]%s", abfd
->my_archive
->filename
,
1254 fprintf (config
.map_file
, "%s", abfd
->filename
);
1256 fprintf (config
.map_file
, "(overhead %d bytes)", (int) bfd_alloc_size (abfd
));
1259 /* Print all the symbols */
1260 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
1268 print_dot
= outside_section_address (i
) + size
;
1272 fprintf (config
.map_file
, "No output section allocated\n");
1278 print_fill_statement (fill
)
1279 lang_fill_statement_type
* fill
;
1281 fprintf (config
.map_file
, "FILL mask ");
1282 print_fill (fill
->fill
);
1286 print_data_statement (data
)
1287 lang_data_statement_type
* data
;
1289 /* bfd_vma value; */
1294 /* ASSERT(print_dot == data->output_vma);*/
1296 print_address (data
->output_vma
+ data
->output_section
->vma
);
1298 print_address (data
->value
);
1303 fprintf (config
.map_file
, "BYTE ");
1304 print_dot
+= BYTE_SIZE
;
1307 fprintf (config
.map_file
, "SHORT ");
1308 print_dot
+= SHORT_SIZE
;
1311 fprintf (config
.map_file
, "LONG ");
1312 print_dot
+= LONG_SIZE
;
1315 fprintf (config
.map_file
, "QUAD ");
1316 print_dot
+= QUAD_SIZE
;
1320 exp_print_tree (data
->exp
);
1322 fprintf (config
.map_file
, "\n");
1325 /* Print a reloc statement. */
1328 print_reloc_statement (reloc
)
1329 lang_reloc_statement_type
*reloc
;
1336 /* ASSERT(print_dot == data->output_vma);*/
1338 print_address (reloc
->output_vma
+ reloc
->output_section
->vma
);
1340 print_address (reloc
->addend_value
);
1343 fprintf (config
.map_file
, "RELOC %s ", reloc
->howto
->name
);
1345 print_dot
+= bfd_get_reloc_size (reloc
->howto
);
1347 exp_print_tree (reloc
->addend_exp
);
1349 fprintf (config
.map_file
, "\n");
1353 print_padding_statement (s
)
1354 lang_padding_statement_type
* s
;
1358 print_section ("*fill*");
1360 print_address (s
->output_offset
+ s
->output_section
->vma
);
1362 print_size (s
->size
);
1364 print_fill (s
->fill
);
1367 print_dot
= s
->output_offset
+ s
->output_section
->vma
+ s
->size
;
1372 print_wild_statement (w
, os
)
1373 lang_wild_statement_type
* w
;
1374 lang_output_section_statement_type
* os
;
1376 fprintf (config
.map_file
, " from ");
1377 if (w
->filename
!= (char *) NULL
)
1379 fprintf (config
.map_file
, "%s", w
->filename
);
1383 fprintf (config
.map_file
, "*");
1385 if (w
->section_name
!= (char *) NULL
)
1387 fprintf (config
.map_file
, "(%s)", w
->section_name
);
1391 fprintf (config
.map_file
, "(*)");
1394 print_statement (w
->children
.head
, os
);
1398 print_statement (s
, os
)
1399 lang_statement_union_type
* s
;
1400 lang_output_section_statement_type
* os
;
1404 switch (s
->header
.type
)
1406 case lang_constructors_statement_enum
:
1407 fprintf (config
.map_file
, "constructors:\n");
1408 print_statement (constructor_list
.head
, os
);
1410 case lang_wild_statement_enum
:
1411 print_wild_statement (&s
->wild_statement
, os
);
1414 fprintf (config
.map_file
, "Fail with %d\n", s
->header
.type
);
1417 case lang_address_statement_enum
:
1418 fprintf (config
.map_file
, "address\n");
1420 case lang_object_symbols_statement_enum
:
1421 fprintf (config
.map_file
, "object symbols\n");
1423 case lang_fill_statement_enum
:
1424 print_fill_statement (&s
->fill_statement
);
1426 case lang_data_statement_enum
:
1427 print_data_statement (&s
->data_statement
);
1429 case lang_reloc_statement_enum
:
1430 print_reloc_statement (&s
->reloc_statement
);
1432 case lang_input_section_enum
:
1433 print_input_section (&s
->input_section
);
1435 case lang_padding_statement_enum
:
1436 print_padding_statement (&s
->padding_statement
);
1438 case lang_output_section_statement_enum
:
1439 print_output_section_statement (&s
->output_section_statement
);
1441 case lang_assignment_statement_enum
:
1442 print_assignment (&s
->assignment_statement
,
1445 case lang_target_statement_enum
:
1446 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1448 case lang_output_statement_enum
:
1449 fprintf (config
.map_file
, "OUTPUT(%s %s)\n",
1450 s
->output_statement
.name
,
1451 output_target
? output_target
: "");
1453 case lang_input_statement_enum
:
1454 print_input_statement (&s
->input_statement
);
1456 case lang_afile_asection_pair_statement_enum
:
1468 print_statement (statement_list
.head
,
1469 abs_output_section
);
1474 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
1475 lang_statement_union_type
** this_ptr
;
1478 asection
* output_section_statement
;
1481 /* Align this section first to the
1482 input sections requirement, then
1483 to the output section's requirement.
1484 If this alignment is > than any seen before,
1485 then record it too. Perform the alignment by
1486 inserting a magic 'padding' statement.
1489 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
1491 if (alignment_needed
!= 0)
1493 lang_statement_union_type
*new =
1494 (lang_statement_union_type
*)
1495 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1497 /* Link into existing chain */
1498 new->header
.next
= *this_ptr
;
1500 new->header
.type
= lang_padding_statement_enum
;
1501 new->padding_statement
.output_section
= output_section_statement
;
1502 new->padding_statement
.output_offset
=
1503 dot
- output_section_statement
->vma
;
1504 new->padding_statement
.fill
= fill
;
1505 new->padding_statement
.size
= alignment_needed
;
1509 /* Remember the most restrictive alignment */
1510 if (power
> output_section_statement
->alignment_power
)
1512 output_section_statement
->alignment_power
= power
;
1514 output_section_statement
->_raw_size
+= alignment_needed
;
1515 return alignment_needed
+ dot
;
1519 /* Work out how much this section will move the dot point */
1521 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
1522 lang_statement_union_type
** this_ptr
;
1523 lang_output_section_statement_type
* output_section_statement
;
1528 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1529 asection
*i
= is
->section
;
1531 if (is
->ifile
->just_syms_flag
== false)
1533 if (output_section_statement
->subsection_alignment
!= -1)
1534 i
->alignment_power
=
1535 output_section_statement
->subsection_alignment
;
1537 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
1538 output_section_statement
->bfd_section
, dot
);
1540 /* Remember where in the output section this input section goes */
1542 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1544 /* Mark how big the output section must be to contain this now
1546 if (i
->_cooked_size
!= 0)
1547 dot
+= i
->_cooked_size
;
1549 dot
+= i
->_raw_size
;
1550 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
1554 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
1560 /* This variable indicates whether bfd_relax_section should be called
1563 static boolean relax_again
;
1565 /* Set the sizes for all the output sections. */
1568 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
1569 lang_statement_union_type
* s
;
1570 lang_output_section_statement_type
* output_section_statement
;
1571 lang_statement_union_type
** prev
;
1576 /* Size up the sections from their constituent parts */
1577 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1579 switch (s
->header
.type
)
1582 case lang_output_section_statement_enum
:
1585 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
1587 if (os
->bfd_section
== NULL
)
1589 /* This section was never actually created. */
1593 /* If this is a COFF shared library section, use the size and
1594 address from the input section. FIXME: This is COFF
1595 specific; it would be cleaner if there were some other way
1596 to do this, but nothing simple comes to mind. */
1597 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
1601 if (os
->children
.head
== NULL
1602 || os
->children
.head
->next
!= NULL
1603 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
1604 einfo ("%P%X: Internal error on COFF shared library section %s",
1607 input
= os
->children
.head
->input_section
.section
;
1608 bfd_set_section_vma (os
->bfd_section
->owner
,
1610 bfd_section_vma (input
->owner
, input
));
1611 os
->bfd_section
->_raw_size
= input
->_raw_size
;
1615 if (bfd_is_abs_section (os
->bfd_section
))
1617 /* No matter what happens, an abs section starts at zero */
1618 ASSERT (os
->bfd_section
->vma
== 0);
1622 if (os
->addr_tree
== (etree_type
*) NULL
)
1624 /* No address specified for this section, get one
1625 from the region specification
1627 if (os
->region
== (lang_memory_region_type
*) NULL
)
1629 os
->region
= lang_memory_region_lookup ("*default*");
1631 dot
= os
->region
->current
;
1632 if (os
->section_alignment
== -1)
1633 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
1639 r
= exp_fold_tree (os
->addr_tree
,
1641 lang_allocating_phase_enum
,
1643 if (r
.valid
== false)
1645 einfo ("%F%S: non constant address expression for section %s\n",
1650 /* The section starts here */
1651 /* First, align to what the section needs */
1653 if (os
->section_alignment
!= -1)
1654 dot
= align_power (dot
, os
->section_alignment
);
1656 bfd_set_section_vma (0, os
->bfd_section
, dot
);
1658 if (os
->load_base
) {
1659 os
->bfd_section
->lma
1660 = exp_get_value_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
1663 os
->bfd_section
->output_offset
= 0;
1666 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
1667 os
->fill
, dot
, relax
);
1668 /* Ignore the size of the input sections, use the vma and size to */
1671 after
= ALIGN_N (os
->bfd_section
->vma
+
1672 os
->bfd_section
->_raw_size
,
1673 /* The coercion here is important, see ld.h. */
1674 (bfd_vma
) os
->block_value
);
1676 if (bfd_is_abs_section (os
->bfd_section
))
1677 ASSERT (after
== os
->bfd_section
->vma
);
1679 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
1680 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1681 os
->processed
= true;
1683 /* Replace into region ? */
1684 if (os
->region
!= (lang_memory_region_type
*) NULL
)
1686 os
->region
->current
= dot
;
1687 /* Make sure this isn't silly */
1688 if (( os
->region
->current
1689 > os
->region
->origin
+ os
->region
->length
)
1690 || ( os
->region
->origin
> os
->region
->current
))
1692 einfo ("%X%P: region %s is full (%B section %s)\n",
1694 os
->bfd_section
->owner
,
1695 os
->bfd_section
->name
);
1696 /* Reset the region pointer */
1697 os
->region
->current
= 0;
1705 case lang_constructors_statement_enum
:
1706 dot
= lang_size_sections (constructor_list
.head
,
1707 output_section_statement
,
1708 &s
->wild_statement
.children
.head
,
1713 case lang_data_statement_enum
:
1715 unsigned int size
= 0;
1717 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1718 s
->data_statement
.output_section
=
1719 output_section_statement
->bfd_section
;
1721 switch (s
->data_statement
.type
)
1738 output_section_statement
->bfd_section
->_raw_size
+= size
;
1742 case lang_reloc_statement_enum
:
1746 s
->reloc_statement
.output_vma
=
1747 dot
- output_section_statement
->bfd_section
->vma
;
1748 s
->reloc_statement
.output_section
=
1749 output_section_statement
->bfd_section
;
1750 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
1752 output_section_statement
->bfd_section
->_raw_size
+= size
;
1756 case lang_wild_statement_enum
:
1758 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
1759 output_section_statement
,
1760 &s
->wild_statement
.children
.head
,
1766 case lang_object_symbols_statement_enum
:
1767 link_info
.create_object_symbols_section
=
1768 output_section_statement
->bfd_section
;
1770 case lang_output_statement_enum
:
1771 case lang_target_statement_enum
:
1773 case lang_input_section_enum
:
1777 i
= (*prev
)->input_section
.section
;
1779 i
->_cooked_size
= i
->_raw_size
;
1784 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
1785 einfo ("%P%F: can't relax section: %E\n");
1789 dot
= size_input_section (prev
,
1790 output_section_statement
,
1791 output_section_statement
->fill
,
1795 case lang_input_statement_enum
:
1797 case lang_fill_statement_enum
:
1798 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
1800 fill
= s
->fill_statement
.fill
;
1802 case lang_assignment_statement_enum
:
1804 bfd_vma newdot
= dot
;
1806 exp_fold_tree (s
->assignment_statement
.exp
,
1807 output_section_statement
,
1808 lang_allocating_phase_enum
,
1812 if (newdot
!= dot
&& !relax
)
1814 /* The assignment changed dot. Insert a pad. */
1815 if (output_section_statement
== abs_output_section
)
1817 /* If we don't have an output section, then just adjust
1818 the default memory address. */
1819 lang_memory_region_lookup ("*default*")->current
= newdot
;
1823 lang_statement_union_type
*new =
1824 ((lang_statement_union_type
*)
1825 stat_alloc (sizeof (lang_padding_statement_type
)));
1827 /* Link into existing chain */
1828 new->header
.next
= *prev
;
1830 new->header
.type
= lang_padding_statement_enum
;
1831 new->padding_statement
.output_section
=
1832 output_section_statement
->bfd_section
;
1833 new->padding_statement
.output_offset
=
1834 dot
- output_section_statement
->bfd_section
->vma
;
1835 new->padding_statement
.fill
= fill
;
1836 new->padding_statement
.size
= newdot
- dot
;
1837 output_section_statement
->bfd_section
->_raw_size
+=
1838 new->padding_statement
.size
;
1846 case lang_padding_statement_enum
:
1847 /* If we are relaxing, and this is not the first pass, some
1848 padding statements may have been inserted during previous
1849 passes. We may have to move the padding statement to a new
1850 location if dot has a different value at this point in this
1851 pass than it did at this point in the previous pass. */
1852 s
->padding_statement
.output_offset
=
1853 dot
- output_section_statement
->bfd_section
->vma
;
1854 dot
+= s
->padding_statement
.size
;
1861 /* This can only get here when relaxing is turned on */
1863 case lang_address_statement_enum
:
1866 prev
= &s
->header
.next
;
1872 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
1873 lang_statement_union_type
* s
;
1874 lang_output_section_statement_type
* output_section_statement
;
1878 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1880 switch (s
->header
.type
)
1882 case lang_constructors_statement_enum
:
1883 dot
= lang_do_assignments (constructor_list
.head
,
1884 output_section_statement
,
1889 case lang_output_section_statement_enum
:
1891 lang_output_section_statement_type
*os
=
1892 &(s
->output_section_statement
);
1894 if (os
->bfd_section
!= NULL
)
1896 dot
= os
->bfd_section
->vma
;
1897 (void) lang_do_assignments (os
->children
.head
, os
,
1899 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1903 case lang_wild_statement_enum
:
1905 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
1906 output_section_statement
,
1911 case lang_object_symbols_statement_enum
:
1912 case lang_output_statement_enum
:
1913 case lang_target_statement_enum
:
1915 case lang_common_statement_enum
:
1918 case lang_data_statement_enum
:
1920 etree_value_type value
;
1922 value
= exp_fold_tree (s
->data_statement
.exp
,
1924 lang_final_phase_enum
, dot
, &dot
);
1925 s
->data_statement
.value
= value
.value
;
1926 if (value
.valid
== false)
1927 einfo ("%F%P: invalid data statement\n");
1929 switch (s
->data_statement
.type
)
1946 case lang_reloc_statement_enum
:
1948 etree_value_type value
;
1950 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
1952 lang_final_phase_enum
, dot
, &dot
);
1953 s
->reloc_statement
.addend_value
= value
.value
;
1954 if (value
.valid
== false)
1955 einfo ("%F%P: invalid reloc statement\n");
1957 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
);
1960 case lang_input_section_enum
:
1962 asection
*in
= s
->input_section
.section
;
1964 if (in
->_cooked_size
!= 0)
1965 dot
+= in
->_cooked_size
;
1967 dot
+= in
->_raw_size
;
1971 case lang_input_statement_enum
:
1973 case lang_fill_statement_enum
:
1974 fill
= s
->fill_statement
.fill
;
1976 case lang_assignment_statement_enum
:
1978 exp_fold_tree (s
->assignment_statement
.exp
,
1979 output_section_statement
,
1980 lang_final_phase_enum
,
1986 case lang_padding_statement_enum
:
1987 dot
+= s
->padding_statement
.size
;
1992 case lang_address_statement_enum
:
2003 struct bfd_link_hash_entry
*h
;
2004 boolean warn
= link_info
.relocateable
? false : true;
2006 if (entry_symbol
== (char *) NULL
)
2008 /* No entry has been specified. Look for start, but don't warn
2009 if we don't find it. */
2010 entry_symbol
= "start";
2014 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
2015 if (h
!= (struct bfd_link_hash_entry
*) NULL
2016 && h
->type
== bfd_link_hash_defined
)
2020 val
= (h
->u
.def
.value
2021 + bfd_get_section_vma (output_bfd
,
2022 h
->u
.def
.section
->output_section
)
2023 + h
->u
.def
.section
->output_offset
);
2024 if (! bfd_set_start_address (output_bfd
, val
))
2025 einfo ("%P%F:%s: can't set start address\n", entry_symbol
);
2031 /* Can't find the entry symbol. Use the first address in the
2033 ts
= bfd_get_section_by_name (output_bfd
, ".text");
2034 if (ts
!= (asection
*) NULL
)
2037 einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
2038 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
2039 if (! bfd_set_start_address (output_bfd
,
2040 bfd_get_section_vma (output_bfd
, ts
)))
2041 einfo ("%P%F: can't set start address\n");
2046 einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2052 /* By now we know the target architecture, and we may have an */
2053 /* ldfile_output_machine_name */
2057 lang_statement_union_type
*file
;
2059 unsigned long input_machine
;
2060 enum bfd_architecture input_architecture
;
2061 CONST bfd_arch_info_type
*compatible
;
2063 for (file
= file_chain
.head
;
2064 file
!= (lang_statement_union_type
*) NULL
;
2065 file
= file
->input_statement
.next
)
2067 input_bfd
= file
->input_statement
.the_bfd
;
2069 input_machine
= bfd_get_mach (input_bfd
);
2070 input_architecture
= bfd_get_arch (input_bfd
);
2073 /* Inspect the architecture and ensure we're linking like with
2076 compatible
= bfd_arch_get_compatible (input_bfd
,
2081 ldfile_output_machine
= compatible
->mach
;
2082 ldfile_output_architecture
= compatible
->arch
;
2087 einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2088 bfd_printable_name (input_bfd
), input_bfd
,
2089 bfd_printable_name (output_bfd
));
2091 if (! bfd_set_arch_mach (output_bfd
,
2094 einfo ("%P%F:%s: can't set architecture: %E\n",
2095 bfd_get_filename (output_bfd
));
2101 /* Look through all the global common symbols and attach them to the
2102 correct section. The -sort-common command line switch may be used
2103 to roughly sort the entries by size. */
2108 if (link_info
.relocateable
2109 && ! command_line
.force_common_definition
)
2112 if (! config
.sort_common
)
2113 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
2118 for (power
= 1; power
<= 16; power
<<= 1)
2119 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
2124 /* Place one common symbol in the correct section. */
2127 lang_one_common (h
, info
)
2128 struct bfd_link_hash_entry
*h
;
2131 unsigned int power_of_two
;
2136 if (h
->type
!= bfd_link_hash_common
)
2169 if (config
.sort_common
&& align
!= *(unsigned int *) info
)
2172 section
= h
->u
.c
.section
;
2174 /* Increase the size of the section. */
2175 section
->_raw_size
= ALIGN_N (section
->_raw_size
, align
);
2177 /* Adjust the alignment if necessary. */
2178 if (power_of_two
> section
->alignment_power
)
2179 section
->alignment_power
= power_of_two
;
2181 /* Change the symbol from common to defined. */
2182 h
->type
= bfd_link_hash_defined
;
2183 h
->u
.def
.section
= section
;
2184 h
->u
.def
.value
= section
->_raw_size
;
2186 /* Increase the size of the section. */
2187 section
->_raw_size
+= size
;
2189 if (config
.map_file
!= NULL
)
2190 fprintf (config
.map_file
, "Allocating common %s: %lx at %lx %s\n",
2191 h
->root
.string
, (unsigned long) size
,
2192 (unsigned long) h
->u
.def
.value
, section
->owner
->filename
);
2198 run through the input files and ensure that every input
2199 section has somewhere to go. If one is found without
2200 a destination then create an input request and place it
2201 into the statement tree.
2205 lang_place_orphans ()
2207 lang_input_statement_type
*file
;
2209 for (file
= (lang_input_statement_type
*) file_chain
.head
;
2210 file
!= (lang_input_statement_type
*) NULL
;
2211 file
= (lang_input_statement_type
*) file
->next
)
2215 if (file
->just_syms_flag
)
2218 for (s
= file
->the_bfd
->sections
;
2219 s
!= (asection
*) NULL
;
2222 if (s
->output_section
== (asection
*) NULL
)
2224 /* This section of the file is not attatched, root
2225 around for a sensible place for it to go */
2227 if (file
->common_section
== s
)
2229 /* This is a lonely common section which must
2230 have come from an archive. We attatch to the
2231 section with the wildcard */
2232 if (! link_info
.relocateable
2233 && ! command_line
.force_common_definition
)
2235 if (default_common_section
==
2236 (lang_output_section_statement_type
*) NULL
)
2238 info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2240 default_common_section
=
2241 lang_output_section_statement_lookup (".bss");
2244 wild_doit (&default_common_section
->children
, s
,
2245 default_common_section
, file
);
2250 lang_output_section_statement_type
*os
=
2251 lang_output_section_statement_lookup (s
->name
);
2253 wild_doit (&os
->children
, s
, os
, file
);
2262 lang_set_flags (ptr
, flags
)
2266 boolean state
= false;
2281 /* ptr->flag_read = state; */
2284 /* ptr->flag_write = state; */
2287 /* ptr->flag_executable= state;*/
2291 /* ptr->flag_loadable= state;*/
2294 einfo ("%P%F: invalid syntax in flags\n");
2301 /* Call a function on each input file. This function will be called
2302 on an archive, but not on the elements. */
2305 lang_for_each_input_file (func
)
2306 void (*func
) PARAMS ((lang_input_statement_type
*));
2308 lang_input_statement_type
*f
;
2310 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
2312 f
= (lang_input_statement_type
*) f
->next_real_file
)
2316 /* Call a function on each file. The function will be called on all
2317 the elements of an archive which are included in the link, but will
2318 not be called on the archive file itself. */
2321 lang_for_each_file (func
)
2322 void (*func
) PARAMS ((lang_input_statement_type
*));
2324 lang_input_statement_type
*f
;
2326 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2327 f
!= (lang_input_statement_type
*) NULL
;
2328 f
= (lang_input_statement_type
*) f
->next
)
2339 lang_for_each_input_section (func
)
2340 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
2342 lang_input_statement_type
*f
;
2344 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2345 f
!= (lang_input_statement_type
*) NULL
;
2346 f
= (lang_input_statement_type
*) f
->next
)
2350 for (s
= f
->the_bfd
->sections
;
2351 s
!= (asection
*) NULL
;
2354 func (f
->the_bfd
, s
);
2362 ldlang_add_file (entry
)
2363 lang_input_statement_type
* entry
;
2367 lang_statement_append (&file_chain
,
2368 (lang_statement_union_type
*) entry
,
2371 /* The BFD linker needs to have a list of all input BFDs involved in
2373 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
2374 ASSERT (entry
->the_bfd
!= output_bfd
);
2375 for (pp
= &link_info
.input_bfds
;
2376 *pp
!= (bfd
*) NULL
;
2377 pp
= &(*pp
)->link_next
)
2379 *pp
= entry
->the_bfd
;
2380 entry
->the_bfd
->usrdata
= (PTR
) entry
;
2381 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
2385 lang_add_output (name
, from_script
)
2389 /* Make -o on command line override OUTPUT in script. */
2390 if (had_output_filename
== false || !from_script
)
2392 output_filename
= name
;
2393 had_output_filename
= true;
2398 static lang_output_section_statement_type
*current_section
;
2400 static int topower(x
)
2405 if (x
< 0) return -1;
2406 for (l
= 0; l
< 32; l
++)
2408 if (i
>= x
) return l
;
2414 lang_enter_output_section_statement (output_section_statement_name
,
2415 address_exp
, flags
, block_value
,
2416 align
, subalign
, ebase
)
2417 const char *output_section_statement_name
;
2418 etree_type
* address_exp
;
2420 bfd_vma block_value
;
2422 etree_type
*subalign
;
2425 lang_output_section_statement_type
*os
;
2429 lang_output_section_statement_lookup (output_section_statement_name
);
2433 /* Add this statement to tree */
2434 /* add_statement(lang_output_section_statement_enum,
2435 output_section_statement);*/
2436 /* Make next things chain into subchain of this */
2438 if (os
->addr_tree
==
2439 (etree_type
*) NULL
)
2445 if (flags
& SEC_NEVER_LOAD
)
2449 os
->block_value
= block_value
? block_value
: 1;
2450 stat_ptr
= &os
->children
;
2452 os
->subsection_alignment
= topower(
2453 exp_get_value_int(subalign
, -1,
2454 "subsection alignment",
2456 os
->section_alignment
= topower(
2457 exp_get_value_int(align
, -1,
2458 "section alignment", 0));
2460 os
->load_base
= ebase
;
2467 lang_output_statement_type
*new =
2468 new_stat (lang_output_statement
, stat_ptr
);
2470 new->name
= output_filename
;
2473 /* Reset the current counters in the regions */
2475 reset_memory_regions ()
2477 lang_memory_region_type
*p
= lang_memory_region_list
;
2479 for (p
= lang_memory_region_list
;
2480 p
!= (lang_memory_region_type
*) NULL
;
2483 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
2484 p
->current
= p
->origin
;
2491 lang_reasonable_defaults ();
2492 current_target
= default_target
;
2494 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
2496 ldemul_create_output_section_statements ();
2498 /* Add to the hash table all undefineds on the command line */
2499 lang_place_undefineds ();
2501 /* Create a bfd for each input file */
2502 current_target
= default_target
;
2503 lang_for_each_statement (open_input_bfds
);
2505 /* Build all sets based on the information gathered from the input
2507 ldctor_build_sets ();
2509 /* Size up the common data */
2512 /* Run through the contours of the script and attatch input sections
2513 to the correct output sections
2515 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
2516 (lang_output_section_statement_type
*) NULL
);
2519 /* Find any sections not attatched explicitly and handle them */
2520 lang_place_orphans ();
2522 ldemul_before_allocation ();
2524 /* Now run around and relax if we can */
2525 if (command_line
.relax
)
2527 /* First time round is a trial run to get the 'worst case'
2528 addresses of the objects if there was no relaxing. */
2529 lang_size_sections (statement_list
.head
,
2531 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2534 reset_memory_regions ();
2536 /* Keep relaxing until bfd_relax_section gives up. */
2539 relax_again
= false;
2541 /* Do all the assignments with our current guesses as to
2543 lang_do_assignments (statement_list
.head
,
2545 (fill_type
) 0, (bfd_vma
) 0);
2547 /* Perform another relax pass - this time we know where the
2548 globals are, so can make better guess. */
2549 lang_size_sections (statement_list
.head
,
2551 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2553 while (relax_again
);
2557 /* Size up the sections. */
2558 lang_size_sections (statement_list
.head
,
2560 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2563 /* See if anything special should be done now we know how big
2565 ldemul_after_allocation ();
2567 /* Do all the assignments, now that we know the final restingplaces
2568 of all the symbols */
2570 lang_do_assignments (statement_list
.head
,
2572 (fill_type
) 0, (bfd_vma
) 0);
2574 /* Make sure that we're not mixing architectures */
2584 /* EXPORTED TO YACC */
2587 lang_add_wild (section_name
, filename
)
2588 CONST
char *CONST section_name
;
2589 CONST
char *CONST filename
;
2591 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
2594 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
2596 placed_commons
= true;
2598 if (filename
!= (char *) NULL
)
2600 lang_has_input_file
= true;
2602 new->section_name
= section_name
;
2603 new->filename
= filename
;
2604 lang_list_init (&new->children
);
2608 lang_section_start (name
, address
)
2610 etree_type
* address
;
2612 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
2614 ad
->section_name
= name
;
2615 ad
->address
= address
;
2618 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
2619 because of a -e argument on the command line, or zero if this is
2620 called by ENTRY in a linker script. Command line arguments take
2624 lang_add_entry (name
, cmdline
)
2628 static int from_cmdline
;
2630 if (entry_symbol
== NULL
2634 entry_symbol
= name
;
2635 from_cmdline
= cmdline
;
2640 lang_add_target (name
)
2643 lang_target_statement_type
*new = new_stat (lang_target_statement
,
2659 map_option_f
= true;
2670 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
2677 lang_add_data (type
, exp
)
2679 union etree_union
*exp
;
2682 lang_data_statement_type
*new = new_stat (lang_data_statement
,
2690 /* Create a new reloc statement. RELOC is the BFD relocation type to
2691 generate. HOWTO is the corresponding howto structure (we could
2692 look this up, but the caller has already done so). SECTION is the
2693 section to generate a reloc against, or NAME is the name of the
2694 symbol to generate a reloc against. Exactly one of SECTION and
2695 NAME must be NULL. ADDEND is an expression for the addend. */
2698 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
2699 bfd_reloc_code_real_type reloc
;
2700 const reloc_howto_type
*howto
;
2703 union etree_union
*addend
;
2705 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
2709 p
->section
= section
;
2711 p
->addend_exp
= addend
;
2713 p
->addend_value
= 0;
2714 p
->output_section
= NULL
;
2719 lang_add_assignment (exp
)
2722 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
2729 lang_add_attribute (attribute
)
2730 enum statement_enum attribute
;
2732 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
2739 if (startup_file
!= (char *) NULL
)
2741 einfo ("%P%Fmultiple STARTUP files\n");
2743 first_file
->filename
= name
;
2744 first_file
->local_sym_name
= name
;
2745 first_file
->real
= true;
2747 startup_file
= name
;
2754 lang_float_flag
= maybe
;
2758 lang_leave_output_section_statement (fill
, memspec
)
2760 CONST
char *memspec
;
2762 current_section
->fill
= fill
;
2763 current_section
->region
= lang_memory_region_lookup (memspec
);
2764 stat_ptr
= &statement_list
;
2768 Create an absolute symbol with the given name with the value of the
2769 address of first byte of the section named.
2771 If the symbol already exists, then do nothing.
2774 lang_abs_symbol_at_beginning_of (secname
, name
)
2775 const char *secname
;
2778 struct bfd_link_hash_entry
*h
;
2780 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2781 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2782 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2784 if (h
->type
== bfd_link_hash_new
2785 || h
->type
== bfd_link_hash_undefined
)
2789 h
->type
= bfd_link_hash_defined
;
2791 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2792 if (sec
== (asection
*) NULL
)
2795 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
2797 h
->u
.def
.section
= bfd_abs_section_ptr
;
2802 Create an absolute symbol with the given name with the value of the
2803 address of the first byte after the end of the section named.
2805 If the symbol already exists, then do nothing.
2808 lang_abs_symbol_at_end_of (secname
, name
)
2809 const char *secname
;
2812 struct bfd_link_hash_entry
*h
;
2814 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2815 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2816 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2818 if (h
->type
== bfd_link_hash_new
2819 || h
->type
== bfd_link_hash_undefined
)
2823 h
->type
= bfd_link_hash_defined
;
2825 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2826 if (sec
== (asection
*) NULL
)
2829 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
2830 + bfd_section_size (output_bfd
, sec
));
2832 h
->u
.def
.section
= bfd_abs_section_ptr
;
2837 lang_statement_append (list
, element
, field
)
2838 lang_statement_list_type
* list
;
2839 lang_statement_union_type
* element
;
2840 lang_statement_union_type
** field
;
2842 *(list
->tail
) = element
;
2846 /* Set the output format type. -oformat overrides scripts. */
2848 lang_add_output_format (format
, from_script
)
2852 if (output_target
== NULL
|| !from_script
)
2853 output_target
= format
;