1 /* Linker command language support.
2 Copyright 1991, 1992, 1993 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. */
36 static void print_statements
PARAMS ((void));
37 static void print_statement
PARAMS ((lang_statement_union_type
*,
38 lang_output_section_statement_type
*));
39 static lang_statement_union_type
*new_statement
PARAMS ((enum statement_enum
,
41 lang_statement_list_type
*));
45 static struct obstack stat_obstack
;
47 #define obstack_chunk_alloc ldmalloc
48 #define obstack_chunk_free free
49 static CONST
char *startup_file
;
50 static lang_statement_list_type input_file_chain
;
52 /* Points to the last statement in the .data section, so we can add
53 stuff to the data section without pain */
54 static lang_statement_list_type end_of_data_section_statement_list
;
56 static boolean placed_commons
= false;
57 static lang_output_section_statement_type
*default_common_section
;
58 static boolean map_option_f
;
59 static bfd_vma print_dot
;
60 static lang_input_statement_type
*first_file
;
61 static lang_statement_list_type lang_output_section_statement
;
62 static CONST
char *current_target
;
63 static CONST
char *output_target
;
64 static int longest_section_name
= 8;
65 static lang_statement_list_type statement_list
;
67 static void print_size
PARAMS ((size_t value
));
68 static void print_alignment
PARAMS ((unsigned int value
));
69 static void print_fill
PARAMS ((fill_type value
));
70 static void print_section
PARAMS ((const char *name
));
71 static void lang_for_each_statement_worker
72 PARAMS ((void (*func
) (lang_statement_union_type
*),
73 lang_statement_union_type
*s
));
74 static lang_input_statement_type
*new_afile
75 PARAMS ((const char *name
, lang_input_file_enum_type file_type
,
77 static void print_flags
PARAMS ((int *ignore_flags
));
78 static void init_os
PARAMS ((lang_output_section_statement_type
*s
));
79 static void wild_doit
PARAMS ((lang_statement_list_type
*ptr
,
81 lang_output_section_statement_type
*output
,
82 lang_input_statement_type
*file
));
83 static asection
*our_bfd_get_section_by_name
PARAMS ((bfd
*abfd
,
84 const char *section
));
85 static void wild_section
PARAMS ((lang_wild_statement_type
*ptr
,
87 lang_input_statement_type
*file
,
88 lang_output_section_statement_type
*output
));
89 static lang_input_statement_type
*lookup_name
PARAMS ((const char *name
));
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 lang_create_output_section_statements
PARAMS ((void));
100 static void map_input_to_output_sections
101 PARAMS ((lang_statement_union_type
*s
,
103 lang_output_section_statement_type
*output_section_statement
));
104 static void print_output_section_statement
105 PARAMS ((lang_output_section_statement_type
*output_section_statement
));
106 static void print_assignment
107 PARAMS ((lang_assignment_statement_type
*assignment
,
108 lang_output_section_statement_type
*output_section
));
109 static void print_input_statement
PARAMS ((lang_input_statement_type
*statm
));
110 static void print_symbol
PARAMS ((asymbol
*q
));
111 static void print_input_section
PARAMS ((lang_input_section_type
*in
));
112 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*fill
));
113 static void print_data_statement
PARAMS ((lang_data_statement_type
*data
));
114 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*s
));
115 static void print_wild_statement
116 PARAMS ((lang_wild_statement_type
*w
,
117 lang_output_section_statement_type
*os
));
118 static void print_statement
PARAMS ((lang_statement_union_type
*s
,
119 lang_output_section_statement_type
*os
));
120 static void print_statements
PARAMS ((void));
121 static bfd_vma insert_pad
PARAMS ((lang_statement_union_type
**this_ptr
,
122 fill_type fill
, unsigned int power
,
123 asection
*output_section_statement
,
125 static bfd_vma size_input_section
126 PARAMS ((lang_statement_union_type
**this_ptr
,
127 lang_output_section_statement_type
*output_section_statement
,
128 fill_type fill
, bfd_vma dot
, boolean relax
));
129 static bfd_vma lang_size_sections
130 PARAMS ((lang_statement_union_type
*s
,
131 lang_output_section_statement_type
*output_section_statement
,
132 lang_statement_union_type
**prev
, fill_type fill
,
133 bfd_vma dot
, boolean relax
));
134 static bfd_vma lang_do_assignments
135 PARAMS ((lang_statement_union_type
* s
,
136 lang_output_section_statement_type
*output_section_statement
,
139 static void lang_finish
PARAMS ((void));
140 static void lang_check
PARAMS ((void));
141 static void lang_common
PARAMS ((void));
142 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
143 static void lang_place_orphans
PARAMS ((void));
144 static int topower
PARAMS ((int));
145 static void reset_memory_regions
PARAMS ((void));
148 lang_output_section_statement_type
*abs_output_section
;
149 lang_statement_list_type
*stat_ptr
= &statement_list
;
150 lang_statement_list_type file_chain
=
152 CONST
char *entry_symbol
= 0;
153 bfd_size_type largest_section
= 0;
154 boolean lang_has_input_file
= false;
155 boolean had_output_filename
= false;
156 boolean lang_float_flag
= false;
157 boolean delete_output_file_on_failure
= false;
159 etree_type
*base
; /* Relocation base - or null */
163 #define cat(a,b) a##b
165 #define cat(a,b) a/**/b
168 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
170 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
172 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
178 return obstack_alloc (&stat_obstack
, size
);
185 fprintf (config
.map_file
, "%5x", (unsigned) value
);
189 print_alignment (value
)
192 fprintf (config
.map_file
, "2**%1u", value
);
199 fprintf (config
.map_file
, "%04x", (unsigned) value
);
206 fprintf (config
.map_file
, "%*s", -longest_section_name
, name
);
209 /*----------------------------------------------------------------------
210 lang_for_each_statement walks the parse tree and calls the provided
211 function for each node
215 lang_for_each_statement_worker (func
, s
)
216 void (*func
) PARAMS ((lang_statement_union_type
*));
217 lang_statement_union_type
*s
;
219 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
223 switch (s
->header
.type
)
225 case lang_constructors_statement_enum
:
226 lang_for_each_statement_worker (func
, constructor_list
.head
);
228 case lang_output_section_statement_enum
:
229 lang_for_each_statement_worker
231 s
->output_section_statement
.children
.head
);
233 case lang_wild_statement_enum
:
234 lang_for_each_statement_worker
236 s
->wild_statement
.children
.head
);
238 case lang_data_statement_enum
:
239 case lang_object_symbols_statement_enum
:
240 case lang_output_statement_enum
:
241 case lang_target_statement_enum
:
242 case lang_input_section_enum
:
243 case lang_input_statement_enum
:
244 case lang_assignment_statement_enum
:
245 case lang_padding_statement_enum
:
246 case lang_address_statement_enum
:
256 lang_for_each_statement (func
)
257 void (*func
) PARAMS ((lang_statement_union_type
*));
259 lang_for_each_statement_worker (func
,
260 statement_list
.head
);
263 /*----------------------------------------------------------------------*/
265 lang_list_init (list
)
266 lang_statement_list_type
*list
;
268 list
->head
= (lang_statement_union_type
*) NULL
;
269 list
->tail
= &list
->head
;
272 /*----------------------------------------------------------------------
274 build a new statement node for the parse tree
279 lang_statement_union_type
*
280 new_statement (type
, size
, list
)
281 enum statement_enum type
;
283 lang_statement_list_type
* list
;
285 lang_statement_union_type
*new = (lang_statement_union_type
*)
288 new->header
.type
= type
;
289 new->header
.next
= (lang_statement_union_type
*) NULL
;
290 lang_statement_append (list
, new, &new->header
.next
);
295 Build a new input file node for the language. There are several ways
296 in which we treat an input file, eg, we only look at symbols, or
297 prefix it with a -l etc.
299 We can be supplied with requests for input files more than once;
300 they may, for example be split over serveral lines like foo.o(.text)
301 foo.o(.data) etc, so when asked for a file we check that we havn't
302 got it already so we don't duplicate the bfd.
305 static lang_input_statement_type
*
306 new_afile (name
, file_type
, target
)
308 lang_input_file_enum_type file_type
;
312 lang_input_statement_type
*p
= new_stat (lang_input_statement
,
315 lang_has_input_file
= true;
317 p
->complained
= false;
320 case lang_input_file_is_symbols_only_enum
:
322 p
->is_archive
= false;
324 p
->local_sym_name
= name
;
325 p
->just_syms_flag
= true;
326 p
->search_dirs_flag
= false;
328 case lang_input_file_is_fake_enum
:
330 p
->is_archive
= false;
332 p
->local_sym_name
= name
;
333 p
->just_syms_flag
= false;
334 p
->search_dirs_flag
= false;
336 case lang_input_file_is_l_enum
:
337 p
->is_archive
= true;
340 p
->local_sym_name
= concat ("-l", name
, "");
341 p
->just_syms_flag
= false;
342 p
->search_dirs_flag
= true;
344 case lang_input_file_is_search_file_enum
:
345 case lang_input_file_is_marker_enum
:
347 p
->is_archive
= false;
349 p
->local_sym_name
= name
;
350 p
->just_syms_flag
= false;
351 p
->search_dirs_flag
= true;
353 case lang_input_file_is_file_enum
:
355 p
->is_archive
= false;
357 p
->local_sym_name
= name
;
358 p
->just_syms_flag
= false;
359 p
->search_dirs_flag
= false;
364 p
->asymbols
= (asymbol
**) NULL
;
365 p
->superfile
= (lang_input_statement_type
*) NULL
;
366 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
367 p
->next
= (lang_statement_union_type
*) NULL
;
369 p
->common_output_section
= (asection
*) NULL
;
371 lang_statement_append (&input_file_chain
,
372 (lang_statement_union_type
*) p
,
377 lang_input_statement_type
*
378 lang_add_input_file (name
, file_type
, target
)
380 lang_input_file_enum_type file_type
;
383 /* Look it up or build a new one */
384 lang_has_input_file
= true;
387 lang_input_statement_type
*p
;
389 for (p
= (lang_input_statement_type
*) input_file_chain
.head
;
390 p
!= (lang_input_statement_type
*) NULL
;
391 p
= (lang_input_statement_type
*) (p
->next_real_file
))
393 /* Sometimes we have incomplete entries in here */
394 if (p
->filename
!= (char *) NULL
)
396 if (strcmp (name
, p
->filename
) == 0)
402 return new_afile (name
, file_type
, target
);
405 /* Build enough state so that the parser can build its tree */
409 obstack_begin (&stat_obstack
, 1000);
411 stat_ptr
= &statement_list
;
413 lang_list_init (stat_ptr
);
415 lang_list_init (&input_file_chain
);
416 lang_list_init (&lang_output_section_statement
);
417 lang_list_init (&file_chain
);
418 first_file
= lang_add_input_file ((char *) NULL
,
419 lang_input_file_is_marker_enum
,
421 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
423 abs_output_section
->bfd_section
= &bfd_abs_section
;
427 /*----------------------------------------------------------------------
428 A region is an area of memory declared with the
429 MEMORY { name:org=exp, len=exp ... }
432 We maintain a list of all the regions here
434 If no regions are specified in the script, then the default is used
435 which is created when looked up to be the entire data space
438 static lang_memory_region_type
*lang_memory_region_list
;
439 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
441 lang_memory_region_type
*
442 lang_memory_region_lookup (name
)
443 CONST
char *CONST name
;
446 lang_memory_region_type
*p
= lang_memory_region_list
;
448 for (p
= lang_memory_region_list
;
449 p
!= (lang_memory_region_type
*) NULL
;
452 if (strcmp (p
->name
, name
) == 0)
457 if (strcmp (name
, "*default*") == 0)
459 /* This is the default region, dig out first one on the list */
460 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
462 return lang_memory_region_list
;
466 lang_memory_region_type
*new =
467 (lang_memory_region_type
*) stat_alloc ((bfd_size_type
) (sizeof (lang_memory_region_type
)));
469 new->name
= buystring (name
);
470 new->next
= (lang_memory_region_type
*) NULL
;
472 *lang_memory_region_list_tail
= new;
473 lang_memory_region_list_tail
= &new->next
;
475 new->length
= ~(bfd_size_type
)0;
477 new->had_full_message
= false;
484 lang_output_section_statement_type
*
485 lang_output_section_find (name
)
486 CONST
char *CONST name
;
488 lang_statement_union_type
*u
;
489 lang_output_section_statement_type
*lookup
;
491 for (u
= lang_output_section_statement
.head
;
492 u
!= (lang_statement_union_type
*) NULL
;
495 lookup
= &u
->output_section_statement
;
496 if (strcmp (name
, lookup
->name
) == 0)
501 return (lang_output_section_statement_type
*) NULL
;
504 lang_output_section_statement_type
*
505 lang_output_section_statement_lookup (name
)
506 CONST
char *CONST name
;
508 lang_output_section_statement_type
*lookup
;
510 lookup
= lang_output_section_find (name
);
511 if (lookup
== (lang_output_section_statement_type
*) NULL
)
514 lookup
= (lang_output_section_statement_type
*)
515 new_stat (lang_output_section_statement
, stat_ptr
);
516 lookup
->region
= (lang_memory_region_type
*) NULL
;
518 lookup
->block_value
= 1;
521 lookup
->next
= (lang_statement_union_type
*) NULL
;
522 lookup
->bfd_section
= (asection
*) NULL
;
523 lookup
->processed
= false;
524 lookup
->loadable
= 1;
525 lookup
->addr_tree
= (etree_type
*) NULL
;
526 lang_list_init (&lookup
->children
);
528 lookup
->memspec
= (CONST
char *) NULL
;
530 lookup
->subsection_alignment
= -1;
531 lookup
->section_alignment
= -1;
532 lookup
->load_base
= (union etree_union
*) NULL
;
534 lang_statement_append (&lang_output_section_statement
,
535 (lang_statement_union_type
*) lookup
,
543 print_flags (ignore_flags
)
546 fprintf (config
.map_file
, "(");
548 if (flags
->flag_read
)
549 fprintf (outfile
, "R");
550 if (flags
->flag_write
)
551 fprintf (outfile
, "W");
552 if (flags
->flag_executable
)
553 fprintf (outfile
, "X");
554 if (flags
->flag_loadable
)
555 fprintf (outfile
, "L");
557 fprintf (config
.map_file
, ")");
563 lang_memory_region_type
*m
;
565 fprintf (config
.map_file
, "**MEMORY CONFIGURATION**\n\n");
567 fprintf (config
.map_file
, "name\t\torigin\t\tlength\t\tattributes\n");
569 fprintf (config
.map_file
,
570 "name\t\torigin length r_size c_size is attributes\n");
573 for (m
= lang_memory_region_list
;
574 m
!= (lang_memory_region_type
*) NULL
;
577 fprintf (config
.map_file
, "%-16s", m
->name
);
578 print_address (m
->origin
);
580 print_address ((bfd_vma
)m
->length
);
582 print_address ((bfd_vma
)m
->old_length
);
584 print_address (m
->current
- m
->origin
);
587 fprintf (config
.map_file
, " %2d%% ",
588 (int) ((m
->current
- m
->origin
) * 100 / m
->old_length
));
589 print_flags (&m
->flags
);
590 fprintf (config
.map_file
, "\n");
592 fprintf (config
.map_file
, "\n\n**LINK EDITOR MEMORY MAP**\n\n");
593 fprintf (config
.map_file
, "output input virtual\n");
594 fprintf (config
.map_file
, "section section address tsize\n\n");
605 lang_output_section_statement_type
* s
;
607 /* asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
608 section_userdata_type
*new =
609 (section_userdata_type
*)
610 stat_alloc ((bfd_size_type
) (sizeof (section_userdata_type
)));
612 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
613 if (s
->bfd_section
== (asection
*) NULL
)
614 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
615 if (s
->bfd_section
== (asection
*) NULL
)
617 einfo ("%P%F: output format %s cannot represent section called %s\n",
618 output_bfd
->xvec
->name
, s
->name
);
620 s
->bfd_section
->output_section
= s
->bfd_section
;
621 /* s->bfd_section->flags = s->flags;*/
623 /* We initialize an output sections output offset to minus its own */
624 /* vma to allow us to output a section through itself */
625 s
->bfd_section
->output_offset
= 0;
626 get_userdata (s
->bfd_section
) = (PTR
) new;
630 /***********************************************************************
633 These expand statements like *(.text) and foo.o to a list of
634 explicit actions, like foo.o(.text), bar.o(.text) and
637 The toplevel routine, wild, takes a statement, section, file and
638 target. If either the section or file is null it is taken to be the
639 wildcard. Seperate lang_input_section statements are created for
640 each part of the expanstion, and placed after the statement provided.
645 wild_doit (ptr
, section
, output
, file
)
646 lang_statement_list_type
* ptr
;
648 lang_output_section_statement_type
* output
;
649 lang_input_statement_type
* file
;
651 if (output
->bfd_section
== (asection
*) NULL
)
654 /* Initialize the vma and size to the existing section. This will
655 be overriden in lang_size_sections unless SEC_NEVER_LOAD gets
657 if (section
!= (asection
*) NULL
)
659 bfd_set_section_vma (0, output
->bfd_section
,
660 bfd_section_vma (0, section
));
661 output
->bfd_section
->_raw_size
= section
->_raw_size
;
665 if (section
!= (asection
*) NULL
666 && section
->output_section
== (asection
*) NULL
)
668 /* Add a section reference to the list */
669 lang_input_section_type
*new = new_stat (lang_input_section
, ptr
);
671 new->section
= section
;
673 section
->output_section
= output
->bfd_section
;
675 /* Be selective about what the output section inherits from the
678 if ((section
->flags
& SEC_SHARED_LIBRARY
) != 0)
679 section
->output_section
->flags
|= section
->flags
;
681 section
->output_section
->flags
|=
682 section
->flags
& (flagword
) (~ SEC_NEVER_LOAD
);
684 if (!output
->loadable
)
686 /* Turn off load flag */
687 output
->bfd_section
->flags
&= ~SEC_LOAD
;
688 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
690 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
692 output
->bfd_section
->alignment_power
= section
->alignment_power
;
694 /* If supplied an aligmnet, then force it */
695 if (output
->section_alignment
!= -1)
697 output
->bfd_section
->alignment_power
= output
->section_alignment
;
703 our_bfd_get_section_by_name (abfd
, section
)
707 return bfd_get_section_by_name (abfd
, section
);
711 wild_section (ptr
, section
, file
, output
)
712 lang_wild_statement_type
* ptr
;
714 lang_input_statement_type
* file
;
715 lang_output_section_statement_type
* output
;
719 if (file
->just_syms_flag
== false)
721 if (section
== (char *) NULL
)
723 /* Do the creation to all sections in the file */
724 for (s
= file
->the_bfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
727 if ((s
->flags
& SEC_IS_COMMON
) == 0)
729 wild_doit (&ptr
->children
, s
, output
, file
);
735 /* Do the creation to the named section only */
736 wild_doit (&ptr
->children
,
737 our_bfd_get_section_by_name (file
->the_bfd
, section
),
743 /* passed a file name (which must have been seen already and added to
744 the statement tree. We will see if it has been opened already and
745 had its symbols read. If not then we'll read it.
747 Archives are pecuilar here. We may open them once, but if they do
748 not define anything we need at the time, they won't have all their
749 symbols read. If we need them later, we'll have to redo it.
752 lang_input_statement_type
*
756 lang_input_statement_type
*search
;
758 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
759 search
!= (lang_input_statement_type
*) NULL
;
760 search
= (lang_input_statement_type
*) search
->next_real_file
)
762 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
764 if (search
->filename
!= (char *) NULL
765 && name
!= (char *) NULL
766 && strcmp (search
->filename
, name
) == 0)
770 if (search
== (lang_input_statement_type
*) NULL
)
772 /* There isn't an afile entry for this file yet, this must be
773 because the name has only appeared inside a load script and
774 not on the command line */
775 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
);
778 /* If we have already added this file, or this file is not real
779 (FIXME: can that ever actually happen?) or the name is NULL
780 (FIXME: can that ever actually happen?) don't add this file. */
783 || search
->filename
== (const char *) NULL
)
786 ldfile_open_file (search
);
788 if (bfd_check_format (search
->the_bfd
, bfd_object
))
790 ldlang_add_file (search
);
791 if (trace_files
|| trace_file_tries
)
792 info_msg ("%I\n", search
);
794 else if (bfd_check_format (search
->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", search
->the_bfd
);
803 bfd_set_gp_size (search
->the_bfd
, g_switch_value
);
805 if (bfd_link_add_symbols (search
->the_bfd
, &link_info
) == false)
806 einfo ("%F%B: could not read symbols: %E\n", search
->the_bfd
);
808 search
->loaded
= true;
814 wild (s
, section
, file
, target
, output
)
815 lang_wild_statement_type
* s
;
819 lang_output_section_statement_type
* output
;
821 lang_input_statement_type
*f
;
823 if (file
== (char *) NULL
)
825 /* Perform the iteration over all files in the list */
826 for (f
= (lang_input_statement_type
*) file_chain
.head
;
827 f
!= (lang_input_statement_type
*) NULL
;
828 f
= (lang_input_statement_type
*) f
->next
)
830 wild_section (s
, section
, f
, output
);
835 /* Perform the iteration over a single file */
836 wild_section (s
, section
, lookup_name (file
), output
);
838 if (section
!= (char *) NULL
839 && strcmp (section
, "COMMON") == 0
840 && default_common_section
== (lang_output_section_statement_type
*) NULL
)
842 /* Remember the section that common is going to incase we later
843 get something which doesn't know where to put it */
844 default_common_section
= output
;
849 read in all the files
858 if (output_target
== (char *) NULL
)
860 if (current_target
!= (char *) NULL
)
861 output_target
= current_target
;
863 output_target
= default_target
;
865 output
= bfd_openw (name
, output_target
);
867 if (output
== (bfd
*) NULL
)
869 if (bfd_error
== invalid_target
)
871 einfo ("%P%F: target %s not found\n", output_target
);
873 einfo ("%P%F: cannot open output file %s: %E\n", name
);
876 delete_output_file_on_failure
= 1;
878 /* output->flags |= D_PAGED;*/
880 if (! bfd_set_format (output
, bfd_object
))
881 einfo ("%P%F:%s: can not make object file: %E\n", name
);
882 if (! bfd_set_arch_mach (output
,
883 ldfile_output_architecture
,
884 ldfile_output_machine
))
885 einfo ("%P%F:%s: can not set architecture: %E\n", name
);
887 link_info
.hash
= bfd_link_hash_table_create (output
);
888 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
889 einfo ("%P%F: can not create link hash table: %E\n");
891 bfd_set_gp_size (output
, g_switch_value
);
899 ldlang_open_output (statement
)
900 lang_statement_union_type
* statement
;
902 switch (statement
->header
.type
)
904 case lang_output_statement_enum
:
905 ASSERT (output_bfd
== (bfd
*) NULL
);
906 output_bfd
= open_output (statement
->output_statement
.name
);
907 ldemul_set_output_arch ();
908 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
909 output_bfd
->flags
|= D_PAGED
;
911 output_bfd
->flags
&= ~D_PAGED
;
912 if (config
.text_read_only
)
913 output_bfd
->flags
|= WP_TEXT
;
915 output_bfd
->flags
&= ~WP_TEXT
;
918 case lang_target_statement_enum
:
919 current_target
= statement
->target_statement
.target
;
927 open_input_bfds (statement
)
928 lang_statement_union_type
* statement
;
930 switch (statement
->header
.type
)
932 case lang_target_statement_enum
:
933 current_target
= statement
->target_statement
.target
;
935 case lang_wild_statement_enum
:
936 /* Maybe we should load the file's symbols */
937 if (statement
->wild_statement
.filename
)
939 (void) lookup_name (statement
->wild_statement
.filename
);
942 case lang_input_statement_enum
:
943 if (statement
->input_statement
.real
== true)
945 statement
->input_statement
.target
= current_target
;
946 lookup_name (statement
->input_statement
.filename
);
954 /* If there are [COMMONS] statements, put a wild one into the bss section */
957 lang_reasonable_defaults ()
960 lang_output_section_statement_lookup (".text");
961 lang_output_section_statement_lookup (".data");
963 default_common_section
=
964 lang_output_section_statement_lookup (".bss");
967 if (placed_commons
== false)
969 lang_wild_statement_type
*new =
970 new_stat (lang_wild_statement
,
971 &default_common_section
->children
);
973 new->section_name
= "COMMON";
974 new->filename
= (char *) NULL
;
975 lang_list_init (&new->children
);
982 Add the supplied name to the symbol table as an undefined reference.
983 Remove items from the chain as we open input bfds
985 typedef struct ldlang_undef_chain_list
987 struct ldlang_undef_chain_list
*next
;
989 } ldlang_undef_chain_list_type
;
991 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
994 ldlang_add_undef (name
)
995 CONST
char *CONST name
;
997 ldlang_undef_chain_list_type
*new =
998 (ldlang_undef_chain_list_type
999 *) stat_alloc ((bfd_size_type
) (sizeof (ldlang_undef_chain_list_type
)));
1001 new->next
= ldlang_undef_chain_list_head
;
1002 ldlang_undef_chain_list_head
= new;
1004 new->name
= buystring (name
);
1007 /* Run through the list of undefineds created above and place them
1008 into the linker hash table as undefined symbols belonging to the
1012 lang_place_undefineds ()
1014 ldlang_undef_chain_list_type
*ptr
;
1016 for (ptr
= ldlang_undef_chain_list_head
;
1017 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
1020 struct bfd_link_hash_entry
*h
;
1022 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
1023 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1024 einfo ("%P%F: bfd_link_hash_lookup failed: %E");
1025 if (h
->type
== bfd_link_hash_new
)
1027 h
->type
= bfd_link_hash_undefined
;
1028 h
->u
.undef
.abfd
= NULL
;
1029 bfd_link_add_undef (link_info
.hash
, h
);
1034 /* Copy important data from out internal form to the bfd way. Also
1035 create a section for the dummy file
1039 lang_create_output_section_statements ()
1041 lang_statement_union_type
*os
;
1043 for (os
= lang_output_section_statement
.head
;
1044 os
!= (lang_statement_union_type
*) NULL
;
1045 os
= os
->output_section_statement
.next
)
1047 lang_output_section_statement_type
*s
=
1048 &os
->output_section_statement
;
1055 /* Open input files and attatch to output sections */
1057 map_input_to_output_sections (s
, target
, output_section_statement
)
1058 lang_statement_union_type
* s
;
1060 lang_output_section_statement_type
* output_section_statement
;
1062 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1064 switch (s
->header
.type
)
1068 case lang_wild_statement_enum
:
1069 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1070 s
->wild_statement
.filename
, target
,
1071 output_section_statement
);
1074 case lang_constructors_statement_enum
:
1075 map_input_to_output_sections (constructor_list
.head
,
1077 output_section_statement
);
1079 case lang_output_section_statement_enum
:
1080 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1082 &s
->output_section_statement
);
1084 case lang_output_statement_enum
:
1086 case lang_target_statement_enum
:
1087 target
= s
->target_statement
.target
;
1089 case lang_fill_statement_enum
:
1090 case lang_input_section_enum
:
1091 case lang_object_symbols_statement_enum
:
1092 case lang_data_statement_enum
:
1093 case lang_assignment_statement_enum
:
1094 case lang_padding_statement_enum
:
1096 case lang_afile_asection_pair_statement_enum
:
1099 case lang_address_statement_enum
:
1100 /* Mark the specified section with the supplied address */
1102 lang_output_section_statement_type
*os
=
1103 lang_output_section_statement_lookup
1104 (s
->address_statement
.section_name
);
1106 os
->addr_tree
= s
->address_statement
.address
;
1107 if (os
->bfd_section
== (asection
*) NULL
)
1109 einfo ("%P%F: cannot set the address of undefined section %s\n",
1110 s
->address_statement
.section_name
);
1114 case lang_input_statement_enum
:
1115 /* A standard input statement, has no wildcards */
1122 print_output_section_statement (output_section_statement
)
1123 lang_output_section_statement_type
* output_section_statement
;
1125 asection
*section
= output_section_statement
->bfd_section
;
1128 print_section (output_section_statement
->name
);
1133 print_dot
= section
->vma
;
1137 print_address (section
->vma
);
1139 print_size (section
->_raw_size
);
1141 print_size(section
->_cooked_size
);
1143 print_alignment (section
->alignment_power
);
1146 fprintf (config
.map_file
, "%s flags", output_section_statement
->region
->name
);
1147 print_flags (stdout
, &output_section_statement
->flags
);
1149 if (section
->flags
& SEC_LOAD
)
1150 fprintf (config
.map_file
, "load ");
1151 if (section
->flags
& SEC_ALLOC
)
1152 fprintf (config
.map_file
, "alloc ");
1153 if (section
->flags
& SEC_RELOC
)
1154 fprintf (config
.map_file
, "reloc ");
1155 if (section
->flags
& SEC_HAS_CONTENTS
)
1156 fprintf (config
.map_file
, "contents ");
1161 fprintf (config
.map_file
, "No attached output section");
1164 if (output_section_statement
->load_base
)
1166 int b
= exp_get_value_int(output_section_statement
->load_base
,
1167 0, "output base", lang_final_phase_enum
);
1168 printf("Output address %08x\n", b
);
1170 if (output_section_statement
->section_alignment
>= 0
1171 || output_section_statement
->section_alignment
>= 0)
1173 printf("\t\t\t\t\tforced alignment ");
1174 if ( output_section_statement
->section_alignment
>= 0)
1176 printf("section 2**%d ",output_section_statement
->section_alignment
);
1178 if ( output_section_statement
->subsection_alignment
>= 0)
1180 printf("subsection 2**%d ",output_section_statement
->subsection_alignment
);
1185 print_statement (output_section_statement
->children
.head
,
1186 output_section_statement
);
1191 print_assignment (assignment
, output_section
)
1192 lang_assignment_statement_type
* assignment
;
1193 lang_output_section_statement_type
* output_section
;
1195 etree_value_type result
;
1201 print_address (print_dot
);
1203 result
= exp_fold_tree (assignment
->exp
->assign
.src
,
1205 lang_final_phase_enum
,
1211 print_address (result
.value
);
1215 fprintf (config
.map_file
, "*undefined*");
1218 exp_print_tree (assignment
->exp
);
1220 fprintf (config
.map_file
, "\n");
1224 print_input_statement (statm
)
1225 lang_input_statement_type
* statm
;
1227 if (statm
->filename
!= (char *) NULL
)
1229 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1238 fprintf (config
.map_file
, " ");
1240 fprintf (config
.map_file
, " ");
1241 print_address (outside_symbol_address (q
));
1242 fprintf (config
.map_file
, " %s", q
->name
? q
->name
: " ");
1243 if (q
->flags
& BSF_WEAK
)
1244 fprintf (config
.map_file
, " *weak*");
1249 print_input_section (in
)
1250 lang_input_section_type
* in
;
1252 asection
*i
= in
->section
;
1253 int size
= i
->reloc_done
?
1254 bfd_get_section_size_after_reloc (i
) :
1255 bfd_get_section_size_before_reloc (i
);
1260 fprintf (config
.map_file
, " ");
1261 print_section (i
->name
);
1262 fprintf (config
.map_file
, " ");
1263 if (i
->output_section
)
1265 print_address (i
->output_section
->vma
+ i
->output_offset
);
1266 fprintf (config
.map_file
, " ");
1267 print_size (i
->_raw_size
);
1268 fprintf (config
.map_file
, " ");
1269 print_size(i
->_cooked_size
);
1270 fprintf (config
.map_file
, " ");
1271 print_alignment (i
->alignment_power
);
1272 fprintf (config
.map_file
, " ");
1276 bfd
*abfd
= in
->ifile
->the_bfd
;
1278 if (in
->ifile
->just_syms_flag
== true)
1280 fprintf (config
.map_file
, "symbols only ");
1283 fprintf (config
.map_file
, " %s ", abfd
->xvec
->name
);
1284 if (abfd
->my_archive
!= (bfd
*) NULL
)
1286 fprintf (config
.map_file
, "[%s]%s", abfd
->my_archive
->filename
,
1291 fprintf (config
.map_file
, "%s", abfd
->filename
);
1293 fprintf (config
.map_file
, "(overhead %d bytes)", (int) bfd_alloc_size (abfd
));
1296 /* Find all the symbols in this file defined in this section */
1298 if (in
->ifile
->symbol_count
)
1302 for (p
= in
->ifile
->asymbols
; *p
; p
++)
1306 if (bfd_get_section (q
) == i
1307 && (q
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0)
1320 print_dot
= outside_section_address (i
) + size
;
1324 fprintf (config
.map_file
, "No output section allocated\n");
1330 print_fill_statement (fill
)
1331 lang_fill_statement_type
* fill
;
1333 fprintf (config
.map_file
, "FILL mask ");
1334 print_fill (fill
->fill
);
1338 print_data_statement (data
)
1339 lang_data_statement_type
* data
;
1341 /* bfd_vma value; */
1346 /* ASSERT(print_dot == data->output_vma);*/
1348 print_address (data
->output_vma
+ data
->output_section
->vma
);
1350 print_address (data
->value
);
1355 fprintf (config
.map_file
, "BYTE ");
1356 print_dot
+= BYTE_SIZE
;
1359 fprintf (config
.map_file
, "SHORT ");
1360 print_dot
+= SHORT_SIZE
;
1363 fprintf (config
.map_file
, "LONG ");
1364 print_dot
+= LONG_SIZE
;
1367 fprintf (config
.map_file
, "QUAD ");
1368 print_dot
+= QUAD_SIZE
;
1372 exp_print_tree (data
->exp
);
1374 fprintf (config
.map_file
, "\n");
1379 print_padding_statement (s
)
1380 lang_padding_statement_type
* s
;
1384 print_section ("*fill*");
1386 print_address (s
->output_offset
+ s
->output_section
->vma
);
1388 print_size (s
->size
);
1390 print_fill (s
->fill
);
1393 print_dot
= s
->output_offset
+ s
->output_section
->vma
+ s
->size
;
1398 print_wild_statement (w
, os
)
1399 lang_wild_statement_type
* w
;
1400 lang_output_section_statement_type
* os
;
1402 fprintf (config
.map_file
, " from ");
1403 if (w
->filename
!= (char *) NULL
)
1405 fprintf (config
.map_file
, "%s", w
->filename
);
1409 fprintf (config
.map_file
, "*");
1411 if (w
->section_name
!= (char *) NULL
)
1413 fprintf (config
.map_file
, "(%s)", w
->section_name
);
1417 fprintf (config
.map_file
, "(*)");
1420 print_statement (w
->children
.head
, os
);
1424 print_statement (s
, os
)
1425 lang_statement_union_type
* s
;
1426 lang_output_section_statement_type
* os
;
1430 switch (s
->header
.type
)
1432 case lang_constructors_statement_enum
:
1433 fprintf (config
.map_file
, "constructors:\n");
1434 print_statement (constructor_list
.head
, os
);
1436 case lang_wild_statement_enum
:
1437 print_wild_statement (&s
->wild_statement
, os
);
1440 fprintf (config
.map_file
, "Fail with %d\n", s
->header
.type
);
1443 case lang_address_statement_enum
:
1444 fprintf (config
.map_file
, "address\n");
1446 case lang_object_symbols_statement_enum
:
1447 fprintf (config
.map_file
, "object symbols\n");
1449 case lang_fill_statement_enum
:
1450 print_fill_statement (&s
->fill_statement
);
1452 case lang_data_statement_enum
:
1453 print_data_statement (&s
->data_statement
);
1455 case lang_input_section_enum
:
1456 print_input_section (&s
->input_section
);
1458 case lang_padding_statement_enum
:
1459 print_padding_statement (&s
->padding_statement
);
1461 case lang_output_section_statement_enum
:
1462 print_output_section_statement (&s
->output_section_statement
);
1464 case lang_assignment_statement_enum
:
1465 print_assignment (&s
->assignment_statement
,
1468 case lang_target_statement_enum
:
1469 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1471 case lang_output_statement_enum
:
1472 fprintf (config
.map_file
, "OUTPUT(%s %s)\n",
1473 s
->output_statement
.name
,
1474 output_target
? output_target
: "");
1476 case lang_input_statement_enum
:
1477 print_input_statement (&s
->input_statement
);
1479 case lang_afile_asection_pair_statement_enum
:
1491 print_statement (statement_list
.head
,
1492 abs_output_section
);
1497 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
1498 lang_statement_union_type
** this_ptr
;
1501 asection
* output_section_statement
;
1504 /* Align this section first to the
1505 input sections requirement, then
1506 to the output section's requirement.
1507 If this alignment is > than any seen before,
1508 then record it too. Perform the alignment by
1509 inserting a magic 'padding' statement.
1512 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
1514 if (alignment_needed
!= 0)
1516 lang_statement_union_type
*new =
1517 (lang_statement_union_type
*)
1518 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1520 /* Link into existing chain */
1521 new->header
.next
= *this_ptr
;
1523 new->header
.type
= lang_padding_statement_enum
;
1524 new->padding_statement
.output_section
= output_section_statement
;
1525 new->padding_statement
.output_offset
=
1526 dot
- output_section_statement
->vma
;
1527 new->padding_statement
.fill
= fill
;
1528 new->padding_statement
.size
= alignment_needed
;
1532 /* Remember the most restrictive alignment */
1533 if (power
> output_section_statement
->alignment_power
)
1535 output_section_statement
->alignment_power
= power
;
1537 output_section_statement
->_raw_size
+= alignment_needed
;
1538 return alignment_needed
+ dot
;
1542 /* Work out how much this section will move the dot point */
1544 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
1545 lang_statement_union_type
** this_ptr
;
1546 lang_output_section_statement_type
* output_section_statement
;
1551 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1552 asection
*i
= is
->section
;
1554 if (is
->ifile
->just_syms_flag
== false)
1556 if (output_section_statement
->subsection_alignment
!= -1)
1557 i
->alignment_power
=
1558 output_section_statement
->subsection_alignment
;
1560 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
1561 output_section_statement
->bfd_section
, dot
);
1563 /* remember the largest size so we can malloc the largest area
1564 needed for the output stage. Only remember the size of sections
1565 which we will actually allocate */
1566 if ((i
->flags
& SEC_HAS_CONTENTS
) != 0
1567 && (bfd_get_section_size_before_reloc (i
) > largest_section
))
1569 largest_section
= bfd_get_section_size_before_reloc (i
);
1572 /* Remember where in the output section this input section goes */
1574 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1576 /* Mark how big the output section must be to contain this now
1580 dot
+= i
->_cooked_size
;
1584 dot
+= i
->_raw_size
;
1586 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
1590 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
1596 /* Sizing happens in two passes, first pass we allocate worst case
1597 stuff. The second pass (if relaxing), we use what we learnt to
1598 change the size of some relocs from worst case to better
1600 static boolean had_relax
;
1603 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
1604 lang_statement_union_type
* s
;
1605 lang_output_section_statement_type
* output_section_statement
;
1606 lang_statement_union_type
** prev
;
1611 /* Size up the sections from their constituent parts */
1612 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1614 switch (s
->header
.type
)
1617 case lang_output_section_statement_enum
:
1620 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
1622 /* If this is a shared library section, don't change the size
1624 if (os
->bfd_section
->flags
& SEC_SHARED_LIBRARY
)
1627 if (os
->bfd_section
== &bfd_abs_section
)
1629 /* No matter what happens, an abs section starts at zero */
1630 bfd_set_section_vma (0, os
->bfd_section
, 0);
1634 if (os
->addr_tree
== (etree_type
*) NULL
)
1636 /* No address specified for this section, get one
1637 from the region specification
1639 if (os
->region
== (lang_memory_region_type
*) NULL
)
1641 os
->region
= lang_memory_region_lookup ("*default*");
1643 dot
= os
->region
->current
;
1649 r
= exp_fold_tree (os
->addr_tree
,
1651 lang_allocating_phase_enum
,
1653 if (r
.valid
== false)
1655 einfo ("%F%S: non constant address expression for section %s\n",
1660 /* The section starts here */
1661 /* First, align to what the section needs */
1664 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
1665 bfd_set_section_vma (0, os
->bfd_section
, dot
);
1667 if (os
->load_base
) {
1668 os
->bfd_section
->lma
1669 = exp_get_value_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
1674 os
->bfd_section
->output_offset
= 0;
1676 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
1677 os
->fill
, dot
, relax
);
1678 /* Ignore the size of the input sections, use the vma and size to */
1681 after
= ALIGN_N (os
->bfd_section
->vma
+
1682 os
->bfd_section
->_raw_size
,
1683 /* The coercion here is important, see ld.h. */
1684 (bfd_vma
) os
->block_value
);
1686 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
1687 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1688 os
->processed
= true;
1690 /* Replace into region ? */
1691 if (os
->addr_tree
== (etree_type
*) NULL
1692 && os
->region
!= (lang_memory_region_type
*) NULL
)
1694 os
->region
->current
= dot
;
1695 /* Make sure this isn't silly */
1696 if (( os
->region
->current
1697 > os
->region
->origin
+ os
->region
->length
)
1698 || ( os
->region
->origin
> os
->region
->current
))
1700 einfo ("%X%P: region %s is full (%B section %s)\n",
1702 os
->bfd_section
->owner
,
1703 os
->bfd_section
->name
);
1704 /* Reset the region pointer */
1705 os
->region
->current
= 0;
1713 case lang_constructors_statement_enum
:
1714 dot
= lang_size_sections (constructor_list
.head
,
1715 output_section_statement
,
1716 &s
->wild_statement
.children
.head
,
1721 case lang_data_statement_enum
:
1723 unsigned int size
= 0;
1725 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1726 s
->data_statement
.output_section
=
1727 output_section_statement
->bfd_section
;
1729 switch (s
->data_statement
.type
)
1746 output_section_statement
->bfd_section
->_raw_size
+= size
;
1750 case lang_wild_statement_enum
:
1752 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
1753 output_section_statement
,
1754 &s
->wild_statement
.children
.head
,
1760 case lang_object_symbols_statement_enum
:
1761 link_info
.create_object_symbols_section
=
1762 output_section_statement
->bfd_section
;
1764 case lang_output_statement_enum
:
1765 case lang_target_statement_enum
:
1767 case lang_input_section_enum
:
1770 lang_input_section_type
*is
;
1773 is
= &(*prev
)->input_section
;
1776 /* FIXME: The interface to bfd_relax_section should be changed
1777 to not require the generic symbols to be read. Changing
1778 this would require changing both b_out_relax_section and
1779 bfd_coff_relax16_section. */
1780 if (is
->ifile
->asymbols
== (asymbol
**) NULL
)
1782 unsigned int symsize
;
1784 symsize
= get_symtab_upper_bound (i
->owner
);
1785 is
->ifile
->asymbols
= (asymbol
**) ldmalloc (symsize
);
1786 is
->ifile
->symbol_count
=
1787 bfd_canonicalize_symtab (i
->owner
, is
->ifile
->asymbols
);
1789 /* The generic linker code in BFD requires that these
1790 symbols be stored in the outsymbols and symcount
1791 fields. When the bfd_relax_section is interface is
1792 fixed this should also be fixed. */
1793 i
->owner
->outsymbols
= is
->ifile
->asymbols
;
1794 i
->owner
->symcount
= is
->ifile
->symbol_count
;
1797 if (bfd_relax_section (i
->owner
, i
, &link_info
, is
->ifile
->asymbols
))
1801 (*prev
)->input_section
.section
->_cooked_size
=
1802 (*prev
)->input_section
.section
->_raw_size
;
1805 dot
= size_input_section (prev
,
1806 output_section_statement
,
1807 output_section_statement
->fill
,
1810 case lang_input_statement_enum
:
1812 case lang_fill_statement_enum
:
1813 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
1815 fill
= s
->fill_statement
.fill
;
1817 case lang_assignment_statement_enum
:
1819 bfd_vma newdot
= dot
;
1821 exp_fold_tree (s
->assignment_statement
.exp
,
1822 output_section_statement
,
1823 lang_allocating_phase_enum
,
1827 if (newdot
!= dot
&& !relax
)
1828 /* We've been moved ! so insert a pad */
1830 lang_statement_union_type
*new =
1831 (lang_statement_union_type
*)
1832 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1834 /* Link into existing chain */
1835 new->header
.next
= *prev
;
1837 new->header
.type
= lang_padding_statement_enum
;
1838 new->padding_statement
.output_section
=
1839 output_section_statement
->bfd_section
;
1840 new->padding_statement
.output_offset
=
1841 dot
- output_section_statement
->bfd_section
->vma
;
1842 new->padding_statement
.fill
= fill
;
1843 new->padding_statement
.size
= newdot
- dot
;
1844 output_section_statement
->bfd_section
->_raw_size
+=
1845 new->padding_statement
.size
;
1854 /* This can only get here when relaxing is turned on */
1855 case lang_padding_statement_enum
:
1857 case lang_address_statement_enum
:
1860 prev
= &s
->header
.next
;
1866 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
1867 lang_statement_union_type
* s
;
1868 lang_output_section_statement_type
* output_section_statement
;
1872 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1874 switch (s
->header
.type
)
1876 case lang_constructors_statement_enum
:
1877 dot
= lang_do_assignments (constructor_list
.head
,
1878 output_section_statement
,
1883 case lang_output_section_statement_enum
:
1885 lang_output_section_statement_type
*os
=
1886 &(s
->output_section_statement
);
1888 dot
= os
->bfd_section
->vma
;
1889 (void) lang_do_assignments (os
->children
.head
, os
, os
->fill
, dot
);
1890 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1893 case lang_wild_statement_enum
:
1895 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
1896 output_section_statement
,
1901 case lang_object_symbols_statement_enum
:
1902 case lang_output_statement_enum
:
1903 case lang_target_statement_enum
:
1905 case lang_common_statement_enum
:
1908 case lang_data_statement_enum
:
1910 etree_value_type value
;
1912 value
= exp_fold_tree (s
->data_statement
.exp
,
1914 lang_final_phase_enum
, dot
, &dot
);
1915 s
->data_statement
.value
= value
.value
;
1916 if (value
.valid
== false)
1917 einfo ("%F%P: invalid data statement\n");
1919 switch (s
->data_statement
.type
)
1935 case lang_input_section_enum
:
1937 asection
*in
= s
->input_section
.section
;
1939 dot
+= bfd_get_section_size_before_reloc (in
);
1943 case lang_input_statement_enum
:
1945 case lang_fill_statement_enum
:
1946 fill
= s
->fill_statement
.fill
;
1948 case lang_assignment_statement_enum
:
1950 exp_fold_tree (s
->assignment_statement
.exp
,
1951 output_section_statement
,
1952 lang_final_phase_enum
,
1958 case lang_padding_statement_enum
:
1959 dot
+= s
->padding_statement
.size
;
1964 case lang_address_statement_enum
:
1975 struct bfd_link_hash_entry
*h
;
1976 boolean warn
= link_info
.relocateable
? false : true;
1978 if (entry_symbol
== (char *) NULL
)
1980 /* No entry has been specified. Look for start, but don't warn
1981 if we don't find it. */
1982 entry_symbol
= "start";
1986 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
1987 if (h
!= (struct bfd_link_hash_entry
*) NULL
1988 && h
->type
== bfd_link_hash_defined
)
1992 val
= (h
->u
.def
.value
1993 + bfd_get_section_vma (output_bfd
,
1994 h
->u
.def
.section
->output_section
)
1995 + h
->u
.def
.section
->output_offset
);
1996 if (! bfd_set_start_address (output_bfd
, val
))
1997 einfo ("%P%F:%s: can't set start address\n", entry_symbol
);
2003 /* Can't find the entry symbol. Use the first address in the
2005 ts
= bfd_get_section_by_name (output_bfd
, ".text");
2006 if (ts
!= (asection
*) NULL
)
2009 einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
2010 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
2011 if (! bfd_set_start_address (output_bfd
,
2012 bfd_get_section_vma (output_bfd
, ts
)))
2013 einfo ("%P%F: can't set start address\n");
2018 einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2024 /* By now we know the target architecture, and we may have an */
2025 /* ldfile_output_machine_name */
2029 lang_statement_union_type
*file
;
2031 unsigned long input_machine
;
2032 enum bfd_architecture input_architecture
;
2033 CONST bfd_arch_info_type
*compatible
;
2035 for (file
= file_chain
.head
;
2036 file
!= (lang_statement_union_type
*) NULL
;
2037 file
= file
->input_statement
.next
)
2039 input_bfd
= file
->input_statement
.the_bfd
;
2041 input_machine
= bfd_get_mach (input_bfd
);
2042 input_architecture
= bfd_get_arch (input_bfd
);
2045 /* Inspect the architecture and ensure we're linking like with
2048 compatible
= bfd_arch_get_compatible (input_bfd
,
2053 ldfile_output_machine
= compatible
->mach
;
2054 ldfile_output_architecture
= compatible
->arch
;
2059 einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2060 bfd_printable_name (input_bfd
), input_bfd
,
2061 bfd_printable_name (output_bfd
));
2063 if (! bfd_set_arch_mach (output_bfd
,
2066 einfo ("%P%F:%s: can't set architecture: %E\n",
2067 bfd_get_filename (output_bfd
));
2073 /* Look through all the global common symbols and attach them to the
2074 correct section. The -sort-common command line switch may be used
2075 to roughly sort the entries by size. */
2080 if (link_info
.relocateable
2081 && ! command_line
.force_common_definition
)
2084 if (! config
.sort_common
)
2085 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
2090 for (power
= 1; power
<= 16; power
<<= 1)
2091 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
2096 /* Place one common symbol in the correct section. */
2099 lang_one_common (h
, info
)
2100 struct bfd_link_hash_entry
*h
;
2103 unsigned int power_of_two
;
2108 if (h
->type
!= bfd_link_hash_common
)
2141 if (config
.sort_common
&& align
!= *(unsigned int *) info
)
2144 section
= h
->u
.c
.section
;
2146 /* Increase the size of the section. */
2147 section
->_raw_size
= ALIGN_N (section
->_raw_size
, align
);
2149 /* Adjust the alignment if necessary. */
2150 if (power_of_two
> section
->alignment_power
)
2151 section
->alignment_power
= power_of_two
;
2153 /* Change the symbol from common to defined. */
2154 h
->type
= bfd_link_hash_defined
;
2155 h
->u
.def
.section
= section
;
2156 h
->u
.def
.value
= section
->_raw_size
;
2158 /* Increase the size of the section. */
2159 section
->_raw_size
+= size
;
2161 if (write_map
&& config
.map_file
!= NULL
)
2162 fprintf (config
.map_file
, "Allocating common %s: %lx at %lx %s\n",
2163 h
->root
.string
, (unsigned long) size
,
2164 (unsigned long) h
->u
.def
.value
, section
->owner
->filename
);
2170 run through the input files and ensure that every input
2171 section has somewhere to go. If one is found without
2172 a destination then create an input request and place it
2173 into the statement tree.
2177 lang_place_orphans ()
2179 lang_input_statement_type
*file
;
2181 for (file
= (lang_input_statement_type
*) file_chain
.head
;
2182 file
!= (lang_input_statement_type
*) NULL
;
2183 file
= (lang_input_statement_type
*) file
->next
)
2187 for (s
= file
->the_bfd
->sections
;
2188 s
!= (asection
*) NULL
;
2191 if (s
->output_section
== (asection
*) NULL
)
2193 /* This section of the file is not attatched, root
2194 around for a sensible place for it to go */
2196 if (file
->common_section
== s
)
2198 /* This is a lonely common section which must
2199 have come from an archive. We attatch to the
2200 section with the wildcard */
2201 if (! link_info
.relocateable
2202 && ! command_line
.force_common_definition
)
2204 if (default_common_section
==
2205 (lang_output_section_statement_type
*) NULL
)
2207 info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2209 default_common_section
=
2210 lang_output_section_statement_lookup (".bss");
2213 wild_doit (&default_common_section
->children
, s
,
2214 default_common_section
, file
);
2219 lang_output_section_statement_type
*os
=
2220 lang_output_section_statement_lookup (s
->name
);
2222 wild_doit (&os
->children
, s
, os
, file
);
2231 lang_set_flags (ptr
, flags
)
2235 boolean state
= false;
2250 /* ptr->flag_read = state; */
2253 /* ptr->flag_write = state; */
2256 /* ptr->flag_executable= state;*/
2260 /* ptr->flag_loadable= state;*/
2263 einfo ("%P%F: invalid syntax in flags\n");
2273 lang_for_each_file (func
)
2274 void (*func
) PARAMS ((lang_input_statement_type
*));
2276 lang_input_statement_type
*f
;
2278 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2279 f
!= (lang_input_statement_type
*) NULL
;
2280 f
= (lang_input_statement_type
*) f
->next
)
2291 lang_for_each_input_section (func
)
2292 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
2294 lang_input_statement_type
*f
;
2296 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2297 f
!= (lang_input_statement_type
*) NULL
;
2298 f
= (lang_input_statement_type
*) f
->next
)
2302 for (s
= f
->the_bfd
->sections
;
2303 s
!= (asection
*) NULL
;
2306 func (f
->the_bfd
, s
);
2314 ldlang_add_file (entry
)
2315 lang_input_statement_type
* entry
;
2319 lang_statement_append (&file_chain
,
2320 (lang_statement_union_type
*) entry
,
2323 /* The BFD linker needs to have a list of all input BFDs involved in
2325 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
2326 ASSERT (entry
->the_bfd
!= output_bfd
);
2327 for (pp
= &link_info
.input_bfds
;
2328 *pp
!= (bfd
*) NULL
;
2329 pp
= &(*pp
)->link_next
)
2331 *pp
= entry
->the_bfd
;
2332 entry
->the_bfd
->usrdata
= (PTR
) entry
;
2336 lang_add_output (name
, from_script
)
2340 /* Make -o on command line override OUTPUT in script. */
2341 if (had_output_filename
== false || !from_script
)
2343 output_filename
= name
;
2344 had_output_filename
= true;
2349 static lang_output_section_statement_type
*current_section
;
2351 static int topower(x
)
2356 if (x
< 0) return -1;
2357 for (l
= 0; l
< 32; l
++)
2359 if (i
>= x
) return l
;
2365 lang_enter_output_section_statement (output_section_statement_name
,
2366 address_exp
, flags
, block_value
,
2367 align
, subalign
, ebase
)
2368 const char *output_section_statement_name
;
2369 etree_type
* address_exp
;
2371 bfd_vma block_value
;
2373 etree_type
*subalign
;
2376 lang_output_section_statement_type
*os
;
2380 lang_output_section_statement_lookup (output_section_statement_name
);
2384 /* Add this statement to tree */
2385 /* add_statement(lang_output_section_statement_enum,
2386 output_section_statement);*/
2387 /* Make next things chain into subchain of this */
2389 if (os
->addr_tree
==
2390 (etree_type
*) NULL
)
2396 if (flags
& SEC_NEVER_LOAD
)
2400 os
->block_value
= block_value
? block_value
: 1;
2401 stat_ptr
= &os
->children
;
2403 os
->subsection_alignment
= topower(
2404 exp_get_value_int(subalign
, -1,
2405 "subsection alignment",
2407 os
->section_alignment
= topower(
2408 exp_get_value_int(align
, -1,
2409 "section alignment", 0));
2411 os
->load_base
= ebase
;
2418 lang_output_statement_type
*new =
2419 new_stat (lang_output_statement
, stat_ptr
);
2421 new->name
= output_filename
;
2424 /* Reset the current counters in the regions */
2426 reset_memory_regions ()
2428 lang_memory_region_type
*p
= lang_memory_region_list
;
2430 for (p
= lang_memory_region_list
;
2431 p
!= (lang_memory_region_type
*) NULL
;
2434 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
2435 p
->current
= p
->origin
;
2442 lang_reasonable_defaults ();
2443 current_target
= default_target
;
2445 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
2446 /* For each output section statement, create a section in the output
2448 lang_create_output_section_statements ();
2450 ldemul_create_output_section_statements ();
2452 /* Add to the hash table all undefineds on the command line */
2453 lang_place_undefineds ();
2455 /* Create a bfd for each input file */
2456 current_target
= default_target
;
2457 lang_for_each_statement (open_input_bfds
);
2459 /* Build all sets based on the information gathered from the input
2461 ldctor_build_sets ();
2463 /* Run through the contours of the script and attatch input sections
2464 to the correct output sections
2466 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
2467 (lang_output_section_statement_type
*) NULL
);
2470 /* Find any sections not attatched explicitly and handle them */
2471 lang_place_orphans ();
2473 /* Size up the common data */
2476 ldemul_before_allocation ();
2486 lang_size_sections (statement_list
.head
,
2487 (lang_output_section_statement_type
*) NULL
,
2488 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2489 /* FIXME. Until the code in relax is fixed so that it only reads in
2490 stuff once, we cant iterate since there is no way for the linker to
2491 know what has been patched and what hasn't */
2497 /* Now run around and relax if we can */
2498 if (command_line
.relax
)
2500 /* First time round is a trial run to get the 'worst case'
2501 addresses of the objects if there was no relaxing. */
2502 lang_size_sections (statement_list
.head
,
2503 (lang_output_section_statement_type
*) NULL
,
2504 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2507 reset_memory_regions ();
2509 /* Do all the assignments, now that we know the final resting
2510 places of all the symbols. */
2512 lang_do_assignments (statement_list
.head
,
2514 (fill_type
) 0, (bfd_vma
) 0);
2516 /* Perform another relax pass - this time we know where the
2517 globals are, so can make better guess. */
2518 lang_size_sections (statement_list
.head
,
2519 (lang_output_section_statement_type
*) NULL
,
2520 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2524 /* Size up the sections. */
2525 lang_size_sections (statement_list
.head
,
2527 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2530 /* See if anything special should be done now we know how big
2532 ldemul_after_allocation ();
2534 /* Do all the assignments, now that we know the final restingplaces
2535 of all the symbols */
2537 lang_do_assignments (statement_list
.head
,
2539 (fill_type
) 0, (bfd_vma
) 0);
2541 /* Make sure that we're not mixing architectures */
2550 /* DO NOT REENABLE THIS CALL. IF THIS CALL IS MADE, THE SUN4 LINKER
2551 CAN NOT BOOTSTRAP!! No, I don't know why, but don't change it
2552 unless you fix it. */
2553 /* Size up the sections. */
2554 lang_size_sections (statement_list
.head
,
2556 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2562 /* EXPORTED TO YACC */
2565 lang_add_wild (section_name
, filename
)
2566 CONST
char *CONST section_name
;
2567 CONST
char *CONST filename
;
2569 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
2572 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
2574 placed_commons
= true;
2576 if (filename
!= (char *) NULL
)
2578 lang_has_input_file
= true;
2580 new->section_name
= section_name
;
2581 new->filename
= filename
;
2582 lang_list_init (&new->children
);
2586 lang_section_start (name
, address
)
2588 etree_type
* address
;
2590 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
2592 ad
->section_name
= name
;
2593 ad
->address
= address
;
2597 lang_add_entry (name
)
2600 entry_symbol
= name
;
2604 lang_add_target (name
)
2607 lang_target_statement_type
*new = new_stat (lang_target_statement
,
2623 map_option_f
= true;
2634 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
2641 lang_add_data (type
, exp
)
2643 union etree_union
*exp
;
2646 lang_data_statement_type
*new = new_stat (lang_data_statement
,
2655 lang_add_assignment (exp
)
2658 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
2665 lang_add_attribute (attribute
)
2666 enum statement_enum attribute
;
2668 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
2675 if (startup_file
!= (char *) NULL
)
2677 einfo ("%P%Fmultiple STARTUP files\n");
2679 first_file
->filename
= name
;
2680 first_file
->local_sym_name
= name
;
2682 startup_file
= name
;
2689 lang_float_flag
= maybe
;
2693 lang_leave_output_section_statement (fill
, memspec
)
2695 CONST
char *memspec
;
2697 current_section
->fill
= fill
;
2698 current_section
->region
= lang_memory_region_lookup (memspec
);
2699 stat_ptr
= &statement_list
;
2701 /* We remember if we are closing a .data section, since we use it to
2702 store constructors in */
2703 if (strcmp (current_section
->name
, ".data") == 0)
2705 end_of_data_section_statement_list
= statement_list
;
2711 Create an absolute symbol with the given name with the value of the
2712 address of first byte of the section named.
2714 If the symbol already exists, then do nothing.
2717 lang_abs_symbol_at_beginning_of (secname
, name
)
2718 const char *secname
;
2721 struct bfd_link_hash_entry
*h
;
2723 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2724 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2725 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2727 if (h
->type
== bfd_link_hash_new
2728 || h
->type
== bfd_link_hash_undefined
)
2732 h
->type
= bfd_link_hash_defined
;
2734 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2735 if (sec
== (asection
*) NULL
)
2738 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
2740 h
->u
.def
.section
= &bfd_abs_section
;
2745 Create an absolute symbol with the given name with the value of the
2746 address of the first byte after the end of the section named.
2748 If the symbol already exists, then do nothing.
2751 lang_abs_symbol_at_end_of (secname
, name
)
2752 const char *secname
;
2755 struct bfd_link_hash_entry
*h
;
2757 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2758 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2759 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2761 if (h
->type
== bfd_link_hash_new
2762 || h
->type
== bfd_link_hash_undefined
)
2766 h
->type
= bfd_link_hash_defined
;
2768 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2769 if (sec
== (asection
*) NULL
)
2772 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
2773 + bfd_section_size (output_bfd
, sec
));
2775 h
->u
.def
.section
= &bfd_abs_section
;
2780 lang_statement_append (list
, element
, field
)
2781 lang_statement_list_type
* list
;
2782 lang_statement_union_type
* element
;
2783 lang_statement_union_type
** field
;
2785 *(list
->tail
) = element
;
2789 /* Set the output format type. -oformat overrides scripts. */
2791 lang_add_output_format (format
, from_script
)
2795 if (output_target
== NULL
|| !from_script
)
2796 output_target
= format
;