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
,
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 asection
*our_bfd_get_section_by_name
PARAMS ((bfd
*abfd
,
85 const char *section
));
86 static void wild_section
PARAMS ((lang_wild_statement_type
*ptr
,
88 lang_input_statement_type
*file
,
89 lang_output_section_statement_type
*output
));
90 static lang_input_statement_type
*lookup_name
PARAMS ((const char *name
,
92 static void wild
PARAMS ((lang_wild_statement_type
*s
,
93 const char *section
, const char *file
,
95 lang_output_section_statement_type
*output
));
96 static bfd
*open_output
PARAMS ((const char *name
));
97 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*statement
));
98 static void open_input_bfds
PARAMS ((lang_statement_union_type
*statement
));
99 static void lang_reasonable_defaults
PARAMS ((void));
100 static void lang_place_undefineds
PARAMS ((void));
101 static void lang_create_output_section_statements
PARAMS ((void));
102 static void map_input_to_output_sections
103 PARAMS ((lang_statement_union_type
*s
,
105 lang_output_section_statement_type
*output_section_statement
));
106 static void print_output_section_statement
107 PARAMS ((lang_output_section_statement_type
*output_section_statement
));
108 static void print_assignment
109 PARAMS ((lang_assignment_statement_type
*assignment
,
110 lang_output_section_statement_type
*output_section
));
111 static void print_input_statement
PARAMS ((lang_input_statement_type
*statm
));
112 static void print_input_section
PARAMS ((lang_input_section_type
*in
));
113 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*fill
));
114 static void print_data_statement
PARAMS ((lang_data_statement_type
*data
));
115 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*s
));
116 static void print_wild_statement
117 PARAMS ((lang_wild_statement_type
*w
,
118 lang_output_section_statement_type
*os
));
119 static void print_statement
PARAMS ((lang_statement_union_type
*s
,
120 lang_output_section_statement_type
*os
));
121 static void print_statements
PARAMS ((void));
122 static bfd_vma insert_pad
PARAMS ((lang_statement_union_type
**this_ptr
,
123 fill_type fill
, unsigned int power
,
124 asection
*output_section_statement
,
126 static bfd_vma size_input_section
127 PARAMS ((lang_statement_union_type
**this_ptr
,
128 lang_output_section_statement_type
*output_section_statement
,
129 fill_type fill
, bfd_vma dot
, boolean relax
));
130 static bfd_vma lang_do_assignments
131 PARAMS ((lang_statement_union_type
* s
,
132 lang_output_section_statement_type
*output_section_statement
,
135 static void lang_finish
PARAMS ((void));
136 static void lang_check
PARAMS ((void));
137 static void lang_common
PARAMS ((void));
138 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
139 static void lang_place_orphans
PARAMS ((void));
140 static int topower
PARAMS ((int));
141 static void reset_memory_regions
PARAMS ((void));
144 lang_output_section_statement_type
*abs_output_section
;
145 lang_statement_list_type
*stat_ptr
= &statement_list
;
146 lang_statement_list_type file_chain
=
148 CONST
char *entry_symbol
= 0;
149 boolean lang_has_input_file
= false;
150 boolean had_output_filename
= false;
151 boolean lang_float_flag
= false;
152 boolean delete_output_file_on_failure
= false;
154 etree_type
*base
; /* Relocation base - or null */
158 #define cat(a,b) a##b
160 #define cat(a,b) a/**/b
163 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
165 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
167 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
173 return obstack_alloc (&stat_obstack
, size
);
180 fprintf (config
.map_file
, "%5x", (unsigned) value
);
184 print_alignment (value
)
187 fprintf (config
.map_file
, "2**%1u", value
);
194 fprintf (config
.map_file
, "%04x", (unsigned) value
);
201 fprintf (config
.map_file
, "%*s", -longest_section_name
, name
);
204 /*----------------------------------------------------------------------
205 lang_for_each_statement walks the parse tree and calls the provided
206 function for each node
210 lang_for_each_statement_worker (func
, s
)
211 void (*func
) PARAMS ((lang_statement_union_type
*));
212 lang_statement_union_type
*s
;
214 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
218 switch (s
->header
.type
)
220 case lang_constructors_statement_enum
:
221 lang_for_each_statement_worker (func
, constructor_list
.head
);
223 case lang_output_section_statement_enum
:
224 lang_for_each_statement_worker
226 s
->output_section_statement
.children
.head
);
228 case lang_wild_statement_enum
:
229 lang_for_each_statement_worker
231 s
->wild_statement
.children
.head
);
233 case lang_data_statement_enum
:
234 case lang_object_symbols_statement_enum
:
235 case lang_output_statement_enum
:
236 case lang_target_statement_enum
:
237 case lang_input_section_enum
:
238 case lang_input_statement_enum
:
239 case lang_assignment_statement_enum
:
240 case lang_padding_statement_enum
:
241 case lang_address_statement_enum
:
251 lang_for_each_statement (func
)
252 void (*func
) PARAMS ((lang_statement_union_type
*));
254 lang_for_each_statement_worker (func
,
255 statement_list
.head
);
258 /*----------------------------------------------------------------------*/
260 lang_list_init (list
)
261 lang_statement_list_type
*list
;
263 list
->head
= (lang_statement_union_type
*) NULL
;
264 list
->tail
= &list
->head
;
267 /*----------------------------------------------------------------------
269 build a new statement node for the parse tree
274 lang_statement_union_type
*
275 new_statement (type
, size
, list
)
276 enum statement_enum type
;
278 lang_statement_list_type
* list
;
280 lang_statement_union_type
*new = (lang_statement_union_type
*)
283 new->header
.type
= type
;
284 new->header
.next
= (lang_statement_union_type
*) NULL
;
285 lang_statement_append (list
, new, &new->header
.next
);
290 Build a new input file node for the language. There are several ways
291 in which we treat an input file, eg, we only look at symbols, or
292 prefix it with a -l etc.
294 We can be supplied with requests for input files more than once;
295 they may, for example be split over serveral lines like foo.o(.text)
296 foo.o(.data) etc, so when asked for a file we check that we havn't
297 got it already so we don't duplicate the bfd.
300 static lang_input_statement_type
*
301 new_afile (name
, file_type
, target
)
303 lang_input_file_enum_type file_type
;
307 lang_input_statement_type
*p
= new_stat (lang_input_statement
,
310 lang_has_input_file
= true;
312 p
->complained
= false;
315 case lang_input_file_is_symbols_only_enum
:
317 p
->is_archive
= false;
319 p
->local_sym_name
= name
;
320 p
->just_syms_flag
= true;
321 p
->search_dirs_flag
= false;
323 case lang_input_file_is_fake_enum
:
325 p
->is_archive
= false;
327 p
->local_sym_name
= name
;
328 p
->just_syms_flag
= false;
329 p
->search_dirs_flag
= false;
331 case lang_input_file_is_l_enum
:
332 p
->is_archive
= true;
335 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
336 p
->just_syms_flag
= false;
337 p
->search_dirs_flag
= true;
339 case lang_input_file_is_search_file_enum
:
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_file_enum
:
350 p
->is_archive
= false;
352 p
->local_sym_name
= name
;
353 p
->just_syms_flag
= false;
354 p
->search_dirs_flag
= false;
359 p
->asymbols
= (asymbol
**) NULL
;
360 p
->superfile
= (lang_input_statement_type
*) NULL
;
361 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
362 p
->next
= (lang_statement_union_type
*) NULL
;
364 p
->common_output_section
= (asection
*) NULL
;
366 lang_statement_append (&input_file_chain
,
367 (lang_statement_union_type
*) p
,
372 lang_input_statement_type
*
373 lang_add_input_file (name
, file_type
, target
)
375 lang_input_file_enum_type file_type
;
378 /* Look it up or build a new one */
379 lang_has_input_file
= true;
382 lang_input_statement_type
*p
;
384 for (p
= (lang_input_statement_type
*) input_file_chain
.head
;
385 p
!= (lang_input_statement_type
*) NULL
;
386 p
= (lang_input_statement_type
*) (p
->next_real_file
))
388 /* Sometimes we have incomplete entries in here */
389 if (p
->filename
!= (char *) NULL
)
391 if (strcmp (name
, p
->filename
) == 0)
397 return new_afile (name
, file_type
, target
);
400 /* Build enough state so that the parser can build its tree */
404 obstack_begin (&stat_obstack
, 1000);
406 stat_ptr
= &statement_list
;
408 lang_list_init (stat_ptr
);
410 lang_list_init (&input_file_chain
);
411 lang_list_init (&lang_output_section_statement
);
412 lang_list_init (&file_chain
);
413 first_file
= lang_add_input_file ((char *) NULL
,
414 lang_input_file_is_marker_enum
,
416 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
418 abs_output_section
->bfd_section
= &bfd_abs_section
;
422 /*----------------------------------------------------------------------
423 A region is an area of memory declared with the
424 MEMORY { name:org=exp, len=exp ... }
427 We maintain a list of all the regions here
429 If no regions are specified in the script, then the default is used
430 which is created when looked up to be the entire data space
433 static lang_memory_region_type
*lang_memory_region_list
;
434 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
436 lang_memory_region_type
*
437 lang_memory_region_lookup (name
)
438 CONST
char *CONST name
;
441 lang_memory_region_type
*p
= lang_memory_region_list
;
443 for (p
= lang_memory_region_list
;
444 p
!= (lang_memory_region_type
*) NULL
;
447 if (strcmp (p
->name
, name
) == 0)
452 if (strcmp (name
, "*default*") == 0)
454 /* This is the default region, dig out first one on the list */
455 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
457 return lang_memory_region_list
;
461 lang_memory_region_type
*new =
462 (lang_memory_region_type
*) stat_alloc ((bfd_size_type
) (sizeof (lang_memory_region_type
)));
464 new->name
= buystring (name
);
465 new->next
= (lang_memory_region_type
*) NULL
;
467 *lang_memory_region_list_tail
= new;
468 lang_memory_region_list_tail
= &new->next
;
470 new->length
= ~(bfd_size_type
)0;
472 new->had_full_message
= false;
479 lang_output_section_statement_type
*
480 lang_output_section_find (name
)
481 CONST
char *CONST name
;
483 lang_statement_union_type
*u
;
484 lang_output_section_statement_type
*lookup
;
486 for (u
= lang_output_section_statement
.head
;
487 u
!= (lang_statement_union_type
*) NULL
;
490 lookup
= &u
->output_section_statement
;
491 if (strcmp (name
, lookup
->name
) == 0)
496 return (lang_output_section_statement_type
*) NULL
;
499 lang_output_section_statement_type
*
500 lang_output_section_statement_lookup (name
)
501 CONST
char *CONST name
;
503 lang_output_section_statement_type
*lookup
;
505 lookup
= lang_output_section_find (name
);
506 if (lookup
== (lang_output_section_statement_type
*) NULL
)
509 lookup
= (lang_output_section_statement_type
*)
510 new_stat (lang_output_section_statement
, stat_ptr
);
511 lookup
->region
= (lang_memory_region_type
*) NULL
;
513 lookup
->block_value
= 1;
516 lookup
->next
= (lang_statement_union_type
*) NULL
;
517 lookup
->bfd_section
= (asection
*) NULL
;
518 lookup
->processed
= false;
519 lookup
->loadable
= 1;
520 lookup
->addr_tree
= (etree_type
*) NULL
;
521 lang_list_init (&lookup
->children
);
523 lookup
->memspec
= (CONST
char *) NULL
;
525 lookup
->subsection_alignment
= -1;
526 lookup
->section_alignment
= -1;
527 lookup
->load_base
= (union etree_union
*) NULL
;
529 lang_statement_append (&lang_output_section_statement
,
530 (lang_statement_union_type
*) lookup
,
538 print_flags (ignore_flags
)
541 fprintf (config
.map_file
, "(");
543 if (flags
->flag_read
)
544 fprintf (outfile
, "R");
545 if (flags
->flag_write
)
546 fprintf (outfile
, "W");
547 if (flags
->flag_executable
)
548 fprintf (outfile
, "X");
549 if (flags
->flag_loadable
)
550 fprintf (outfile
, "L");
552 fprintf (config
.map_file
, ")");
558 lang_memory_region_type
*m
;
560 fprintf (config
.map_file
, "**MEMORY CONFIGURATION**\n\n");
562 fprintf (config
.map_file
, "name\t\torigin\t\tlength\t\tattributes\n");
564 fprintf (config
.map_file
,
565 "name\t\torigin length r_size c_size is attributes\n");
568 for (m
= lang_memory_region_list
;
569 m
!= (lang_memory_region_type
*) NULL
;
572 fprintf (config
.map_file
, "%-16s", m
->name
);
573 print_address (m
->origin
);
575 print_address ((bfd_vma
)m
->length
);
577 print_address ((bfd_vma
)m
->old_length
);
579 print_address (m
->current
- m
->origin
);
582 fprintf (config
.map_file
, " %2d%% ",
583 (int) ((m
->current
- m
->origin
) * 100 / m
->old_length
));
584 print_flags (&m
->flags
);
585 fprintf (config
.map_file
, "\n");
587 fprintf (config
.map_file
, "\n\n**LINK EDITOR MEMORY MAP**\n\n");
588 fprintf (config
.map_file
, "output input virtual\n");
589 fprintf (config
.map_file
, "section section address tsize\n\n");
600 lang_output_section_statement_type
* s
;
602 /* asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
603 section_userdata_type
*new =
604 (section_userdata_type
*)
605 stat_alloc ((bfd_size_type
) (sizeof (section_userdata_type
)));
607 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
608 if (s
->bfd_section
== (asection
*) NULL
)
609 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
610 if (s
->bfd_section
== (asection
*) NULL
)
612 einfo ("%P%F: output format %s cannot represent section called %s\n",
613 output_bfd
->xvec
->name
, s
->name
);
615 s
->bfd_section
->output_section
= s
->bfd_section
;
616 /* s->bfd_section->flags = s->flags;*/
618 /* We initialize an output sections output offset to minus its own */
619 /* vma to allow us to output a section through itself */
620 s
->bfd_section
->output_offset
= 0;
621 get_userdata (s
->bfd_section
) = (PTR
) new;
625 /***********************************************************************
628 These expand statements like *(.text) and foo.o to a list of
629 explicit actions, like foo.o(.text), bar.o(.text) and
632 The toplevel routine, wild, takes a statement, section, file and
633 target. If either the section or file is null it is taken to be the
634 wildcard. Seperate lang_input_section statements are created for
635 each part of the expanstion, and placed after the statement provided.
640 wild_doit (ptr
, section
, output
, file
)
641 lang_statement_list_type
* ptr
;
643 lang_output_section_statement_type
* output
;
644 lang_input_statement_type
* file
;
646 if (output
->bfd_section
== (asection
*) NULL
)
649 /* Initialize the vma and size to the existing section. This will
650 be overriden in lang_size_sections unless SEC_NEVER_LOAD gets
652 if (section
!= (asection
*) NULL
)
654 bfd_set_section_vma (0, output
->bfd_section
,
655 bfd_section_vma (0, section
));
656 output
->bfd_section
->_raw_size
= section
->_raw_size
;
660 if (section
!= (asection
*) NULL
661 && section
->output_section
== (asection
*) NULL
)
663 /* Add a section reference to the list */
664 lang_input_section_type
*new = new_stat (lang_input_section
, ptr
);
666 new->section
= section
;
668 section
->output_section
= output
->bfd_section
;
670 /* Be selective about what the output section inherits from the
673 if ((section
->flags
& SEC_SHARED_LIBRARY
) != 0)
674 section
->output_section
->flags
|= section
->flags
;
676 section
->output_section
->flags
|=
677 section
->flags
& (flagword
) (~ SEC_NEVER_LOAD
);
679 if (!output
->loadable
)
681 /* Turn off load flag */
682 output
->bfd_section
->flags
&= ~SEC_LOAD
;
683 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
685 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
687 output
->bfd_section
->alignment_power
= section
->alignment_power
;
689 /* If supplied an aligmnet, then force it */
690 if (output
->section_alignment
!= -1)
692 output
->bfd_section
->alignment_power
= output
->section_alignment
;
698 our_bfd_get_section_by_name (abfd
, section
)
702 return bfd_get_section_by_name (abfd
, section
);
706 wild_section (ptr
, section
, file
, output
)
707 lang_wild_statement_type
* ptr
;
709 lang_input_statement_type
* file
;
710 lang_output_section_statement_type
* output
;
714 if (file
->just_syms_flag
== false)
716 if (section
== (char *) NULL
)
718 /* Do the creation to all sections in the file */
719 for (s
= file
->the_bfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
722 if ((s
->flags
& SEC_IS_COMMON
) == 0)
724 wild_doit (&ptr
->children
, s
, output
, file
);
730 /* Do the creation to the named section only */
731 wild_doit (&ptr
->children
,
732 our_bfd_get_section_by_name (file
->the_bfd
, section
),
738 /* passed a file name (which must have been seen already and added to
739 the statement tree. We will see if it has been opened already and
740 had its symbols read. If not then we'll read it.
742 Archives are pecuilar here. We may open them once, but if they do
743 not define anything we need at the time, they won't have all their
744 symbols read. If we need them later, we'll have to redo it.
747 lang_input_statement_type
*
748 lookup_name (name
, force_load
)
752 lang_input_statement_type
*search
;
754 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
755 search
!= (lang_input_statement_type
*) NULL
;
756 search
= (lang_input_statement_type
*) search
->next_real_file
)
758 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
760 if (search
->filename
!= (char *) NULL
761 && name
!= (char *) NULL
762 && strcmp (search
->filename
, name
) == 0)
766 if (search
== (lang_input_statement_type
*) NULL
)
768 /* There isn't an afile entry for this file yet, this must be
769 because the name has only appeared inside a load script and
770 not on the command line */
771 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
);
774 /* If we have already added this file, or this file is not real
775 (FIXME: can that ever actually happen?) or the name is NULL
776 (FIXME: can that ever actually happen?) don't add this file. */
777 if ((search
->loaded
&& ! force_load
)
779 || search
->filename
== (const char *) NULL
)
782 ldfile_open_file (search
);
784 if (bfd_check_format (search
->the_bfd
, bfd_object
))
786 ldlang_add_file (search
);
787 if (trace_files
|| trace_file_tries
)
788 info_msg ("%I\n", search
);
790 else if (bfd_check_format (search
->the_bfd
, bfd_archive
))
792 /* There is nothing to do here; the add_symbols routine will
793 call ldlang_add_file (via the add_archive_element callback)
794 for each element of the archive which is used. */
797 einfo ("%F%B: file not recognized: %E\n", search
->the_bfd
);
799 bfd_set_gp_size (search
->the_bfd
, g_switch_value
);
801 if (bfd_link_add_symbols (search
->the_bfd
, &link_info
) == false)
802 einfo ("%F%B: could not read symbols: %E\n", search
->the_bfd
);
804 search
->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
, 0), 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
, 1);
938 case lang_input_statement_enum
:
939 if (statement
->input_statement
.real
== true)
941 statement
->input_statement
.target
= current_target
;
942 lookup_name (statement
->input_statement
.filename
, 1);
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 /* Copy important data from out internal form to the bfd way. Also
1031 create a section for the dummy file
1035 lang_create_output_section_statements ()
1037 lang_statement_union_type
*os
;
1039 for (os
= lang_output_section_statement
.head
;
1040 os
!= (lang_statement_union_type
*) NULL
;
1041 os
= os
->output_section_statement
.next
)
1043 lang_output_section_statement_type
*s
=
1044 &os
->output_section_statement
;
1051 /* Open input files and attatch to output sections */
1053 map_input_to_output_sections (s
, target
, output_section_statement
)
1054 lang_statement_union_type
* s
;
1056 lang_output_section_statement_type
* output_section_statement
;
1058 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1060 switch (s
->header
.type
)
1064 case lang_wild_statement_enum
:
1065 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1066 s
->wild_statement
.filename
, target
,
1067 output_section_statement
);
1070 case lang_constructors_statement_enum
:
1071 map_input_to_output_sections (constructor_list
.head
,
1073 output_section_statement
);
1075 case lang_output_section_statement_enum
:
1076 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1078 &s
->output_section_statement
);
1080 case lang_output_statement_enum
:
1082 case lang_target_statement_enum
:
1083 target
= s
->target_statement
.target
;
1085 case lang_fill_statement_enum
:
1086 case lang_input_section_enum
:
1087 case lang_object_symbols_statement_enum
:
1088 case lang_data_statement_enum
:
1089 case lang_assignment_statement_enum
:
1090 case lang_padding_statement_enum
:
1092 case lang_afile_asection_pair_statement_enum
:
1095 case lang_address_statement_enum
:
1096 /* Mark the specified section with the supplied address */
1098 lang_output_section_statement_type
*os
=
1099 lang_output_section_statement_lookup
1100 (s
->address_statement
.section_name
);
1102 os
->addr_tree
= s
->address_statement
.address
;
1103 if (os
->bfd_section
== (asection
*) NULL
)
1105 einfo ("%P%F: cannot set the address of undefined section %s\n",
1106 s
->address_statement
.section_name
);
1110 case lang_input_statement_enum
:
1111 /* A standard input statement, has no wildcards */
1118 print_output_section_statement (output_section_statement
)
1119 lang_output_section_statement_type
* output_section_statement
;
1121 asection
*section
= output_section_statement
->bfd_section
;
1124 print_section (output_section_statement
->name
);
1129 print_dot
= section
->vma
;
1133 print_address (section
->vma
);
1135 print_size (section
->_raw_size
);
1137 print_size(section
->_cooked_size
);
1139 print_alignment (section
->alignment_power
);
1142 fprintf (config
.map_file
, "%s flags", output_section_statement
->region
->name
);
1143 print_flags (stdout
, &output_section_statement
->flags
);
1145 if (section
->flags
& SEC_LOAD
)
1146 fprintf (config
.map_file
, "load ");
1147 if (section
->flags
& SEC_ALLOC
)
1148 fprintf (config
.map_file
, "alloc ");
1149 if (section
->flags
& SEC_RELOC
)
1150 fprintf (config
.map_file
, "reloc ");
1151 if (section
->flags
& SEC_HAS_CONTENTS
)
1152 fprintf (config
.map_file
, "contents ");
1157 fprintf (config
.map_file
, "No attached output section");
1160 if (output_section_statement
->load_base
)
1162 int b
= exp_get_value_int(output_section_statement
->load_base
,
1163 0, "output base", lang_final_phase_enum
);
1164 printf("Output address %08x\n", b
);
1166 if (output_section_statement
->section_alignment
>= 0
1167 || output_section_statement
->section_alignment
>= 0)
1169 printf("\t\t\t\t\tforced alignment ");
1170 if ( output_section_statement
->section_alignment
>= 0)
1172 printf("section 2**%d ",output_section_statement
->section_alignment
);
1174 if ( output_section_statement
->subsection_alignment
>= 0)
1176 printf("subsection 2**%d ",output_section_statement
->subsection_alignment
);
1181 print_statement (output_section_statement
->children
.head
,
1182 output_section_statement
);
1187 print_assignment (assignment
, output_section
)
1188 lang_assignment_statement_type
* assignment
;
1189 lang_output_section_statement_type
* output_section
;
1191 etree_value_type result
;
1197 print_address (print_dot
);
1199 result
= exp_fold_tree (assignment
->exp
->assign
.src
,
1201 lang_final_phase_enum
,
1207 print_address (result
.value
);
1211 fprintf (config
.map_file
, "*undefined*");
1214 exp_print_tree (assignment
->exp
);
1216 fprintf (config
.map_file
, "\n");
1220 print_input_statement (statm
)
1221 lang_input_statement_type
* statm
;
1223 if (statm
->filename
!= (char *) NULL
)
1225 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1229 /* Print all the defined symbols for the abfd provided by in the supplied
1234 print_one_symbol (hash_entry
, ptr
)
1235 struct bfd_link_hash_entry
*hash_entry
;
1238 asection
* sec
= (asection
*)ptr
;
1240 if (hash_entry
->type
== bfd_link_hash_defined
)
1242 if (sec
== hash_entry
->u
.def
.section
) {
1244 fprintf (config
.map_file
, " ");
1246 fprintf (config
.map_file
, " ");
1247 print_address (hash_entry
->u
.def
.value
+ outside_section_address (sec
));
1248 fprintf (config
.map_file
, " %s", hash_entry
->root
.string
);
1257 print_input_section (in
)
1258 lang_input_section_type
* in
;
1260 asection
*i
= in
->section
;
1261 int size
= i
->reloc_done
?
1262 bfd_get_section_size_after_reloc (i
) :
1263 bfd_get_section_size_before_reloc (i
);
1268 fprintf (config
.map_file
, " ");
1269 print_section (i
->name
);
1270 fprintf (config
.map_file
, " ");
1271 if (i
->output_section
)
1273 print_address (i
->output_section
->vma
+ i
->output_offset
);
1274 fprintf (config
.map_file
, " ");
1275 print_size (i
->_raw_size
);
1276 fprintf (config
.map_file
, " ");
1277 print_size(i
->_cooked_size
);
1278 fprintf (config
.map_file
, " ");
1279 print_alignment (i
->alignment_power
);
1280 fprintf (config
.map_file
, " ");
1284 bfd
*abfd
= in
->ifile
->the_bfd
;
1286 if (in
->ifile
->just_syms_flag
== true)
1288 fprintf (config
.map_file
, "symbols only ");
1291 fprintf (config
.map_file
, " %s ", abfd
->xvec
->name
);
1292 if (abfd
->my_archive
!= (bfd
*) NULL
)
1294 fprintf (config
.map_file
, "[%s]%s", abfd
->my_archive
->filename
,
1299 fprintf (config
.map_file
, "%s", abfd
->filename
);
1301 fprintf (config
.map_file
, "(overhead %d bytes)", (int) bfd_alloc_size (abfd
));
1304 /* Print all the symbols */
1305 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
1313 print_dot
= outside_section_address (i
) + size
;
1317 fprintf (config
.map_file
, "No output section allocated\n");
1323 print_fill_statement (fill
)
1324 lang_fill_statement_type
* fill
;
1326 fprintf (config
.map_file
, "FILL mask ");
1327 print_fill (fill
->fill
);
1331 print_data_statement (data
)
1332 lang_data_statement_type
* data
;
1334 /* bfd_vma value; */
1339 /* ASSERT(print_dot == data->output_vma);*/
1341 print_address (data
->output_vma
+ data
->output_section
->vma
);
1343 print_address (data
->value
);
1348 fprintf (config
.map_file
, "BYTE ");
1349 print_dot
+= BYTE_SIZE
;
1352 fprintf (config
.map_file
, "SHORT ");
1353 print_dot
+= SHORT_SIZE
;
1356 fprintf (config
.map_file
, "LONG ");
1357 print_dot
+= LONG_SIZE
;
1360 fprintf (config
.map_file
, "QUAD ");
1361 print_dot
+= QUAD_SIZE
;
1365 exp_print_tree (data
->exp
);
1367 fprintf (config
.map_file
, "\n");
1372 print_padding_statement (s
)
1373 lang_padding_statement_type
* s
;
1377 print_section ("*fill*");
1379 print_address (s
->output_offset
+ s
->output_section
->vma
);
1381 print_size (s
->size
);
1383 print_fill (s
->fill
);
1386 print_dot
= s
->output_offset
+ s
->output_section
->vma
+ s
->size
;
1391 print_wild_statement (w
, os
)
1392 lang_wild_statement_type
* w
;
1393 lang_output_section_statement_type
* os
;
1395 fprintf (config
.map_file
, " from ");
1396 if (w
->filename
!= (char *) NULL
)
1398 fprintf (config
.map_file
, "%s", w
->filename
);
1402 fprintf (config
.map_file
, "*");
1404 if (w
->section_name
!= (char *) NULL
)
1406 fprintf (config
.map_file
, "(%s)", w
->section_name
);
1410 fprintf (config
.map_file
, "(*)");
1413 print_statement (w
->children
.head
, os
);
1417 print_statement (s
, os
)
1418 lang_statement_union_type
* s
;
1419 lang_output_section_statement_type
* os
;
1423 switch (s
->header
.type
)
1425 case lang_constructors_statement_enum
:
1426 fprintf (config
.map_file
, "constructors:\n");
1427 print_statement (constructor_list
.head
, os
);
1429 case lang_wild_statement_enum
:
1430 print_wild_statement (&s
->wild_statement
, os
);
1433 fprintf (config
.map_file
, "Fail with %d\n", s
->header
.type
);
1436 case lang_address_statement_enum
:
1437 fprintf (config
.map_file
, "address\n");
1439 case lang_object_symbols_statement_enum
:
1440 fprintf (config
.map_file
, "object symbols\n");
1442 case lang_fill_statement_enum
:
1443 print_fill_statement (&s
->fill_statement
);
1445 case lang_data_statement_enum
:
1446 print_data_statement (&s
->data_statement
);
1448 case lang_input_section_enum
:
1449 print_input_section (&s
->input_section
);
1451 case lang_padding_statement_enum
:
1452 print_padding_statement (&s
->padding_statement
);
1454 case lang_output_section_statement_enum
:
1455 print_output_section_statement (&s
->output_section_statement
);
1457 case lang_assignment_statement_enum
:
1458 print_assignment (&s
->assignment_statement
,
1461 case lang_target_statement_enum
:
1462 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1464 case lang_output_statement_enum
:
1465 fprintf (config
.map_file
, "OUTPUT(%s %s)\n",
1466 s
->output_statement
.name
,
1467 output_target
? output_target
: "");
1469 case lang_input_statement_enum
:
1470 print_input_statement (&s
->input_statement
);
1472 case lang_afile_asection_pair_statement_enum
:
1484 print_statement (statement_list
.head
,
1485 abs_output_section
);
1490 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
1491 lang_statement_union_type
** this_ptr
;
1494 asection
* output_section_statement
;
1497 /* Align this section first to the
1498 input sections requirement, then
1499 to the output section's requirement.
1500 If this alignment is > than any seen before,
1501 then record it too. Perform the alignment by
1502 inserting a magic 'padding' statement.
1505 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
1507 if (alignment_needed
!= 0)
1509 lang_statement_union_type
*new =
1510 (lang_statement_union_type
*)
1511 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1513 /* Link into existing chain */
1514 new->header
.next
= *this_ptr
;
1516 new->header
.type
= lang_padding_statement_enum
;
1517 new->padding_statement
.output_section
= output_section_statement
;
1518 new->padding_statement
.output_offset
=
1519 dot
- output_section_statement
->vma
;
1520 new->padding_statement
.fill
= fill
;
1521 new->padding_statement
.size
= alignment_needed
;
1525 /* Remember the most restrictive alignment */
1526 if (power
> output_section_statement
->alignment_power
)
1528 output_section_statement
->alignment_power
= power
;
1530 output_section_statement
->_raw_size
+= alignment_needed
;
1531 return alignment_needed
+ dot
;
1535 /* Work out how much this section will move the dot point */
1537 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
1538 lang_statement_union_type
** this_ptr
;
1539 lang_output_section_statement_type
* output_section_statement
;
1544 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1545 asection
*i
= is
->section
;
1547 if (is
->ifile
->just_syms_flag
== false)
1549 if (output_section_statement
->subsection_alignment
!= -1)
1550 i
->alignment_power
=
1551 output_section_statement
->subsection_alignment
;
1553 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
1554 output_section_statement
->bfd_section
, dot
);
1556 /* Remember where in the output section this input section goes */
1558 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1560 /* Mark how big the output section must be to contain this now
1564 dot
+= i
->_cooked_size
;
1568 dot
+= i
->_raw_size
;
1570 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
1574 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
1580 /* Sizing happens in two passes, first pass we allocate worst case
1581 stuff. The second pass (if relaxing), we use what we learnt to
1582 change the size of some relocs from worst case to better
1584 static boolean had_relax
;
1587 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
1588 lang_statement_union_type
* s
;
1589 lang_output_section_statement_type
* output_section_statement
;
1590 lang_statement_union_type
** prev
;
1595 /* Size up the sections from their constituent parts */
1596 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1598 switch (s
->header
.type
)
1601 case lang_output_section_statement_enum
:
1604 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
1606 /* If this is a shared library section, don't change the size
1608 if (os
->bfd_section
->flags
& SEC_SHARED_LIBRARY
)
1611 if (os
->bfd_section
== &bfd_abs_section
)
1613 /* No matter what happens, an abs section starts at zero */
1614 bfd_set_section_vma (0, os
->bfd_section
, 0);
1618 if (os
->addr_tree
== (etree_type
*) NULL
)
1620 /* No address specified for this section, get one
1621 from the region specification
1623 if (os
->region
== (lang_memory_region_type
*) NULL
)
1625 os
->region
= lang_memory_region_lookup ("*default*");
1627 dot
= os
->region
->current
;
1633 r
= exp_fold_tree (os
->addr_tree
,
1635 lang_allocating_phase_enum
,
1637 if (r
.valid
== false)
1639 einfo ("%F%S: non constant address expression for section %s\n",
1644 /* The section starts here */
1645 /* First, align to what the section needs */
1647 if (os
->section_alignment
!= -1)
1648 dot
= align_power (dot
, os
->section_alignment
);
1650 bfd_set_section_vma (0, os
->bfd_section
, dot
);
1652 if (os
->load_base
) {
1653 os
->bfd_section
->lma
1654 = exp_get_value_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
1659 os
->bfd_section
->output_offset
= 0;
1661 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
1662 os
->fill
, dot
, relax
);
1663 /* Ignore the size of the input sections, use the vma and size to */
1666 after
= ALIGN_N (os
->bfd_section
->vma
+
1667 os
->bfd_section
->_raw_size
,
1668 /* The coercion here is important, see ld.h. */
1669 (bfd_vma
) os
->block_value
);
1671 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
1672 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1673 os
->processed
= true;
1675 /* Replace into region ? */
1676 if (os
->addr_tree
== (etree_type
*) NULL
1677 && os
->region
!= (lang_memory_region_type
*) NULL
)
1679 os
->region
->current
= dot
;
1680 /* Make sure this isn't silly */
1681 if (( os
->region
->current
1682 > os
->region
->origin
+ os
->region
->length
)
1683 || ( os
->region
->origin
> os
->region
->current
))
1685 einfo ("%X%P: region %s is full (%B section %s)\n",
1687 os
->bfd_section
->owner
,
1688 os
->bfd_section
->name
);
1689 /* Reset the region pointer */
1690 os
->region
->current
= 0;
1698 case lang_constructors_statement_enum
:
1699 dot
= lang_size_sections (constructor_list
.head
,
1700 output_section_statement
,
1701 &s
->wild_statement
.children
.head
,
1706 case lang_data_statement_enum
:
1708 unsigned int size
= 0;
1710 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1711 s
->data_statement
.output_section
=
1712 output_section_statement
->bfd_section
;
1714 switch (s
->data_statement
.type
)
1731 output_section_statement
->bfd_section
->_raw_size
+= size
;
1735 case lang_wild_statement_enum
:
1737 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
1738 output_section_statement
,
1739 &s
->wild_statement
.children
.head
,
1745 case lang_object_symbols_statement_enum
:
1746 link_info
.create_object_symbols_section
=
1747 output_section_statement
->bfd_section
;
1749 case lang_output_statement_enum
:
1750 case lang_target_statement_enum
:
1752 case lang_input_section_enum
:
1755 lang_input_section_type
*is
;
1758 is
= &(*prev
)->input_section
;
1761 /* FIXME: The interface to bfd_relax_section should be changed
1762 to not require the generic symbols to be read. Changing
1763 this would require changing both b_out_relax_section and
1764 bfd_coff_relax16_section. */
1765 if (is
->ifile
->asymbols
== (asymbol
**) NULL
)
1767 unsigned int symsize
;
1769 symsize
= get_symtab_upper_bound (i
->owner
);
1770 is
->ifile
->asymbols
= (asymbol
**) xmalloc (symsize
);
1771 is
->ifile
->symbol_count
=
1772 bfd_canonicalize_symtab (i
->owner
, is
->ifile
->asymbols
);
1774 /* The generic linker code in BFD requires that these
1775 symbols be stored in the outsymbols and symcount
1776 fields. When the bfd_relax_section is interface is
1777 fixed this should also be fixed. */
1778 i
->owner
->outsymbols
= is
->ifile
->asymbols
;
1779 i
->owner
->symcount
= is
->ifile
->symbol_count
;
1782 bfd_set_error (bfd_error_no_error
);
1783 if (bfd_relax_section (i
->owner
, i
, &link_info
, is
->ifile
->asymbols
))
1785 else if (bfd_get_error () != bfd_error_no_error
)
1786 einfo ("%P%F: can't relax section: %E");
1789 (*prev
)->input_section
.section
->_cooked_size
=
1790 (*prev
)->input_section
.section
->_raw_size
;
1793 dot
= size_input_section (prev
,
1794 output_section_statement
,
1795 output_section_statement
->fill
,
1798 case lang_input_statement_enum
:
1800 case lang_fill_statement_enum
:
1801 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
1803 fill
= s
->fill_statement
.fill
;
1805 case lang_assignment_statement_enum
:
1807 bfd_vma newdot
= dot
;
1809 exp_fold_tree (s
->assignment_statement
.exp
,
1810 output_section_statement
,
1811 lang_allocating_phase_enum
,
1815 if (newdot
!= dot
&& !relax
)
1816 /* We've been moved ! so insert a pad */
1818 lang_statement_union_type
*new =
1819 (lang_statement_union_type
*)
1820 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1822 /* Link into existing chain */
1823 new->header
.next
= *prev
;
1825 new->header
.type
= lang_padding_statement_enum
;
1826 new->padding_statement
.output_section
=
1827 output_section_statement
->bfd_section
;
1828 new->padding_statement
.output_offset
=
1829 dot
- output_section_statement
->bfd_section
->vma
;
1830 new->padding_statement
.fill
= fill
;
1831 new->padding_statement
.size
= newdot
- dot
;
1832 output_section_statement
->bfd_section
->_raw_size
+=
1833 new->padding_statement
.size
;
1842 /* This can only get here when relaxing is turned on */
1843 case lang_padding_statement_enum
:
1845 case lang_address_statement_enum
:
1848 prev
= &s
->header
.next
;
1854 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
1855 lang_statement_union_type
* s
;
1856 lang_output_section_statement_type
* output_section_statement
;
1860 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1862 switch (s
->header
.type
)
1864 case lang_constructors_statement_enum
:
1865 dot
= lang_do_assignments (constructor_list
.head
,
1866 output_section_statement
,
1871 case lang_output_section_statement_enum
:
1873 lang_output_section_statement_type
*os
=
1874 &(s
->output_section_statement
);
1876 dot
= os
->bfd_section
->vma
;
1877 (void) lang_do_assignments (os
->children
.head
, os
, os
->fill
, dot
);
1878 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1881 case lang_wild_statement_enum
:
1883 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
1884 output_section_statement
,
1889 case lang_object_symbols_statement_enum
:
1890 case lang_output_statement_enum
:
1891 case lang_target_statement_enum
:
1893 case lang_common_statement_enum
:
1896 case lang_data_statement_enum
:
1898 etree_value_type value
;
1900 value
= exp_fold_tree (s
->data_statement
.exp
,
1902 lang_final_phase_enum
, dot
, &dot
);
1903 s
->data_statement
.value
= value
.value
;
1904 if (value
.valid
== false)
1905 einfo ("%F%P: invalid data statement\n");
1907 switch (s
->data_statement
.type
)
1923 case lang_input_section_enum
:
1925 asection
*in
= s
->input_section
.section
;
1927 dot
+= bfd_get_section_size_before_reloc (in
);
1931 case lang_input_statement_enum
:
1933 case lang_fill_statement_enum
:
1934 fill
= s
->fill_statement
.fill
;
1936 case lang_assignment_statement_enum
:
1938 exp_fold_tree (s
->assignment_statement
.exp
,
1939 output_section_statement
,
1940 lang_final_phase_enum
,
1946 case lang_padding_statement_enum
:
1947 dot
+= s
->padding_statement
.size
;
1952 case lang_address_statement_enum
:
1963 struct bfd_link_hash_entry
*h
;
1964 boolean warn
= link_info
.relocateable
? false : true;
1966 if (entry_symbol
== (char *) NULL
)
1968 /* No entry has been specified. Look for start, but don't warn
1969 if we don't find it. */
1970 entry_symbol
= "start";
1974 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
1975 if (h
!= (struct bfd_link_hash_entry
*) NULL
1976 && h
->type
== bfd_link_hash_defined
)
1980 val
= (h
->u
.def
.value
1981 + bfd_get_section_vma (output_bfd
,
1982 h
->u
.def
.section
->output_section
)
1983 + h
->u
.def
.section
->output_offset
);
1984 if (! bfd_set_start_address (output_bfd
, val
))
1985 einfo ("%P%F:%s: can't set start address\n", entry_symbol
);
1991 /* Can't find the entry symbol. Use the first address in the
1993 ts
= bfd_get_section_by_name (output_bfd
, ".text");
1994 if (ts
!= (asection
*) NULL
)
1997 einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
1998 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
1999 if (! bfd_set_start_address (output_bfd
,
2000 bfd_get_section_vma (output_bfd
, ts
)))
2001 einfo ("%P%F: can't set start address\n");
2006 einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2012 /* By now we know the target architecture, and we may have an */
2013 /* ldfile_output_machine_name */
2017 lang_statement_union_type
*file
;
2019 unsigned long input_machine
;
2020 enum bfd_architecture input_architecture
;
2021 CONST bfd_arch_info_type
*compatible
;
2023 for (file
= file_chain
.head
;
2024 file
!= (lang_statement_union_type
*) NULL
;
2025 file
= file
->input_statement
.next
)
2027 input_bfd
= file
->input_statement
.the_bfd
;
2029 input_machine
= bfd_get_mach (input_bfd
);
2030 input_architecture
= bfd_get_arch (input_bfd
);
2033 /* Inspect the architecture and ensure we're linking like with
2036 compatible
= bfd_arch_get_compatible (input_bfd
,
2041 ldfile_output_machine
= compatible
->mach
;
2042 ldfile_output_architecture
= compatible
->arch
;
2047 einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2048 bfd_printable_name (input_bfd
), input_bfd
,
2049 bfd_printable_name (output_bfd
));
2051 if (! bfd_set_arch_mach (output_bfd
,
2054 einfo ("%P%F:%s: can't set architecture: %E\n",
2055 bfd_get_filename (output_bfd
));
2061 /* Look through all the global common symbols and attach them to the
2062 correct section. The -sort-common command line switch may be used
2063 to roughly sort the entries by size. */
2068 if (link_info
.relocateable
2069 && ! command_line
.force_common_definition
)
2072 if (! config
.sort_common
)
2073 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
2078 for (power
= 1; power
<= 16; power
<<= 1)
2079 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
2084 /* Place one common symbol in the correct section. */
2087 lang_one_common (h
, info
)
2088 struct bfd_link_hash_entry
*h
;
2091 unsigned int power_of_two
;
2096 if (h
->type
!= bfd_link_hash_common
)
2129 if (config
.sort_common
&& align
!= *(unsigned int *) info
)
2132 section
= h
->u
.c
.section
;
2134 /* Increase the size of the section. */
2135 section
->_raw_size
= ALIGN_N (section
->_raw_size
, align
);
2137 /* Adjust the alignment if necessary. */
2138 if (power_of_two
> section
->alignment_power
)
2139 section
->alignment_power
= power_of_two
;
2141 /* Change the symbol from common to defined. */
2142 h
->type
= bfd_link_hash_defined
;
2143 h
->u
.def
.section
= section
;
2144 h
->u
.def
.value
= section
->_raw_size
;
2146 /* Increase the size of the section. */
2147 section
->_raw_size
+= size
;
2149 if (write_map
&& config
.map_file
!= NULL
)
2150 fprintf (config
.map_file
, "Allocating common %s: %lx at %lx %s\n",
2151 h
->root
.string
, (unsigned long) size
,
2152 (unsigned long) h
->u
.def
.value
, section
->owner
->filename
);
2158 run through the input files and ensure that every input
2159 section has somewhere to go. If one is found without
2160 a destination then create an input request and place it
2161 into the statement tree.
2165 lang_place_orphans ()
2167 lang_input_statement_type
*file
;
2169 for (file
= (lang_input_statement_type
*) file_chain
.head
;
2170 file
!= (lang_input_statement_type
*) NULL
;
2171 file
= (lang_input_statement_type
*) file
->next
)
2175 for (s
= file
->the_bfd
->sections
;
2176 s
!= (asection
*) NULL
;
2179 if (s
->output_section
== (asection
*) NULL
)
2181 /* This section of the file is not attatched, root
2182 around for a sensible place for it to go */
2184 if (file
->common_section
== s
)
2186 /* This is a lonely common section which must
2187 have come from an archive. We attatch to the
2188 section with the wildcard */
2189 if (! link_info
.relocateable
2190 && ! command_line
.force_common_definition
)
2192 if (default_common_section
==
2193 (lang_output_section_statement_type
*) NULL
)
2195 info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2197 default_common_section
=
2198 lang_output_section_statement_lookup (".bss");
2201 wild_doit (&default_common_section
->children
, s
,
2202 default_common_section
, file
);
2207 lang_output_section_statement_type
*os
=
2208 lang_output_section_statement_lookup (s
->name
);
2210 wild_doit (&os
->children
, s
, os
, file
);
2219 lang_set_flags (ptr
, flags
)
2223 boolean state
= false;
2238 /* ptr->flag_read = state; */
2241 /* ptr->flag_write = state; */
2244 /* ptr->flag_executable= state;*/
2248 /* ptr->flag_loadable= state;*/
2251 einfo ("%P%F: invalid syntax in flags\n");
2261 lang_for_each_file (func
)
2262 void (*func
) PARAMS ((lang_input_statement_type
*));
2264 lang_input_statement_type
*f
;
2266 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2267 f
!= (lang_input_statement_type
*) NULL
;
2268 f
= (lang_input_statement_type
*) f
->next
)
2279 lang_for_each_input_section (func
)
2280 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
2282 lang_input_statement_type
*f
;
2284 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2285 f
!= (lang_input_statement_type
*) NULL
;
2286 f
= (lang_input_statement_type
*) f
->next
)
2290 for (s
= f
->the_bfd
->sections
;
2291 s
!= (asection
*) NULL
;
2294 func (f
->the_bfd
, s
);
2302 ldlang_add_file (entry
)
2303 lang_input_statement_type
* entry
;
2307 lang_statement_append (&file_chain
,
2308 (lang_statement_union_type
*) entry
,
2311 /* The BFD linker needs to have a list of all input BFDs involved in
2313 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
2314 ASSERT (entry
->the_bfd
!= output_bfd
);
2315 for (pp
= &link_info
.input_bfds
;
2316 *pp
!= (bfd
*) NULL
;
2317 pp
= &(*pp
)->link_next
)
2319 *pp
= entry
->the_bfd
;
2320 entry
->the_bfd
->usrdata
= (PTR
) entry
;
2324 lang_add_output (name
, from_script
)
2328 /* Make -o on command line override OUTPUT in script. */
2329 if (had_output_filename
== false || !from_script
)
2331 output_filename
= name
;
2332 had_output_filename
= true;
2337 static lang_output_section_statement_type
*current_section
;
2339 static int topower(x
)
2344 if (x
< 0) return -1;
2345 for (l
= 0; l
< 32; l
++)
2347 if (i
>= x
) return l
;
2353 lang_enter_output_section_statement (output_section_statement_name
,
2354 address_exp
, flags
, block_value
,
2355 align
, subalign
, ebase
)
2356 const char *output_section_statement_name
;
2357 etree_type
* address_exp
;
2359 bfd_vma block_value
;
2361 etree_type
*subalign
;
2364 lang_output_section_statement_type
*os
;
2368 lang_output_section_statement_lookup (output_section_statement_name
);
2372 /* Add this statement to tree */
2373 /* add_statement(lang_output_section_statement_enum,
2374 output_section_statement);*/
2375 /* Make next things chain into subchain of this */
2377 if (os
->addr_tree
==
2378 (etree_type
*) NULL
)
2384 if (flags
& SEC_NEVER_LOAD
)
2388 os
->block_value
= block_value
? block_value
: 1;
2389 stat_ptr
= &os
->children
;
2391 os
->subsection_alignment
= topower(
2392 exp_get_value_int(subalign
, -1,
2393 "subsection alignment",
2395 os
->section_alignment
= topower(
2396 exp_get_value_int(align
, -1,
2397 "section alignment", 0));
2399 os
->load_base
= ebase
;
2406 lang_output_statement_type
*new =
2407 new_stat (lang_output_statement
, stat_ptr
);
2409 new->name
= output_filename
;
2412 /* Reset the current counters in the regions */
2414 reset_memory_regions ()
2416 lang_memory_region_type
*p
= lang_memory_region_list
;
2418 for (p
= lang_memory_region_list
;
2419 p
!= (lang_memory_region_type
*) NULL
;
2422 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
2423 p
->current
= p
->origin
;
2430 lang_reasonable_defaults ();
2431 current_target
= default_target
;
2433 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
2434 /* For each output section statement, create a section in the output
2436 lang_create_output_section_statements ();
2438 ldemul_create_output_section_statements ();
2440 /* Add to the hash table all undefineds on the command line */
2441 lang_place_undefineds ();
2443 /* Create a bfd for each input file */
2444 current_target
= default_target
;
2445 lang_for_each_statement (open_input_bfds
);
2447 /* Build all sets based on the information gathered from the input
2449 ldctor_build_sets ();
2451 /* Run through the contours of the script and attatch input sections
2452 to the correct output sections
2454 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
2455 (lang_output_section_statement_type
*) NULL
);
2458 /* Find any sections not attatched explicitly and handle them */
2459 lang_place_orphans ();
2461 /* Size up the common data */
2464 ldemul_before_allocation ();
2474 lang_size_sections (statement_list
.head
,
2475 (lang_output_section_statement_type
*) NULL
,
2476 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2477 /* FIXME. Until the code in relax is fixed so that it only reads in
2478 stuff once, we cant iterate since there is no way for the linker to
2479 know what has been patched and what hasn't */
2485 /* Now run around and relax if we can */
2486 if (command_line
.relax
)
2488 /* First time round is a trial run to get the 'worst case'
2489 addresses of the objects if there was no relaxing. */
2490 lang_size_sections (statement_list
.head
,
2491 (lang_output_section_statement_type
*) NULL
,
2492 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2495 reset_memory_regions ();
2497 /* Do all the assignments, now that we know the final resting
2498 places of all the symbols. */
2500 lang_do_assignments (statement_list
.head
,
2502 (fill_type
) 0, (bfd_vma
) 0);
2504 /* Perform another relax pass - this time we know where the
2505 globals are, so can make better guess. */
2506 lang_size_sections (statement_list
.head
,
2507 (lang_output_section_statement_type
*) NULL
,
2508 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2512 /* Size up the sections. */
2513 lang_size_sections (statement_list
.head
,
2515 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2518 /* See if anything special should be done now we know how big
2520 ldemul_after_allocation ();
2522 /* Do all the assignments, now that we know the final restingplaces
2523 of all the symbols */
2525 lang_do_assignments (statement_list
.head
,
2527 (fill_type
) 0, (bfd_vma
) 0);
2529 /* Make sure that we're not mixing architectures */
2539 /* EXPORTED TO YACC */
2542 lang_add_wild (section_name
, filename
)
2543 CONST
char *CONST section_name
;
2544 CONST
char *CONST filename
;
2546 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
2549 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
2551 placed_commons
= true;
2553 if (filename
!= (char *) NULL
)
2555 lang_has_input_file
= true;
2557 new->section_name
= section_name
;
2558 new->filename
= filename
;
2559 lang_list_init (&new->children
);
2563 lang_section_start (name
, address
)
2565 etree_type
* address
;
2567 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
2569 ad
->section_name
= name
;
2570 ad
->address
= address
;
2574 lang_add_entry (name
)
2577 entry_symbol
= name
;
2581 lang_add_target (name
)
2584 lang_target_statement_type
*new = new_stat (lang_target_statement
,
2600 map_option_f
= true;
2611 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
2618 lang_add_data (type
, exp
)
2620 union etree_union
*exp
;
2623 lang_data_statement_type
*new = new_stat (lang_data_statement
,
2632 lang_add_assignment (exp
)
2635 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
2642 lang_add_attribute (attribute
)
2643 enum statement_enum attribute
;
2645 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
2652 if (startup_file
!= (char *) NULL
)
2654 einfo ("%P%Fmultiple STARTUP files\n");
2656 first_file
->filename
= name
;
2657 first_file
->local_sym_name
= name
;
2659 startup_file
= name
;
2666 lang_float_flag
= maybe
;
2670 lang_leave_output_section_statement (fill
, memspec
)
2672 CONST
char *memspec
;
2674 current_section
->fill
= fill
;
2675 current_section
->region
= lang_memory_region_lookup (memspec
);
2676 stat_ptr
= &statement_list
;
2678 /* We remember if we are closing a .data section, since we use it to
2679 store constructors in */
2680 if (strcmp (current_section
->name
, ".data") == 0)
2682 end_of_data_section_statement_list
= statement_list
;
2688 Create an absolute symbol with the given name with the value of the
2689 address of first byte of the section named.
2691 If the symbol already exists, then do nothing.
2694 lang_abs_symbol_at_beginning_of (secname
, name
)
2695 const char *secname
;
2698 struct bfd_link_hash_entry
*h
;
2700 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2701 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2702 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2704 if (h
->type
== bfd_link_hash_new
2705 || h
->type
== bfd_link_hash_undefined
)
2709 h
->type
= bfd_link_hash_defined
;
2711 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2712 if (sec
== (asection
*) NULL
)
2715 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
2717 h
->u
.def
.section
= &bfd_abs_section
;
2722 Create an absolute symbol with the given name with the value of the
2723 address of the first byte after the end of the section named.
2725 If the symbol already exists, then do nothing.
2728 lang_abs_symbol_at_end_of (secname
, name
)
2729 const char *secname
;
2732 struct bfd_link_hash_entry
*h
;
2734 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2735 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2736 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2738 if (h
->type
== bfd_link_hash_new
2739 || h
->type
== bfd_link_hash_undefined
)
2743 h
->type
= bfd_link_hash_defined
;
2745 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2746 if (sec
== (asection
*) NULL
)
2749 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
2750 + bfd_section_size (output_bfd
, sec
));
2752 h
->u
.def
.section
= &bfd_abs_section
;
2757 lang_statement_append (list
, element
, field
)
2758 lang_statement_list_type
* list
;
2759 lang_statement_union_type
* element
;
2760 lang_statement_union_type
** field
;
2762 *(list
->tail
) = element
;
2766 /* Set the output format type. -oformat overrides scripts. */
2768 lang_add_output_format (format
, from_script
)
2772 if (output_target
== NULL
|| !from_script
)
2773 output_target
= format
;