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
;
53 /* Points to the last statement in the .data section, so we can add
54 stuff to the data section without pain */
55 static lang_statement_list_type end_of_data_section_statement_list
;
57 static boolean placed_commons
= false;
58 static lang_output_section_statement_type
*default_common_section
;
59 static boolean map_option_f
;
60 static bfd_vma print_dot
;
61 static lang_input_statement_type
*first_file
;
62 static lang_statement_list_type lang_output_section_statement
;
63 static CONST
char *current_target
;
64 static CONST
char *output_target
;
65 static int longest_section_name
= 8;
66 static lang_statement_list_type statement_list
;
68 static void print_size
PARAMS ((size_t value
));
69 static void print_alignment
PARAMS ((unsigned int value
));
70 static void print_fill
PARAMS ((fill_type value
));
71 static void print_section
PARAMS ((const char *name
));
72 static void lang_for_each_statement_worker
73 PARAMS ((void (*func
) (lang_statement_union_type
*),
74 lang_statement_union_type
*s
));
75 static lang_input_statement_type
*new_afile
76 PARAMS ((const char *name
, lang_input_file_enum_type file_type
,
77 const char *target
, boolean add_to_list
));
78 static void print_flags
PARAMS ((int *ignore_flags
));
79 static void init_os
PARAMS ((lang_output_section_statement_type
*s
));
80 static void wild_doit
PARAMS ((lang_statement_list_type
*ptr
,
82 lang_output_section_statement_type
*output
,
83 lang_input_statement_type
*file
));
84 static void wild_section
PARAMS ((lang_wild_statement_type
*ptr
,
86 lang_input_statement_type
*file
,
87 lang_output_section_statement_type
*output
));
88 static lang_input_statement_type
*lookup_name
PARAMS ((const char *name
));
89 static void load_symbols
PARAMS ((lang_input_statement_type
*entry
));
90 static void wild
PARAMS ((lang_wild_statement_type
*s
,
91 const char *section
, const char *file
,
93 lang_output_section_statement_type
*output
));
94 static bfd
*open_output
PARAMS ((const char *name
));
95 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*statement
));
96 static void open_input_bfds
PARAMS ((lang_statement_union_type
*statement
));
97 static void lang_reasonable_defaults
PARAMS ((void));
98 static void lang_place_undefineds
PARAMS ((void));
99 static void map_input_to_output_sections
100 PARAMS ((lang_statement_union_type
*s
,
102 lang_output_section_statement_type
*output_section_statement
));
103 static void print_output_section_statement
104 PARAMS ((lang_output_section_statement_type
*output_section_statement
));
105 static void print_assignment
106 PARAMS ((lang_assignment_statement_type
*assignment
,
107 lang_output_section_statement_type
*output_section
));
108 static void print_input_statement
PARAMS ((lang_input_statement_type
*statm
));
109 static void print_input_section
PARAMS ((lang_input_section_type
*in
));
110 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*fill
));
111 static void print_data_statement
PARAMS ((lang_data_statement_type
*data
));
112 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*reloc
));
113 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*s
));
114 static void print_wild_statement
115 PARAMS ((lang_wild_statement_type
*w
,
116 lang_output_section_statement_type
*os
));
117 static void print_statement
PARAMS ((lang_statement_union_type
*s
,
118 lang_output_section_statement_type
*os
));
119 static void print_statements
PARAMS ((void));
120 static bfd_vma insert_pad
PARAMS ((lang_statement_union_type
**this_ptr
,
121 fill_type fill
, unsigned int power
,
122 asection
*output_section_statement
,
124 static bfd_vma size_input_section
125 PARAMS ((lang_statement_union_type
**this_ptr
,
126 lang_output_section_statement_type
*output_section_statement
,
127 fill_type fill
, bfd_vma dot
, boolean relax
));
128 static bfd_vma lang_do_assignments
129 PARAMS ((lang_statement_union_type
* s
,
130 lang_output_section_statement_type
*output_section_statement
,
133 static void lang_finish
PARAMS ((void));
134 static void lang_check
PARAMS ((void));
135 static void lang_common
PARAMS ((void));
136 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
137 static void lang_place_orphans
PARAMS ((void));
138 static int topower
PARAMS ((int));
139 static void reset_memory_regions
PARAMS ((void));
142 lang_output_section_statement_type
*abs_output_section
;
143 lang_statement_list_type
*stat_ptr
= &statement_list
;
144 lang_statement_list_type file_chain
=
146 CONST
char *entry_symbol
= 0;
147 boolean lang_has_input_file
= false;
148 boolean had_output_filename
= false;
149 boolean lang_float_flag
= false;
150 boolean delete_output_file_on_failure
= false;
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))
171 return obstack_alloc (&stat_obstack
, size
);
178 fprintf (config
.map_file
, "%5x", (unsigned) value
);
182 print_alignment (value
)
185 fprintf (config
.map_file
, "2**%1u", value
);
192 fprintf (config
.map_file
, "%04x", (unsigned) value
);
199 fprintf (config
.map_file
, "%*s", -longest_section_name
, name
);
202 /*----------------------------------------------------------------------
203 lang_for_each_statement walks the parse tree and calls the provided
204 function for each node
208 lang_for_each_statement_worker (func
, s
)
209 void (*func
) PARAMS ((lang_statement_union_type
*));
210 lang_statement_union_type
*s
;
212 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
216 switch (s
->header
.type
)
218 case lang_constructors_statement_enum
:
219 lang_for_each_statement_worker (func
, constructor_list
.head
);
221 case lang_output_section_statement_enum
:
222 lang_for_each_statement_worker
224 s
->output_section_statement
.children
.head
);
226 case lang_wild_statement_enum
:
227 lang_for_each_statement_worker
229 s
->wild_statement
.children
.head
);
231 case lang_data_statement_enum
:
232 case lang_reloc_statement_enum
:
233 case lang_object_symbols_statement_enum
:
234 case lang_output_statement_enum
:
235 case lang_target_statement_enum
:
236 case lang_input_section_enum
:
237 case lang_input_statement_enum
:
238 case lang_assignment_statement_enum
:
239 case lang_padding_statement_enum
:
240 case lang_address_statement_enum
:
250 lang_for_each_statement (func
)
251 void (*func
) PARAMS ((lang_statement_union_type
*));
253 lang_for_each_statement_worker (func
,
254 statement_list
.head
);
257 /*----------------------------------------------------------------------*/
259 lang_list_init (list
)
260 lang_statement_list_type
*list
;
262 list
->head
= (lang_statement_union_type
*) NULL
;
263 list
->tail
= &list
->head
;
266 /*----------------------------------------------------------------------
268 build a new statement node for the parse tree
273 lang_statement_union_type
*
274 new_statement (type
, size
, list
)
275 enum statement_enum type
;
277 lang_statement_list_type
* list
;
279 lang_statement_union_type
*new = (lang_statement_union_type
*)
282 new->header
.type
= type
;
283 new->header
.next
= (lang_statement_union_type
*) NULL
;
284 lang_statement_append (list
, new, &new->header
.next
);
289 Build a new input file node for the language. There are several ways
290 in which we treat an input file, eg, we only look at symbols, or
291 prefix it with a -l etc.
293 We can be supplied with requests for input files more than once;
294 they may, for example be split over serveral lines like foo.o(.text)
295 foo.o(.data) etc, so when asked for a file we check that we havn't
296 got it already so we don't duplicate the bfd.
299 static lang_input_statement_type
*
300 new_afile (name
, file_type
, target
, add_to_list
)
302 lang_input_file_enum_type file_type
;
306 lang_input_statement_type
*p
;
309 p
= new_stat (lang_input_statement
, stat_ptr
);
312 p
= ((lang_input_statement_type
*)
313 stat_alloc (sizeof (lang_input_statement_type
)));
314 p
->header
.next
= NULL
;
317 lang_has_input_file
= true;
319 p
->complained
= false;
322 case lang_input_file_is_symbols_only_enum
:
324 p
->is_archive
= false;
326 p
->local_sym_name
= name
;
327 p
->just_syms_flag
= true;
328 p
->search_dirs_flag
= false;
330 case lang_input_file_is_fake_enum
:
332 p
->is_archive
= false;
334 p
->local_sym_name
= name
;
335 p
->just_syms_flag
= false;
336 p
->search_dirs_flag
= false;
338 case lang_input_file_is_l_enum
:
339 p
->is_archive
= true;
342 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
343 p
->just_syms_flag
= false;
344 p
->search_dirs_flag
= true;
346 case lang_input_file_is_marker_enum
:
348 p
->is_archive
= false;
350 p
->local_sym_name
= name
;
351 p
->just_syms_flag
= false;
352 p
->search_dirs_flag
= true;
354 case lang_input_file_is_search_file_enum
:
356 p
->is_archive
= false;
358 p
->local_sym_name
= name
;
359 p
->just_syms_flag
= false;
360 p
->search_dirs_flag
= true;
362 case lang_input_file_is_file_enum
:
364 p
->is_archive
= false;
366 p
->local_sym_name
= name
;
367 p
->just_syms_flag
= false;
368 p
->search_dirs_flag
= false;
373 p
->the_bfd
= (bfd
*) NULL
;
374 p
->asymbols
= (asymbol
**) NULL
;
375 p
->superfile
= (lang_input_statement_type
*) NULL
;
376 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
377 p
->next
= (lang_statement_union_type
*) NULL
;
379 p
->common_output_section
= (asection
*) NULL
;
381 lang_statement_append (&input_file_chain
,
382 (lang_statement_union_type
*) p
,
387 lang_input_statement_type
*
388 lang_add_input_file (name
, file_type
, target
)
390 lang_input_file_enum_type file_type
;
393 /* Look it up or build a new one */
394 lang_has_input_file
= true;
397 lang_input_statement_type
*p
;
399 for (p
= (lang_input_statement_type
*) input_file_chain
.head
;
400 p
!= (lang_input_statement_type
*) NULL
;
401 p
= (lang_input_statement_type
*) (p
->next_real_file
))
403 /* Sometimes we have incomplete entries in here */
404 if (p
->filename
!= (char *) NULL
)
406 if (strcmp (name
, p
->filename
) == 0)
412 return new_afile (name
, file_type
, target
, true);
415 /* Build enough state so that the parser can build its tree */
419 obstack_begin (&stat_obstack
, 1000);
421 stat_ptr
= &statement_list
;
423 lang_list_init (stat_ptr
);
425 lang_list_init (&input_file_chain
);
426 lang_list_init (&lang_output_section_statement
);
427 lang_list_init (&file_chain
);
428 first_file
= lang_add_input_file ((char *) NULL
,
429 lang_input_file_is_marker_enum
,
431 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
433 abs_output_section
->bfd_section
= &bfd_abs_section
;
437 /*----------------------------------------------------------------------
438 A region is an area of memory declared with the
439 MEMORY { name:org=exp, len=exp ... }
442 We maintain a list of all the regions here
444 If no regions are specified in the script, then the default is used
445 which is created when looked up to be the entire data space
448 static lang_memory_region_type
*lang_memory_region_list
;
449 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
451 lang_memory_region_type
*
452 lang_memory_region_lookup (name
)
453 CONST
char *CONST name
;
456 lang_memory_region_type
*p
= lang_memory_region_list
;
458 for (p
= lang_memory_region_list
;
459 p
!= (lang_memory_region_type
*) NULL
;
462 if (strcmp (p
->name
, name
) == 0)
467 if (strcmp (name
, "*default*") == 0)
469 /* This is the default region, dig out first one on the list */
470 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
472 return lang_memory_region_list
;
476 lang_memory_region_type
*new =
477 (lang_memory_region_type
*) stat_alloc ((bfd_size_type
) (sizeof (lang_memory_region_type
)));
479 new->name
= buystring (name
);
480 new->next
= (lang_memory_region_type
*) NULL
;
482 *lang_memory_region_list_tail
= new;
483 lang_memory_region_list_tail
= &new->next
;
485 new->length
= ~(bfd_size_type
)0;
487 new->had_full_message
= false;
494 lang_output_section_statement_type
*
495 lang_output_section_find (name
)
496 CONST
char *CONST name
;
498 lang_statement_union_type
*u
;
499 lang_output_section_statement_type
*lookup
;
501 for (u
= lang_output_section_statement
.head
;
502 u
!= (lang_statement_union_type
*) NULL
;
505 lookup
= &u
->output_section_statement
;
506 if (strcmp (name
, lookup
->name
) == 0)
511 return (lang_output_section_statement_type
*) NULL
;
514 lang_output_section_statement_type
*
515 lang_output_section_statement_lookup (name
)
516 CONST
char *CONST name
;
518 lang_output_section_statement_type
*lookup
;
520 lookup
= lang_output_section_find (name
);
521 if (lookup
== (lang_output_section_statement_type
*) NULL
)
524 lookup
= (lang_output_section_statement_type
*)
525 new_stat (lang_output_section_statement
, stat_ptr
);
526 lookup
->region
= (lang_memory_region_type
*) NULL
;
528 lookup
->block_value
= 1;
531 lookup
->next
= (lang_statement_union_type
*) NULL
;
532 lookup
->bfd_section
= (asection
*) NULL
;
533 lookup
->processed
= false;
534 lookup
->loadable
= 1;
535 lookup
->addr_tree
= (etree_type
*) NULL
;
536 lang_list_init (&lookup
->children
);
538 lookup
->memspec
= (CONST
char *) NULL
;
540 lookup
->subsection_alignment
= -1;
541 lookup
->section_alignment
= -1;
542 lookup
->load_base
= (union etree_union
*) NULL
;
544 lang_statement_append (&lang_output_section_statement
,
545 (lang_statement_union_type
*) lookup
,
553 print_flags (ignore_flags
)
556 fprintf (config
.map_file
, "(");
558 if (flags
->flag_read
)
559 fprintf (outfile
, "R");
560 if (flags
->flag_write
)
561 fprintf (outfile
, "W");
562 if (flags
->flag_executable
)
563 fprintf (outfile
, "X");
564 if (flags
->flag_loadable
)
565 fprintf (outfile
, "L");
567 fprintf (config
.map_file
, ")");
573 lang_memory_region_type
*m
;
575 fprintf (config
.map_file
, "**MEMORY CONFIGURATION**\n\n");
577 fprintf (config
.map_file
, "name\t\torigin\t\tlength\t\tattributes\n");
579 fprintf (config
.map_file
,
580 "name\t\torigin length r_size c_size is attributes\n");
583 for (m
= lang_memory_region_list
;
584 m
!= (lang_memory_region_type
*) NULL
;
587 fprintf (config
.map_file
, "%-16s", m
->name
);
588 print_address (m
->origin
);
590 print_address ((bfd_vma
)m
->length
);
592 print_address ((bfd_vma
)m
->old_length
);
594 print_address (m
->current
- m
->origin
);
597 fprintf (config
.map_file
, " %2d%% ",
598 (int) ((m
->current
- m
->origin
) * 100 / m
->old_length
));
599 print_flags (&m
->flags
);
600 fprintf (config
.map_file
, "\n");
602 fprintf (config
.map_file
, "\n\n**LINK EDITOR MEMORY MAP**\n\n");
603 fprintf (config
.map_file
, "output input virtual\n");
604 fprintf (config
.map_file
, "section section address tsize\n\n");
615 lang_output_section_statement_type
* s
;
617 /* asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
618 section_userdata_type
*new =
619 (section_userdata_type
*)
620 stat_alloc ((bfd_size_type
) (sizeof (section_userdata_type
)));
622 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
623 if (s
->bfd_section
== (asection
*) NULL
)
624 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
625 if (s
->bfd_section
== (asection
*) NULL
)
627 einfo ("%P%F: output format %s cannot represent section called %s\n",
628 output_bfd
->xvec
->name
, s
->name
);
630 s
->bfd_section
->output_section
= s
->bfd_section
;
631 /* s->bfd_section->flags = s->flags;*/
633 /* We initialize an output sections output offset to minus its own */
634 /* vma to allow us to output a section through itself */
635 s
->bfd_section
->output_offset
= 0;
636 get_userdata (s
->bfd_section
) = (PTR
) new;
640 /***********************************************************************
643 These expand statements like *(.text) and foo.o to a list of
644 explicit actions, like foo.o(.text), bar.o(.text) and
647 The toplevel routine, wild, takes a statement, section, file and
648 target. If either the section or file is null it is taken to be the
649 wildcard. Seperate lang_input_section statements are created for
650 each part of the expanstion, and placed after the statement provided.
655 wild_doit (ptr
, section
, output
, file
)
656 lang_statement_list_type
* ptr
;
658 lang_output_section_statement_type
* output
;
659 lang_input_statement_type
* file
;
661 if (output
->bfd_section
== (asection
*) NULL
)
664 if (section
!= (asection
*) NULL
665 && section
->output_section
== (asection
*) NULL
)
667 /* Add a section reference to the list */
668 lang_input_section_type
*new = new_stat (lang_input_section
, ptr
);
670 new->section
= section
;
672 section
->output_section
= output
->bfd_section
;
674 /* We don't copy the SEC_NEVER_LOAD flag from an input section to
675 an output section, because we want to be able to include a
676 SEC_NEVER_LOAD section in the middle of an otherwise loaded
677 section (I don't know why we want to do this, but we do).
678 build_link_order in ldwrite.c handles this case by turning the
679 embedded SEC_NEVER_LOAD section into a fill. */
680 section
->output_section
->flags
|=
681 section
->flags
& (flagword
) (~ SEC_NEVER_LOAD
);
683 if (!output
->loadable
)
685 /* Turn off load flag */
686 output
->bfd_section
->flags
&= ~SEC_LOAD
;
687 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
689 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
691 output
->bfd_section
->alignment_power
= section
->alignment_power
;
693 /* If supplied an aligmnet, then force it */
694 if (output
->section_alignment
!= -1)
696 output
->bfd_section
->alignment_power
= output
->section_alignment
;
702 wild_section (ptr
, section
, file
, output
)
703 lang_wild_statement_type
* ptr
;
705 lang_input_statement_type
* file
;
706 lang_output_section_statement_type
* output
;
710 if (file
->just_syms_flag
== false)
712 if (section
== (char *) NULL
)
714 /* Do the creation to all sections in the file */
715 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
718 if ((s
->flags
& SEC_IS_COMMON
) == 0)
720 wild_doit (&ptr
->children
, s
, output
, file
);
726 /* Do the creation to the named section only */
727 s
= bfd_get_section_by_name (file
->the_bfd
, section
);
729 wild_doit (&ptr
->children
, s
, output
, file
);
734 /* passed a file name (which must have been seen already and added to
735 the statement tree. We will see if it has been opened already and
736 had its symbols read. If not then we'll read it.
738 Archives are pecuilar here. We may open them once, but if they do
739 not define anything we need at the time, they won't have all their
740 symbols read. If we need them later, we'll have to redo it.
742 static lang_input_statement_type
*
746 lang_input_statement_type
*search
;
748 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
749 search
!= (lang_input_statement_type
*) NULL
;
750 search
= (lang_input_statement_type
*) search
->next_real_file
)
752 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
754 if (search
->filename
!= (char *) NULL
755 && name
!= (char *) NULL
756 && strcmp (search
->filename
, name
) == 0)
760 if (search
== (lang_input_statement_type
*) NULL
)
761 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
764 /* If we have already added this file, or this file is not real
765 (FIXME: can that ever actually happen?) or the name is NULL
766 (FIXME: can that ever actually happen?) don't add this file. */
769 || search
->filename
== (const char *) NULL
)
772 load_symbols (search
);
777 /* Get the symbols for an input file. */
781 lang_input_statement_type
*entry
;
786 ldfile_open_file (entry
);
788 if (bfd_check_format (entry
->the_bfd
, bfd_object
))
790 ldlang_add_file (entry
);
791 if (trace_files
|| trace_file_tries
)
792 info_msg ("%I\n", entry
);
794 else if (bfd_check_format (entry
->the_bfd
, bfd_archive
))
796 /* There is nothing to do here; the add_symbols routine will
797 call ldlang_add_file (via the add_archive_element callback)
798 for each element of the archive which is used. */
801 einfo ("%F%B: file not recognized: %E\n", entry
->the_bfd
);
803 if (bfd_link_add_symbols (entry
->the_bfd
, &link_info
) == false)
804 einfo ("%F%B: could not read symbols: %E\n", entry
->the_bfd
);
806 entry
->loaded
= true;
810 wild (s
, section
, file
, target
, output
)
811 lang_wild_statement_type
* s
;
815 lang_output_section_statement_type
* output
;
817 lang_input_statement_type
*f
;
819 if (file
== (char *) NULL
)
821 /* Perform the iteration over all files in the list */
822 for (f
= (lang_input_statement_type
*) file_chain
.head
;
823 f
!= (lang_input_statement_type
*) NULL
;
824 f
= (lang_input_statement_type
*) f
->next
)
826 wild_section (s
, section
, f
, output
);
831 /* Perform the iteration over a single file */
832 wild_section (s
, section
, lookup_name (file
), output
);
834 if (section
!= (char *) NULL
835 && strcmp (section
, "COMMON") == 0
836 && default_common_section
== (lang_output_section_statement_type
*) NULL
)
838 /* Remember the section that common is going to incase we later
839 get something which doesn't know where to put it */
840 default_common_section
= output
;
845 read in all the files
854 if (output_target
== (char *) NULL
)
856 if (current_target
!= (char *) NULL
)
857 output_target
= current_target
;
859 output_target
= default_target
;
861 output
= bfd_openw (name
, output_target
);
863 if (output
== (bfd
*) NULL
)
865 if (bfd_get_error () == bfd_error_invalid_target
)
867 einfo ("%P%F: target %s not found\n", output_target
);
869 einfo ("%P%F: cannot open output file %s: %E\n", name
);
872 delete_output_file_on_failure
= 1;
874 /* output->flags |= D_PAGED;*/
876 if (! bfd_set_format (output
, bfd_object
))
877 einfo ("%P%F:%s: can not make object file: %E\n", name
);
878 if (! bfd_set_arch_mach (output
,
879 ldfile_output_architecture
,
880 ldfile_output_machine
))
881 einfo ("%P%F:%s: can not set architecture: %E\n", name
);
883 link_info
.hash
= bfd_link_hash_table_create (output
);
884 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
885 einfo ("%P%F: can not create link hash table: %E\n");
887 bfd_set_gp_size (output
, g_switch_value
);
895 ldlang_open_output (statement
)
896 lang_statement_union_type
* statement
;
898 switch (statement
->header
.type
)
900 case lang_output_statement_enum
:
901 ASSERT (output_bfd
== (bfd
*) NULL
);
902 output_bfd
= open_output (statement
->output_statement
.name
);
903 ldemul_set_output_arch ();
904 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
905 output_bfd
->flags
|= D_PAGED
;
907 output_bfd
->flags
&= ~D_PAGED
;
908 if (config
.text_read_only
)
909 output_bfd
->flags
|= WP_TEXT
;
911 output_bfd
->flags
&= ~WP_TEXT
;
914 case lang_target_statement_enum
:
915 current_target
= statement
->target_statement
.target
;
923 open_input_bfds (statement
)
924 lang_statement_union_type
* statement
;
926 switch (statement
->header
.type
)
928 case lang_target_statement_enum
:
929 current_target
= statement
->target_statement
.target
;
931 case lang_wild_statement_enum
:
932 /* Maybe we should load the file's symbols */
933 if (statement
->wild_statement
.filename
)
935 (void) lookup_name (statement
->wild_statement
.filename
);
938 case lang_input_statement_enum
:
939 if (statement
->input_statement
.real
== true)
941 statement
->input_statement
.target
= current_target
;
942 load_symbols (&statement
->input_statement
);
950 /* If there are [COMMONS] statements, put a wild one into the bss section */
953 lang_reasonable_defaults ()
956 lang_output_section_statement_lookup (".text");
957 lang_output_section_statement_lookup (".data");
959 default_common_section
=
960 lang_output_section_statement_lookup (".bss");
963 if (placed_commons
== false)
965 lang_wild_statement_type
*new =
966 new_stat (lang_wild_statement
,
967 &default_common_section
->children
);
969 new->section_name
= "COMMON";
970 new->filename
= (char *) NULL
;
971 lang_list_init (&new->children
);
978 Add the supplied name to the symbol table as an undefined reference.
979 Remove items from the chain as we open input bfds
981 typedef struct ldlang_undef_chain_list
983 struct ldlang_undef_chain_list
*next
;
985 } ldlang_undef_chain_list_type
;
987 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
990 ldlang_add_undef (name
)
991 CONST
char *CONST name
;
993 ldlang_undef_chain_list_type
*new =
994 (ldlang_undef_chain_list_type
995 *) stat_alloc ((bfd_size_type
) (sizeof (ldlang_undef_chain_list_type
)));
997 new->next
= ldlang_undef_chain_list_head
;
998 ldlang_undef_chain_list_head
= new;
1000 new->name
= buystring (name
);
1003 /* Run through the list of undefineds created above and place them
1004 into the linker hash table as undefined symbols belonging to the
1008 lang_place_undefineds ()
1010 ldlang_undef_chain_list_type
*ptr
;
1012 for (ptr
= ldlang_undef_chain_list_head
;
1013 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
1016 struct bfd_link_hash_entry
*h
;
1018 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
1019 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1020 einfo ("%P%F: bfd_link_hash_lookup failed: %E");
1021 if (h
->type
== bfd_link_hash_new
)
1023 h
->type
= bfd_link_hash_undefined
;
1024 h
->u
.undef
.abfd
= NULL
;
1025 bfd_link_add_undef (link_info
.hash
, h
);
1030 /* Open input files and attatch to output sections */
1032 map_input_to_output_sections (s
, target
, output_section_statement
)
1033 lang_statement_union_type
* s
;
1035 lang_output_section_statement_type
* output_section_statement
;
1037 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1039 switch (s
->header
.type
)
1043 case lang_wild_statement_enum
:
1044 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1045 s
->wild_statement
.filename
, target
,
1046 output_section_statement
);
1049 case lang_constructors_statement_enum
:
1050 map_input_to_output_sections (constructor_list
.head
,
1052 output_section_statement
);
1054 case lang_output_section_statement_enum
:
1055 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1057 &s
->output_section_statement
);
1059 case lang_output_statement_enum
:
1061 case lang_target_statement_enum
:
1062 target
= s
->target_statement
.target
;
1064 case lang_fill_statement_enum
:
1065 case lang_input_section_enum
:
1066 case lang_object_symbols_statement_enum
:
1067 case lang_data_statement_enum
:
1068 case lang_reloc_statement_enum
:
1069 case lang_assignment_statement_enum
:
1070 case lang_padding_statement_enum
:
1071 case lang_input_statement_enum
:
1072 if (output_section_statement
!= NULL
1073 && output_section_statement
->bfd_section
== NULL
)
1074 init_os (output_section_statement
);
1076 case lang_afile_asection_pair_statement_enum
:
1079 case lang_address_statement_enum
:
1080 /* Mark the specified section with the supplied address */
1082 lang_output_section_statement_type
*os
=
1083 lang_output_section_statement_lookup
1084 (s
->address_statement
.section_name
);
1086 os
->addr_tree
= s
->address_statement
.address
;
1087 if (os
->bfd_section
== (asection
*) NULL
)
1089 einfo ("%P%F: cannot set the address of undefined section %s\n",
1090 s
->address_statement
.section_name
);
1099 print_output_section_statement (output_section_statement
)
1100 lang_output_section_statement_type
* output_section_statement
;
1102 asection
*section
= output_section_statement
->bfd_section
;
1105 print_section (output_section_statement
->name
);
1110 print_dot
= section
->vma
;
1114 print_address (section
->vma
);
1116 print_size (section
->_raw_size
);
1118 print_size(section
->_cooked_size
);
1120 print_alignment (section
->alignment_power
);
1123 fprintf (config
.map_file
, "%s flags", output_section_statement
->region
->name
);
1124 print_flags (stdout
, &output_section_statement
->flags
);
1126 if (section
->flags
& SEC_LOAD
)
1127 fprintf (config
.map_file
, "load ");
1128 if (section
->flags
& SEC_ALLOC
)
1129 fprintf (config
.map_file
, "alloc ");
1130 if (section
->flags
& SEC_RELOC
)
1131 fprintf (config
.map_file
, "reloc ");
1132 if (section
->flags
& SEC_HAS_CONTENTS
)
1133 fprintf (config
.map_file
, "contents ");
1138 fprintf (config
.map_file
, "No attached output section");
1141 if (output_section_statement
->load_base
)
1143 int b
= exp_get_value_int(output_section_statement
->load_base
,
1144 0, "output base", lang_final_phase_enum
);
1145 printf("Output address %08x\n", b
);
1147 if (output_section_statement
->section_alignment
>= 0
1148 || output_section_statement
->section_alignment
>= 0)
1150 printf("\t\t\t\t\tforced alignment ");
1151 if ( output_section_statement
->section_alignment
>= 0)
1153 printf("section 2**%d ",output_section_statement
->section_alignment
);
1155 if ( output_section_statement
->subsection_alignment
>= 0)
1157 printf("subsection 2**%d ",output_section_statement
->subsection_alignment
);
1162 print_statement (output_section_statement
->children
.head
,
1163 output_section_statement
);
1168 print_assignment (assignment
, output_section
)
1169 lang_assignment_statement_type
* assignment
;
1170 lang_output_section_statement_type
* output_section
;
1172 etree_value_type result
;
1178 print_address (print_dot
);
1180 result
= exp_fold_tree (assignment
->exp
->assign
.src
,
1182 lang_final_phase_enum
,
1188 print_address (result
.value
);
1192 fprintf (config
.map_file
, "*undefined*");
1195 exp_print_tree (assignment
->exp
);
1197 fprintf (config
.map_file
, "\n");
1201 print_input_statement (statm
)
1202 lang_input_statement_type
* statm
;
1204 if (statm
->filename
!= (char *) NULL
)
1206 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1210 /* Print all the defined symbols for the abfd provided by in the supplied
1215 print_one_symbol (hash_entry
, ptr
)
1216 struct bfd_link_hash_entry
*hash_entry
;
1219 asection
* sec
= (asection
*)ptr
;
1221 if (hash_entry
->type
== bfd_link_hash_defined
)
1223 if (sec
== hash_entry
->u
.def
.section
) {
1225 fprintf (config
.map_file
, " ");
1227 fprintf (config
.map_file
, " ");
1228 print_address (hash_entry
->u
.def
.value
+ outside_section_address (sec
));
1229 fprintf (config
.map_file
, " %s", hash_entry
->root
.string
);
1238 print_input_section (in
)
1239 lang_input_section_type
* in
;
1241 asection
*i
= in
->section
;
1242 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
1247 fprintf (config
.map_file
, " ");
1248 print_section (i
->name
);
1249 fprintf (config
.map_file
, " ");
1250 if (i
->output_section
)
1252 print_address (i
->output_section
->vma
+ i
->output_offset
);
1253 fprintf (config
.map_file
, " ");
1254 print_size (i
->_raw_size
);
1255 fprintf (config
.map_file
, " ");
1256 print_size(i
->_cooked_size
);
1257 fprintf (config
.map_file
, " ");
1258 print_alignment (i
->alignment_power
);
1259 fprintf (config
.map_file
, " ");
1263 bfd
*abfd
= in
->ifile
->the_bfd
;
1265 if (in
->ifile
->just_syms_flag
== true)
1267 fprintf (config
.map_file
, "symbols only ");
1270 fprintf (config
.map_file
, " %s ", abfd
->xvec
->name
);
1271 if (abfd
->my_archive
!= (bfd
*) NULL
)
1273 fprintf (config
.map_file
, "[%s]%s", abfd
->my_archive
->filename
,
1278 fprintf (config
.map_file
, "%s", abfd
->filename
);
1280 fprintf (config
.map_file
, "(overhead %d bytes)", (int) bfd_alloc_size (abfd
));
1283 /* Print all the symbols */
1284 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
1292 print_dot
= outside_section_address (i
) + size
;
1296 fprintf (config
.map_file
, "No output section allocated\n");
1302 print_fill_statement (fill
)
1303 lang_fill_statement_type
* fill
;
1305 fprintf (config
.map_file
, "FILL mask ");
1306 print_fill (fill
->fill
);
1310 print_data_statement (data
)
1311 lang_data_statement_type
* data
;
1313 /* bfd_vma value; */
1318 /* ASSERT(print_dot == data->output_vma);*/
1320 print_address (data
->output_vma
+ data
->output_section
->vma
);
1322 print_address (data
->value
);
1327 fprintf (config
.map_file
, "BYTE ");
1328 print_dot
+= BYTE_SIZE
;
1331 fprintf (config
.map_file
, "SHORT ");
1332 print_dot
+= SHORT_SIZE
;
1335 fprintf (config
.map_file
, "LONG ");
1336 print_dot
+= LONG_SIZE
;
1339 fprintf (config
.map_file
, "QUAD ");
1340 print_dot
+= QUAD_SIZE
;
1344 exp_print_tree (data
->exp
);
1346 fprintf (config
.map_file
, "\n");
1349 /* Print a reloc statement. */
1352 print_reloc_statement (reloc
)
1353 lang_reloc_statement_type
*reloc
;
1360 /* ASSERT(print_dot == data->output_vma);*/
1362 print_address (reloc
->output_vma
+ reloc
->output_section
->vma
);
1364 print_address (reloc
->addend_value
);
1367 fprintf (config
.map_file
, "RELOC %s ", reloc
->howto
->name
);
1369 print_dot
+= bfd_get_reloc_size (reloc
->howto
);
1371 exp_print_tree (reloc
->addend_exp
);
1373 fprintf (config
.map_file
, "\n");
1377 print_padding_statement (s
)
1378 lang_padding_statement_type
* s
;
1382 print_section ("*fill*");
1384 print_address (s
->output_offset
+ s
->output_section
->vma
);
1386 print_size (s
->size
);
1388 print_fill (s
->fill
);
1391 print_dot
= s
->output_offset
+ s
->output_section
->vma
+ s
->size
;
1396 print_wild_statement (w
, os
)
1397 lang_wild_statement_type
* w
;
1398 lang_output_section_statement_type
* os
;
1400 fprintf (config
.map_file
, " from ");
1401 if (w
->filename
!= (char *) NULL
)
1403 fprintf (config
.map_file
, "%s", w
->filename
);
1407 fprintf (config
.map_file
, "*");
1409 if (w
->section_name
!= (char *) NULL
)
1411 fprintf (config
.map_file
, "(%s)", w
->section_name
);
1415 fprintf (config
.map_file
, "(*)");
1418 print_statement (w
->children
.head
, os
);
1422 print_statement (s
, os
)
1423 lang_statement_union_type
* s
;
1424 lang_output_section_statement_type
* os
;
1428 switch (s
->header
.type
)
1430 case lang_constructors_statement_enum
:
1431 fprintf (config
.map_file
, "constructors:\n");
1432 print_statement (constructor_list
.head
, os
);
1434 case lang_wild_statement_enum
:
1435 print_wild_statement (&s
->wild_statement
, os
);
1438 fprintf (config
.map_file
, "Fail with %d\n", s
->header
.type
);
1441 case lang_address_statement_enum
:
1442 fprintf (config
.map_file
, "address\n");
1444 case lang_object_symbols_statement_enum
:
1445 fprintf (config
.map_file
, "object symbols\n");
1447 case lang_fill_statement_enum
:
1448 print_fill_statement (&s
->fill_statement
);
1450 case lang_data_statement_enum
:
1451 print_data_statement (&s
->data_statement
);
1453 case lang_reloc_statement_enum
:
1454 print_reloc_statement (&s
->reloc_statement
);
1456 case lang_input_section_enum
:
1457 print_input_section (&s
->input_section
);
1459 case lang_padding_statement_enum
:
1460 print_padding_statement (&s
->padding_statement
);
1462 case lang_output_section_statement_enum
:
1463 print_output_section_statement (&s
->output_section_statement
);
1465 case lang_assignment_statement_enum
:
1466 print_assignment (&s
->assignment_statement
,
1469 case lang_target_statement_enum
:
1470 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1472 case lang_output_statement_enum
:
1473 fprintf (config
.map_file
, "OUTPUT(%s %s)\n",
1474 s
->output_statement
.name
,
1475 output_target
? output_target
: "");
1477 case lang_input_statement_enum
:
1478 print_input_statement (&s
->input_statement
);
1480 case lang_afile_asection_pair_statement_enum
:
1492 print_statement (statement_list
.head
,
1493 abs_output_section
);
1498 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
1499 lang_statement_union_type
** this_ptr
;
1502 asection
* output_section_statement
;
1505 /* Align this section first to the
1506 input sections requirement, then
1507 to the output section's requirement.
1508 If this alignment is > than any seen before,
1509 then record it too. Perform the alignment by
1510 inserting a magic 'padding' statement.
1513 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
1515 if (alignment_needed
!= 0)
1517 lang_statement_union_type
*new =
1518 (lang_statement_union_type
*)
1519 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1521 /* Link into existing chain */
1522 new->header
.next
= *this_ptr
;
1524 new->header
.type
= lang_padding_statement_enum
;
1525 new->padding_statement
.output_section
= output_section_statement
;
1526 new->padding_statement
.output_offset
=
1527 dot
- output_section_statement
->vma
;
1528 new->padding_statement
.fill
= fill
;
1529 new->padding_statement
.size
= alignment_needed
;
1533 /* Remember the most restrictive alignment */
1534 if (power
> output_section_statement
->alignment_power
)
1536 output_section_statement
->alignment_power
= power
;
1538 output_section_statement
->_raw_size
+= alignment_needed
;
1539 return alignment_needed
+ dot
;
1543 /* Work out how much this section will move the dot point */
1545 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
1546 lang_statement_union_type
** this_ptr
;
1547 lang_output_section_statement_type
* output_section_statement
;
1552 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1553 asection
*i
= is
->section
;
1555 if (is
->ifile
->just_syms_flag
== false)
1557 if (output_section_statement
->subsection_alignment
!= -1)
1558 i
->alignment_power
=
1559 output_section_statement
->subsection_alignment
;
1561 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
1562 output_section_statement
->bfd_section
, dot
);
1564 /* Remember where in the output section this input section goes */
1566 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1568 /* Mark how big the output section must be to contain this now
1570 if (i
->_cooked_size
!= 0)
1571 dot
+= i
->_cooked_size
;
1573 dot
+= i
->_raw_size
;
1574 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
1578 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
1584 /* This variable indicates whether bfd_relax_section should be called
1587 static boolean relax_again
;
1589 /* Set the sizes for all the output sections. */
1592 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
1593 lang_statement_union_type
* s
;
1594 lang_output_section_statement_type
* output_section_statement
;
1595 lang_statement_union_type
** prev
;
1600 /* Size up the sections from their constituent parts */
1601 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1603 switch (s
->header
.type
)
1606 case lang_output_section_statement_enum
:
1609 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
1611 if (os
->bfd_section
== NULL
)
1613 /* This section was never actually created. */
1617 /* If this is a COFF shared library section, use the size and
1618 address from the input section. FIXME: This is COFF
1619 specific; it would be cleaner if there were some other way
1620 to do this, but nothing simple comes to mind. */
1621 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
1625 if (os
->children
.head
== NULL
1626 || os
->children
.head
->next
!= NULL
1627 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
1628 einfo ("%P%X: Internal error on COFF shared library section %s",
1631 input
= os
->children
.head
->input_section
.section
;
1632 bfd_set_section_vma (os
->bfd_section
->owner
,
1634 bfd_section_vma (input
->owner
, input
));
1635 os
->bfd_section
->_raw_size
= input
->_raw_size
;
1639 if (os
->bfd_section
== &bfd_abs_section
)
1641 /* No matter what happens, an abs section starts at zero */
1642 bfd_set_section_vma (0, os
->bfd_section
, 0);
1646 if (os
->addr_tree
== (etree_type
*) NULL
)
1648 /* No address specified for this section, get one
1649 from the region specification
1651 if (os
->region
== (lang_memory_region_type
*) NULL
)
1653 os
->region
= lang_memory_region_lookup ("*default*");
1655 dot
= os
->region
->current
;
1656 if (os
->section_alignment
== -1)
1657 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
1663 r
= exp_fold_tree (os
->addr_tree
,
1665 lang_allocating_phase_enum
,
1667 if (r
.valid
== false)
1669 einfo ("%F%S: non constant address expression for section %s\n",
1674 /* The section starts here */
1675 /* First, align to what the section needs */
1677 if (os
->section_alignment
!= -1)
1678 dot
= align_power (dot
, os
->section_alignment
);
1680 bfd_set_section_vma (0, os
->bfd_section
, dot
);
1682 if (os
->load_base
) {
1683 os
->bfd_section
->lma
1684 = exp_get_value_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
1689 os
->bfd_section
->output_offset
= 0;
1691 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
1692 os
->fill
, dot
, relax
);
1693 /* Ignore the size of the input sections, use the vma and size to */
1696 after
= ALIGN_N (os
->bfd_section
->vma
+
1697 os
->bfd_section
->_raw_size
,
1698 /* The coercion here is important, see ld.h. */
1699 (bfd_vma
) os
->block_value
);
1701 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
1702 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1703 os
->processed
= true;
1705 /* Replace into region ? */
1706 if (os
->addr_tree
== (etree_type
*) NULL
1707 && os
->region
!= (lang_memory_region_type
*) NULL
)
1709 os
->region
->current
= dot
;
1710 /* Make sure this isn't silly */
1711 if (( os
->region
->current
1712 > os
->region
->origin
+ os
->region
->length
)
1713 || ( os
->region
->origin
> os
->region
->current
))
1715 einfo ("%X%P: region %s is full (%B section %s)\n",
1717 os
->bfd_section
->owner
,
1718 os
->bfd_section
->name
);
1719 /* Reset the region pointer */
1720 os
->region
->current
= 0;
1728 case lang_constructors_statement_enum
:
1729 dot
= lang_size_sections (constructor_list
.head
,
1730 output_section_statement
,
1731 &s
->wild_statement
.children
.head
,
1736 case lang_data_statement_enum
:
1738 unsigned int size
= 0;
1740 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1741 s
->data_statement
.output_section
=
1742 output_section_statement
->bfd_section
;
1744 switch (s
->data_statement
.type
)
1761 output_section_statement
->bfd_section
->_raw_size
+= size
;
1765 case lang_reloc_statement_enum
:
1769 s
->reloc_statement
.output_vma
=
1770 dot
- output_section_statement
->bfd_section
->vma
;
1771 s
->reloc_statement
.output_section
=
1772 output_section_statement
->bfd_section
;
1773 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
1775 output_section_statement
->bfd_section
->_raw_size
+= size
;
1779 case lang_wild_statement_enum
:
1781 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
1782 output_section_statement
,
1783 &s
->wild_statement
.children
.head
,
1789 case lang_object_symbols_statement_enum
:
1790 link_info
.create_object_symbols_section
=
1791 output_section_statement
->bfd_section
;
1793 case lang_output_statement_enum
:
1794 case lang_target_statement_enum
:
1796 case lang_input_section_enum
:
1800 i
= (*prev
)->input_section
.section
;
1802 i
->_cooked_size
= i
->_raw_size
;
1807 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
1808 einfo ("%P%F: can't relax section: %E\n");
1812 dot
= size_input_section (prev
,
1813 output_section_statement
,
1814 output_section_statement
->fill
,
1818 case lang_input_statement_enum
:
1820 case lang_fill_statement_enum
:
1821 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
1823 fill
= s
->fill_statement
.fill
;
1825 case lang_assignment_statement_enum
:
1827 bfd_vma newdot
= dot
;
1829 exp_fold_tree (s
->assignment_statement
.exp
,
1830 output_section_statement
,
1831 lang_allocating_phase_enum
,
1835 if (newdot
!= dot
&& !relax
)
1837 /* The assignment changed dot. Insert a pad. */
1838 if (output_section_statement
== abs_output_section
)
1840 /* If we don't have an output section, then just adjust
1841 the default memory address. */
1842 lang_memory_region_lookup ("*default*")->current
= newdot
;
1846 lang_statement_union_type
*new =
1847 ((lang_statement_union_type
*)
1848 stat_alloc (sizeof (lang_padding_statement_type
)));
1850 /* Link into existing chain */
1851 new->header
.next
= *prev
;
1853 new->header
.type
= lang_padding_statement_enum
;
1854 new->padding_statement
.output_section
=
1855 output_section_statement
->bfd_section
;
1856 new->padding_statement
.output_offset
=
1857 dot
- output_section_statement
->bfd_section
->vma
;
1858 new->padding_statement
.fill
= fill
;
1859 new->padding_statement
.size
= newdot
- dot
;
1860 output_section_statement
->bfd_section
->_raw_size
+=
1861 new->padding_statement
.size
;
1869 case lang_padding_statement_enum
:
1870 /* If we are relaxing, and this is not the first pass, some
1871 padding statements may have been inserted during previous
1872 passes. We may have to move the padding statement to a new
1873 location if dot has a different value at this point in this
1874 pass than it did at this point in the previous pass. */
1875 s
->padding_statement
.output_offset
=
1876 dot
- output_section_statement
->bfd_section
->vma
;
1877 dot
+= s
->padding_statement
.size
;
1884 /* This can only get here when relaxing is turned on */
1886 case lang_address_statement_enum
:
1889 prev
= &s
->header
.next
;
1895 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
1896 lang_statement_union_type
* s
;
1897 lang_output_section_statement_type
* output_section_statement
;
1901 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1903 switch (s
->header
.type
)
1905 case lang_constructors_statement_enum
:
1906 dot
= lang_do_assignments (constructor_list
.head
,
1907 output_section_statement
,
1912 case lang_output_section_statement_enum
:
1914 lang_output_section_statement_type
*os
=
1915 &(s
->output_section_statement
);
1917 dot
= os
->bfd_section
->vma
;
1918 (void) lang_do_assignments (os
->children
.head
, os
, os
->fill
, dot
);
1919 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1922 case lang_wild_statement_enum
:
1924 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
1925 output_section_statement
,
1930 case lang_object_symbols_statement_enum
:
1931 case lang_output_statement_enum
:
1932 case lang_target_statement_enum
:
1934 case lang_common_statement_enum
:
1937 case lang_data_statement_enum
:
1939 etree_value_type value
;
1941 value
= exp_fold_tree (s
->data_statement
.exp
,
1943 lang_final_phase_enum
, dot
, &dot
);
1944 s
->data_statement
.value
= value
.value
;
1945 if (value
.valid
== false)
1946 einfo ("%F%P: invalid data statement\n");
1948 switch (s
->data_statement
.type
)
1965 case lang_reloc_statement_enum
:
1967 etree_value_type value
;
1969 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
1971 lang_final_phase_enum
, dot
, &dot
);
1972 s
->reloc_statement
.addend_value
= value
.value
;
1973 if (value
.valid
== false)
1974 einfo ("%F%P: invalid reloc statement\n");
1976 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
);
1979 case lang_input_section_enum
:
1981 asection
*in
= s
->input_section
.section
;
1983 if (in
->_cooked_size
!= 0)
1984 dot
+= in
->_cooked_size
;
1986 dot
+= in
->_raw_size
;
1990 case lang_input_statement_enum
:
1992 case lang_fill_statement_enum
:
1993 fill
= s
->fill_statement
.fill
;
1995 case lang_assignment_statement_enum
:
1997 exp_fold_tree (s
->assignment_statement
.exp
,
1998 output_section_statement
,
1999 lang_final_phase_enum
,
2005 case lang_padding_statement_enum
:
2006 dot
+= s
->padding_statement
.size
;
2011 case lang_address_statement_enum
:
2022 struct bfd_link_hash_entry
*h
;
2023 boolean warn
= link_info
.relocateable
? false : true;
2025 if (entry_symbol
== (char *) NULL
)
2027 /* No entry has been specified. Look for start, but don't warn
2028 if we don't find it. */
2029 entry_symbol
= "start";
2033 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
2034 if (h
!= (struct bfd_link_hash_entry
*) NULL
2035 && h
->type
== bfd_link_hash_defined
)
2039 val
= (h
->u
.def
.value
2040 + bfd_get_section_vma (output_bfd
,
2041 h
->u
.def
.section
->output_section
)
2042 + h
->u
.def
.section
->output_offset
);
2043 if (! bfd_set_start_address (output_bfd
, val
))
2044 einfo ("%P%F:%s: can't set start address\n", entry_symbol
);
2050 /* Can't find the entry symbol. Use the first address in the
2052 ts
= bfd_get_section_by_name (output_bfd
, ".text");
2053 if (ts
!= (asection
*) NULL
)
2056 einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
2057 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
2058 if (! bfd_set_start_address (output_bfd
,
2059 bfd_get_section_vma (output_bfd
, ts
)))
2060 einfo ("%P%F: can't set start address\n");
2065 einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2071 /* By now we know the target architecture, and we may have an */
2072 /* ldfile_output_machine_name */
2076 lang_statement_union_type
*file
;
2078 unsigned long input_machine
;
2079 enum bfd_architecture input_architecture
;
2080 CONST bfd_arch_info_type
*compatible
;
2082 for (file
= file_chain
.head
;
2083 file
!= (lang_statement_union_type
*) NULL
;
2084 file
= file
->input_statement
.next
)
2086 input_bfd
= file
->input_statement
.the_bfd
;
2088 input_machine
= bfd_get_mach (input_bfd
);
2089 input_architecture
= bfd_get_arch (input_bfd
);
2092 /* Inspect the architecture and ensure we're linking like with
2095 compatible
= bfd_arch_get_compatible (input_bfd
,
2100 ldfile_output_machine
= compatible
->mach
;
2101 ldfile_output_architecture
= compatible
->arch
;
2106 einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2107 bfd_printable_name (input_bfd
), input_bfd
,
2108 bfd_printable_name (output_bfd
));
2110 if (! bfd_set_arch_mach (output_bfd
,
2113 einfo ("%P%F:%s: can't set architecture: %E\n",
2114 bfd_get_filename (output_bfd
));
2120 /* Look through all the global common symbols and attach them to the
2121 correct section. The -sort-common command line switch may be used
2122 to roughly sort the entries by size. */
2127 if (link_info
.relocateable
2128 && ! command_line
.force_common_definition
)
2131 if (! config
.sort_common
)
2132 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
2137 for (power
= 1; power
<= 16; power
<<= 1)
2138 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
2143 /* Place one common symbol in the correct section. */
2146 lang_one_common (h
, info
)
2147 struct bfd_link_hash_entry
*h
;
2150 unsigned int power_of_two
;
2155 if (h
->type
!= bfd_link_hash_common
)
2188 if (config
.sort_common
&& align
!= *(unsigned int *) info
)
2191 section
= h
->u
.c
.section
;
2193 /* Increase the size of the section. */
2194 section
->_raw_size
= ALIGN_N (section
->_raw_size
, align
);
2196 /* Adjust the alignment if necessary. */
2197 if (power_of_two
> section
->alignment_power
)
2198 section
->alignment_power
= power_of_two
;
2200 /* Change the symbol from common to defined. */
2201 h
->type
= bfd_link_hash_defined
;
2202 h
->u
.def
.section
= section
;
2203 h
->u
.def
.value
= section
->_raw_size
;
2205 /* Increase the size of the section. */
2206 section
->_raw_size
+= size
;
2208 if (config
.map_file
!= NULL
)
2209 fprintf (config
.map_file
, "Allocating common %s: %lx at %lx %s\n",
2210 h
->root
.string
, (unsigned long) size
,
2211 (unsigned long) h
->u
.def
.value
, section
->owner
->filename
);
2217 run through the input files and ensure that every input
2218 section has somewhere to go. If one is found without
2219 a destination then create an input request and place it
2220 into the statement tree.
2224 lang_place_orphans ()
2226 lang_input_statement_type
*file
;
2228 for (file
= (lang_input_statement_type
*) file_chain
.head
;
2229 file
!= (lang_input_statement_type
*) NULL
;
2230 file
= (lang_input_statement_type
*) file
->next
)
2234 if (file
->just_syms_flag
)
2237 for (s
= file
->the_bfd
->sections
;
2238 s
!= (asection
*) NULL
;
2241 if (s
->output_section
== (asection
*) NULL
)
2243 /* This section of the file is not attatched, root
2244 around for a sensible place for it to go */
2246 if (file
->common_section
== s
)
2248 /* This is a lonely common section which must
2249 have come from an archive. We attatch to the
2250 section with the wildcard */
2251 if (! link_info
.relocateable
2252 && ! command_line
.force_common_definition
)
2254 if (default_common_section
==
2255 (lang_output_section_statement_type
*) NULL
)
2257 info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2259 default_common_section
=
2260 lang_output_section_statement_lookup (".bss");
2263 wild_doit (&default_common_section
->children
, s
,
2264 default_common_section
, file
);
2269 lang_output_section_statement_type
*os
=
2270 lang_output_section_statement_lookup (s
->name
);
2272 wild_doit (&os
->children
, s
, os
, file
);
2281 lang_set_flags (ptr
, flags
)
2285 boolean state
= false;
2300 /* ptr->flag_read = state; */
2303 /* ptr->flag_write = state; */
2306 /* ptr->flag_executable= state;*/
2310 /* ptr->flag_loadable= state;*/
2313 einfo ("%P%F: invalid syntax in flags\n");
2323 lang_for_each_file (func
)
2324 void (*func
) PARAMS ((lang_input_statement_type
*));
2326 lang_input_statement_type
*f
;
2328 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2329 f
!= (lang_input_statement_type
*) NULL
;
2330 f
= (lang_input_statement_type
*) f
->next
)
2341 lang_for_each_input_section (func
)
2342 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
2344 lang_input_statement_type
*f
;
2346 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2347 f
!= (lang_input_statement_type
*) NULL
;
2348 f
= (lang_input_statement_type
*) f
->next
)
2352 for (s
= f
->the_bfd
->sections
;
2353 s
!= (asection
*) NULL
;
2356 func (f
->the_bfd
, s
);
2364 ldlang_add_file (entry
)
2365 lang_input_statement_type
* entry
;
2369 lang_statement_append (&file_chain
,
2370 (lang_statement_union_type
*) entry
,
2373 /* The BFD linker needs to have a list of all input BFDs involved in
2375 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
2376 ASSERT (entry
->the_bfd
!= output_bfd
);
2377 for (pp
= &link_info
.input_bfds
;
2378 *pp
!= (bfd
*) NULL
;
2379 pp
= &(*pp
)->link_next
)
2381 *pp
= entry
->the_bfd
;
2382 entry
->the_bfd
->usrdata
= (PTR
) entry
;
2383 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
2387 lang_add_output (name
, from_script
)
2391 /* Make -o on command line override OUTPUT in script. */
2392 if (had_output_filename
== false || !from_script
)
2394 output_filename
= name
;
2395 had_output_filename
= true;
2400 static lang_output_section_statement_type
*current_section
;
2402 static int topower(x
)
2407 if (x
< 0) return -1;
2408 for (l
= 0; l
< 32; l
++)
2410 if (i
>= x
) return l
;
2416 lang_enter_output_section_statement (output_section_statement_name
,
2417 address_exp
, flags
, block_value
,
2418 align
, subalign
, ebase
)
2419 const char *output_section_statement_name
;
2420 etree_type
* address_exp
;
2422 bfd_vma block_value
;
2424 etree_type
*subalign
;
2427 lang_output_section_statement_type
*os
;
2431 lang_output_section_statement_lookup (output_section_statement_name
);
2435 /* Add this statement to tree */
2436 /* add_statement(lang_output_section_statement_enum,
2437 output_section_statement);*/
2438 /* Make next things chain into subchain of this */
2440 if (os
->addr_tree
==
2441 (etree_type
*) NULL
)
2447 if (flags
& SEC_NEVER_LOAD
)
2451 os
->block_value
= block_value
? block_value
: 1;
2452 stat_ptr
= &os
->children
;
2454 os
->subsection_alignment
= topower(
2455 exp_get_value_int(subalign
, -1,
2456 "subsection alignment",
2458 os
->section_alignment
= topower(
2459 exp_get_value_int(align
, -1,
2460 "section alignment", 0));
2462 os
->load_base
= ebase
;
2469 lang_output_statement_type
*new =
2470 new_stat (lang_output_statement
, stat_ptr
);
2472 new->name
= output_filename
;
2475 /* Reset the current counters in the regions */
2477 reset_memory_regions ()
2479 lang_memory_region_type
*p
= lang_memory_region_list
;
2481 for (p
= lang_memory_region_list
;
2482 p
!= (lang_memory_region_type
*) NULL
;
2485 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
2486 p
->current
= p
->origin
;
2493 lang_reasonable_defaults ();
2494 current_target
= default_target
;
2496 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
2498 ldemul_create_output_section_statements ();
2500 /* Add to the hash table all undefineds on the command line */
2501 lang_place_undefineds ();
2503 /* Create a bfd for each input file */
2504 current_target
= default_target
;
2505 lang_for_each_statement (open_input_bfds
);
2507 /* Build all sets based on the information gathered from the input
2509 ldctor_build_sets ();
2511 /* Size up the common data */
2514 /* Run through the contours of the script and attatch input sections
2515 to the correct output sections
2517 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
2518 (lang_output_section_statement_type
*) NULL
);
2521 /* Find any sections not attatched explicitly and handle them */
2522 lang_place_orphans ();
2524 ldemul_before_allocation ();
2526 /* Now run around and relax if we can */
2527 if (command_line
.relax
)
2529 /* First time round is a trial run to get the 'worst case'
2530 addresses of the objects if there was no relaxing. */
2531 lang_size_sections (statement_list
.head
,
2533 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2536 reset_memory_regions ();
2538 /* Keep relaxing until bfd_relax_section gives up. */
2541 relax_again
= false;
2543 /* Do all the assignments with our current guesses as to
2545 lang_do_assignments (statement_list
.head
,
2547 (fill_type
) 0, (bfd_vma
) 0);
2549 /* Perform another relax pass - this time we know where the
2550 globals are, so can make better guess. */
2551 lang_size_sections (statement_list
.head
,
2553 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2555 while (relax_again
);
2559 /* Size up the sections. */
2560 lang_size_sections (statement_list
.head
,
2562 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2565 /* See if anything special should be done now we know how big
2567 ldemul_after_allocation ();
2569 /* Do all the assignments, now that we know the final restingplaces
2570 of all the symbols */
2572 lang_do_assignments (statement_list
.head
,
2574 (fill_type
) 0, (bfd_vma
) 0);
2576 /* Make sure that we're not mixing architectures */
2586 /* EXPORTED TO YACC */
2589 lang_add_wild (section_name
, filename
)
2590 CONST
char *CONST section_name
;
2591 CONST
char *CONST filename
;
2593 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
2596 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
2598 placed_commons
= true;
2600 if (filename
!= (char *) NULL
)
2602 lang_has_input_file
= true;
2604 new->section_name
= section_name
;
2605 new->filename
= filename
;
2606 lang_list_init (&new->children
);
2610 lang_section_start (name
, address
)
2612 etree_type
* address
;
2614 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
2616 ad
->section_name
= name
;
2617 ad
->address
= address
;
2621 lang_add_entry (name
)
2624 entry_symbol
= name
;
2628 lang_add_target (name
)
2631 lang_target_statement_type
*new = new_stat (lang_target_statement
,
2647 map_option_f
= true;
2658 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
2665 lang_add_data (type
, exp
)
2667 union etree_union
*exp
;
2670 lang_data_statement_type
*new = new_stat (lang_data_statement
,
2678 /* Create a new reloc statement. RELOC is the BFD relocation type to
2679 generate. HOWTO is the corresponding howto structure (we could
2680 look this up, but the caller has already done so). SECTION is the
2681 section to generate a reloc against, or NAME is the name of the
2682 symbol to generate a reloc against. Exactly one of SECTION and
2683 NAME must be NULL. ADDEND is an expression for the addend. */
2686 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
2687 bfd_reloc_code_real_type reloc
;
2688 const reloc_howto_type
*howto
;
2691 union etree_union
*addend
;
2693 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
2697 p
->section
= section
;
2699 p
->addend_exp
= addend
;
2701 p
->addend_value
= 0;
2702 p
->output_section
= NULL
;
2707 lang_add_assignment (exp
)
2710 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
2717 lang_add_attribute (attribute
)
2718 enum statement_enum attribute
;
2720 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
2727 if (startup_file
!= (char *) NULL
)
2729 einfo ("%P%Fmultiple STARTUP files\n");
2731 first_file
->filename
= name
;
2732 first_file
->local_sym_name
= name
;
2733 first_file
->real
= true;
2735 startup_file
= name
;
2742 lang_float_flag
= maybe
;
2746 lang_leave_output_section_statement (fill
, memspec
)
2748 CONST
char *memspec
;
2750 current_section
->fill
= fill
;
2751 current_section
->region
= lang_memory_region_lookup (memspec
);
2752 stat_ptr
= &statement_list
;
2754 /* We remember if we are closing a .data section, since we use it to
2755 store constructors in */
2756 if (strcmp (current_section
->name
, ".data") == 0)
2758 end_of_data_section_statement_list
= statement_list
;
2764 Create an absolute symbol with the given name with the value of the
2765 address of first byte of the section named.
2767 If the symbol already exists, then do nothing.
2770 lang_abs_symbol_at_beginning_of (secname
, name
)
2771 const char *secname
;
2774 struct bfd_link_hash_entry
*h
;
2776 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2777 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2778 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2780 if (h
->type
== bfd_link_hash_new
2781 || h
->type
== bfd_link_hash_undefined
)
2785 h
->type
= bfd_link_hash_defined
;
2787 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2788 if (sec
== (asection
*) NULL
)
2791 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
2793 h
->u
.def
.section
= &bfd_abs_section
;
2798 Create an absolute symbol with the given name with the value of the
2799 address of the first byte after the end of the section named.
2801 If the symbol already exists, then do nothing.
2804 lang_abs_symbol_at_end_of (secname
, name
)
2805 const char *secname
;
2808 struct bfd_link_hash_entry
*h
;
2810 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2811 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2812 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2814 if (h
->type
== bfd_link_hash_new
2815 || h
->type
== bfd_link_hash_undefined
)
2819 h
->type
= bfd_link_hash_defined
;
2821 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2822 if (sec
== (asection
*) NULL
)
2825 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
2826 + bfd_section_size (output_bfd
, sec
));
2828 h
->u
.def
.section
= &bfd_abs_section
;
2833 lang_statement_append (list
, element
, field
)
2834 lang_statement_list_type
* list
;
2835 lang_statement_union_type
* element
;
2836 lang_statement_union_type
** field
;
2838 *(list
->tail
) = element
;
2842 /* Set the output format type. -oformat overrides scripts. */
2844 lang_add_output_format (format
, from_script
)
2848 if (output_target
== NULL
|| !from_script
)
2849 output_target
= format
;