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_reloc_statement
PARAMS ((lang_reloc_statement_type
*reloc
));
116 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*s
));
117 static void print_wild_statement
118 PARAMS ((lang_wild_statement_type
*w
,
119 lang_output_section_statement_type
*os
));
120 static void print_statement
PARAMS ((lang_statement_union_type
*s
,
121 lang_output_section_statement_type
*os
));
122 static void print_statements
PARAMS ((void));
123 static bfd_vma insert_pad
PARAMS ((lang_statement_union_type
**this_ptr
,
124 fill_type fill
, unsigned int power
,
125 asection
*output_section_statement
,
127 static bfd_vma size_input_section
128 PARAMS ((lang_statement_union_type
**this_ptr
,
129 lang_output_section_statement_type
*output_section_statement
,
130 fill_type fill
, bfd_vma dot
, boolean relax
));
131 static bfd_vma lang_do_assignments
132 PARAMS ((lang_statement_union_type
* s
,
133 lang_output_section_statement_type
*output_section_statement
,
136 static void lang_finish
PARAMS ((void));
137 static void lang_check
PARAMS ((void));
138 static void lang_common
PARAMS ((void));
139 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
140 static void lang_place_orphans
PARAMS ((void));
141 static int topower
PARAMS ((int));
142 static void reset_memory_regions
PARAMS ((void));
145 lang_output_section_statement_type
*abs_output_section
;
146 lang_statement_list_type
*stat_ptr
= &statement_list
;
147 lang_statement_list_type file_chain
=
149 CONST
char *entry_symbol
= 0;
150 boolean lang_has_input_file
= false;
151 boolean had_output_filename
= false;
152 boolean lang_float_flag
= false;
153 boolean delete_output_file_on_failure
= false;
155 etree_type
*base
; /* Relocation base - or null */
158 #if defined(__STDC__) || defined(ALMOST_STDC)
159 #define cat(a,b) a##b
161 #define cat(a,b) a/**/b
164 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
166 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
168 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
174 return obstack_alloc (&stat_obstack
, size
);
181 fprintf (config
.map_file
, "%5x", (unsigned) value
);
185 print_alignment (value
)
188 fprintf (config
.map_file
, "2**%1u", value
);
195 fprintf (config
.map_file
, "%04x", (unsigned) value
);
202 fprintf (config
.map_file
, "%*s", -longest_section_name
, name
);
205 /*----------------------------------------------------------------------
206 lang_for_each_statement walks the parse tree and calls the provided
207 function for each node
211 lang_for_each_statement_worker (func
, s
)
212 void (*func
) PARAMS ((lang_statement_union_type
*));
213 lang_statement_union_type
*s
;
215 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
219 switch (s
->header
.type
)
221 case lang_constructors_statement_enum
:
222 lang_for_each_statement_worker (func
, constructor_list
.head
);
224 case lang_output_section_statement_enum
:
225 lang_for_each_statement_worker
227 s
->output_section_statement
.children
.head
);
229 case lang_wild_statement_enum
:
230 lang_for_each_statement_worker
232 s
->wild_statement
.children
.head
);
234 case lang_data_statement_enum
:
235 case lang_reloc_statement_enum
:
236 case lang_object_symbols_statement_enum
:
237 case lang_output_statement_enum
:
238 case lang_target_statement_enum
:
239 case lang_input_section_enum
:
240 case lang_input_statement_enum
:
241 case lang_assignment_statement_enum
:
242 case lang_padding_statement_enum
:
243 case lang_address_statement_enum
:
253 lang_for_each_statement (func
)
254 void (*func
) PARAMS ((lang_statement_union_type
*));
256 lang_for_each_statement_worker (func
,
257 statement_list
.head
);
260 /*----------------------------------------------------------------------*/
262 lang_list_init (list
)
263 lang_statement_list_type
*list
;
265 list
->head
= (lang_statement_union_type
*) NULL
;
266 list
->tail
= &list
->head
;
269 /*----------------------------------------------------------------------
271 build a new statement node for the parse tree
276 lang_statement_union_type
*
277 new_statement (type
, size
, list
)
278 enum statement_enum type
;
280 lang_statement_list_type
* list
;
282 lang_statement_union_type
*new = (lang_statement_union_type
*)
285 new->header
.type
= type
;
286 new->header
.next
= (lang_statement_union_type
*) NULL
;
287 lang_statement_append (list
, new, &new->header
.next
);
292 Build a new input file node for the language. There are several ways
293 in which we treat an input file, eg, we only look at symbols, or
294 prefix it with a -l etc.
296 We can be supplied with requests for input files more than once;
297 they may, for example be split over serveral lines like foo.o(.text)
298 foo.o(.data) etc, so when asked for a file we check that we havn't
299 got it already so we don't duplicate the bfd.
302 static lang_input_statement_type
*
303 new_afile (name
, file_type
, target
)
305 lang_input_file_enum_type file_type
;
309 lang_input_statement_type
*p
= new_stat (lang_input_statement
,
312 lang_has_input_file
= true;
314 p
->complained
= false;
317 case lang_input_file_is_symbols_only_enum
:
319 p
->is_archive
= false;
321 p
->local_sym_name
= name
;
322 p
->just_syms_flag
= true;
323 p
->search_dirs_flag
= false;
325 case lang_input_file_is_fake_enum
:
327 p
->is_archive
= false;
329 p
->local_sym_name
= name
;
330 p
->just_syms_flag
= false;
331 p
->search_dirs_flag
= false;
333 case lang_input_file_is_l_enum
:
334 p
->is_archive
= true;
337 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
338 p
->just_syms_flag
= false;
339 p
->search_dirs_flag
= true;
341 case lang_input_file_is_search_file_enum
:
342 case lang_input_file_is_marker_enum
:
344 p
->is_archive
= false;
346 p
->local_sym_name
= name
;
347 p
->just_syms_flag
= false;
348 p
->search_dirs_flag
= true;
350 case lang_input_file_is_file_enum
:
352 p
->is_archive
= false;
354 p
->local_sym_name
= name
;
355 p
->just_syms_flag
= false;
356 p
->search_dirs_flag
= false;
361 p
->asymbols
= (asymbol
**) NULL
;
362 p
->superfile
= (lang_input_statement_type
*) NULL
;
363 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
364 p
->next
= (lang_statement_union_type
*) NULL
;
366 p
->common_output_section
= (asection
*) NULL
;
368 lang_statement_append (&input_file_chain
,
369 (lang_statement_union_type
*) p
,
374 lang_input_statement_type
*
375 lang_add_input_file (name
, file_type
, target
)
377 lang_input_file_enum_type file_type
;
380 /* Look it up or build a new one */
381 lang_has_input_file
= true;
384 lang_input_statement_type
*p
;
386 for (p
= (lang_input_statement_type
*) input_file_chain
.head
;
387 p
!= (lang_input_statement_type
*) NULL
;
388 p
= (lang_input_statement_type
*) (p
->next_real_file
))
390 /* Sometimes we have incomplete entries in here */
391 if (p
->filename
!= (char *) NULL
)
393 if (strcmp (name
, p
->filename
) == 0)
399 return new_afile (name
, file_type
, target
);
402 /* Build enough state so that the parser can build its tree */
406 obstack_begin (&stat_obstack
, 1000);
408 stat_ptr
= &statement_list
;
410 lang_list_init (stat_ptr
);
412 lang_list_init (&input_file_chain
);
413 lang_list_init (&lang_output_section_statement
);
414 lang_list_init (&file_chain
);
415 first_file
= lang_add_input_file ((char *) NULL
,
416 lang_input_file_is_marker_enum
,
418 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
420 abs_output_section
->bfd_section
= &bfd_abs_section
;
424 /*----------------------------------------------------------------------
425 A region is an area of memory declared with the
426 MEMORY { name:org=exp, len=exp ... }
429 We maintain a list of all the regions here
431 If no regions are specified in the script, then the default is used
432 which is created when looked up to be the entire data space
435 static lang_memory_region_type
*lang_memory_region_list
;
436 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
438 lang_memory_region_type
*
439 lang_memory_region_lookup (name
)
440 CONST
char *CONST name
;
443 lang_memory_region_type
*p
= lang_memory_region_list
;
445 for (p
= lang_memory_region_list
;
446 p
!= (lang_memory_region_type
*) NULL
;
449 if (strcmp (p
->name
, name
) == 0)
454 if (strcmp (name
, "*default*") == 0)
456 /* This is the default region, dig out first one on the list */
457 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
459 return lang_memory_region_list
;
463 lang_memory_region_type
*new =
464 (lang_memory_region_type
*) stat_alloc ((bfd_size_type
) (sizeof (lang_memory_region_type
)));
466 new->name
= buystring (name
);
467 new->next
= (lang_memory_region_type
*) NULL
;
469 *lang_memory_region_list_tail
= new;
470 lang_memory_region_list_tail
= &new->next
;
472 new->length
= ~(bfd_size_type
)0;
474 new->had_full_message
= false;
481 lang_output_section_statement_type
*
482 lang_output_section_find (name
)
483 CONST
char *CONST name
;
485 lang_statement_union_type
*u
;
486 lang_output_section_statement_type
*lookup
;
488 for (u
= lang_output_section_statement
.head
;
489 u
!= (lang_statement_union_type
*) NULL
;
492 lookup
= &u
->output_section_statement
;
493 if (strcmp (name
, lookup
->name
) == 0)
498 return (lang_output_section_statement_type
*) NULL
;
501 lang_output_section_statement_type
*
502 lang_output_section_statement_lookup (name
)
503 CONST
char *CONST name
;
505 lang_output_section_statement_type
*lookup
;
507 lookup
= lang_output_section_find (name
);
508 if (lookup
== (lang_output_section_statement_type
*) NULL
)
511 lookup
= (lang_output_section_statement_type
*)
512 new_stat (lang_output_section_statement
, stat_ptr
);
513 lookup
->region
= (lang_memory_region_type
*) NULL
;
515 lookup
->block_value
= 1;
518 lookup
->next
= (lang_statement_union_type
*) NULL
;
519 lookup
->bfd_section
= (asection
*) NULL
;
520 lookup
->processed
= false;
521 lookup
->loadable
= 1;
522 lookup
->addr_tree
= (etree_type
*) NULL
;
523 lang_list_init (&lookup
->children
);
525 lookup
->memspec
= (CONST
char *) NULL
;
527 lookup
->subsection_alignment
= -1;
528 lookup
->section_alignment
= -1;
529 lookup
->load_base
= (union etree_union
*) NULL
;
531 lang_statement_append (&lang_output_section_statement
,
532 (lang_statement_union_type
*) lookup
,
540 print_flags (ignore_flags
)
543 fprintf (config
.map_file
, "(");
545 if (flags
->flag_read
)
546 fprintf (outfile
, "R");
547 if (flags
->flag_write
)
548 fprintf (outfile
, "W");
549 if (flags
->flag_executable
)
550 fprintf (outfile
, "X");
551 if (flags
->flag_loadable
)
552 fprintf (outfile
, "L");
554 fprintf (config
.map_file
, ")");
560 lang_memory_region_type
*m
;
562 fprintf (config
.map_file
, "**MEMORY CONFIGURATION**\n\n");
564 fprintf (config
.map_file
, "name\t\torigin\t\tlength\t\tattributes\n");
566 fprintf (config
.map_file
,
567 "name\t\torigin length r_size c_size is attributes\n");
570 for (m
= lang_memory_region_list
;
571 m
!= (lang_memory_region_type
*) NULL
;
574 fprintf (config
.map_file
, "%-16s", m
->name
);
575 print_address (m
->origin
);
577 print_address ((bfd_vma
)m
->length
);
579 print_address ((bfd_vma
)m
->old_length
);
581 print_address (m
->current
- m
->origin
);
584 fprintf (config
.map_file
, " %2d%% ",
585 (int) ((m
->current
- m
->origin
) * 100 / m
->old_length
));
586 print_flags (&m
->flags
);
587 fprintf (config
.map_file
, "\n");
589 fprintf (config
.map_file
, "\n\n**LINK EDITOR MEMORY MAP**\n\n");
590 fprintf (config
.map_file
, "output input virtual\n");
591 fprintf (config
.map_file
, "section section address tsize\n\n");
602 lang_output_section_statement_type
* s
;
604 /* asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
605 section_userdata_type
*new =
606 (section_userdata_type
*)
607 stat_alloc ((bfd_size_type
) (sizeof (section_userdata_type
)));
609 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
610 if (s
->bfd_section
== (asection
*) NULL
)
611 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
612 if (s
->bfd_section
== (asection
*) NULL
)
614 einfo ("%P%F: output format %s cannot represent section called %s\n",
615 output_bfd
->xvec
->name
, s
->name
);
617 s
->bfd_section
->output_section
= s
->bfd_section
;
618 /* s->bfd_section->flags = s->flags;*/
620 /* We initialize an output sections output offset to minus its own */
621 /* vma to allow us to output a section through itself */
622 s
->bfd_section
->output_offset
= 0;
623 get_userdata (s
->bfd_section
) = (PTR
) new;
627 /***********************************************************************
630 These expand statements like *(.text) and foo.o to a list of
631 explicit actions, like foo.o(.text), bar.o(.text) and
634 The toplevel routine, wild, takes a statement, section, file and
635 target. If either the section or file is null it is taken to be the
636 wildcard. Seperate lang_input_section statements are created for
637 each part of the expanstion, and placed after the statement provided.
642 wild_doit (ptr
, section
, output
, file
)
643 lang_statement_list_type
* ptr
;
645 lang_output_section_statement_type
* output
;
646 lang_input_statement_type
* file
;
648 if (output
->bfd_section
== (asection
*) NULL
)
651 /* Initialize the vma and size to the existing section. This will
652 be overriden in lang_size_sections unless SEC_NEVER_LOAD gets
654 if (section
!= (asection
*) NULL
)
656 bfd_set_section_vma (0, output
->bfd_section
,
657 bfd_section_vma (0, section
));
658 output
->bfd_section
->_raw_size
= section
->_raw_size
;
662 if (section
!= (asection
*) NULL
663 && section
->output_section
== (asection
*) NULL
)
665 /* Add a section reference to the list */
666 lang_input_section_type
*new = new_stat (lang_input_section
, ptr
);
668 new->section
= section
;
670 section
->output_section
= output
->bfd_section
;
672 /* Be selective about what the output section inherits from the
675 if ((section
->flags
& SEC_SHARED_LIBRARY
) != 0)
676 section
->output_section
->flags
|= section
->flags
;
678 section
->output_section
->flags
|=
679 section
->flags
& (flagword
) (~ SEC_NEVER_LOAD
);
681 if (!output
->loadable
)
683 /* Turn off load flag */
684 output
->bfd_section
->flags
&= ~SEC_LOAD
;
685 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
687 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
689 output
->bfd_section
->alignment_power
= section
->alignment_power
;
691 /* If supplied an aligmnet, then force it */
692 if (output
->section_alignment
!= -1)
694 output
->bfd_section
->alignment_power
= output
->section_alignment
;
700 our_bfd_get_section_by_name (abfd
, section
)
704 return bfd_get_section_by_name (abfd
, section
);
708 wild_section (ptr
, section
, file
, output
)
709 lang_wild_statement_type
* ptr
;
711 lang_input_statement_type
* file
;
712 lang_output_section_statement_type
* output
;
716 if (file
->just_syms_flag
== false)
718 if (section
== (char *) NULL
)
720 /* Do the creation to all sections in the file */
721 for (s
= file
->the_bfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
724 if ((s
->flags
& SEC_IS_COMMON
) == 0)
726 wild_doit (&ptr
->children
, s
, output
, file
);
732 /* Do the creation to the named section only */
733 wild_doit (&ptr
->children
,
734 our_bfd_get_section_by_name (file
->the_bfd
, section
),
740 /* passed a file name (which must have been seen already and added to
741 the statement tree. We will see if it has been opened already and
742 had its symbols read. If not then we'll read it.
744 Archives are pecuilar here. We may open them once, but if they do
745 not define anything we need at the time, they won't have all their
746 symbols read. If we need them later, we'll have to redo it.
749 lang_input_statement_type
*
750 lookup_name (name
, force_load
)
754 lang_input_statement_type
*search
;
756 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
757 search
!= (lang_input_statement_type
*) NULL
;
758 search
= (lang_input_statement_type
*) search
->next_real_file
)
760 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
762 if (search
->filename
!= (char *) NULL
763 && name
!= (char *) NULL
764 && strcmp (search
->filename
, name
) == 0)
768 if (search
== (lang_input_statement_type
*) NULL
)
770 /* There isn't an afile entry for this file yet, this must be
771 because the name has only appeared inside a load script and
772 not on the command line */
773 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
);
776 /* If we have already added this file, or this file is not real
777 (FIXME: can that ever actually happen?) or the name is NULL
778 (FIXME: can that ever actually happen?) don't add this file. */
779 if ((search
->loaded
&& ! force_load
)
781 || search
->filename
== (const char *) NULL
)
783 /* start-sanitize-mpw */
785 /* I hate adding code that works, but for reasons I don't know. */
786 search
->the_bfd
= NULL
;
788 /* end-sanitize-mpw */
790 ldfile_open_file (search
);
792 if (bfd_check_format (search
->the_bfd
, bfd_object
))
794 ldlang_add_file (search
);
795 if (trace_files
|| trace_file_tries
)
796 info_msg ("%I\n", search
);
798 else if (bfd_check_format (search
->the_bfd
, bfd_archive
))
800 /* There is nothing to do here; the add_symbols routine will
801 call ldlang_add_file (via the add_archive_element callback)
802 for each element of the archive which is used. */
805 einfo ("%F%B: file not recognized: %E\n", search
->the_bfd
);
807 if (bfd_link_add_symbols (search
->the_bfd
, &link_info
) == false)
808 einfo ("%F%B: could not read symbols: %E\n", search
->the_bfd
);
810 search
->loaded
= true;
816 wild (s
, section
, file
, target
, output
)
817 lang_wild_statement_type
* s
;
821 lang_output_section_statement_type
* output
;
823 lang_input_statement_type
*f
;
825 if (file
== (char *) NULL
)
827 /* Perform the iteration over all files in the list */
828 for (f
= (lang_input_statement_type
*) file_chain
.head
;
829 f
!= (lang_input_statement_type
*) NULL
;
830 f
= (lang_input_statement_type
*) f
->next
)
832 wild_section (s
, section
, f
, output
);
837 /* Perform the iteration over a single file */
838 wild_section (s
, section
, lookup_name (file
, 0), output
);
840 if (section
!= (char *) NULL
841 && strcmp (section
, "COMMON") == 0
842 && default_common_section
== (lang_output_section_statement_type
*) NULL
)
844 /* Remember the section that common is going to incase we later
845 get something which doesn't know where to put it */
846 default_common_section
= output
;
851 read in all the files
860 if (output_target
== (char *) NULL
)
862 if (current_target
!= (char *) NULL
)
863 output_target
= current_target
;
865 output_target
= default_target
;
867 output
= bfd_openw (name
, output_target
);
869 if (output
== (bfd
*) NULL
)
871 if (bfd_get_error () == bfd_error_invalid_target
)
873 einfo ("%P%F: target %s not found\n", output_target
);
875 einfo ("%P%F: cannot open output file %s: %E\n", name
);
878 delete_output_file_on_failure
= 1;
880 /* output->flags |= D_PAGED;*/
882 if (! bfd_set_format (output
, bfd_object
))
883 einfo ("%P%F:%s: can not make object file: %E\n", name
);
884 if (! bfd_set_arch_mach (output
,
885 ldfile_output_architecture
,
886 ldfile_output_machine
))
887 einfo ("%P%F:%s: can not set architecture: %E\n", name
);
889 link_info
.hash
= bfd_link_hash_table_create (output
);
890 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
891 einfo ("%P%F: can not create link hash table: %E\n");
893 bfd_set_gp_size (output
, g_switch_value
);
901 ldlang_open_output (statement
)
902 lang_statement_union_type
* statement
;
904 switch (statement
->header
.type
)
906 case lang_output_statement_enum
:
907 ASSERT (output_bfd
== (bfd
*) NULL
);
908 output_bfd
= open_output (statement
->output_statement
.name
);
909 ldemul_set_output_arch ();
910 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
911 output_bfd
->flags
|= D_PAGED
;
913 output_bfd
->flags
&= ~D_PAGED
;
914 if (config
.text_read_only
)
915 output_bfd
->flags
|= WP_TEXT
;
917 output_bfd
->flags
&= ~WP_TEXT
;
920 case lang_target_statement_enum
:
921 current_target
= statement
->target_statement
.target
;
929 open_input_bfds (statement
)
930 lang_statement_union_type
* statement
;
932 switch (statement
->header
.type
)
934 case lang_target_statement_enum
:
935 current_target
= statement
->target_statement
.target
;
937 case lang_wild_statement_enum
:
938 /* Maybe we should load the file's symbols */
939 if (statement
->wild_statement
.filename
)
941 (void) lookup_name (statement
->wild_statement
.filename
, 1);
944 case lang_input_statement_enum
:
945 if (statement
->input_statement
.real
== true)
947 statement
->input_statement
.target
= current_target
;
948 lookup_name (statement
->input_statement
.filename
, 1);
956 /* If there are [COMMONS] statements, put a wild one into the bss section */
959 lang_reasonable_defaults ()
962 lang_output_section_statement_lookup (".text");
963 lang_output_section_statement_lookup (".data");
965 default_common_section
=
966 lang_output_section_statement_lookup (".bss");
969 if (placed_commons
== false)
971 lang_wild_statement_type
*new =
972 new_stat (lang_wild_statement
,
973 &default_common_section
->children
);
975 new->section_name
= "COMMON";
976 new->filename
= (char *) NULL
;
977 lang_list_init (&new->children
);
984 Add the supplied name to the symbol table as an undefined reference.
985 Remove items from the chain as we open input bfds
987 typedef struct ldlang_undef_chain_list
989 struct ldlang_undef_chain_list
*next
;
991 } ldlang_undef_chain_list_type
;
993 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
996 ldlang_add_undef (name
)
997 CONST
char *CONST name
;
999 ldlang_undef_chain_list_type
*new =
1000 (ldlang_undef_chain_list_type
1001 *) stat_alloc ((bfd_size_type
) (sizeof (ldlang_undef_chain_list_type
)));
1003 new->next
= ldlang_undef_chain_list_head
;
1004 ldlang_undef_chain_list_head
= new;
1006 new->name
= buystring (name
);
1009 /* Run through the list of undefineds created above and place them
1010 into the linker hash table as undefined symbols belonging to the
1014 lang_place_undefineds ()
1016 ldlang_undef_chain_list_type
*ptr
;
1018 for (ptr
= ldlang_undef_chain_list_head
;
1019 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
1022 struct bfd_link_hash_entry
*h
;
1024 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
1025 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1026 einfo ("%P%F: bfd_link_hash_lookup failed: %E");
1027 if (h
->type
== bfd_link_hash_new
)
1029 h
->type
= bfd_link_hash_undefined
;
1030 h
->u
.undef
.abfd
= NULL
;
1031 bfd_link_add_undef (link_info
.hash
, h
);
1036 /* Copy important data from out internal form to the bfd way. Also
1037 create a section for the dummy file
1041 lang_create_output_section_statements ()
1043 lang_statement_union_type
*os
;
1045 for (os
= lang_output_section_statement
.head
;
1046 os
!= (lang_statement_union_type
*) NULL
;
1047 os
= os
->output_section_statement
.next
)
1049 lang_output_section_statement_type
*s
=
1050 &os
->output_section_statement
;
1057 /* Open input files and attatch to output sections */
1059 map_input_to_output_sections (s
, target
, output_section_statement
)
1060 lang_statement_union_type
* s
;
1062 lang_output_section_statement_type
* output_section_statement
;
1064 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1066 switch (s
->header
.type
)
1070 case lang_wild_statement_enum
:
1071 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1072 s
->wild_statement
.filename
, target
,
1073 output_section_statement
);
1076 case lang_constructors_statement_enum
:
1077 map_input_to_output_sections (constructor_list
.head
,
1079 output_section_statement
);
1081 case lang_output_section_statement_enum
:
1082 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1084 &s
->output_section_statement
);
1086 case lang_output_statement_enum
:
1088 case lang_target_statement_enum
:
1089 target
= s
->target_statement
.target
;
1091 case lang_fill_statement_enum
:
1092 case lang_input_section_enum
:
1093 case lang_object_symbols_statement_enum
:
1094 case lang_data_statement_enum
:
1095 case lang_reloc_statement_enum
:
1096 case lang_assignment_statement_enum
:
1097 case lang_padding_statement_enum
:
1099 case lang_afile_asection_pair_statement_enum
:
1102 case lang_address_statement_enum
:
1103 /* Mark the specified section with the supplied address */
1105 lang_output_section_statement_type
*os
=
1106 lang_output_section_statement_lookup
1107 (s
->address_statement
.section_name
);
1109 os
->addr_tree
= s
->address_statement
.address
;
1110 if (os
->bfd_section
== (asection
*) NULL
)
1112 einfo ("%P%F: cannot set the address of undefined section %s\n",
1113 s
->address_statement
.section_name
);
1117 case lang_input_statement_enum
:
1118 /* A standard input statement, has no wildcards */
1125 print_output_section_statement (output_section_statement
)
1126 lang_output_section_statement_type
* output_section_statement
;
1128 asection
*section
= output_section_statement
->bfd_section
;
1131 print_section (output_section_statement
->name
);
1136 print_dot
= section
->vma
;
1140 print_address (section
->vma
);
1142 print_size (section
->_raw_size
);
1144 print_size(section
->_cooked_size
);
1146 print_alignment (section
->alignment_power
);
1149 fprintf (config
.map_file
, "%s flags", output_section_statement
->region
->name
);
1150 print_flags (stdout
, &output_section_statement
->flags
);
1152 if (section
->flags
& SEC_LOAD
)
1153 fprintf (config
.map_file
, "load ");
1154 if (section
->flags
& SEC_ALLOC
)
1155 fprintf (config
.map_file
, "alloc ");
1156 if (section
->flags
& SEC_RELOC
)
1157 fprintf (config
.map_file
, "reloc ");
1158 if (section
->flags
& SEC_HAS_CONTENTS
)
1159 fprintf (config
.map_file
, "contents ");
1164 fprintf (config
.map_file
, "No attached output section");
1167 if (output_section_statement
->load_base
)
1169 int b
= exp_get_value_int(output_section_statement
->load_base
,
1170 0, "output base", lang_final_phase_enum
);
1171 printf("Output address %08x\n", b
);
1173 if (output_section_statement
->section_alignment
>= 0
1174 || output_section_statement
->section_alignment
>= 0)
1176 printf("\t\t\t\t\tforced alignment ");
1177 if ( output_section_statement
->section_alignment
>= 0)
1179 printf("section 2**%d ",output_section_statement
->section_alignment
);
1181 if ( output_section_statement
->subsection_alignment
>= 0)
1183 printf("subsection 2**%d ",output_section_statement
->subsection_alignment
);
1188 print_statement (output_section_statement
->children
.head
,
1189 output_section_statement
);
1194 print_assignment (assignment
, output_section
)
1195 lang_assignment_statement_type
* assignment
;
1196 lang_output_section_statement_type
* output_section
;
1198 etree_value_type result
;
1204 print_address (print_dot
);
1206 result
= exp_fold_tree (assignment
->exp
->assign
.src
,
1208 lang_final_phase_enum
,
1214 print_address (result
.value
);
1218 fprintf (config
.map_file
, "*undefined*");
1221 exp_print_tree (assignment
->exp
);
1223 fprintf (config
.map_file
, "\n");
1227 print_input_statement (statm
)
1228 lang_input_statement_type
* statm
;
1230 if (statm
->filename
!= (char *) NULL
)
1232 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1236 /* Print all the defined symbols for the abfd provided by in the supplied
1241 print_one_symbol (hash_entry
, ptr
)
1242 struct bfd_link_hash_entry
*hash_entry
;
1245 asection
* sec
= (asection
*)ptr
;
1247 if (hash_entry
->type
== bfd_link_hash_defined
)
1249 if (sec
== hash_entry
->u
.def
.section
) {
1251 fprintf (config
.map_file
, " ");
1253 fprintf (config
.map_file
, " ");
1254 print_address (hash_entry
->u
.def
.value
+ outside_section_address (sec
));
1255 fprintf (config
.map_file
, " %s", hash_entry
->root
.string
);
1264 print_input_section (in
)
1265 lang_input_section_type
* in
;
1267 asection
*i
= in
->section
;
1268 int size
= i
->reloc_done
?
1269 bfd_get_section_size_after_reloc (i
) :
1270 bfd_get_section_size_before_reloc (i
);
1275 fprintf (config
.map_file
, " ");
1276 print_section (i
->name
);
1277 fprintf (config
.map_file
, " ");
1278 if (i
->output_section
)
1280 print_address (i
->output_section
->vma
+ i
->output_offset
);
1281 fprintf (config
.map_file
, " ");
1282 print_size (i
->_raw_size
);
1283 fprintf (config
.map_file
, " ");
1284 print_size(i
->_cooked_size
);
1285 fprintf (config
.map_file
, " ");
1286 print_alignment (i
->alignment_power
);
1287 fprintf (config
.map_file
, " ");
1291 bfd
*abfd
= in
->ifile
->the_bfd
;
1293 if (in
->ifile
->just_syms_flag
== true)
1295 fprintf (config
.map_file
, "symbols only ");
1298 fprintf (config
.map_file
, " %s ", abfd
->xvec
->name
);
1299 if (abfd
->my_archive
!= (bfd
*) NULL
)
1301 fprintf (config
.map_file
, "[%s]%s", abfd
->my_archive
->filename
,
1306 fprintf (config
.map_file
, "%s", abfd
->filename
);
1308 fprintf (config
.map_file
, "(overhead %d bytes)", (int) bfd_alloc_size (abfd
));
1311 /* Print all the symbols */
1312 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
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");
1377 /* Print a reloc statement. */
1380 print_reloc_statement (reloc
)
1381 lang_reloc_statement_type
*reloc
;
1388 /* ASSERT(print_dot == data->output_vma);*/
1390 print_address (reloc
->output_vma
+ reloc
->output_section
->vma
);
1392 print_address (reloc
->addend_value
);
1395 fprintf (config
.map_file
, "RELOC %s ", reloc
->howto
->name
);
1397 print_dot
+= bfd_get_reloc_size (reloc
->howto
);
1399 exp_print_tree (reloc
->addend_exp
);
1401 fprintf (config
.map_file
, "\n");
1405 print_padding_statement (s
)
1406 lang_padding_statement_type
* s
;
1410 print_section ("*fill*");
1412 print_address (s
->output_offset
+ s
->output_section
->vma
);
1414 print_size (s
->size
);
1416 print_fill (s
->fill
);
1419 print_dot
= s
->output_offset
+ s
->output_section
->vma
+ s
->size
;
1424 print_wild_statement (w
, os
)
1425 lang_wild_statement_type
* w
;
1426 lang_output_section_statement_type
* os
;
1428 fprintf (config
.map_file
, " from ");
1429 if (w
->filename
!= (char *) NULL
)
1431 fprintf (config
.map_file
, "%s", w
->filename
);
1435 fprintf (config
.map_file
, "*");
1437 if (w
->section_name
!= (char *) NULL
)
1439 fprintf (config
.map_file
, "(%s)", w
->section_name
);
1443 fprintf (config
.map_file
, "(*)");
1446 print_statement (w
->children
.head
, os
);
1450 print_statement (s
, os
)
1451 lang_statement_union_type
* s
;
1452 lang_output_section_statement_type
* os
;
1456 switch (s
->header
.type
)
1458 case lang_constructors_statement_enum
:
1459 fprintf (config
.map_file
, "constructors:\n");
1460 print_statement (constructor_list
.head
, os
);
1462 case lang_wild_statement_enum
:
1463 print_wild_statement (&s
->wild_statement
, os
);
1466 fprintf (config
.map_file
, "Fail with %d\n", s
->header
.type
);
1469 case lang_address_statement_enum
:
1470 fprintf (config
.map_file
, "address\n");
1472 case lang_object_symbols_statement_enum
:
1473 fprintf (config
.map_file
, "object symbols\n");
1475 case lang_fill_statement_enum
:
1476 print_fill_statement (&s
->fill_statement
);
1478 case lang_data_statement_enum
:
1479 print_data_statement (&s
->data_statement
);
1481 case lang_reloc_statement_enum
:
1482 print_reloc_statement (&s
->reloc_statement
);
1484 case lang_input_section_enum
:
1485 print_input_section (&s
->input_section
);
1487 case lang_padding_statement_enum
:
1488 print_padding_statement (&s
->padding_statement
);
1490 case lang_output_section_statement_enum
:
1491 print_output_section_statement (&s
->output_section_statement
);
1493 case lang_assignment_statement_enum
:
1494 print_assignment (&s
->assignment_statement
,
1497 case lang_target_statement_enum
:
1498 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1500 case lang_output_statement_enum
:
1501 fprintf (config
.map_file
, "OUTPUT(%s %s)\n",
1502 s
->output_statement
.name
,
1503 output_target
? output_target
: "");
1505 case lang_input_statement_enum
:
1506 print_input_statement (&s
->input_statement
);
1508 case lang_afile_asection_pair_statement_enum
:
1520 print_statement (statement_list
.head
,
1521 abs_output_section
);
1526 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
1527 lang_statement_union_type
** this_ptr
;
1530 asection
* output_section_statement
;
1533 /* Align this section first to the
1534 input sections requirement, then
1535 to the output section's requirement.
1536 If this alignment is > than any seen before,
1537 then record it too. Perform the alignment by
1538 inserting a magic 'padding' statement.
1541 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
1543 if (alignment_needed
!= 0)
1545 lang_statement_union_type
*new =
1546 (lang_statement_union_type
*)
1547 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1549 /* Link into existing chain */
1550 new->header
.next
= *this_ptr
;
1552 new->header
.type
= lang_padding_statement_enum
;
1553 new->padding_statement
.output_section
= output_section_statement
;
1554 new->padding_statement
.output_offset
=
1555 dot
- output_section_statement
->vma
;
1556 new->padding_statement
.fill
= fill
;
1557 new->padding_statement
.size
= alignment_needed
;
1561 /* Remember the most restrictive alignment */
1562 if (power
> output_section_statement
->alignment_power
)
1564 output_section_statement
->alignment_power
= power
;
1566 output_section_statement
->_raw_size
+= alignment_needed
;
1567 return alignment_needed
+ dot
;
1571 /* Work out how much this section will move the dot point */
1573 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
1574 lang_statement_union_type
** this_ptr
;
1575 lang_output_section_statement_type
* output_section_statement
;
1580 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1581 asection
*i
= is
->section
;
1583 if (is
->ifile
->just_syms_flag
== false)
1585 if (output_section_statement
->subsection_alignment
!= -1)
1586 i
->alignment_power
=
1587 output_section_statement
->subsection_alignment
;
1589 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
1590 output_section_statement
->bfd_section
, dot
);
1592 /* Remember where in the output section this input section goes */
1594 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1596 /* Mark how big the output section must be to contain this now
1600 dot
+= i
->_cooked_size
;
1604 dot
+= i
->_raw_size
;
1606 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
1610 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
1616 /* Sizing happens in two passes, first pass we allocate worst case
1617 stuff. The second pass (if relaxing), we use what we learnt to
1618 change the size of some relocs from worst case to better
1620 static boolean had_relax
;
1623 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
1624 lang_statement_union_type
* s
;
1625 lang_output_section_statement_type
* output_section_statement
;
1626 lang_statement_union_type
** prev
;
1631 /* Size up the sections from their constituent parts */
1632 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1634 switch (s
->header
.type
)
1637 case lang_output_section_statement_enum
:
1640 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
1642 /* If this is a shared library section, don't change the size
1644 if (os
->bfd_section
->flags
& SEC_SHARED_LIBRARY
)
1647 if (os
->bfd_section
== &bfd_abs_section
)
1649 /* No matter what happens, an abs section starts at zero */
1650 bfd_set_section_vma (0, os
->bfd_section
, 0);
1654 if (os
->addr_tree
== (etree_type
*) NULL
)
1656 /* No address specified for this section, get one
1657 from the region specification
1659 if (os
->region
== (lang_memory_region_type
*) NULL
)
1661 os
->region
= lang_memory_region_lookup ("*default*");
1663 dot
= os
->region
->current
;
1669 r
= exp_fold_tree (os
->addr_tree
,
1671 lang_allocating_phase_enum
,
1673 if (r
.valid
== false)
1675 einfo ("%F%S: non constant address expression for section %s\n",
1680 /* The section starts here */
1681 /* First, align to what the section needs */
1683 if (os
->section_alignment
!= -1)
1684 dot
= align_power (dot
, os
->section_alignment
);
1686 bfd_set_section_vma (0, os
->bfd_section
, dot
);
1688 if (os
->load_base
) {
1689 os
->bfd_section
->lma
1690 = exp_get_value_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
1695 os
->bfd_section
->output_offset
= 0;
1697 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
1698 os
->fill
, dot
, relax
);
1699 /* Ignore the size of the input sections, use the vma and size to */
1702 after
= ALIGN_N (os
->bfd_section
->vma
+
1703 os
->bfd_section
->_raw_size
,
1704 /* The coercion here is important, see ld.h. */
1705 (bfd_vma
) os
->block_value
);
1707 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
1708 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1709 os
->processed
= true;
1711 /* Replace into region ? */
1712 if (os
->addr_tree
== (etree_type
*) NULL
1713 && os
->region
!= (lang_memory_region_type
*) NULL
)
1715 os
->region
->current
= dot
;
1716 /* Make sure this isn't silly */
1717 if (( os
->region
->current
1718 > os
->region
->origin
+ os
->region
->length
)
1719 || ( os
->region
->origin
> os
->region
->current
))
1721 einfo ("%X%P: region %s is full (%B section %s)\n",
1723 os
->bfd_section
->owner
,
1724 os
->bfd_section
->name
);
1725 /* Reset the region pointer */
1726 os
->region
->current
= 0;
1734 case lang_constructors_statement_enum
:
1735 dot
= lang_size_sections (constructor_list
.head
,
1736 output_section_statement
,
1737 &s
->wild_statement
.children
.head
,
1742 case lang_data_statement_enum
:
1744 unsigned int size
= 0;
1746 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1747 s
->data_statement
.output_section
=
1748 output_section_statement
->bfd_section
;
1750 switch (s
->data_statement
.type
)
1767 output_section_statement
->bfd_section
->_raw_size
+= size
;
1771 case lang_reloc_statement_enum
:
1775 s
->reloc_statement
.output_vma
=
1776 dot
- output_section_statement
->bfd_section
->vma
;
1777 s
->reloc_statement
.output_section
=
1778 output_section_statement
->bfd_section
;
1779 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
1781 output_section_statement
->bfd_section
->_raw_size
+= size
;
1785 case lang_wild_statement_enum
:
1787 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
1788 output_section_statement
,
1789 &s
->wild_statement
.children
.head
,
1795 case lang_object_symbols_statement_enum
:
1796 link_info
.create_object_symbols_section
=
1797 output_section_statement
->bfd_section
;
1799 case lang_output_statement_enum
:
1800 case lang_target_statement_enum
:
1802 case lang_input_section_enum
:
1805 lang_input_section_type
*is
;
1808 is
= &(*prev
)->input_section
;
1811 /* FIXME: The interface to bfd_relax_section should be changed
1812 to not require the generic symbols to be read. Changing
1813 this would require changing both b_out_relax_section and
1814 bfd_coff_relax16_section. */
1815 if (is
->ifile
->asymbols
== (asymbol
**) NULL
)
1817 unsigned int symsize
;
1819 symsize
= get_symtab_upper_bound (i
->owner
);
1820 is
->ifile
->asymbols
= (asymbol
**) xmalloc (symsize
);
1821 is
->ifile
->symbol_count
=
1822 bfd_canonicalize_symtab (i
->owner
, is
->ifile
->asymbols
);
1824 /* The generic linker code in BFD requires that these
1825 symbols be stored in the outsymbols and symcount
1826 fields. When the bfd_relax_section is interface is
1827 fixed this should also be fixed. */
1828 i
->owner
->outsymbols
= is
->ifile
->asymbols
;
1829 i
->owner
->symcount
= is
->ifile
->symbol_count
;
1832 bfd_set_error (bfd_error_no_error
);
1833 if (bfd_relax_section (i
->owner
, i
, &link_info
, is
->ifile
->asymbols
))
1835 else if (bfd_get_error () != bfd_error_no_error
)
1836 einfo ("%P%F: can't relax section: %E");
1839 (*prev
)->input_section
.section
->_cooked_size
=
1840 (*prev
)->input_section
.section
->_raw_size
;
1843 dot
= size_input_section (prev
,
1844 output_section_statement
,
1845 output_section_statement
->fill
,
1848 case lang_input_statement_enum
:
1850 case lang_fill_statement_enum
:
1851 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
1853 fill
= s
->fill_statement
.fill
;
1855 case lang_assignment_statement_enum
:
1857 bfd_vma newdot
= dot
;
1859 exp_fold_tree (s
->assignment_statement
.exp
,
1860 output_section_statement
,
1861 lang_allocating_phase_enum
,
1865 if (newdot
!= dot
&& !relax
)
1866 /* We've been moved ! so insert a pad */
1868 lang_statement_union_type
*new =
1869 (lang_statement_union_type
*)
1870 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1872 /* Link into existing chain */
1873 new->header
.next
= *prev
;
1875 new->header
.type
= lang_padding_statement_enum
;
1876 new->padding_statement
.output_section
=
1877 output_section_statement
->bfd_section
;
1878 new->padding_statement
.output_offset
=
1879 dot
- output_section_statement
->bfd_section
->vma
;
1880 new->padding_statement
.fill
= fill
;
1881 new->padding_statement
.size
= newdot
- dot
;
1882 output_section_statement
->bfd_section
->_raw_size
+=
1883 new->padding_statement
.size
;
1892 /* This can only get here when relaxing is turned on */
1893 case lang_padding_statement_enum
:
1895 case lang_address_statement_enum
:
1898 prev
= &s
->header
.next
;
1904 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
1905 lang_statement_union_type
* s
;
1906 lang_output_section_statement_type
* output_section_statement
;
1910 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1912 switch (s
->header
.type
)
1914 case lang_constructors_statement_enum
:
1915 dot
= lang_do_assignments (constructor_list
.head
,
1916 output_section_statement
,
1921 case lang_output_section_statement_enum
:
1923 lang_output_section_statement_type
*os
=
1924 &(s
->output_section_statement
);
1926 dot
= os
->bfd_section
->vma
;
1927 (void) lang_do_assignments (os
->children
.head
, os
, os
->fill
, dot
);
1928 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1931 case lang_wild_statement_enum
:
1933 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
1934 output_section_statement
,
1939 case lang_object_symbols_statement_enum
:
1940 case lang_output_statement_enum
:
1941 case lang_target_statement_enum
:
1943 case lang_common_statement_enum
:
1946 case lang_data_statement_enum
:
1948 etree_value_type value
;
1950 value
= exp_fold_tree (s
->data_statement
.exp
,
1952 lang_final_phase_enum
, dot
, &dot
);
1953 s
->data_statement
.value
= value
.value
;
1954 if (value
.valid
== false)
1955 einfo ("%F%P: invalid data statement\n");
1957 switch (s
->data_statement
.type
)
1974 case lang_reloc_statement_enum
:
1976 etree_value_type value
;
1978 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
1980 lang_final_phase_enum
, dot
, &dot
);
1981 s
->reloc_statement
.addend_value
= value
.value
;
1982 if (value
.valid
== false)
1983 einfo ("%F%P: invalid reloc statement\n");
1985 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
);
1988 case lang_input_section_enum
:
1990 asection
*in
= s
->input_section
.section
;
1992 dot
+= bfd_get_section_size_before_reloc (in
);
1996 case lang_input_statement_enum
:
1998 case lang_fill_statement_enum
:
1999 fill
= s
->fill_statement
.fill
;
2001 case lang_assignment_statement_enum
:
2003 exp_fold_tree (s
->assignment_statement
.exp
,
2004 output_section_statement
,
2005 lang_final_phase_enum
,
2011 case lang_padding_statement_enum
:
2012 dot
+= s
->padding_statement
.size
;
2017 case lang_address_statement_enum
:
2028 struct bfd_link_hash_entry
*h
;
2029 boolean warn
= link_info
.relocateable
? false : true;
2031 if (entry_symbol
== (char *) NULL
)
2033 /* No entry has been specified. Look for start, but don't warn
2034 if we don't find it. */
2035 entry_symbol
= "start";
2039 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
2040 if (h
!= (struct bfd_link_hash_entry
*) NULL
2041 && h
->type
== bfd_link_hash_defined
)
2045 val
= (h
->u
.def
.value
2046 + bfd_get_section_vma (output_bfd
,
2047 h
->u
.def
.section
->output_section
)
2048 + h
->u
.def
.section
->output_offset
);
2049 if (! bfd_set_start_address (output_bfd
, val
))
2050 einfo ("%P%F:%s: can't set start address\n", entry_symbol
);
2056 /* Can't find the entry symbol. Use the first address in the
2058 ts
= bfd_get_section_by_name (output_bfd
, ".text");
2059 if (ts
!= (asection
*) NULL
)
2062 einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
2063 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
2064 if (! bfd_set_start_address (output_bfd
,
2065 bfd_get_section_vma (output_bfd
, ts
)))
2066 einfo ("%P%F: can't set start address\n");
2071 einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2077 /* By now we know the target architecture, and we may have an */
2078 /* ldfile_output_machine_name */
2082 lang_statement_union_type
*file
;
2084 unsigned long input_machine
;
2085 enum bfd_architecture input_architecture
;
2086 CONST bfd_arch_info_type
*compatible
;
2088 for (file
= file_chain
.head
;
2089 file
!= (lang_statement_union_type
*) NULL
;
2090 file
= file
->input_statement
.next
)
2092 input_bfd
= file
->input_statement
.the_bfd
;
2094 input_machine
= bfd_get_mach (input_bfd
);
2095 input_architecture
= bfd_get_arch (input_bfd
);
2098 /* Inspect the architecture and ensure we're linking like with
2101 compatible
= bfd_arch_get_compatible (input_bfd
,
2106 ldfile_output_machine
= compatible
->mach
;
2107 ldfile_output_architecture
= compatible
->arch
;
2112 einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2113 bfd_printable_name (input_bfd
), input_bfd
,
2114 bfd_printable_name (output_bfd
));
2116 if (! bfd_set_arch_mach (output_bfd
,
2119 einfo ("%P%F:%s: can't set architecture: %E\n",
2120 bfd_get_filename (output_bfd
));
2126 /* Look through all the global common symbols and attach them to the
2127 correct section. The -sort-common command line switch may be used
2128 to roughly sort the entries by size. */
2133 if (link_info
.relocateable
2134 && ! command_line
.force_common_definition
)
2137 if (! config
.sort_common
)
2138 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
2143 for (power
= 1; power
<= 16; power
<<= 1)
2144 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
2149 /* Place one common symbol in the correct section. */
2152 lang_one_common (h
, info
)
2153 struct bfd_link_hash_entry
*h
;
2156 unsigned int power_of_two
;
2161 if (h
->type
!= bfd_link_hash_common
)
2194 if (config
.sort_common
&& align
!= *(unsigned int *) info
)
2197 section
= h
->u
.c
.section
;
2199 /* Increase the size of the section. */
2200 section
->_raw_size
= ALIGN_N (section
->_raw_size
, align
);
2202 /* Adjust the alignment if necessary. */
2203 if (power_of_two
> section
->alignment_power
)
2204 section
->alignment_power
= power_of_two
;
2206 /* Change the symbol from common to defined. */
2207 h
->type
= bfd_link_hash_defined
;
2208 h
->u
.def
.section
= section
;
2209 h
->u
.def
.value
= section
->_raw_size
;
2211 /* Increase the size of the section. */
2212 section
->_raw_size
+= size
;
2214 if (config
.map_file
!= NULL
)
2215 fprintf (config
.map_file
, "Allocating common %s: %lx at %lx %s\n",
2216 h
->root
.string
, (unsigned long) size
,
2217 (unsigned long) h
->u
.def
.value
, section
->owner
->filename
);
2223 run through the input files and ensure that every input
2224 section has somewhere to go. If one is found without
2225 a destination then create an input request and place it
2226 into the statement tree.
2230 lang_place_orphans ()
2232 lang_input_statement_type
*file
;
2234 for (file
= (lang_input_statement_type
*) file_chain
.head
;
2235 file
!= (lang_input_statement_type
*) NULL
;
2236 file
= (lang_input_statement_type
*) file
->next
)
2240 for (s
= file
->the_bfd
->sections
;
2241 s
!= (asection
*) NULL
;
2244 if (s
->output_section
== (asection
*) NULL
)
2246 /* This section of the file is not attatched, root
2247 around for a sensible place for it to go */
2249 if (file
->common_section
== s
)
2251 /* This is a lonely common section which must
2252 have come from an archive. We attatch to the
2253 section with the wildcard */
2254 if (! link_info
.relocateable
2255 && ! command_line
.force_common_definition
)
2257 if (default_common_section
==
2258 (lang_output_section_statement_type
*) NULL
)
2260 info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2262 default_common_section
=
2263 lang_output_section_statement_lookup (".bss");
2266 wild_doit (&default_common_section
->children
, s
,
2267 default_common_section
, file
);
2272 lang_output_section_statement_type
*os
=
2273 lang_output_section_statement_lookup (s
->name
);
2275 wild_doit (&os
->children
, s
, os
, file
);
2284 lang_set_flags (ptr
, flags
)
2288 boolean state
= false;
2303 /* ptr->flag_read = state; */
2306 /* ptr->flag_write = state; */
2309 /* ptr->flag_executable= state;*/
2313 /* ptr->flag_loadable= state;*/
2316 einfo ("%P%F: invalid syntax in flags\n");
2326 lang_for_each_file (func
)
2327 void (*func
) PARAMS ((lang_input_statement_type
*));
2329 lang_input_statement_type
*f
;
2331 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2332 f
!= (lang_input_statement_type
*) NULL
;
2333 f
= (lang_input_statement_type
*) f
->next
)
2344 lang_for_each_input_section (func
)
2345 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
2347 lang_input_statement_type
*f
;
2349 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2350 f
!= (lang_input_statement_type
*) NULL
;
2351 f
= (lang_input_statement_type
*) f
->next
)
2355 for (s
= f
->the_bfd
->sections
;
2356 s
!= (asection
*) NULL
;
2359 func (f
->the_bfd
, s
);
2367 ldlang_add_file (entry
)
2368 lang_input_statement_type
* entry
;
2372 lang_statement_append (&file_chain
,
2373 (lang_statement_union_type
*) entry
,
2376 /* The BFD linker needs to have a list of all input BFDs involved in
2378 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
2379 ASSERT (entry
->the_bfd
!= output_bfd
);
2380 for (pp
= &link_info
.input_bfds
;
2381 *pp
!= (bfd
*) NULL
;
2382 pp
= &(*pp
)->link_next
)
2384 *pp
= entry
->the_bfd
;
2385 entry
->the_bfd
->usrdata
= (PTR
) entry
;
2386 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
2390 lang_add_output (name
, from_script
)
2394 /* Make -o on command line override OUTPUT in script. */
2395 if (had_output_filename
== false || !from_script
)
2397 output_filename
= name
;
2398 had_output_filename
= true;
2403 static lang_output_section_statement_type
*current_section
;
2405 static int topower(x
)
2410 if (x
< 0) return -1;
2411 for (l
= 0; l
< 32; l
++)
2413 if (i
>= x
) return l
;
2419 lang_enter_output_section_statement (output_section_statement_name
,
2420 address_exp
, flags
, block_value
,
2421 align
, subalign
, ebase
)
2422 const char *output_section_statement_name
;
2423 etree_type
* address_exp
;
2425 bfd_vma block_value
;
2427 etree_type
*subalign
;
2430 lang_output_section_statement_type
*os
;
2434 lang_output_section_statement_lookup (output_section_statement_name
);
2438 /* Add this statement to tree */
2439 /* add_statement(lang_output_section_statement_enum,
2440 output_section_statement);*/
2441 /* Make next things chain into subchain of this */
2443 if (os
->addr_tree
==
2444 (etree_type
*) NULL
)
2450 if (flags
& SEC_NEVER_LOAD
)
2454 os
->block_value
= block_value
? block_value
: 1;
2455 stat_ptr
= &os
->children
;
2457 os
->subsection_alignment
= topower(
2458 exp_get_value_int(subalign
, -1,
2459 "subsection alignment",
2461 os
->section_alignment
= topower(
2462 exp_get_value_int(align
, -1,
2463 "section alignment", 0));
2465 os
->load_base
= ebase
;
2472 lang_output_statement_type
*new =
2473 new_stat (lang_output_statement
, stat_ptr
);
2475 new->name
= output_filename
;
2478 /* Reset the current counters in the regions */
2480 reset_memory_regions ()
2482 lang_memory_region_type
*p
= lang_memory_region_list
;
2484 for (p
= lang_memory_region_list
;
2485 p
!= (lang_memory_region_type
*) NULL
;
2488 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
2489 p
->current
= p
->origin
;
2496 lang_reasonable_defaults ();
2497 current_target
= default_target
;
2499 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
2500 /* For each output section statement, create a section in the output
2502 lang_create_output_section_statements ();
2504 ldemul_create_output_section_statements ();
2506 /* Add to the hash table all undefineds on the command line */
2507 lang_place_undefineds ();
2509 /* Create a bfd for each input file */
2510 current_target
= default_target
;
2511 lang_for_each_statement (open_input_bfds
);
2513 /* Build all sets based on the information gathered from the input
2515 ldctor_build_sets ();
2517 /* Size up the common data */
2520 /* Run through the contours of the script and attatch input sections
2521 to the correct output sections
2523 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
2524 (lang_output_section_statement_type
*) NULL
);
2527 /* Find any sections not attatched explicitly and handle them */
2528 lang_place_orphans ();
2530 ldemul_before_allocation ();
2540 lang_size_sections (statement_list
.head
,
2541 (lang_output_section_statement_type
*) NULL
,
2542 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2543 /* FIXME. Until the code in relax is fixed so that it only reads in
2544 stuff once, we cant iterate since there is no way for the linker to
2545 know what has been patched and what hasn't */
2551 /* Now run around and relax if we can */
2552 if (command_line
.relax
)
2554 /* First time round is a trial run to get the 'worst case'
2555 addresses of the objects if there was no relaxing. */
2556 lang_size_sections (statement_list
.head
,
2557 (lang_output_section_statement_type
*) NULL
,
2558 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2561 reset_memory_regions ();
2563 /* Do all the assignments, now that we know the final resting
2564 places of all the symbols. */
2566 lang_do_assignments (statement_list
.head
,
2568 (fill_type
) 0, (bfd_vma
) 0);
2570 /* Perform another relax pass - this time we know where the
2571 globals are, so can make better guess. */
2572 lang_size_sections (statement_list
.head
,
2573 (lang_output_section_statement_type
*) NULL
,
2574 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2578 /* Size up the sections. */
2579 lang_size_sections (statement_list
.head
,
2581 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2584 /* See if anything special should be done now we know how big
2586 ldemul_after_allocation ();
2588 /* Do all the assignments, now that we know the final restingplaces
2589 of all the symbols */
2591 lang_do_assignments (statement_list
.head
,
2593 (fill_type
) 0, (bfd_vma
) 0);
2595 /* Make sure that we're not mixing architectures */
2605 /* EXPORTED TO YACC */
2608 lang_add_wild (section_name
, filename
)
2609 CONST
char *CONST section_name
;
2610 CONST
char *CONST filename
;
2612 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
2615 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
2617 placed_commons
= true;
2619 if (filename
!= (char *) NULL
)
2621 lang_has_input_file
= true;
2623 new->section_name
= section_name
;
2624 new->filename
= filename
;
2625 lang_list_init (&new->children
);
2629 lang_section_start (name
, address
)
2631 etree_type
* address
;
2633 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
2635 ad
->section_name
= name
;
2636 ad
->address
= address
;
2640 lang_add_entry (name
)
2643 entry_symbol
= name
;
2647 lang_add_target (name
)
2650 lang_target_statement_type
*new = new_stat (lang_target_statement
,
2666 map_option_f
= true;
2677 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
2684 lang_add_data (type
, exp
)
2686 union etree_union
*exp
;
2689 lang_data_statement_type
*new = new_stat (lang_data_statement
,
2697 /* Create a new reloc statement. RELOC is the BFD relocation type to
2698 generate. HOWTO is the corresponding howto structure (we could
2699 look this up, but the caller has already done so). SECTION is the
2700 section to generate a reloc against, or NAME is the name of the
2701 symbol to generate a reloc against. Exactly one of SECTION and
2702 NAME must be NULL. ADDEND is an expression for the addend. */
2705 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
2706 bfd_reloc_code_real_type reloc
;
2707 const reloc_howto_type
*howto
;
2710 union etree_union
*addend
;
2712 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
2716 p
->section
= section
;
2718 p
->addend_exp
= addend
;
2720 p
->addend_value
= 0;
2721 p
->output_section
= NULL
;
2726 lang_add_assignment (exp
)
2729 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
2736 lang_add_attribute (attribute
)
2737 enum statement_enum attribute
;
2739 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
2746 if (startup_file
!= (char *) NULL
)
2748 einfo ("%P%Fmultiple STARTUP files\n");
2750 first_file
->filename
= name
;
2751 first_file
->local_sym_name
= name
;
2753 startup_file
= name
;
2760 lang_float_flag
= maybe
;
2764 lang_leave_output_section_statement (fill
, memspec
)
2766 CONST
char *memspec
;
2768 current_section
->fill
= fill
;
2769 current_section
->region
= lang_memory_region_lookup (memspec
);
2770 stat_ptr
= &statement_list
;
2772 /* We remember if we are closing a .data section, since we use it to
2773 store constructors in */
2774 if (strcmp (current_section
->name
, ".data") == 0)
2776 end_of_data_section_statement_list
= statement_list
;
2782 Create an absolute symbol with the given name with the value of the
2783 address of first byte of the section named.
2785 If the symbol already exists, then do nothing.
2788 lang_abs_symbol_at_beginning_of (secname
, name
)
2789 const char *secname
;
2792 struct bfd_link_hash_entry
*h
;
2794 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2795 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2796 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2798 if (h
->type
== bfd_link_hash_new
2799 || h
->type
== bfd_link_hash_undefined
)
2803 h
->type
= bfd_link_hash_defined
;
2805 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2806 if (sec
== (asection
*) NULL
)
2809 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
2811 h
->u
.def
.section
= &bfd_abs_section
;
2816 Create an absolute symbol with the given name with the value of the
2817 address of the first byte after the end of the section named.
2819 If the symbol already exists, then do nothing.
2822 lang_abs_symbol_at_end_of (secname
, name
)
2823 const char *secname
;
2826 struct bfd_link_hash_entry
*h
;
2828 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2829 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2830 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2832 if (h
->type
== bfd_link_hash_new
2833 || h
->type
== bfd_link_hash_undefined
)
2837 h
->type
= bfd_link_hash_defined
;
2839 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2840 if (sec
== (asection
*) NULL
)
2843 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
2844 + bfd_section_size (output_bfd
, sec
));
2846 h
->u
.def
.section
= &bfd_abs_section
;
2851 lang_statement_append (list
, element
, field
)
2852 lang_statement_list_type
* list
;
2853 lang_statement_union_type
* element
;
2854 lang_statement_union_type
** field
;
2856 *(list
->tail
) = element
;
2860 /* Set the output format type. -oformat overrides scripts. */
2862 lang_add_output_format (format
, from_script
)
2866 if (output_target
== NULL
|| !from_script
)
2867 output_target
= format
;