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. */
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 ldmalloc
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 /* List of statements needed to handle constructors */
58 extern lang_statement_list_type constructor_list
;
60 static boolean placed_commons
= false;
61 static lang_output_section_statement_type
*default_common_section
;
62 static boolean map_option_f
;
63 static bfd_vma print_dot
;
64 static lang_input_statement_type
*first_file
;
65 static lang_statement_list_type lang_output_section_statement
;
66 static CONST
char *current_target
;
67 static CONST
char *output_target
;
68 static size_t longest_section_name
= 8;
69 static section_userdata_type common_section_userdata
;
70 static lang_statement_list_type statement_list
;
74 lang_output_section_statement_type
*abs_output_section
;
75 lang_statement_list_type
*stat_ptr
= &statement_list
;
76 lang_input_statement_type
*script_file
= 0;
77 lang_statement_list_type file_chain
=
79 CONST
char *entry_symbol
= 0;
80 bfd_size_type largest_section
= 0;
81 boolean lang_has_input_file
= false;
82 lang_output_section_statement_type
*create_object_symbols
= 0;
83 boolean had_output_filename
= false;
84 boolean lang_float_flag
= false;
85 boolean delete_output_file_on_failure
= false;
88 extern char *default_target
;
90 extern char *current_file
;
91 extern bfd
*output_bfd
;
92 extern enum bfd_architecture ldfile_output_architecture
;
93 extern unsigned long ldfile_output_machine
;
94 extern char *ldfile_output_machine_name
;
95 extern ldsym_type
*symbol_head
;
96 extern unsigned int commons_pending
;
97 extern args_type command_line
;
98 extern ld_config_type config
;
99 extern boolean write_map
;
100 extern int g_switch_value
;
103 etree_type
*base
; /* Relocation base - or null */
107 #define cat(a,b) a##b
109 #define cat(a,b) a/**/b
112 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
114 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
116 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
118 void lang_add_data
PARAMS ((int type
, union etree_union
* exp
));
124 return obstack_alloc (&stat_obstack
, size
);
130 fprintf (config
.map_file
, "%5x", (unsigned) value
);
133 print_alignment (value
)
136 fprintf (config
.map_file
, "2**%1u", value
);
139 DEFUN (print_fill
, (value
),
142 fprintf (config
.map_file
, "%04x", (unsigned) value
);
148 CONST
char *CONST name
;
150 fprintf (config
.map_file
, "%*s", -longest_section_name
, name
);
153 /*----------------------------------------------------------------------
154 lang_for_each_statement walks the parse tree and calls the provided
155 function for each node
159 lang_for_each_statement_worker (func
, s
)
161 lang_statement_union_type
*s
;
163 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
167 switch (s
->header
.type
)
169 case lang_constructors_statement_enum
:
170 lang_for_each_statement_worker (func
, constructor_list
.head
);
172 case lang_output_section_statement_enum
:
173 lang_for_each_statement_worker
175 s
->output_section_statement
.children
.head
);
177 case lang_wild_statement_enum
:
178 lang_for_each_statement_worker
180 s
->wild_statement
.children
.head
);
182 case lang_data_statement_enum
:
183 case lang_object_symbols_statement_enum
:
184 case lang_output_statement_enum
:
185 case lang_target_statement_enum
:
186 case lang_input_section_enum
:
187 case lang_input_statement_enum
:
188 case lang_assignment_statement_enum
:
189 case lang_padding_statement_enum
:
190 case lang_address_statement_enum
:
200 lang_for_each_statement (func
)
203 lang_for_each_statement_worker (func
,
204 statement_list
.head
);
207 /*----------------------------------------------------------------------*/
209 lang_list_init (list
)
210 lang_statement_list_type
*list
;
212 list
->head
= (lang_statement_union_type
*) NULL
;
213 list
->tail
= &list
->head
;
216 /*----------------------------------------------------------------------
218 build a new statement node for the parse tree
223 lang_statement_union_type
*
224 new_statement (type
, size
, list
)
225 enum statement_enum type
;
227 lang_statement_list_type
* list
;
229 lang_statement_union_type
*new = (lang_statement_union_type
*)
232 new->header
.type
= type
;
233 new->header
.next
= (lang_statement_union_type
*) NULL
;
234 lang_statement_append (list
, new, &new->header
.next
);
239 Build a new input file node for the language. There are several ways
240 in which we treat an input file, eg, we only look at symbols, or
241 prefix it with a -l etc.
243 We can be supplied with requests for input files more than once;
244 they may, for example be split over serveral lines like foo.o(.text)
245 foo.o(.data) etc, so when asked for a file we check that we havn't
246 got it already so we don't duplicate the bfd.
249 static lang_input_statement_type
*
250 new_afile (name
, file_type
, target
)
251 CONST
char *CONST name
;
252 CONST lang_input_file_enum_type file_type
;
253 CONST
char *CONST target
;
256 lang_input_statement_type
*p
= new_stat (lang_input_statement
,
259 lang_has_input_file
= true;
261 p
->complained
= false;
264 case lang_input_file_is_symbols_only_enum
:
266 p
->is_archive
= false;
268 p
->local_sym_name
= name
;
269 p
->just_syms_flag
= true;
270 p
->search_dirs_flag
= false;
272 case lang_input_file_is_fake_enum
:
274 p
->is_archive
= false;
276 p
->local_sym_name
= name
;
277 p
->just_syms_flag
= false;
278 p
->search_dirs_flag
= false;
280 case lang_input_file_is_l_enum
:
281 p
->is_archive
= true;
284 p
->local_sym_name
= concat ("-l", name
, "");
285 p
->just_syms_flag
= false;
286 p
->search_dirs_flag
= true;
288 case lang_input_file_is_search_file_enum
:
289 case lang_input_file_is_marker_enum
:
291 p
->is_archive
= false;
293 p
->local_sym_name
= name
;
294 p
->just_syms_flag
= false;
295 p
->search_dirs_flag
= true;
297 case lang_input_file_is_file_enum
:
299 p
->is_archive
= false;
301 p
->local_sym_name
= name
;
302 p
->just_syms_flag
= false;
303 p
->search_dirs_flag
= false;
308 p
->asymbols
= (asymbol
**) NULL
;
309 p
->superfile
= (lang_input_statement_type
*) NULL
;
310 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
311 p
->next
= (lang_statement_union_type
*) NULL
;
313 p
->common_output_section
= (asection
*) NULL
;
314 lang_statement_append (&input_file_chain
,
315 (lang_statement_union_type
*) p
,
320 lang_input_statement_type
*
321 lang_add_input_file (name
, file_type
, target
)
323 lang_input_file_enum_type file_type
;
326 /* Look it up or build a new one */
327 lang_has_input_file
= true;
330 lang_input_statement_type
*p
;
332 for (p
= (lang_input_statement_type
*) input_file_chain
.head
;
333 p
!= (lang_input_statement_type
*) NULL
;
334 p
= (lang_input_statement_type
*) (p
->next_real_file
))
336 /* Sometimes we have incomplete entries in here */
337 if (p
->filename
!= (char *) NULL
)
339 if (strcmp (name
, p
->filename
) == 0)
345 return new_afile (name
, file_type
, target
);
349 lang_add_keepsyms_file (filename
)
350 CONST
char *filename
;
352 extern strip_symbols_type strip_symbols
;
353 if (keepsyms_file
!= 0)
354 info_msg ("%X%P: error: duplicated keep-symbols-file value\n");
355 keepsyms_file
= filename
;
356 if (strip_symbols
!= STRIP_NONE
)
357 info_msg ("%P: `-keep-only-symbols-file' overrides `-s' and `-S'\n");
358 strip_symbols
= STRIP_SOME
;
361 /* Build enough state so that the parser can build its tree */
365 obstack_begin (&stat_obstack
, 1000);
367 stat_ptr
= &statement_list
;
369 lang_list_init (stat_ptr
);
371 lang_list_init (&input_file_chain
);
372 lang_list_init (&lang_output_section_statement
);
373 lang_list_init (&file_chain
);
374 first_file
= lang_add_input_file ((char *) NULL
,
375 lang_input_file_is_marker_enum
,
377 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
379 abs_output_section
->bfd_section
= &bfd_abs_section
;
383 /*----------------------------------------------------------------------
384 A region is an area of memory declared with the
385 MEMORY { name:org=exp, len=exp ... }
388 We maintain a list of all the regions here
390 If no regions are specified in the script, then the default is used
391 which is created when looked up to be the entire data space
394 static lang_memory_region_type
*lang_memory_region_list
;
395 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
397 lang_memory_region_type
*
398 lang_memory_region_lookup (name
)
399 CONST
char *CONST name
;
402 lang_memory_region_type
*p
= lang_memory_region_list
;
404 for (p
= lang_memory_region_list
;
405 p
!= (lang_memory_region_type
*) NULL
;
408 if (strcmp (p
->name
, name
) == 0)
413 if (strcmp (name
, "*default*") == 0)
415 /* This is the default region, dig out first one on the list */
416 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
418 return lang_memory_region_list
;
422 lang_memory_region_type
*new =
423 (lang_memory_region_type
*) stat_alloc ((bfd_size_type
) (sizeof (lang_memory_region_type
)));
425 new->name
= buystring (name
);
426 new->next
= (lang_memory_region_type
*) NULL
;
428 *lang_memory_region_list_tail
= new;
429 lang_memory_region_list_tail
= &new->next
;
431 new->length
= ~(bfd_size_type
)0;
433 new->had_full_message
= false;
440 lang_output_section_statement_type
*
441 lang_output_section_find (name
)
442 CONST
char *CONST name
;
444 lang_statement_union_type
*u
;
445 lang_output_section_statement_type
*lookup
;
447 for (u
= lang_output_section_statement
.head
;
448 u
!= (lang_statement_union_type
*) NULL
;
451 lookup
= &u
->output_section_statement
;
452 if (strcmp (name
, lookup
->name
) == 0)
457 return (lang_output_section_statement_type
*) NULL
;
460 lang_output_section_statement_type
*
461 lang_output_section_statement_lookup (name
)
462 CONST
char *CONST name
;
464 lang_output_section_statement_type
*lookup
;
466 lookup
= lang_output_section_find (name
);
467 if (lookup
== (lang_output_section_statement_type
*) NULL
)
470 lookup
= (lang_output_section_statement_type
*)
471 new_stat (lang_output_section_statement
, stat_ptr
);
472 lookup
->region
= (lang_memory_region_type
*) NULL
;
474 lookup
->block_value
= 1;
477 lookup
->next
= (lang_statement_union_type
*) NULL
;
478 lookup
->bfd_section
= (asection
*) NULL
;
479 lookup
->processed
= false;
480 lookup
->loadable
= 1;
481 lookup
->addr_tree
= (etree_type
*) NULL
;
482 lang_list_init (&lookup
->children
);
484 lookup
->memspec
= (CONST
char *) NULL
;
486 lookup
->subsection_alignment
= -1;
487 lookup
->section_alignment
= -1;
488 lookup
->load_base
= (union etree_union
*) NULL
;
490 lang_statement_append (&lang_output_section_statement
,
491 (lang_statement_union_type
*) lookup
,
499 print_flags (ignore_flags
)
502 fprintf (config
.map_file
, "(");
504 if (flags
->flag_read
)
505 fprintf (outfile
, "R");
506 if (flags
->flag_write
)
507 fprintf (outfile
, "W");
508 if (flags
->flag_executable
)
509 fprintf (outfile
, "X");
510 if (flags
->flag_loadable
)
511 fprintf (outfile
, "L");
513 fprintf (config
.map_file
, ")");
519 lang_memory_region_type
*m
;
521 fprintf (config
.map_file
, "**MEMORY CONFIGURATION**\n\n");
523 fprintf (config
.map_file
, "name\t\torigin\t\tlength\t\tattributes\n");
525 fprintf (config
.map_file
,
526 "name\t\torigin length r_size c_size is attributes\n");
529 for (m
= lang_memory_region_list
;
530 m
!= (lang_memory_region_type
*) NULL
;
533 fprintf (config
.map_file
, "%-16s", m
->name
);
534 print_address (m
->origin
);
536 print_address ((bfd_vma
)m
->length
);
538 print_address ((bfd_vma
)m
->old_length
);
540 print_address (m
->current
- m
->origin
);
543 fprintf(config
.map_file
," %2d%% ", ( m
->current
- m
->origin
) * 100 / m
->old_length
);
544 print_flags (&m
->flags
);
545 fprintf (config
.map_file
, "\n");
547 fprintf (config
.map_file
, "\n\n**LINK EDITOR MEMORY MAP**\n\n");
548 fprintf (config
.map_file
, "output input virtual\n");
549 fprintf (config
.map_file
, "section section address tsize\n\n");
560 lang_output_section_statement_type
* s
;
562 /* asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
563 section_userdata_type
*new =
564 (section_userdata_type
*)
565 stat_alloc ((bfd_size_type
) (sizeof (section_userdata_type
)));
567 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
568 if (s
->bfd_section
== (asection
*) NULL
)
569 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
570 if (s
->bfd_section
== (asection
*) NULL
)
572 einfo ("%P%F: output format %s cannot represent section called %s\n",
573 output_bfd
->xvec
->name
, s
->name
);
575 s
->bfd_section
->output_section
= s
->bfd_section
;
576 /* s->bfd_section->flags = s->flags;*/
578 /* We initialize an output sections output offset to minus its own */
579 /* vma to allow us to output a section through itself */
580 s
->bfd_section
->output_offset
= 0;
581 get_userdata (s
->bfd_section
) = (PTR
) new;
585 /***********************************************************************
588 These expand statements like *(.text) and foo.o to a list of
589 explicit actions, like foo.o(.text), bar.o(.text) and
592 The toplevel routine, wild, takes a statement, section, file and
593 target. If either the section or file is null it is taken to be the
594 wildcard. Seperate lang_input_section statements are created for
595 each part of the expanstion, and placed after the statement provided.
600 wild_doit (ptr
, section
, output
, file
)
601 lang_statement_list_type
* ptr
;
603 lang_output_section_statement_type
* output
;
604 lang_input_statement_type
* file
;
606 if (output
->bfd_section
== (asection
*) NULL
)
609 /* Initialize the vma and size to the existing section. This will
610 be overriden in lang_size_sections unless SEC_NEVER_LOAD gets
612 if (section
!= (asection
*) NULL
)
614 bfd_set_section_vma (0, output
->bfd_section
,
615 bfd_section_vma (0, section
));
616 output
->bfd_section
->_raw_size
= section
->_raw_size
;
620 if (section
!= (asection
*) NULL
621 && section
->output_section
== (asection
*) NULL
)
623 /* Add a section reference to the list */
624 lang_input_section_type
*new = new_stat (lang_input_section
, ptr
);
626 new->section
= section
;
628 section
->output_section
= output
->bfd_section
;
630 /* Be selective about what the output section inherits from the
633 if ((section
->flags
& SEC_SHARED_LIBRARY
) != 0)
634 section
->output_section
->flags
|= section
->flags
;
636 section
->output_section
->flags
|= section
->flags
& ~SEC_NEVER_LOAD
;
638 if (!output
->loadable
)
640 /* Turn off load flag */
641 output
->bfd_section
->flags
&= ~SEC_LOAD
;
642 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
644 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
646 output
->bfd_section
->alignment_power
= section
->alignment_power
;
648 /* If supplied an aligmnet, then force it */
649 if (output
->section_alignment
!= -1)
651 output
->bfd_section
->alignment_power
= output
->section_alignment
;
657 our_bfd_get_section_by_name (abfd
, section
)
661 return bfd_get_section_by_name (abfd
, section
);
665 wild_section (ptr
, section
, file
, output
)
666 lang_wild_statement_type
* ptr
;
668 lang_input_statement_type
* file
;
669 lang_output_section_statement_type
* output
;
673 if (file
->just_syms_flag
== false)
675 if (section
== (char *) NULL
)
677 /* Do the creation to all sections in the file */
678 for (s
= file
->the_bfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
681 if ((s
->flags
& SEC_IS_COMMON
) == 0)
683 wild_doit (&ptr
->children
, s
, output
, file
);
689 /* Do the creation to the named section only */
690 wild_doit (&ptr
->children
,
691 our_bfd_get_section_by_name (file
->the_bfd
, section
),
697 /* passed a file name (which must have been seen already and added to
698 the statement tree. We will see if it has been opened already and
699 had its symbols read. If not then we'll read it.
701 Archives are pecuilar here. We may open them once, but if they do
702 not define anything we need at the time, they won't have all their
703 symbols read. If we need them later, we'll have to redo it.
706 lang_input_statement_type
*
708 CONST
char *CONST name
;
710 lang_input_statement_type
*search
;
712 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
713 search
!= (lang_input_statement_type
*) NULL
;
714 search
= (lang_input_statement_type
*) search
->next_real_file
)
716 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
720 if (search
->filename
!= (char *) NULL
&& name
!= (char *) NULL
)
722 if (strcmp (search
->filename
, name
) == 0)
724 ldmain_open_file_read_symbol (search
);
730 /* There isn't an afile entry for this file yet, this must be
731 because the name has only appeared inside a load script and not
732 on the command line */
733 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
);
734 ldmain_open_file_read_symbol (search
);
741 wild (s
, section
, file
, target
, output
)
742 lang_wild_statement_type
* s
;
743 CONST
char *CONST section
;
744 CONST
char *CONST file
;
745 CONST
char *CONST target
;
746 lang_output_section_statement_type
* output
;
748 lang_input_statement_type
*f
;
750 if (file
== (char *) NULL
)
752 /* Perform the iteration over all files in the list */
753 for (f
= (lang_input_statement_type
*) file_chain
.head
;
754 f
!= (lang_input_statement_type
*) NULL
;
755 f
= (lang_input_statement_type
*) f
->next
)
757 wild_section (s
, section
, f
, output
);
759 /* Once more for the script file */
760 wild_section(s
, section
, script_file
, output
);
764 /* Perform the iteration over a single file */
765 wild_section (s
, section
, lookup_name (file
), output
);
767 if (section
!= (char *) NULL
768 && strcmp (section
, "COMMON") == 0
769 && default_common_section
== (lang_output_section_statement_type
*) NULL
)
771 /* Remember the section that common is going to incase we later
772 get something which doesn't know where to put it */
773 default_common_section
= output
;
778 read in all the files
783 CONST
char *CONST name
;
785 extern unsigned long ldfile_output_machine
;
786 extern enum bfd_architecture ldfile_output_architecture
;
788 extern CONST
char *output_filename
;
791 if (output_target
== (char *) NULL
)
793 if (current_target
!= (char *) NULL
)
794 output_target
= current_target
;
796 output_target
= default_target
;
798 output
= bfd_openw (name
, output_target
);
799 output_filename
= name
;
801 if (output
== (bfd
*) NULL
)
803 if (bfd_error
== invalid_target
)
805 einfo ("%P%F: target %s not found\n", output_target
);
807 einfo ("%P%F: cannot open output file %s: %E\n", name
);
810 delete_output_file_on_failure
= 1;
812 /* output->flags |= D_PAGED;*/
814 if (! bfd_set_format (output
, bfd_object
))
815 einfo ("%P%F:%s: can not make object file: %E\n", name
);
816 if (! bfd_set_arch_mach (output
,
817 ldfile_output_architecture
,
818 ldfile_output_machine
))
819 einfo ("%P%F:%s: can not set architecture: %E\n", name
);
821 bfd_set_gp_size (output
, g_switch_value
);
829 ldlang_open_output (statement
)
830 lang_statement_union_type
* statement
;
832 switch (statement
->header
.type
)
834 case lang_output_statement_enum
:
835 output_bfd
= open_output (statement
->output_statement
.name
);
836 ldemul_set_output_arch ();
837 if (config
.magic_demand_paged
&& !config
.relocateable_output
)
838 output_bfd
->flags
|= D_PAGED
;
840 output_bfd
->flags
&= ~D_PAGED
;
841 if (config
.text_read_only
)
842 output_bfd
->flags
|= WP_TEXT
;
844 output_bfd
->flags
&= ~WP_TEXT
;
847 case lang_target_statement_enum
:
848 current_target
= statement
->target_statement
.target
;
856 open_input_bfds (statement
)
857 lang_statement_union_type
* statement
;
859 switch (statement
->header
.type
)
861 case lang_target_statement_enum
:
862 current_target
= statement
->target_statement
.target
;
864 case lang_wild_statement_enum
:
865 /* Maybe we should load the file's symbols */
866 if (statement
->wild_statement
.filename
)
868 (void) lookup_name (statement
->wild_statement
.filename
);
871 case lang_input_statement_enum
:
872 if (statement
->input_statement
.real
== true)
874 statement
->input_statement
.target
= current_target
;
875 lookup_name (statement
->input_statement
.filename
);
883 /* If there are [COMMONS] statements, put a wild one into the bss section */
886 lang_reasonable_defaults ()
892 lang_output_section_statement_lookup (".text");
893 lang_output_section_statement_lookup (".data");
895 default_common_section
=
896 lang_output_section_statement_lookup (".bss");
899 if (placed_commons
== false)
901 lang_wild_statement_type
*new =
902 new_stat (lang_wild_statement
,
903 &default_common_section
->children
);
905 new->section_name
= "COMMON";
906 new->filename
= (char *) NULL
;
907 lang_list_init (&new->children
);
914 Add the supplied name to the symbol table as an undefined reference.
915 Remove items from the chain as we open input bfds
917 typedef struct ldlang_undef_chain_list
919 struct ldlang_undef_chain_list
*next
;
921 } ldlang_undef_chain_list_type
;
923 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
926 ldlang_add_undef (name
)
927 CONST
char *CONST name
;
929 ldlang_undef_chain_list_type
*new =
930 (ldlang_undef_chain_list_type
931 *) stat_alloc ((bfd_size_type
) (sizeof (ldlang_undef_chain_list_type
)));
933 new->next
= ldlang_undef_chain_list_head
;
934 ldlang_undef_chain_list_head
= new;
936 new->name
= buystring (name
);
939 /* Run through the list of undefineds created above and place them
940 into the linker hash table as undefined symbols belonging to the
944 lang_place_undefineds ()
946 ldlang_undef_chain_list_type
*ptr
= ldlang_undef_chain_list_head
;
948 while (ptr
!= (ldlang_undef_chain_list_type
*) NULL
)
951 asymbol
**def_ptr
= (asymbol
**) stat_alloc ((bfd_size_type
) (sizeof (asymbol
**)));
953 def
= (asymbol
*) bfd_make_empty_symbol (script_file
->the_bfd
);
955 def
->name
= ptr
->name
;
956 def
->section
= &bfd_und_section
;
957 enter_global_ref (def_ptr
, ptr
->name
);
962 /* Copy important data from out internal form to the bfd way. Also
963 create a section for the dummy file
967 lang_create_output_section_statements ()
969 lang_statement_union_type
*os
;
971 for (os
= lang_output_section_statement
.head
;
972 os
!= (lang_statement_union_type
*) NULL
;
973 os
= os
->output_section_statement
.next
)
975 lang_output_section_statement_type
*s
=
976 &os
->output_section_statement
;
984 lang_init_script_file ()
986 script_file
= lang_add_input_file ("command line",
987 lang_input_file_is_fake_enum
,
989 script_file
->the_bfd
= bfd_create ("command line", output_bfd
);
990 script_file
->symbol_count
= 0;
991 script_file
->the_bfd
->sections
= 0;
993 /* The user data of a bfd points to the input statement attatched */
994 script_file
->the_bfd
->usrdata
= (void *)script_file
;
995 script_file
->common_section
=
996 bfd_make_section(script_file
->the_bfd
,"COMMON");
999 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
1001 abs_output_section
->bfd_section
= &bfd_abs_section
;
1005 /* Open input files and attatch to output sections */
1007 map_input_to_output_sections (s
, target
, output_section_statement
)
1008 lang_statement_union_type
* s
;
1010 lang_output_section_statement_type
* output_section_statement
;
1012 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1014 switch (s
->header
.type
)
1018 case lang_wild_statement_enum
:
1019 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1020 s
->wild_statement
.filename
, target
,
1021 output_section_statement
);
1024 case lang_constructors_statement_enum
:
1025 map_input_to_output_sections (constructor_list
.head
,
1027 output_section_statement
);
1029 case lang_output_section_statement_enum
:
1030 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1032 &s
->output_section_statement
);
1034 case lang_output_statement_enum
:
1036 case lang_target_statement_enum
:
1037 target
= s
->target_statement
.target
;
1039 case lang_fill_statement_enum
:
1040 case lang_input_section_enum
:
1041 case lang_object_symbols_statement_enum
:
1042 case lang_data_statement_enum
:
1043 case lang_assignment_statement_enum
:
1044 case lang_padding_statement_enum
:
1046 case lang_afile_asection_pair_statement_enum
:
1049 case lang_address_statement_enum
:
1050 /* Mark the specified section with the supplied address */
1052 lang_output_section_statement_type
*os
=
1053 lang_output_section_statement_lookup
1054 (s
->address_statement
.section_name
);
1056 os
->addr_tree
= s
->address_statement
.address
;
1057 if (os
->bfd_section
== (asection
*) NULL
)
1059 einfo ("%P%F: cannot set the address of undefined section %s\n",
1060 s
->address_statement
.section_name
);
1064 case lang_input_statement_enum
:
1065 /* A standard input statement, has no wildcards */
1066 /* ldmain_open_file_read_symbol(&s->input_statement);*/
1077 print_output_section_statement (output_section_statement
)
1078 lang_output_section_statement_type
* output_section_statement
;
1080 asection
*section
= output_section_statement
->bfd_section
;
1083 print_section (output_section_statement
->name
);
1088 print_dot
= section
->vma
;
1092 print_address (section
->vma
);
1094 print_size (section
->_raw_size
);
1096 print_size(section
->_cooked_size
);
1098 print_alignment (section
->alignment_power
);
1101 fprintf (config
.map_file
, "%s flags", output_section_statement
->region
->name
);
1102 print_flags (stdout
, &output_section_statement
->flags
);
1104 if (section
->flags
& SEC_LOAD
)
1105 fprintf (config
.map_file
, "load ");
1106 if (section
->flags
& SEC_ALLOC
)
1107 fprintf (config
.map_file
, "alloc ");
1108 if (section
->flags
& SEC_RELOC
)
1109 fprintf (config
.map_file
, "reloc ");
1110 if (section
->flags
& SEC_HAS_CONTENTS
)
1111 fprintf (config
.map_file
, "contents ");
1116 fprintf (config
.map_file
, "No attached output section");
1119 if (output_section_statement
->load_base
)
1121 int b
= exp_get_value_int(output_section_statement
->load_base
,
1122 0, "output base", lang_final_phase_enum
);
1123 printf("Output address %08x\n", b
);
1125 if (output_section_statement
->section_alignment
>= 0
1126 || output_section_statement
->section_alignment
>= 0)
1128 printf("\t\t\t\t\tforced alignment ");
1129 if ( output_section_statement
->section_alignment
>= 0)
1131 printf("section 2**%d ",output_section_statement
->section_alignment
);
1133 if ( output_section_statement
->subsection_alignment
>= 0)
1135 printf("subsection 2**%d ",output_section_statement
->subsection_alignment
);
1140 print_statement (output_section_statement
->children
.head
,
1141 output_section_statement
);
1146 print_assignment (assignment
, output_section
)
1147 lang_assignment_statement_type
* assignment
;
1148 lang_output_section_statement_type
* output_section
;
1150 etree_value_type result
;
1156 print_address (print_dot
);
1158 result
= exp_fold_tree (assignment
->exp
->assign
.src
,
1160 lang_final_phase_enum
,
1166 print_address (result
.value
);
1170 fprintf (config
.map_file
, "*undefined*");
1173 exp_print_tree (assignment
->exp
);
1175 fprintf (config
.map_file
, "\n");
1179 print_input_statement (statm
)
1180 lang_input_statement_type
* statm
;
1182 if (statm
->filename
!= (char *) NULL
)
1184 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1193 fprintf (config
.map_file
, " ");
1195 fprintf (config
.map_file
, " ");
1196 print_address (outside_symbol_address (q
));
1197 fprintf (config
.map_file
, " %s", q
->name
? q
->name
: " ");
1198 if (q
->flags
& BSF_WEAK
)
1199 fprintf (config
.map_file
, " *weak*");
1204 print_input_section (in
)
1205 lang_input_section_type
* in
;
1207 asection
*i
= in
->section
;
1208 int size
= i
->reloc_done
?
1209 bfd_get_section_size_after_reloc (i
) :
1210 bfd_get_section_size_before_reloc (i
);
1215 fprintf (config
.map_file
, " ");
1216 print_section (i
->name
);
1217 fprintf (config
.map_file
, " ");
1218 if (i
->output_section
)
1220 print_address (i
->output_section
->vma
+ i
->output_offset
);
1221 fprintf (config
.map_file
, " ");
1222 print_size (i
->_raw_size
);
1223 fprintf (config
.map_file
, " ");
1224 print_size(i
->_cooked_size
);
1225 fprintf (config
.map_file
, " ");
1226 print_alignment (i
->alignment_power
);
1227 fprintf (config
.map_file
, " ");
1231 bfd
*abfd
= in
->ifile
->the_bfd
;
1233 if (in
->ifile
->just_syms_flag
== true)
1235 fprintf (config
.map_file
, "symbols only ");
1238 fprintf (config
.map_file
, " %s ", abfd
->xvec
->name
);
1239 if (abfd
->my_archive
!= (bfd
*) NULL
)
1241 fprintf (config
.map_file
, "[%s]%s", abfd
->my_archive
->filename
,
1246 fprintf (config
.map_file
, "%s", abfd
->filename
);
1248 fprintf (config
.map_file
, "(overhead %d bytes)", (int) bfd_alloc_size (abfd
));
1251 /* Find all the symbols in this file defined in this section */
1253 if (in
->ifile
->symbol_count
)
1257 for (p
= in
->ifile
->asymbols
; *p
; p
++)
1261 if (bfd_get_section (q
) == i
1262 && (q
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0)
1275 print_dot
= outside_section_address (i
) + size
;
1279 fprintf (config
.map_file
, "No output section allocated\n");
1285 print_fill_statement (fill
)
1286 lang_fill_statement_type
* fill
;
1288 fprintf (config
.map_file
, "FILL mask ");
1289 print_fill (fill
->fill
);
1293 print_data_statement (data
)
1294 lang_data_statement_type
* data
;
1296 /* bfd_vma value; */
1301 /* ASSERT(print_dot == data->output_vma);*/
1303 print_address (data
->output_vma
+ data
->output_section
->vma
);
1305 print_address (data
->value
);
1310 fprintf (config
.map_file
, "BYTE ");
1311 print_dot
+= BYTE_SIZE
;
1314 fprintf (config
.map_file
, "SHORT ");
1315 print_dot
+= SHORT_SIZE
;
1318 fprintf (config
.map_file
, "LONG ");
1319 print_dot
+= LONG_SIZE
;
1323 exp_print_tree (data
->exp
);
1325 fprintf (config
.map_file
, "\n");
1330 print_padding_statement (s
)
1331 lang_padding_statement_type
* s
;
1335 print_section ("*fill*");
1337 print_address (s
->output_offset
+ s
->output_section
->vma
);
1339 print_size (s
->size
);
1341 print_fill (s
->fill
);
1344 print_dot
= s
->output_offset
+ s
->output_section
->vma
+ s
->size
;
1349 print_wild_statement (w
, os
)
1350 lang_wild_statement_type
* w
;
1351 lang_output_section_statement_type
* os
;
1353 fprintf (config
.map_file
, " from ");
1354 if (w
->filename
!= (char *) NULL
)
1356 fprintf (config
.map_file
, "%s", w
->filename
);
1360 fprintf (config
.map_file
, "*");
1362 if (w
->section_name
!= (char *) NULL
)
1364 fprintf (config
.map_file
, "(%s)", w
->section_name
);
1368 fprintf (config
.map_file
, "(*)");
1371 print_statement (w
->children
.head
, os
);
1375 print_statement (s
, os
)
1376 lang_statement_union_type
* s
;
1377 lang_output_section_statement_type
* os
;
1381 switch (s
->header
.type
)
1383 case lang_constructors_statement_enum
:
1384 fprintf (config
.map_file
, "constructors:\n");
1385 print_statement (constructor_list
.head
, os
);
1387 case lang_wild_statement_enum
:
1388 print_wild_statement (&s
->wild_statement
, os
);
1391 fprintf (config
.map_file
, "Fail with %d\n", s
->header
.type
);
1394 case lang_address_statement_enum
:
1395 fprintf (config
.map_file
, "address\n");
1397 case lang_object_symbols_statement_enum
:
1398 fprintf (config
.map_file
, "object symbols\n");
1400 case lang_fill_statement_enum
:
1401 print_fill_statement (&s
->fill_statement
);
1403 case lang_data_statement_enum
:
1404 print_data_statement (&s
->data_statement
);
1406 case lang_input_section_enum
:
1407 print_input_section (&s
->input_section
);
1409 case lang_padding_statement_enum
:
1410 print_padding_statement (&s
->padding_statement
);
1412 case lang_output_section_statement_enum
:
1413 print_output_section_statement (&s
->output_section_statement
);
1415 case lang_assignment_statement_enum
:
1416 print_assignment (&s
->assignment_statement
,
1419 case lang_target_statement_enum
:
1420 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1422 case lang_output_statement_enum
:
1423 fprintf (config
.map_file
, "OUTPUT(%s %s)\n",
1424 s
->output_statement
.name
,
1425 output_target
? output_target
: "");
1427 case lang_input_statement_enum
:
1428 print_input_statement (&s
->input_statement
);
1430 case lang_afile_asection_pair_statement_enum
:
1442 print_statement (statement_list
.head
,
1443 abs_output_section
);
1448 DEFUN (insert_pad
, (this_ptr
, fill
, power
, output_section_statement
, dot
),
1449 lang_statement_union_type
** this_ptr AND
1451 unsigned int power AND
1452 asection
* output_section_statement AND
1455 /* Align this section first to the
1456 input sections requirement, then
1457 to the output section's requirement.
1458 If this alignment is > than any seen before,
1459 then record it too. Perform the alignment by
1460 inserting a magic 'padding' statement.
1463 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
1465 if (alignment_needed
!= 0)
1467 lang_statement_union_type
*new =
1468 (lang_statement_union_type
*)
1469 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1471 /* Link into existing chain */
1472 new->header
.next
= *this_ptr
;
1474 new->header
.type
= lang_padding_statement_enum
;
1475 new->padding_statement
.output_section
= output_section_statement
;
1476 new->padding_statement
.output_offset
=
1477 dot
- output_section_statement
->vma
;
1478 new->padding_statement
.fill
= fill
;
1479 new->padding_statement
.size
= alignment_needed
;
1483 /* Remember the most restrictive alignment */
1484 if (power
> output_section_statement
->alignment_power
)
1486 output_section_statement
->alignment_power
= power
;
1488 output_section_statement
->_raw_size
+= alignment_needed
;
1489 return alignment_needed
+ dot
;
1493 /* Work out how much this section will move the dot point */
1495 DEFUN (size_input_section
, (this_ptr
, output_section_statement
, fill
, dot
, relax
),
1496 lang_statement_union_type
** this_ptr AND
1497 lang_output_section_statement_type
* output_section_statement AND
1498 unsigned short fill AND
1502 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1503 asection
*i
= is
->section
;
1505 if (is
->ifile
->just_syms_flag
== false)
1507 if (output_section_statement
->subsection_alignment
!= -1)
1508 i
->alignment_power
=
1509 output_section_statement
->subsection_alignment
;
1511 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
1512 output_section_statement
->bfd_section
, dot
);
1514 /* remember the largest size so we can malloc the largest area
1515 needed for the output stage. Only remember the size of sections
1516 which we will actually allocate */
1517 if ((i
->flags
& SEC_HAS_CONTENTS
) != 0
1518 && (bfd_get_section_size_before_reloc (i
) > largest_section
))
1520 largest_section
= bfd_get_section_size_before_reloc (i
);
1523 /* Remember where in the output section this input section goes */
1525 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1527 /* Mark how big the output section must be to contain this now
1531 dot
+= i
->_cooked_size
;
1535 dot
+= i
->_raw_size
;
1537 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
1541 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
1547 /* Sizing happens in two passes, first pass we allocate worst case
1548 stuff. The second pass (if relaxing), we use what we learnt to
1549 change the size of some relocs from worst case to better
1551 static boolean had_relax
;
1554 DEFUN (lang_size_sections
, (s
, output_section_statement
, prev
, fill
, dot
, relax
),
1555 lang_statement_union_type
* s AND
1556 lang_output_section_statement_type
* output_section_statement AND
1557 lang_statement_union_type
** prev AND
1558 unsigned short fill AND
1562 /* Size up the sections from their constituent parts */
1563 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1565 switch (s
->header
.type
)
1568 case lang_output_section_statement_enum
:
1571 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
1573 /* If this is a shared library section, don't change the size
1575 if (os
->bfd_section
->flags
& SEC_SHARED_LIBRARY
)
1578 if (os
->bfd_section
== &bfd_abs_section
)
1580 /* No matter what happens, an abs section starts at zero */
1581 bfd_set_section_vma (0, os
->bfd_section
, 0);
1585 if (os
->addr_tree
== (etree_type
*) NULL
)
1587 /* No address specified for this section, get one
1588 from the region specification
1590 if (os
->region
== (lang_memory_region_type
*) NULL
)
1592 os
->region
= lang_memory_region_lookup ("*default*");
1594 dot
= os
->region
->current
;
1600 r
= exp_fold_tree (os
->addr_tree
,
1602 lang_allocating_phase_enum
,
1604 if (r
.valid
== false)
1606 einfo ("%F%S: non constant address expression for section %s\n",
1611 /* The section starts here */
1612 /* First, align to what the section needs */
1615 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
1616 bfd_set_section_vma (0, os
->bfd_section
, dot
);
1618 if (os
->load_base
) {
1619 os
->bfd_section
->lma
1620 = exp_get_value_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
1625 os
->bfd_section
->output_offset
= 0;
1627 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
1628 os
->fill
, dot
, relax
);
1629 /* Ignore the size of the input sections, use the vma and size to */
1632 after
= ALIGN_N (os
->bfd_section
->vma
+
1633 os
->bfd_section
->_raw_size
,
1634 /* The coercion here is important, see ld.h. */
1635 (bfd_vma
) os
->block_value
);
1637 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
1638 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1639 os
->processed
= true;
1641 /* Replace into region ? */
1642 if (os
->addr_tree
== (etree_type
*) NULL
1643 && os
->region
!= (lang_memory_region_type
*) NULL
)
1645 os
->region
->current
= dot
;
1646 /* Make sure this isn't silly */
1647 if (( os
->region
->current
1648 > os
->region
->origin
+ os
->region
->length
)
1649 || ( os
->region
->origin
> os
->region
->current
))
1651 einfo ("%X%P: region %s is full (%B section %s)\n",
1653 os
->bfd_section
->owner
,
1654 os
->bfd_section
->name
);
1655 /* Reset the region pointer */
1656 os
->region
->current
= 0;
1664 case lang_constructors_statement_enum
:
1665 dot
= lang_size_sections (constructor_list
.head
,
1666 output_section_statement
,
1667 &s
->wild_statement
.children
.head
,
1672 case lang_data_statement_enum
:
1674 unsigned int size
= 0;
1676 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1677 s
->data_statement
.output_section
=
1678 output_section_statement
->bfd_section
;
1680 switch (s
->data_statement
.type
)
1694 output_section_statement
->bfd_section
->_raw_size
+= size
;
1698 case lang_wild_statement_enum
:
1700 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
1701 output_section_statement
,
1702 &s
->wild_statement
.children
.head
,
1708 case lang_object_symbols_statement_enum
:
1709 create_object_symbols
= output_section_statement
;
1711 case lang_output_statement_enum
:
1712 case lang_target_statement_enum
:
1714 case lang_input_section_enum
:
1719 if( relax_section (prev
))
1725 (*prev
)->input_section
.section
->_cooked_size
=
1726 (*prev
)->input_section
.section
->_raw_size
;
1729 dot
= size_input_section (prev
,
1730 output_section_statement
,
1731 output_section_statement
->fill
,
1734 case lang_input_statement_enum
:
1736 case lang_fill_statement_enum
:
1737 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
1739 fill
= s
->fill_statement
.fill
;
1741 case lang_assignment_statement_enum
:
1743 bfd_vma newdot
= dot
;
1745 exp_fold_tree (s
->assignment_statement
.exp
,
1746 output_section_statement
,
1747 lang_allocating_phase_enum
,
1751 if (newdot
!= dot
&& !relax
)
1752 /* We've been moved ! so insert a pad */
1754 lang_statement_union_type
*new =
1755 (lang_statement_union_type
*)
1756 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1758 /* Link into existing chain */
1759 new->header
.next
= *prev
;
1761 new->header
.type
= lang_padding_statement_enum
;
1762 new->padding_statement
.output_section
=
1763 output_section_statement
->bfd_section
;
1764 new->padding_statement
.output_offset
=
1765 dot
- output_section_statement
->bfd_section
->vma
;
1766 new->padding_statement
.fill
= fill
;
1767 new->padding_statement
.size
= newdot
- dot
;
1768 output_section_statement
->bfd_section
->_raw_size
+=
1769 new->padding_statement
.size
;
1778 /* This can only get here when relaxing is turned on */
1779 case lang_padding_statement_enum
:
1781 case lang_address_statement_enum
:
1784 prev
= &s
->header
.next
;
1790 DEFUN (lang_do_assignments
, (s
, output_section_statement
, fill
, dot
),
1791 lang_statement_union_type
* s AND
1792 lang_output_section_statement_type
* output_section_statement AND
1793 unsigned short fill AND
1797 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1799 switch (s
->header
.type
)
1801 case lang_constructors_statement_enum
:
1802 dot
= lang_do_assignments (constructor_list
.head
,
1803 output_section_statement
,
1808 case lang_output_section_statement_enum
:
1810 lang_output_section_statement_type
*os
=
1811 &(s
->output_section_statement
);
1813 dot
= os
->bfd_section
->vma
;
1814 (void) lang_do_assignments (os
->children
.head
, os
, os
->fill
, dot
);
1815 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1818 case lang_wild_statement_enum
:
1820 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
1821 output_section_statement
,
1826 case lang_object_symbols_statement_enum
:
1827 case lang_output_statement_enum
:
1828 case lang_target_statement_enum
:
1830 case lang_common_statement_enum
:
1833 case lang_data_statement_enum
:
1835 etree_value_type value
;
1837 value
= exp_fold_tree (s
->data_statement
.exp
,
1839 lang_final_phase_enum
, dot
, &dot
);
1840 s
->data_statement
.value
= value
.value
;
1841 if (value
.valid
== false)
1842 einfo ("%F%P: invalid data statement\n");
1844 switch (s
->data_statement
.type
)
1857 case lang_input_section_enum
:
1859 asection
*in
= s
->input_section
.section
;
1861 dot
+= bfd_get_section_size_before_reloc (in
);
1865 case lang_input_statement_enum
:
1867 case lang_fill_statement_enum
:
1868 fill
= s
->fill_statement
.fill
;
1870 case lang_assignment_statement_enum
:
1872 exp_fold_tree (s
->assignment_statement
.exp
,
1873 output_section_statement
,
1874 lang_final_phase_enum
,
1880 case lang_padding_statement_enum
:
1881 dot
+= s
->padding_statement
.size
;
1886 case lang_address_statement_enum
:
1897 lang_relocate_globals ()
1900 Each ldsym_type maintains a chain of pointers to asymbols which
1901 references the definition. Replace each pointer to the referenence
1902 with a pointer to only one place, preferably the definition. If
1903 the defintion isn't available then the common symbol, and if
1904 there isn't one of them then choose one reference.
1907 FOR_EACH_LDSYM (lgs
)
1911 /* Skip indirect symbols. */
1912 if (lgs
->flags
& SYM_INDIRECT
)
1915 if (lgs
->sdefs_chain
)
1917 it
= *(lgs
->sdefs_chain
);
1919 else if (lgs
->scoms_chain
!= (asymbol
**) NULL
)
1921 it
= *(lgs
->scoms_chain
);
1923 else if (lgs
->srefs_chain
!= (asymbol
**) NULL
)
1925 it
= *(lgs
->srefs_chain
);
1929 /* This can happen when the command line asked for a symbol to
1931 it
= (asymbol
*) NULL
;
1933 if (it
!= (asymbol
*) NULL
)
1936 asymbol
**ptr
= lgs
->srefs_chain
;;
1937 if (lgs
->flags
& SYM_WARNING
)
1939 produce_warnings (lgs
, it
);
1942 while (ptr
!= (asymbol
**) NULL
1945 asymbol
*ref
= *ptr
;
1948 ptr
= (asymbol
**) (ref
->udata
);
1960 int warn
= config
.relocateable_output
!= true;
1961 if (entry_symbol
== (char *) NULL
)
1963 /* No entry has been specified, look for start, but don't warn */
1964 entry_symbol
= "start";
1967 lgs
= ldsym_get_soft (entry_symbol
);
1968 if (lgs
&& lgs
->sdefs_chain
)
1970 asymbol
*sy
= *(lgs
->sdefs_chain
);
1972 /* We can set the entry address*/
1973 bfd_set_start_address (output_bfd
,
1974 outside_symbol_address (sy
));
1979 /* Cannot find anything reasonable,
1980 use the first address in the text section
1982 asection
*ts
= bfd_get_section_by_name (output_bfd
, ".text");
1986 einfo ("%P: warning: cannot find entry symbol %s, defaulting to %V\n",
1987 entry_symbol
, ts
->vma
);
1989 bfd_set_start_address (output_bfd
, ts
->vma
);
1994 einfo ("%P: warning: cannot find entry symbol %s, not setting start address\n",
2000 /* By now we know the target architecture, and we may have an */
2001 /* ldfile_output_machine_name */
2005 lang_statement_union_type
*file
;
2007 unsigned long input_machine
;
2008 enum bfd_architecture input_architecture
;
2009 CONST bfd_arch_info_type
*compatible
;
2011 for (file
= file_chain
.head
;
2012 file
!= (lang_statement_union_type
*) NULL
;
2013 file
= file
->input_statement
.next
)
2015 input_bfd
= file
->input_statement
.the_bfd
;
2017 input_machine
= bfd_get_mach (input_bfd
);
2018 input_architecture
= bfd_get_arch (input_bfd
);
2021 /* Inspect the architecture and ensure we're linking like with
2024 compatible
= bfd_arch_get_compatible (input_bfd
,
2029 ldfile_output_machine
= compatible
->mach
;
2030 ldfile_output_architecture
= compatible
->arch
;
2035 info_msg ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2036 bfd_printable_name (input_bfd
), input_bfd
,
2037 bfd_printable_name (output_bfd
));
2039 if (! bfd_set_arch_mach (output_bfd
,
2042 einfo ("%P%F:%s: can't set architecture: %E\n",
2043 bfd_get_filename (output_bfd
));
2050 * run through all the global common symbols and tie them
2051 * to the output section requested.
2053 As an experiment we do this 4 times, once for all the byte sizes,
2054 then all the two bytes, all the four bytes and then everything else
2063 if (config
.relocateable_output
== false ||
2064 command_line
.force_common_definition
== true)
2066 for (power
= 1; (config
.sort_common
== true && power
== 1) || (power
<= 16); power
<<= 1)
2068 for (lgs
= symbol_head
;
2069 lgs
!= (ldsym_type
*) NULL
;
2073 unsigned int power_of_two
;
2077 if (lgs
->scoms_chain
!= (asymbol
**) NULL
)
2079 com
= *(lgs
->scoms_chain
);
2109 if (config
.sort_common
== false || align
== power
)
2113 /* Change from a common symbol into a definition of
2115 lgs
->sdefs_chain
= lgs
->scoms_chain
;
2116 lgs
->scoms_chain
= (asymbol
**) NULL
;
2119 /* Point to the correct common section */
2120 symbfd
= bfd_asymbol_bfd (com
);
2121 if (com
->section
== &bfd_com_section
)
2123 ((lang_input_statement_type
*) symbfd
->usrdata
)
2130 name
= bfd_get_section_name (symbfd
,
2132 newsec
= bfd_get_section_by_name (symbfd
,
2134 /* BFD backend must provide this section. */
2135 if (newsec
== (asection
*) NULL
)
2136 einfo ("%P%F: no output section %s", name
);
2137 com
->section
= newsec
;
2140 /* Fix the size of the common section */
2142 com
->section
->_raw_size
=
2143 ALIGN_N (com
->section
->_raw_size
,
2144 /* The coercion here is important, see ld.h. */
2147 /* Remember if this is the biggest alignment ever seen */
2148 if (power_of_two
> com
->section
->alignment_power
)
2150 com
->section
->alignment_power
= power_of_two
;
2153 /* Symbol stops being common and starts being global, but
2154 we remember that it was common once. */
2156 com
->flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_OLD_COMMON
;
2157 com
->value
= com
->section
->_raw_size
;
2159 if (write_map
&& config
.map_file
)
2161 fprintf (config
.map_file
, "Allocating common %s: %x at %x %s\n",
2164 (unsigned) com
->value
,
2165 bfd_asymbol_bfd(com
)->filename
);
2168 com
->section
->_raw_size
+= size
;
2181 run through the input files and ensure that every input
2182 section has somewhere to go. If one is found without
2183 a destination then create an input request and place it
2184 into the statement tree.
2188 lang_place_orphans ()
2190 lang_input_statement_type
*file
;
2192 for (file
= (lang_input_statement_type
*) file_chain
.head
;
2193 file
!= (lang_input_statement_type
*) NULL
;
2194 file
= (lang_input_statement_type
*) file
->next
)
2198 for (s
= file
->the_bfd
->sections
;
2199 s
!= (asection
*) NULL
;
2202 if (s
->output_section
== (asection
*) NULL
)
2204 /* This section of the file is not attatched, root
2205 around for a sensible place for it to go */
2207 if (file
->common_section
== s
)
2209 /* This is a lonely common section which must
2210 have come from an archive. We attatch to the
2211 section with the wildcard */
2212 if (config
.relocateable_output
!= true
2213 && command_line
.force_common_definition
== false)
2215 if (default_common_section
==
2216 (lang_output_section_statement_type
*) NULL
)
2218 info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2220 default_common_section
=
2221 lang_output_section_statement_lookup (".bss");
2224 wild_doit (&default_common_section
->children
, s
,
2225 default_common_section
, file
);
2230 lang_output_section_statement_type
*os
=
2231 lang_output_section_statement_lookup (s
->name
);
2233 wild_doit (&os
->children
, s
, os
, file
);
2242 lang_set_flags (ptr
, flags
)
2246 boolean state
= false;
2261 /* ptr->flag_read = state; */
2264 /* ptr->flag_write = state; */
2267 /* ptr->flag_executable= state;*/
2271 /* ptr->flag_loadable= state;*/
2274 einfo ("%P%F: invalid syntax in flags\n");
2284 lang_for_each_file (func
)
2285 void (*func
) PARAMS ((lang_input_statement_type
*));
2287 lang_input_statement_type
*f
;
2289 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2290 f
!= (lang_input_statement_type
*) NULL
;
2291 f
= (lang_input_statement_type
*) f
->next
)
2299 lang_for_each_input_section (func
)
2300 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
2302 lang_input_statement_type
*f
;
2304 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2305 f
!= (lang_input_statement_type
*) NULL
;
2306 f
= (lang_input_statement_type
*) f
->next
)
2310 for (s
= f
->the_bfd
->sections
;
2311 s
!= (asection
*) NULL
;
2314 func (f
->the_bfd
, s
);
2322 ldlang_add_file (entry
)
2323 lang_input_statement_type
* entry
;
2326 lang_statement_append (&file_chain
,
2327 (lang_statement_union_type
*) entry
,
2332 lang_add_output (name
)
2335 lang_output_statement_type
*new = new_stat (lang_output_statement
,
2339 had_output_filename
= true;
2343 static lang_output_section_statement_type
*current_section
;
2345 static int topower(x
)
2350 if (x
< 0) return -1;
2351 for (l
= 0; l
< 32; l
++)
2353 if (i
>= x
) return l
;
2359 lang_enter_output_section_statement (output_section_statement_name
,
2360 address_exp
, flags
, block_value
,
2361 align
, subalign
, base
)
2362 char *output_section_statement_name
;
2363 etree_type
* address_exp
;
2365 bfd_vma block_value
;
2367 etree_type
*subalign
;
2370 lang_output_section_statement_type
*os
;
2374 lang_output_section_statement_lookup (output_section_statement_name
);
2378 /* Add this statement to tree */
2379 /* add_statement(lang_output_section_statement_enum,
2380 output_section_statement);*/
2381 /* Make next things chain into subchain of this */
2383 if (os
->addr_tree
==
2384 (etree_type
*) NULL
)
2390 if (flags
& SEC_NEVER_LOAD
)
2394 os
->block_value
= block_value
? block_value
: 1;
2395 stat_ptr
= &os
->children
;
2397 os
->subsection_alignment
= topower(
2398 exp_get_value_int(subalign
, -1,
2399 "subsection alignment",
2401 os
->section_alignment
= topower(
2402 exp_get_value_int(align
, -1,
2403 "section alignment", 0));
2405 os
->load_base
= base
;
2412 if (had_output_filename
== false)
2414 extern CONST
char *output_filename
;
2416 lang_add_output (output_filename
);
2420 /* Reset the current counters in the regions */
2422 reset_memory_regions ()
2424 lang_memory_region_type
*p
= lang_memory_region_list
;
2426 for (p
= lang_memory_region_list
;
2427 p
!= (lang_memory_region_type
*) NULL
;
2430 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
2431 p
->current
= p
->origin
;
2438 DEFUN (create_symbol
, (name
, flags
, section
),
2439 CONST
char *name AND
2443 extern lang_input_statement_type
*script_file
;
2444 asymbol
**def_ptr
= (asymbol
**) stat_alloc ((bfd_size_type
) (sizeof (asymbol
**)));
2446 /* Add this definition to script file */
2447 asymbol
*def
= (asymbol
*) bfd_make_empty_symbol (script_file
->the_bfd
);
2448 def
->name
= buystring (name
);
2451 def
->section
= section
;
2453 enter_global_ref (def_ptr
, name
);
2460 lang_reasonable_defaults ();
2461 current_target
= default_target
;
2463 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
2464 /* For each output section statement, create a section in the output
2466 lang_create_output_section_statements ();
2468 ldemul_create_output_section_statements ();
2470 /* Create a dummy bfd for the script */
2471 lang_init_script_file ();
2473 /* Add to the hash table all undefineds on the command line */
2474 lang_place_undefineds ();
2476 /* Create a bfd for each input file */
2477 current_target
= default_target
;
2478 lang_for_each_statement (open_input_bfds
);
2480 /* Run through the contours of the script and attatch input sections
2481 to the correct output sections
2483 find_constructors ();
2484 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
2485 (lang_output_section_statement_type
*) NULL
);
2488 /* Find any sections not attatched explicitly and handle them */
2489 lang_place_orphans ();
2491 /* Size up the common data */
2494 ldemul_before_allocation ();
2504 lang_size_sections (statement_list
.head
,
2505 (lang_output_section_statement_type
*) NULL
,
2506 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2507 /* FIXME. Until the code in relax is fixed so that it only reads in
2508 stuff once, we cant iterate since there is no way for the linker to
2509 know what has been patched and what hasn't */
2515 /* Now run around and relax if we can */
2516 if (command_line
.relax
)
2518 /* First time round is a trial run to get the 'worst case'
2519 addresses of the objects if there was no relaxing. */
2520 lang_size_sections (statement_list
.head
,
2521 (lang_output_section_statement_type
*) NULL
,
2522 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2524 /* Move the global symbols around so the second pass of relaxing
2526 lang_relocate_globals ();
2528 reset_memory_regions ();
2530 /* Do all the assignments, now that we know the final resting
2531 places of all the symbols. */
2533 lang_do_assignments (statement_list
.head
,
2537 /* Perform another relax pass - this time we know where the
2538 globals are, so can make better guess. */
2539 lang_size_sections (statement_list
.head
,
2540 (lang_output_section_statement_type
*) NULL
,
2541 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2545 /* Size up the sections. */
2546 lang_size_sections (statement_list
.head
,
2548 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2551 /* See if anything special should be done now we know how big
2553 ldemul_after_allocation ();
2555 /* Do all the assignments, now that we know the final restingplaces
2556 of all the symbols */
2558 lang_do_assignments (statement_list
.head
,
2563 /* Move the global symbols around */
2564 lang_relocate_globals ();
2566 /* Make sure that we're not mixing architectures */
2573 /* Size up the sections. */
2574 lang_size_sections (statement_list
.head
,
2576 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2580 /* EXPORTED TO YACC */
2583 lang_add_wild (section_name
, filename
)
2584 CONST
char *CONST section_name
;
2585 CONST
char *CONST filename
;
2587 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
2590 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
2592 placed_commons
= true;
2594 if (filename
!= (char *) NULL
)
2596 lang_has_input_file
= true;
2598 new->section_name
= section_name
;
2599 new->filename
= filename
;
2600 lang_list_init (&new->children
);
2604 lang_section_start (name
, address
)
2606 etree_type
* address
;
2608 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
2610 ad
->section_name
= name
;
2611 ad
->address
= address
;
2615 lang_add_entry (name
)
2618 entry_symbol
= name
;
2622 lang_add_target (name
)
2625 lang_target_statement_type
*new = new_stat (lang_target_statement
,
2641 map_option_f
= true;
2652 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
2659 lang_add_data (type
, exp
)
2661 union etree_union
*exp
;
2664 lang_data_statement_type
*new = new_stat (lang_data_statement
,
2673 lang_add_assignment (exp
)
2676 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
2683 lang_add_attribute (attribute
)
2684 enum statement_enum attribute
;
2686 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
2693 if (startup_file
!= (char *) NULL
)
2695 einfo ("%P%Fmultiple STARTUP files\n");
2697 first_file
->filename
= name
;
2698 first_file
->local_sym_name
= name
;
2700 startup_file
= name
;
2707 lang_float_flag
= maybe
;
2711 lang_leave_output_section_statement (fill
, memspec
)
2713 CONST
char *memspec
;
2715 current_section
->fill
= fill
;
2716 current_section
->region
= lang_memory_region_lookup (memspec
);
2717 stat_ptr
= &statement_list
;
2719 /* We remember if we are closing a .data section, since we use it to
2720 store constructors in */
2721 if (strcmp (current_section
->name
, ".data") == 0)
2723 end_of_data_section_statement_list
= statement_list
;
2729 Create an absolute symbol with the given name with the value of the
2730 address of first byte of the section named.
2732 If the symbol already exists, then do nothing.
2735 lang_abs_symbol_at_beginning_of (section
, name
)
2736 CONST
char *section
;
2739 if (ldsym_undefined (name
))
2741 asection
*s
= bfd_get_section_by_name (output_bfd
, section
);
2742 asymbol
*def
= create_symbol (name
,
2743 BSF_GLOBAL
| BSF_EXPORT
,
2746 if (s
!= (asection
*) NULL
)
2748 def
->value
= s
->vma
;
2758 Create an absolute symbol with the given name with the value of the
2759 address of the first byte after the end of the section named.
2761 If the symbol already exists, then do nothing.
2764 lang_abs_symbol_at_end_of (section
, name
)
2765 CONST
char *section
;
2768 if (ldsym_undefined (name
))
2770 asection
*s
= bfd_get_section_by_name (output_bfd
, section
);
2772 /* Add a symbol called _end */
2773 asymbol
*def
= create_symbol (name
,
2774 BSF_GLOBAL
| BSF_EXPORT
,
2777 if (s
!= (asection
*) NULL
)
2779 def
->value
= s
->vma
+ s
->_raw_size
;
2789 lang_statement_append (list
, element
, field
)
2790 lang_statement_list_type
* list
;
2791 lang_statement_union_type
* element
;
2792 lang_statement_union_type
** field
;
2794 *(list
->tail
) = element
;
2798 /* Set the output format type. -oformat overrides scripts. */
2800 lang_add_output_format (format
, from_script
)
2804 if (!from_script
|| output_target
== NULL
)
2805 output_target
= format
;