1 /* Copyright (C) 1991 Free Software Foundation, Inc.
3 This file is part of GLD, the Gnu Linker.
5 GLD is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 1, or (at your option)
10 GLD is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GLD; see the file COPYING. If not, write to
17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
35 PROTO (static void, print_statements
, (void));
36 PROTO (static void, print_statement
, (lang_statement_union_type
*,
37 lang_output_section_statement_type
*));
40 static struct obstack stat_obstack
;
42 #define obstack_chunk_alloc ldmalloc
43 #define obstack_chunk_free free
44 static CONST
char *startup_file
;
45 static lang_statement_list_type input_file_chain
;
47 /* Points to the last statement in the .data section, so we can add
48 stuff to the data section without pain */
49 static lang_statement_list_type end_of_data_section_statement_list
;
51 /* List of statements needed to handle constructors */
52 extern lang_statement_list_type constructor_list
;
54 static boolean placed_commons
= false;
55 static lang_output_section_statement_type
*default_common_section
;
56 static boolean map_option_f
;
57 static bfd_vma print_dot
;
58 static lang_input_statement_type
*first_file
;
59 static lang_statement_list_type lang_output_section_statement
;
60 static CONST
char *current_target
;
61 static CONST
char *output_target
;
62 static size_t longest_section_name
= 8;
63 static asection common_section
;
64 static section_userdata_type common_section_userdata
;
65 static lang_statement_list_type statement_list
;
69 lang_output_section_statement_type
*abs_output_section
;
70 lang_statement_list_type
*stat_ptr
= &statement_list
;
71 lang_input_statement_type
*script_file
= 0;
72 boolean option_longmap
= false;
73 lang_statement_list_type file_chain
=
75 CONST
char *entry_symbol
= 0;
76 bfd_size_type largest_section
= 0;
77 boolean lang_has_input_file
= false;
78 lang_output_section_statement_type
*create_object_symbols
= 0;
79 boolean had_output_filename
= false;
80 boolean lang_float_flag
= false;
83 extern char *default_target
;
85 extern unsigned int undefined_global_sym_count
;
86 extern char *current_file
;
87 extern bfd
*output_bfd
;
88 extern enum bfd_architecture ldfile_output_architecture
;
89 extern unsigned long ldfile_output_machine
;
90 extern char *ldfile_output_machine_name
;
91 extern ldsym_type
*symbol_head
;
92 extern unsigned int commons_pending
;
93 extern args_type command_line
;
94 extern ld_config_type config
;
95 extern boolean had_script
;
96 extern boolean write_map
;
101 #define cat(a,b) a/**/b
104 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
106 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
108 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
110 void EXFUN (lang_add_data
, (int type
, union etree_union
* exp
));
113 DEFUN (stat_alloc
, (size
),
116 return obstack_alloc (&stat_obstack
, size
);
119 DEFUN (print_size
, (value
),
122 fprintf (config
.map_file
, "%5x", (unsigned) value
);
125 DEFUN (print_alignment
, (value
),
128 fprintf (config
.map_file
, "2**%1u", value
);
131 DEFUN (print_fill
, (value
),
134 fprintf (config
.map_file
, "%04x", (unsigned) value
);
139 DEFUN (print_section
, (name
),
140 CONST
char *CONST name
)
142 fprintf (config
.map_file
, "%*s", -longest_section_name
, name
);
145 /*----------------------------------------------------------------------
146 lang_for_each_statement walks the parse tree and calls the provided
147 function for each node
151 DEFUN (lang_for_each_statement_worker
, (func
, s
),
153 lang_statement_union_type
* s
)
155 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
159 switch (s
->header
.type
)
161 case lang_constructors_statement_enum
:
162 lang_for_each_statement_worker (func
, constructor_list
.head
);
164 case lang_output_section_statement_enum
:
165 lang_for_each_statement_worker
167 s
->output_section_statement
.children
.head
);
169 case lang_wild_statement_enum
:
170 lang_for_each_statement_worker
172 s
->wild_statement
.children
.head
);
174 case lang_data_statement_enum
:
175 case lang_object_symbols_statement_enum
:
176 case lang_output_statement_enum
:
177 case lang_target_statement_enum
:
178 case lang_input_section_enum
:
179 case lang_input_statement_enum
:
180 case lang_assignment_statement_enum
:
181 case lang_padding_statement_enum
:
182 case lang_address_statement_enum
:
192 DEFUN (lang_for_each_statement
, (func
),
195 lang_for_each_statement_worker (func
,
196 statement_list
.head
);
199 /*----------------------------------------------------------------------*/
201 DEFUN (lang_list_init
, (list
),
202 lang_statement_list_type
* list
)
204 list
->head
= (lang_statement_union_type
*) NULL
;
205 list
->tail
= &list
->head
;
208 /*----------------------------------------------------------------------
210 build a new statement node for the parse tree
215 lang_statement_union_type
*
216 DEFUN (new_statement
, (type
, size
, list
),
217 enum statement_enum type AND
218 bfd_size_type size AND
219 lang_statement_list_type
* list
)
221 lang_statement_union_type
*new = (lang_statement_union_type
*)
224 new->header
.type
= type
;
225 new->header
.next
= (lang_statement_union_type
*) NULL
;
226 lang_statement_append (list
, new, &new->header
.next
);
231 Build a new input file node for the language. There are several ways
232 in which we treat an input file, eg, we only look at symbols, or
233 prefix it with a -l etc.
235 We can be supplied with requests for input files more than once;
236 they may, for example be split over serveral lines like foo.o(.text)
237 foo.o(.data) etc, so when asked for a file we check that we havn't
238 got it already so we don't duplicate the bfd.
241 static lang_input_statement_type
*
242 DEFUN (new_afile
, (name
, file_type
, target
),
243 CONST
char *CONST name AND
244 CONST lang_input_file_enum_type file_type AND
245 CONST
char *CONST target
)
248 lang_input_statement_type
*p
= new_stat (lang_input_statement
,
251 lang_has_input_file
= true;
253 p
->complained
= false;
256 case lang_input_file_is_symbols_only_enum
:
258 p
->is_archive
= false;
260 p
->local_sym_name
= name
;
261 p
->just_syms_flag
= true;
262 p
->search_dirs_flag
= false;
264 case lang_input_file_is_fake_enum
:
266 p
->is_archive
= false;
268 p
->local_sym_name
= name
;
269 p
->just_syms_flag
= false;
270 p
->search_dirs_flag
= false;
272 case lang_input_file_is_l_enum
:
273 p
->is_archive
= true;
276 p
->local_sym_name
= concat ("-l", name
, "");
277 p
->just_syms_flag
= false;
278 p
->search_dirs_flag
= true;
280 case lang_input_file_is_search_file_enum
:
281 case lang_input_file_is_marker_enum
:
283 p
->is_archive
= false;
285 p
->local_sym_name
= name
;
286 p
->just_syms_flag
= false;
287 p
->search_dirs_flag
= true;
289 case lang_input_file_is_file_enum
:
291 p
->is_archive
= false;
293 p
->local_sym_name
= name
;
294 p
->just_syms_flag
= false;
295 p
->search_dirs_flag
= false;
300 p
->asymbols
= (asymbol
**) NULL
;
301 p
->superfile
= (lang_input_statement_type
*) NULL
;
302 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
303 p
->next
= (lang_statement_union_type
*) NULL
;
305 p
->common_output_section
= (asection
*) NULL
;
306 lang_statement_append (&input_file_chain
,
307 (lang_statement_union_type
*) p
,
312 lang_input_statement_type
*
313 DEFUN (lang_add_input_file
, (name
, file_type
, target
),
315 lang_input_file_enum_type file_type AND
318 /* Look it up or build a new one */
319 lang_has_input_file
= true;
321 lang_input_statement_type
*p
;
323 for (p
= (lang_input_statement_type
*) input_file_chain
.head
;
324 p
!= (lang_input_statement_type
*) NULL
;
325 p
= (lang_input_statement_type
*) (p
->next_real_file
))
327 /* Sometimes we have incomplete entries in here */
328 if (p
->filename
!= (char *) NULL
)
330 if (strcmp (name
, p
->filename
) == 0)
336 return new_afile (name
, file_type
, target
);
340 DEFUN (lang_add_keepsyms_file
, (filename
),
341 CONST
char *filename
)
343 extern strip_symbols_type strip_symbols
;
344 if (keepsyms_file
!= 0)
345 info ("%X%P error: duplicated keep-symbols-file value\n");
346 keepsyms_file
= filename
;
347 if (strip_symbols
!= STRIP_NONE
)
348 info ("%P `-keep-only-symbols-file' overrides `-s' and `-S'\n");
349 strip_symbols
= STRIP_SOME
;
352 /* Build enough state so that the parser can build its tree */
354 DEFUN_VOID (lang_init
)
356 obstack_begin (&stat_obstack
, 1000);
358 stat_ptr
= &statement_list
;
360 lang_list_init (stat_ptr
);
362 lang_list_init (&input_file_chain
);
363 lang_list_init (&lang_output_section_statement
);
364 lang_list_init (&file_chain
);
365 first_file
= lang_add_input_file ((char *) NULL
,
366 lang_input_file_is_marker_enum
,
368 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
370 abs_output_section
->bfd_section
= &bfd_abs_section
;
374 /*----------------------------------------------------------------------
375 A region is an area of memory declared with the
376 MEMORY { name:org=exp, len=exp ... }
379 We maintain a list of all the regions here
381 If no regions are specified in the script, then the default is used
382 which is created when looked up to be the entire data space
385 static lang_memory_region_type
*lang_memory_region_list
;
386 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
388 lang_memory_region_type
*
389 DEFUN (lang_memory_region_lookup
, (name
),
390 CONST
char *CONST name
)
393 lang_memory_region_type
*p
= lang_memory_region_list
;
395 for (p
= lang_memory_region_list
;
396 p
!= (lang_memory_region_type
*) NULL
;
399 if (strcmp (p
->name
, name
) == 0)
404 if (strcmp (name
, "*default*") == 0)
406 /* This is the default region, dig out first one on the list */
407 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
409 return lang_memory_region_list
;
413 lang_memory_region_type
*new =
414 (lang_memory_region_type
*) stat_alloc ((bfd_size_type
) (sizeof (lang_memory_region_type
)));
416 new->name
= buystring (name
);
417 new->next
= (lang_memory_region_type
*) NULL
;
419 *lang_memory_region_list_tail
= new;
420 lang_memory_region_list_tail
= &new->next
;
424 new->had_full_message
= false;
431 lang_output_section_statement_type
*
432 DEFUN (lang_output_section_find
, (name
),
433 CONST
char *CONST name
)
435 lang_statement_union_type
*u
;
436 lang_output_section_statement_type
*lookup
;
438 for (u
= lang_output_section_statement
.head
;
439 u
!= (lang_statement_union_type
*) NULL
;
442 lookup
= &u
->output_section_statement
;
443 if (strcmp (name
, lookup
->name
) == 0)
448 return (lang_output_section_statement_type
*) NULL
;
451 lang_output_section_statement_type
*
452 DEFUN (lang_output_section_statement_lookup
, (name
),
453 CONST
char *CONST name
)
455 lang_output_section_statement_type
*lookup
;
457 lookup
= lang_output_section_find (name
);
458 if (lookup
== (lang_output_section_statement_type
*) NULL
)
461 lookup
= (lang_output_section_statement_type
*)
462 new_stat (lang_output_section_statement
, stat_ptr
);
463 lookup
->region
= (lang_memory_region_type
*) NULL
;
465 lookup
->block_value
= 1;
468 lookup
->next
= (lang_statement_union_type
*) NULL
;
469 lookup
->bfd_section
= (asection
*) NULL
;
470 lookup
->processed
= false;
471 lookup
->loadable
= 1;
472 lookup
->addr_tree
= (etree_type
*) NULL
;
473 lang_list_init (&lookup
->children
);
475 lang_statement_append (&lang_output_section_statement
,
476 (lang_statement_union_type
*) lookup
,
484 DEFUN (print_flags
, (ignore_flags
),
487 fprintf (config
.map_file
, "(");
489 if (flags
->flag_read
)
490 fprintf (outfile
, "R");
491 if (flags
->flag_write
)
492 fprintf (outfile
, "W");
493 if (flags
->flag_executable
)
494 fprintf (outfile
, "X");
495 if (flags
->flag_loadable
)
496 fprintf (outfile
, "L");
498 fprintf (config
.map_file
, ")");
502 DEFUN_VOID (lang_map
)
504 lang_memory_region_type
*m
;
506 fprintf (config
.map_file
, "**MEMORY CONFIGURATION**\n\n");
508 fprintf (config
.map_file
, "name\t\torigin\t\tlength\t\tattributes\n");
510 fprintf (config
.map_file
,
511 "name\t\torigin length r_size c_size is attributes\n");
514 for (m
= lang_memory_region_list
;
515 m
!= (lang_memory_region_type
*) NULL
;
518 fprintf (config
.map_file
, "%-16s", m
->name
);
519 print_address (m
->origin
);
521 print_address (m
->length
);
523 print_address (m
->old_length
);
525 print_address (m
->current
- m
->origin
);
528 fprintf(config
.map_file
," %2d%% ", ( m
->current
- m
->origin
) * 100 / m
->old_length
);
529 print_flags (&m
->flags
);
530 fprintf (config
.map_file
, "\n");
532 fprintf (config
.map_file
, "\n\n**LINK EDITOR MEMORY MAP**\n\n");
533 fprintf (config
.map_file
, "output input virtual\n");
534 fprintf (config
.map_file
, "section section address tsize\n\n");
545 lang_output_section_statement_type
* s
)
547 /* asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
548 section_userdata_type
*new =
549 (section_userdata_type
*)
550 stat_alloc ((bfd_size_type
) (sizeof (section_userdata_type
)));
552 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
553 if (s
->bfd_section
== (asection
*) NULL
)
554 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
555 if (s
->bfd_section
== (asection
*) NULL
)
557 einfo ("%P%F output format %s cannot represent section called %s\n",
558 output_bfd
->xvec
->name
, s
->name
);
560 s
->bfd_section
->output_section
= s
->bfd_section
;
561 /* s->bfd_section->flags = s->flags;*/
563 /* We initialize an output sections output offset to minus its own */
564 /* vma to allow us to output a section through itself */
565 s
->bfd_section
->output_offset
= 0;
566 get_userdata (s
->bfd_section
) = (PTR
) new;
570 /***********************************************************************
573 These expand statements like *(.text) and foo.o to a list of
574 explicit actions, like foo.o(.text), bar.o(.text) and
577 The toplevel routine, wild, takes a statement, section, file and
578 target. If either the section or file is null it is taken to be the
579 wildcard. Seperate lang_input_section statements are created for
580 each part of the expanstion, and placed after the statement provided.
585 DEFUN (wild_doit
, (ptr
, section
, output
, file
),
586 lang_statement_list_type
* ptr AND
587 asection
* section AND
588 lang_output_section_statement_type
* output AND
589 lang_input_statement_type
* file
)
591 if (output
->bfd_section
== (asection
*) NULL
)
596 if (section
!= (asection
*) NULL
597 && section
->output_section
== (asection
*) NULL
)
599 /* Add a section reference to the list */
600 lang_input_section_type
*new = new_stat (lang_input_section
, ptr
);
602 new->section
= section
;
604 section
->output_section
= output
->bfd_section
;
605 section
->output_section
->flags
|= section
->flags
;
606 if (!output
->loadable
)
608 /* Turn of load flag */
609 output
->bfd_section
->flags
&= ~SEC_LOAD
;
611 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
613 output
->bfd_section
->alignment_power
= section
->alignment_power
;
619 DEFUN (our_bfd_get_section_by_name
, (abfd
, section
),
623 return bfd_get_section_by_name (abfd
, section
);
627 DEFUN (wild_section
, (ptr
, section
, file
, output
),
628 lang_wild_statement_type
* ptr AND
629 CONST
char *section AND
630 lang_input_statement_type
* file AND
631 lang_output_section_statement_type
* output
)
635 if (file
->just_syms_flag
== false)
637 if (section
== (char *) NULL
)
639 /* Do the creation to all sections in the file */
640 for (s
= file
->the_bfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
642 wild_doit (&ptr
->children
, s
, output
, file
);
647 /* Do the creation to the named section only */
648 wild_doit (&ptr
->children
,
649 our_bfd_get_section_by_name (file
->the_bfd
, section
),
655 /* passed a file name (which must have been seen already and added to
656 the statement tree. We will see if it has been opened already and
657 had its symbols read. If not then we'll read it.
659 Archives are pecuilar here. We may open them once, but if they do
660 not define anything we need at the time, they won't have all their
661 symbols read. If we need them later, we'll have to redo it.
664 lang_input_statement_type
*
665 DEFUN (lookup_name
, (name
),
666 CONST
char *CONST name
)
668 lang_input_statement_type
*search
;
670 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
671 search
!= (lang_input_statement_type
*) NULL
;
672 search
= (lang_input_statement_type
*) search
->next_real_file
)
674 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
678 if (search
->filename
!= (char *) NULL
&& name
!= (char *) NULL
)
680 if (strcmp (search
->filename
, name
) == 0)
682 ldmain_open_file_read_symbol (search
);
688 /* There isn't an afile entry for this file yet, this must be
689 because the name has only appeared inside a load script and not
690 on the command line */
691 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
);
692 ldmain_open_file_read_symbol (search
);
699 DEFUN (wild
, (s
, section
, file
, target
, output
),
700 lang_wild_statement_type
* s AND
701 CONST
char *CONST section AND
702 CONST
char *CONST file AND
703 CONST
char *CONST target AND
704 lang_output_section_statement_type
* output
)
706 lang_input_statement_type
*f
;
708 if (file
== (char *) NULL
)
710 /* Perform the iteration over all files in the list */
711 for (f
= (lang_input_statement_type
*) file_chain
.head
;
712 f
!= (lang_input_statement_type
*) NULL
;
713 f
= (lang_input_statement_type
*) f
->next
)
715 wild_section (s
, section
, f
, output
);
720 /* Perform the iteration over a single file */
721 wild_section (s
, section
, lookup_name (file
), output
);
723 if (section
!= (char *) NULL
724 && strcmp (section
, "COMMON") == 0
725 && default_common_section
== (lang_output_section_statement_type
*) NULL
)
727 /* Remember the section that common is going to incase we later
728 get something which doesn't know where to put it */
729 default_common_section
= output
;
734 read in all the files
737 DEFUN (open_output
, (name
),
738 CONST
char *CONST name
)
740 extern unsigned long ldfile_output_machine
;
741 extern enum bfd_architecture ldfile_output_architecture
;
743 extern CONST
char *output_filename
;
746 if (output_target
== (char *) NULL
)
748 if (current_target
!= (char *) NULL
)
749 output_target
= current_target
;
751 output_target
= default_target
;
753 output
= bfd_openw (name
, output_target
);
754 output_filename
= name
;
756 if (output
== (bfd
*) NULL
)
758 if (bfd_error
== invalid_target
)
760 einfo ("%P%F target %s not found\n", output_target
);
762 einfo ("%P%F problem opening output file %s, %E", name
);
765 /* output->flags |= D_PAGED;*/
767 bfd_set_format (output
, bfd_object
);
768 bfd_set_arch_mach (output
,
769 ldfile_output_architecture
,
770 ldfile_output_machine
);
778 DEFUN (ldlang_open_output
, (statement
),
779 lang_statement_union_type
* statement
)
781 switch (statement
->header
.type
)
783 case lang_output_statement_enum
:
784 output_bfd
= open_output (statement
->output_statement
.name
);
785 ldemul_set_output_arch ();
786 if (config
.magic_demand_paged
&& !config
.relocateable_output
)
787 output_bfd
->flags
|= D_PAGED
;
789 output_bfd
->flags
&= ~D_PAGED
;
790 if (config
.text_read_only
)
791 output_bfd
->flags
|= WP_TEXT
;
793 output_bfd
->flags
&= ~WP_TEXT
;
796 case lang_target_statement_enum
:
797 current_target
= statement
->target_statement
.target
;
805 DEFUN (open_input_bfds
, (statement
),
806 lang_statement_union_type
* statement
)
808 switch (statement
->header
.type
)
810 case lang_target_statement_enum
:
811 current_target
= statement
->target_statement
.target
;
813 case lang_wild_statement_enum
:
814 /* Maybe we should load the file's symbols */
815 if (statement
->wild_statement
.filename
)
817 (void) lookup_name (statement
->wild_statement
.filename
);
820 case lang_input_statement_enum
:
821 if (statement
->input_statement
.real
== true)
823 statement
->input_statement
.target
= current_target
;
824 lookup_name (statement
->input_statement
.filename
);
832 /* If there are [COMMONS] statements, put a wild one into the bss section */
835 lang_reasonable_defaults ()
841 lang_output_section_statement_lookup (".text");
842 lang_output_section_statement_lookup (".data");
844 default_common_section
=
845 lang_output_section_statement_lookup (".bss");
848 if (placed_commons
== false)
850 lang_wild_statement_type
*new =
851 new_stat (lang_wild_statement
,
852 &default_common_section
->children
);
854 new->section_name
= "COMMON";
855 new->filename
= (char *) NULL
;
856 lang_list_init (&new->children
);
863 Add the supplied name to the symbol table as an undefined reference.
864 Remove items from the chain as we open input bfds
866 typedef struct ldlang_undef_chain_list
868 struct ldlang_undef_chain_list
*next
;
870 } ldlang_undef_chain_list_type
;
872 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
875 DEFUN (ldlang_add_undef
, (name
),
876 CONST
char *CONST name
)
878 ldlang_undef_chain_list_type
*new =
879 (ldlang_undef_chain_list_type
880 *) stat_alloc ((bfd_size_type
) (sizeof (ldlang_undef_chain_list_type
)));
882 new->next
= ldlang_undef_chain_list_head
;
883 ldlang_undef_chain_list_head
= new;
885 new->name
= buystring (name
);
888 /* Run through the list of undefineds created above and place them
889 into the linker hash table as undefined symbols belonging to the
893 DEFUN_VOID (lang_place_undefineds
)
895 ldlang_undef_chain_list_type
*ptr
= ldlang_undef_chain_list_head
;
897 while (ptr
!= (ldlang_undef_chain_list_type
*) NULL
)
900 asymbol
**def_ptr
= (asymbol
**) stat_alloc ((bfd_size_type
) (sizeof (asymbol
**)));
902 def
= (asymbol
*) bfd_make_empty_symbol (script_file
->the_bfd
);
904 def
->name
= ptr
->name
;
905 def
->section
= &bfd_und_section
;
906 Q_enter_global_ref (def_ptr
, ptr
->name
);
911 /* Copy important data from out internal form to the bfd way. Also
912 create a section for the dummy file
916 DEFUN_VOID (lang_create_output_section_statements
)
918 lang_statement_union_type
*os
;
920 for (os
= lang_output_section_statement
.head
;
921 os
!= (lang_statement_union_type
*) NULL
;
922 os
= os
->output_section_statement
.next
)
924 lang_output_section_statement_type
*s
=
925 &os
->output_section_statement
;
933 DEFUN_VOID (lang_init_script_file
)
935 script_file
= lang_add_input_file ("script file",
936 lang_input_file_is_fake_enum
,
938 script_file
->the_bfd
= bfd_create ("script file", output_bfd
);
939 script_file
->symbol_count
= 0;
940 script_file
->the_bfd
->sections
= output_bfd
->sections
;
941 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
943 abs_output_section
->bfd_section
= &bfd_abs_section
;
947 /* Open input files and attatch to output sections */
949 DEFUN (map_input_to_output_sections
, (s
, target
, output_section_statement
),
950 lang_statement_union_type
* s AND
951 CONST
char *target AND
952 lang_output_section_statement_type
* output_section_statement
)
954 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
956 switch (s
->header
.type
)
960 case lang_wild_statement_enum
:
961 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
962 s
->wild_statement
.filename
, target
,
963 output_section_statement
);
966 case lang_constructors_statement_enum
:
967 map_input_to_output_sections (constructor_list
.head
,
969 output_section_statement
);
971 case lang_output_section_statement_enum
:
972 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
974 &s
->output_section_statement
);
976 case lang_output_statement_enum
:
978 case lang_target_statement_enum
:
979 target
= s
->target_statement
.target
;
981 case lang_fill_statement_enum
:
982 case lang_input_section_enum
:
983 case lang_object_symbols_statement_enum
:
984 case lang_data_statement_enum
:
985 case lang_assignment_statement_enum
:
986 case lang_padding_statement_enum
:
988 case lang_afile_asection_pair_statement_enum
:
991 case lang_address_statement_enum
:
992 /* Mark the specified section with the supplied address */
994 lang_output_section_statement_type
*os
=
995 lang_output_section_statement_lookup
996 (s
->address_statement
.section_name
);
998 os
->addr_tree
= s
->address_statement
.address
;
999 if (os
->bfd_section
== (asection
*) NULL
)
1001 einfo ("%P%F can't set the address of undefined section %s\n",
1002 s
->address_statement
.section_name
);
1006 case lang_input_statement_enum
:
1007 /* A standard input statement, has no wildcards */
1008 /* ldmain_open_file_read_symbol(&s->input_statement);*/
1019 DEFUN (print_output_section_statement
, (output_section_statement
),
1020 lang_output_section_statement_type
* output_section_statement
)
1022 asection
*section
= output_section_statement
->bfd_section
;
1025 print_section (output_section_statement
->name
);
1029 print_dot
= section
->vma
;
1033 print_address (section
->vma
);
1035 print_size (section
->_raw_size
);
1037 print_size(section
->_cooked_size
);
1039 print_alignment (section
->alignment_power
);
1042 fprintf (config
.map_file
, "%s flags", output_section_statement
->region
->name
);
1043 print_flags (stdout
, &output_section_statement
->flags
);
1045 if (section
->flags
& SEC_LOAD
)
1046 fprintf (config
.map_file
, "load ");
1047 if (section
->flags
& SEC_ALLOC
)
1048 fprintf (config
.map_file
, "alloc ");
1049 if (section
->flags
& SEC_RELOC
)
1050 fprintf (config
.map_file
, "reloc ");
1051 if (section
->flags
& SEC_HAS_CONTENTS
)
1052 fprintf (config
.map_file
, "contents ");
1057 fprintf (config
.map_file
, "No attached output section");
1060 print_statement (output_section_statement
->children
.head
,
1061 output_section_statement
);
1066 DEFUN (print_assignment
, (assignment
, output_section
),
1067 lang_assignment_statement_type
* assignment AND
1068 lang_output_section_statement_type
* output_section
)
1070 etree_value_type result
;
1076 print_address (print_dot
);
1078 result
= exp_fold_tree (assignment
->exp
->assign
.src
,
1080 lang_final_phase_enum
,
1086 print_address (result
.value
);
1090 fprintf (config
.map_file
, "*undefined*");
1093 exp_print_tree (assignment
->exp
);
1095 fprintf (config
.map_file
, "\n");
1099 DEFUN (print_input_statement
, (statm
),
1100 lang_input_statement_type
* statm
)
1102 if (statm
->filename
!= (char *) NULL
)
1104 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1109 DEFUN (print_symbol
, (q
),
1113 fprintf (config
.map_file
, " ");
1115 fprintf (config
.map_file
, " ");
1116 print_address (outside_symbol_address (q
));
1117 fprintf (config
.map_file
, " %s", q
->name
? q
->name
: " ");
1122 DEFUN (print_input_section
, (in
),
1123 lang_input_section_type
* in
)
1125 asection
*i
= in
->section
;
1126 int size
= i
->reloc_done
?
1127 bfd_get_section_size_after_reloc (i
) :
1128 bfd_get_section_size_before_reloc (i
);
1133 fprintf (config
.map_file
, " ");
1134 print_section (i
->name
);
1135 fprintf (config
.map_file
, " ");
1136 if (i
->output_section
)
1138 print_address (i
->output_section
->vma
+ i
->output_offset
);
1139 fprintf (config
.map_file
, " ");
1140 print_size (i
->_raw_size
);
1141 fprintf (config
.map_file
, " ");
1142 print_size(i
->_cooked_size
);
1143 fprintf (config
.map_file
, " ");
1144 print_alignment (i
->alignment_power
);
1145 fprintf (config
.map_file
, " ");
1149 bfd
*abfd
= in
->ifile
->the_bfd
;
1151 if (in
->ifile
->just_syms_flag
== true)
1153 fprintf (config
.map_file
, "symbols only ");
1156 fprintf (config
.map_file
, " %s ", abfd
->xvec
->name
);
1157 if (abfd
->my_archive
!= (bfd
*) NULL
)
1159 fprintf (config
.map_file
, "[%s]%s", abfd
->my_archive
->filename
,
1164 fprintf (config
.map_file
, "%s", abfd
->filename
);
1166 fprintf (config
.map_file
, "(overhead %d bytes)", (int) bfd_alloc_size (abfd
));
1169 /* Find all the symbols in this file defined in this section */
1171 if (in
->ifile
->symbol_count
)
1175 for (p
= in
->ifile
->asymbols
; *p
; p
++)
1179 if (bfd_get_section (q
) == i
&& q
->flags
& BSF_GLOBAL
)
1192 print_dot
= outside_section_address (i
) + size
;
1196 fprintf (config
.map_file
, "No output section allocated\n");
1202 DEFUN (print_fill_statement
, (fill
),
1203 lang_fill_statement_type
* fill
)
1205 fprintf (config
.map_file
, "FILL mask ");
1206 print_fill (fill
->fill
);
1210 DEFUN (print_data_statement
, (data
),
1211 lang_data_statement_type
* data
)
1213 /* bfd_vma value; */
1218 /* ASSERT(print_dot == data->output_vma);*/
1220 print_address (data
->output_vma
+ data
->output_section
->vma
);
1222 print_address (data
->value
);
1227 fprintf (config
.map_file
, "BYTE ");
1228 print_dot
+= BYTE_SIZE
;
1231 fprintf (config
.map_file
, "SHORT ");
1232 print_dot
+= SHORT_SIZE
;
1235 fprintf (config
.map_file
, "LONG ");
1236 print_dot
+= LONG_SIZE
;
1240 exp_print_tree (data
->exp
);
1242 fprintf (config
.map_file
, "\n");
1247 DEFUN (print_padding_statement
, (s
),
1248 lang_padding_statement_type
* s
)
1252 print_section ("*fill*");
1254 print_address (s
->output_offset
+ s
->output_section
->vma
);
1256 print_size (s
->size
);
1258 print_fill (s
->fill
);
1261 print_dot
= s
->output_offset
+ s
->output_section
->vma
+ s
->size
;
1266 DEFUN (print_wild_statement
, (w
, os
),
1267 lang_wild_statement_type
* w AND
1268 lang_output_section_statement_type
* os
)
1270 fprintf (config
.map_file
, " from ");
1271 if (w
->filename
!= (char *) NULL
)
1273 fprintf (config
.map_file
, "%s", w
->filename
);
1277 fprintf (config
.map_file
, "*");
1279 if (w
->section_name
!= (char *) NULL
)
1281 fprintf (config
.map_file
, "(%s)", w
->section_name
);
1285 fprintf (config
.map_file
, "(*)");
1288 print_statement (w
->children
.head
, os
);
1292 DEFUN (print_statement
, (s
, os
),
1293 lang_statement_union_type
* s AND
1294 lang_output_section_statement_type
* os
)
1298 switch (s
->header
.type
)
1300 case lang_constructors_statement_enum
:
1301 fprintf (config
.map_file
, "constructors:\n");
1302 print_statement (constructor_list
.head
, os
);
1304 case lang_wild_statement_enum
:
1305 print_wild_statement (&s
->wild_statement
, os
);
1308 fprintf (config
.map_file
, "Fail with %d\n", s
->header
.type
);
1311 case lang_address_statement_enum
:
1312 fprintf (config
.map_file
, "address\n");
1314 case lang_object_symbols_statement_enum
:
1315 fprintf (config
.map_file
, "object symbols\n");
1317 case lang_fill_statement_enum
:
1318 print_fill_statement (&s
->fill_statement
);
1320 case lang_data_statement_enum
:
1321 print_data_statement (&s
->data_statement
);
1323 case lang_input_section_enum
:
1324 print_input_section (&s
->input_section
);
1326 case lang_padding_statement_enum
:
1327 print_padding_statement (&s
->padding_statement
);
1329 case lang_output_section_statement_enum
:
1330 print_output_section_statement (&s
->output_section_statement
);
1332 case lang_assignment_statement_enum
:
1333 print_assignment (&s
->assignment_statement
,
1336 case lang_target_statement_enum
:
1337 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1339 case lang_output_statement_enum
:
1340 fprintf (config
.map_file
, "OUTPUT(%s %s)\n",
1341 s
->output_statement
.name
,
1344 case lang_input_statement_enum
:
1345 print_input_statement (&s
->input_statement
);
1347 case lang_afile_asection_pair_statement_enum
:
1357 DEFUN_VOID (print_statements
)
1359 print_statement (statement_list
.head
,
1360 abs_output_section
);
1365 DEFUN (insert_pad
, (this_ptr
, fill
, power
, output_section_statement
, dot
),
1366 lang_statement_union_type
** this_ptr AND
1368 unsigned int power AND
1369 asection
* output_section_statement AND
1372 /* Align this section first to the
1373 input sections requirement, then
1374 to the output section's requirement.
1375 If this alignment is > than any seen before,
1376 then record it too. Perform the alignment by
1377 inserting a magic 'padding' statement.
1380 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
1382 if (alignment_needed
!= 0)
1384 lang_statement_union_type
*new =
1385 (lang_statement_union_type
*)
1386 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1388 /* Link into existing chain */
1389 new->header
.next
= *this_ptr
;
1391 new->header
.type
= lang_padding_statement_enum
;
1392 new->padding_statement
.output_section
= output_section_statement
;
1393 new->padding_statement
.output_offset
=
1394 dot
- output_section_statement
->vma
;
1395 new->padding_statement
.fill
= fill
;
1396 new->padding_statement
.size
= alignment_needed
;
1400 /* Remember the most restrictive alignment */
1401 if (power
> output_section_statement
->alignment_power
)
1403 output_section_statement
->alignment_power
= power
;
1405 output_section_statement
->_raw_size
+= alignment_needed
;
1406 return alignment_needed
+ dot
;
1410 /* Work out how much this section will move the dot point */
1412 DEFUN (size_input_section
, (this_ptr
, output_section_statement
, fill
,
1414 lang_statement_union_type
** this_ptr AND
1415 lang_output_section_statement_type
* output_section_statement AND
1416 unsigned short fill AND
1420 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1421 asection
*i
= is
->section
;
1423 if (is
->ifile
->just_syms_flag
== false)
1425 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
1426 output_section_statement
->bfd_section
, dot
);
1428 /* remember the largest size so we can malloc the largest area
1429 needed for the output stage. Only remember the size of sections
1430 which we will actually allocate */
1432 (SEC_HAS_CONTENTS
| SEC_ALLOC
)) == (SEC_HAS_CONTENTS
| SEC_ALLOC
))
1433 && (bfd_get_section_size_before_reloc (i
) > largest_section
))
1435 largest_section
= bfd_get_section_size_before_reloc (i
);
1438 /* Remember where in the output section this input section goes */
1440 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1442 /* Mark how big the output section must be to contain this now
1446 dot
+= i
->_cooked_size
;
1450 dot
+= i
->_raw_size
;
1452 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
1456 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
1462 /* Sizing happens in two passes, first pass we allocate worst case
1463 stuff. The second pass (if relaxing), we use what we learnt to
1464 change the size of some relocs from worst case to better
1466 static boolean had_relax
;
1469 DEFUN (lang_size_sections
, (s
, output_section_statement
, prev
, fill
,
1471 lang_statement_union_type
* s AND
1472 lang_output_section_statement_type
* output_section_statement AND
1473 lang_statement_union_type
** prev AND
1474 unsigned short fill AND
1478 /* Size up the sections from their constituent parts */
1479 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1481 switch (s
->header
.type
)
1484 case lang_output_section_statement_enum
:
1487 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
1489 if (os
->bfd_section
== &bfd_abs_section
)
1491 /* No matter what happens, an abs section starts at zero */
1492 bfd_set_section_vma (0, os
->bfd_section
, 0);
1496 if (os
->addr_tree
== (etree_type
*) NULL
)
1498 /* No address specified for this section, get one
1499 from the region specification
1501 if (os
->region
== (lang_memory_region_type
*) NULL
)
1503 os
->region
= lang_memory_region_lookup ("*default*");
1505 dot
= os
->region
->current
;
1511 r
= exp_fold_tree (os
->addr_tree
,
1513 lang_allocating_phase_enum
,
1515 if (r
.valid
== false)
1517 einfo ("%F%S: non constant address expression for section %s\n",
1522 /* The section starts here */
1523 /* First, align to what the section needs */
1526 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
1527 bfd_set_section_vma (0, os
->bfd_section
, dot
);
1531 os
->bfd_section
->output_offset
= 0;
1533 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
1534 os
->fill
, dot
, relax
);
1535 /* Ignore the size of the input sections, use the vma and size to */
1539 after
= ALIGN (os
->bfd_section
->vma
+
1540 os
->bfd_section
->_raw_size
,
1544 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
1545 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1546 os
->processed
= true;
1548 /* Replace into region ? */
1549 if (os
->addr_tree
== (etree_type
*) NULL
1550 && os
->region
!= (lang_memory_region_type
*) NULL
)
1552 os
->region
->current
= dot
;
1553 /* Make sure this isn't silly */
1554 if (os
->region
->current
>
1555 os
->region
->origin
+
1558 einfo ("%X%P: Region %s is full (%B section %s)\n",
1560 os
->bfd_section
->owner
,
1561 os
->bfd_section
->name
);
1562 /* Reset the region pointer */
1563 os
->region
->current
= 0;
1571 case lang_constructors_statement_enum
:
1572 dot
= lang_size_sections (constructor_list
.head
,
1573 output_section_statement
,
1574 &s
->wild_statement
.children
.head
,
1579 case lang_data_statement_enum
:
1581 unsigned int size
= 0;
1583 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1584 s
->data_statement
.output_section
=
1585 output_section_statement
->bfd_section
;
1587 switch (s
->data_statement
.type
)
1601 output_section_statement
->bfd_section
->_raw_size
+= size
;
1605 case lang_wild_statement_enum
:
1607 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
1608 output_section_statement
,
1609 &s
->wild_statement
.children
.head
,
1615 case lang_object_symbols_statement_enum
:
1616 create_object_symbols
= output_section_statement
;
1618 case lang_output_statement_enum
:
1619 case lang_target_statement_enum
:
1621 case lang_input_section_enum
:
1626 if( relax_section (prev
))
1632 (*prev
)->input_section
.section
->_cooked_size
=
1633 (*prev
)->input_section
.section
->_raw_size
;
1636 dot
= size_input_section (prev
,
1637 output_section_statement
,
1638 output_section_statement
->fill
,
1641 case lang_input_statement_enum
:
1643 case lang_fill_statement_enum
:
1644 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
1646 fill
= s
->fill_statement
.fill
;
1648 case lang_assignment_statement_enum
:
1650 bfd_vma newdot
= dot
;
1652 exp_fold_tree (s
->assignment_statement
.exp
,
1653 output_section_statement
,
1654 lang_allocating_phase_enum
,
1658 if (newdot
!= dot
&& !relax
)
1659 /* We've been moved ! so insert a pad */
1661 lang_statement_union_type
*new =
1662 (lang_statement_union_type
*)
1663 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1665 /* Link into existing chain */
1666 new->header
.next
= *prev
;
1668 new->header
.type
= lang_padding_statement_enum
;
1669 new->padding_statement
.output_section
=
1670 output_section_statement
->bfd_section
;
1671 new->padding_statement
.output_offset
=
1672 dot
- output_section_statement
->bfd_section
->vma
;
1673 new->padding_statement
.fill
= fill
;
1674 new->padding_statement
.size
= newdot
- dot
;
1675 output_section_statement
->bfd_section
->_raw_size
+=
1676 new->padding_statement
.size
;
1685 /* This can only get here when relaxing is turned on */
1686 case lang_padding_statement_enum
:
1688 case lang_address_statement_enum
:
1691 prev
= &s
->header
.next
;
1697 DEFUN (lang_do_assignments
, (s
, output_section_statement
, fill
, dot
),
1698 lang_statement_union_type
* s AND
1699 lang_output_section_statement_type
* output_section_statement AND
1700 unsigned short fill AND
1704 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1706 switch (s
->header
.type
)
1708 case lang_constructors_statement_enum
:
1709 dot
= lang_do_assignments (constructor_list
.head
,
1710 output_section_statement
,
1715 case lang_output_section_statement_enum
:
1717 lang_output_section_statement_type
*os
=
1718 &(s
->output_section_statement
);
1720 dot
= os
->bfd_section
->vma
;
1721 (void) lang_do_assignments (os
->children
.head
, os
, os
->fill
, dot
);
1722 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1725 case lang_wild_statement_enum
:
1727 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
1728 output_section_statement
,
1733 case lang_object_symbols_statement_enum
:
1734 case lang_output_statement_enum
:
1735 case lang_target_statement_enum
:
1737 case lang_common_statement_enum
:
1740 case lang_data_statement_enum
:
1742 etree_value_type value
;
1744 value
= exp_fold_tree (s
->data_statement
.exp
,
1746 lang_final_phase_enum
, dot
, &dot
);
1747 s
->data_statement
.value
= value
.value
;
1748 if (value
.valid
== false)
1749 einfo ("%F%P: Invalid data statement\n");
1751 switch (s
->data_statement
.type
)
1764 case lang_input_section_enum
:
1766 asection
*in
= s
->input_section
.section
;
1768 dot
+= bfd_get_section_size_before_reloc (in
);
1772 case lang_input_statement_enum
:
1774 case lang_fill_statement_enum
:
1775 fill
= s
->fill_statement
.fill
;
1777 case lang_assignment_statement_enum
:
1779 exp_fold_tree (s
->assignment_statement
.exp
,
1780 output_section_statement
,
1781 lang_final_phase_enum
,
1787 case lang_padding_statement_enum
:
1788 dot
+= s
->padding_statement
.size
;
1793 case lang_address_statement_enum
:
1804 DEFUN_VOID (lang_relocate_globals
)
1808 Each ldsym_type maintains a chain of pointers to asymbols which
1809 references the definition. Replace each pointer to the referenence
1810 with a pointer to only one place, preferably the definition. If
1811 the defintion isn't available then the common symbol, and if
1812 there isn't one of them then choose one reference.
1815 FOR_EACH_LDSYM (lgs
)
1819 if (lgs
->sdefs_chain
)
1821 it
= *(lgs
->sdefs_chain
);
1823 else if (lgs
->scoms_chain
!= (asymbol
**) NULL
)
1825 it
= *(lgs
->scoms_chain
);
1827 else if (lgs
->srefs_chain
!= (asymbol
**) NULL
)
1829 it
= *(lgs
->srefs_chain
);
1833 /* This can happen when the command line asked for a symbol to
1835 it
= (asymbol
*) NULL
;
1837 if (it
!= (asymbol
*) NULL
)
1839 asymbol
**ptr
= lgs
->srefs_chain
;;
1840 if (lgs
->flags
& SYM_WARNING
)
1842 produce_warnings (lgs
, it
);
1845 while (ptr
!= (asymbol
**) NULL
)
1847 asymbol
*ref
= *ptr
;
1850 ptr
= (asymbol
**) (ref
->udata
);
1859 DEFUN_VOID (lang_finish
)
1862 int warn
= config
.relocateable_output
!= true;
1863 if (entry_symbol
== (char *) NULL
)
1865 /* No entry has been specified, look for start, but don't warn */
1866 entry_symbol
= "start";
1869 lgs
= ldsym_get_soft (entry_symbol
);
1870 if (lgs
&& lgs
->sdefs_chain
)
1872 asymbol
*sy
= *(lgs
->sdefs_chain
);
1874 /* We can set the entry address*/
1875 bfd_set_start_address (output_bfd
,
1876 outside_symbol_address (sy
));
1881 /* Can't find anything reasonable,
1882 use the first address in the text section
1884 asection
*ts
= bfd_get_section_by_name (output_bfd
, ".text");
1888 einfo ("%P: Warning, can't find entry symbol %s, defaulting to %V\n",
1889 entry_symbol
, ts
->vma
);
1891 bfd_set_start_address (output_bfd
, ts
->vma
);
1896 einfo ("%P: Warning, can't find entry symbol %s, not setting start address\n",
1902 /* By now we know the target architecture, and we may have an */
1903 /* ldfile_output_machine_name */
1905 DEFUN_VOID (lang_check
)
1907 lang_statement_union_type
*file
;
1909 unsigned long input_machine
;
1910 enum bfd_architecture input_architecture
;
1911 CONST bfd_arch_info_type
*compatible
;
1913 for (file
= file_chain
.head
;
1914 file
!= (lang_statement_union_type
*) NULL
;
1915 file
= file
->input_statement
.next
)
1917 unsigned long ldfile_new_output_machine
= 0;
1918 enum bfd_architecture ldfile_new_output_architecture
= bfd_arch_unknown
;
1920 input_bfd
= file
->input_statement
.the_bfd
;
1922 input_machine
= bfd_get_mach (input_bfd
);
1923 input_architecture
= bfd_get_arch (input_bfd
);
1926 /* Inspect the architecture and ensure we're linking like with
1929 compatible
= bfd_arch_get_compatible (input_bfd
,
1934 ldfile_output_machine
= compatible
->mach
;
1935 ldfile_output_architecture
= compatible
->arch
;
1940 info ("%P: warning, %s architecture of input file `%B' incompatible with %s output\n",
1941 bfd_printable_name (input_bfd
), input_bfd
,
1942 bfd_printable_name (output_bfd
));
1944 bfd_set_arch_mach (output_bfd
,
1953 * run through all the global common symbols and tie them
1954 * to the output section requested.
1956 As an experiment we do this 4 times, once for all the byte sizes,
1957 then all the two bytes, all the four bytes and then everything else
1961 DEFUN_VOID (lang_common
)
1966 if (config
.relocateable_output
== false ||
1967 command_line
.force_common_definition
== true)
1969 for (power
= 1; (config
.sort_common
== true && power
== 1) || (power
<= 16); power
<<= 1)
1971 for (lgs
= symbol_head
;
1972 lgs
!= (ldsym_type
*) NULL
;
1976 unsigned int power_of_two
;
1980 if (lgs
->scoms_chain
!= (asymbol
**) NULL
)
1982 com
= *(lgs
->scoms_chain
);
2012 if (config
.sort_common
== false || align
== power
)
2014 /* Change from a common symbol into a definition of
2016 lgs
->sdefs_chain
= lgs
->scoms_chain
;
2017 lgs
->scoms_chain
= (asymbol
**) NULL
;
2019 /* Point to the correct common section */
2021 ((lang_input_statement_type
*)
2022 (com
->the_bfd
->usrdata
))->common_section
;
2023 /* Fix the size of the common section */
2025 com
->section
->_raw_size
=
2026 ALIGN (com
->section
->_raw_size
, align
);
2028 /* Remember if this is the biggest alignment ever seen */
2029 if (power_of_two
> com
->section
->alignment_power
)
2031 com
->section
->alignment_power
= power_of_two
;
2034 /* Symbol stops being common and starts being global, but
2035 we remember that it was common once. */
2037 com
->flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_OLD_COMMON
;
2038 com
->value
= com
->section
->_raw_size
;
2042 fprintf (config
.map_file
, "Allocating common %s: %x at %x %s\n",
2045 (unsigned) com
->value
,
2046 com
->the_bfd
->filename
);
2049 com
->section
->_raw_size
+= size
;
2062 run through the input files and ensure that every input
2063 section has somewhere to go. If one is found without
2064 a destination then create an input request and place it
2065 into the statement tree.
2069 DEFUN_VOID (lang_place_orphans
)
2071 lang_input_statement_type
*file
;
2073 for (file
= (lang_input_statement_type
*) file_chain
.head
;
2074 file
!= (lang_input_statement_type
*) NULL
;
2075 file
= (lang_input_statement_type
*) file
->next
)
2079 for (s
= file
->the_bfd
->sections
;
2080 s
!= (asection
*) NULL
;
2083 if (s
->output_section
== (asection
*) NULL
)
2085 /* This section of the file is not attatched, root
2086 around for a sensible place for it to go */
2088 if (file
->common_section
== s
)
2090 /* This is a lonely common section which must
2091 have come from an archive. We attatch to the
2092 section with the wildcard */
2093 if (config
.relocateable_output
!= true
2094 && command_line
.force_common_definition
== false)
2096 if (default_common_section
==
2097 (lang_output_section_statement_type
*) NULL
)
2099 info ("%P: No [COMMON] command, defaulting to .bss\n");
2101 default_common_section
=
2102 lang_output_section_statement_lookup (".bss");
2105 wild_doit (&default_common_section
->children
, s
,
2106 default_common_section
, file
);
2111 lang_output_section_statement_type
*os
=
2112 lang_output_section_statement_lookup (s
->name
);
2114 wild_doit (&os
->children
, s
, os
, file
);
2123 DEFUN (lang_set_flags
, (ptr
, flags
),
2127 boolean state
= false;
2142 /* ptr->flag_read = state; */
2145 /* ptr->flag_write = state; */
2148 /* ptr->flag_executable= state;*/
2152 /* ptr->flag_loadable= state;*/
2155 einfo ("%P%F illegal syntax in flags\n");
2165 DEFUN (lang_for_each_file
, (func
),
2166 PROTO (void, (*func
), (lang_input_statement_type
*)))
2168 lang_input_statement_type
*f
;
2170 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2171 f
!= (lang_input_statement_type
*) NULL
;
2172 f
= (lang_input_statement_type
*) f
->next
)
2180 DEFUN (lang_for_each_input_section
, (func
),
2181 PROTO (void, (*func
), (bfd
* ab
, asection
* as
)))
2183 lang_input_statement_type
*f
;
2185 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2186 f
!= (lang_input_statement_type
*) NULL
;
2187 f
= (lang_input_statement_type
*) f
->next
)
2191 for (s
= f
->the_bfd
->sections
;
2192 s
!= (asection
*) NULL
;
2195 func (f
->the_bfd
, s
);
2203 DEFUN (ldlang_add_file
, (entry
),
2204 lang_input_statement_type
* entry
)
2207 lang_statement_append (&file_chain
,
2208 (lang_statement_union_type
*) entry
,
2213 DEFUN (lang_add_output
, (name
),
2216 lang_output_statement_type
*new = new_stat (lang_output_statement
,
2220 had_output_filename
= true;
2224 static lang_output_section_statement_type
*current_section
;
2227 DEFUN (lang_enter_output_section_statement
,
2228 (output_section_statement_name
,
2232 char *output_section_statement_name AND
2233 etree_type
* address_exp AND
2235 bfd_vma block_value
)
2237 lang_output_section_statement_type
*os
;
2241 lang_output_section_statement_lookup (output_section_statement_name
);
2245 /* Add this statement to tree */
2246 /* add_statement(lang_output_section_statement_enum,
2247 output_section_statement);*/
2248 /* Make next things chain into subchain of this */
2250 if (os
->addr_tree
==
2251 (etree_type
*) NULL
)
2257 if (flags
& SEC_NEVER_LOAD
)
2261 os
->block_value
= block_value
;
2262 stat_ptr
= &os
->children
;
2267 DEFUN_VOID (lang_final
)
2269 if (had_output_filename
== false)
2271 extern CONST
char *output_filename
;
2273 lang_add_output (output_filename
);
2277 /* Reset the current counters in the regions */
2279 DEFUN_VOID (reset_memory_regions
)
2281 lang_memory_region_type
*p
= lang_memory_region_list
;
2283 for (p
= lang_memory_region_list
;
2284 p
!= (lang_memory_region_type
*) NULL
;
2287 p
->old_length
= p
->current
- p
->origin
;
2288 p
->current
= p
->origin
;
2295 DEFUN (create_symbol
, (name
, flags
, section
),
2296 CONST
char *name AND
2300 extern lang_input_statement_type
*script_file
;
2301 asymbol
**def_ptr
= (asymbol
**) stat_alloc ((bfd_size_type
) (sizeof (asymbol
**)));
2303 /* Add this definition to script file */
2304 asymbol
*def
= (asymbol
*) bfd_make_empty_symbol (script_file
->the_bfd
);
2306 def
->name
= buystring (name
);
2309 def
->section
= section
;
2312 Q_enter_global_ref (def_ptr
, name
);
2317 DEFUN_VOID (lang_process
)
2320 if (had_script
== false)
2322 parse_line (ldemul_get_script (), 1);
2324 lang_reasonable_defaults ();
2325 current_target
= default_target
;
2327 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
2328 /* For each output section statement, create a section in the output
2330 lang_create_output_section_statements ();
2332 /* Create a dummy bfd for the script */
2333 lang_init_script_file ();
2335 /* Add to the hash table all undefineds on the command line */
2336 lang_place_undefineds ();
2338 /* Create a bfd for each input file */
2339 current_target
= default_target
;
2340 lang_for_each_statement (open_input_bfds
);
2342 common_section
.userdata
= (PTR
) & common_section_userdata
;
2345 /* Run through the contours of the script and attatch input sections
2346 to the correct output sections
2348 find_constructors ();
2349 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
2350 (lang_output_section_statement_type
*) NULL
);
2353 /* Find any sections not attatched explicitly and handle them */
2354 lang_place_orphans ();
2356 /* Size up the common data */
2359 ldemul_before_allocation ();
2369 lang_size_sections (statement_list
.head
,
2370 (lang_output_section_statement_type
*) NULL
,
2371 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2372 /* FIXME. Until the code in relax is fixed so that it only reads in
2373 stuff once, we cant iterate since there is no way for the linker to
2374 know what has been patched and what hasn't */
2380 /* Now run around and relax if we can */
2381 if (command_line
.relax
)
2383 /* First time round is a trial run to get the 'worst case' addresses of the
2384 objects if there was no relaxing */
2385 lang_size_sections (statement_list
.head
,
2386 (lang_output_section_statement_type
*) NULL
,
2387 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2391 /* Move the global symbols around so the second pass of relaxing can
2393 lang_relocate_globals ();
2395 reset_memory_regions ();
2397 /* Do all the assignments, now that we know the final restingplaces
2398 of all the symbols */
2400 lang_do_assignments (statement_list
.head
,
2405 /* Perform another relax pass - this time we know where the
2406 globals are, so can make better guess */
2407 lang_size_sections (statement_list
.head
,
2408 (lang_output_section_statement_type
*) NULL
,
2409 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2417 /* Size up the sections */
2418 lang_size_sections (statement_list
.head
,
2420 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2425 /* See if anything special should be done now we know how big
2427 ldemul_after_allocation ();
2429 /* Do all the assignments, now that we know the final restingplaces
2430 of all the symbols */
2432 lang_do_assignments (statement_list
.head
,
2437 /* Move the global symbols around */
2438 lang_relocate_globals ();
2440 /* Make sure that we're not mixing architectures */
2448 /* EXPORTED TO YACC */
2451 DEFUN (lang_add_wild
, (section_name
, filename
),
2452 CONST
char *CONST section_name AND
2453 CONST
char *CONST filename
)
2455 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
2458 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
2460 placed_commons
= true;
2462 if (filename
!= (char *) NULL
)
2464 lang_has_input_file
= true;
2466 new->section_name
= section_name
;
2467 new->filename
= filename
;
2468 lang_list_init (&new->children
);
2472 DEFUN (lang_section_start
, (name
, address
),
2473 CONST
char *name AND
2474 etree_type
* address
)
2476 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
2478 ad
->section_name
= name
;
2479 ad
->address
= address
;
2483 DEFUN (lang_add_entry
, (name
),
2486 entry_symbol
= name
;
2490 DEFUN (lang_add_target
, (name
),
2493 lang_target_statement_type
*new = new_stat (lang_target_statement
,
2501 DEFUN (lang_add_map
, (name
),
2509 map_option_f
= true;
2517 DEFUN (lang_add_fill
, (exp
),
2520 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
2527 DEFUN (lang_add_data
, (type
, exp
),
2529 union etree_union
*exp
)
2532 lang_data_statement_type
*new = new_stat (lang_data_statement
,
2541 DEFUN (lang_add_assignment
, (exp
),
2544 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
2551 DEFUN (lang_add_attribute
, (attribute
),
2552 enum statement_enum attribute
)
2554 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
2558 DEFUN (lang_startup
, (name
),
2561 if (startup_file
!= (char *) NULL
)
2563 einfo ("%P%FMultiple STARTUP files\n");
2565 first_file
->filename
= name
;
2566 first_file
->local_sym_name
= name
;
2568 startup_file
= name
;
2572 DEFUN (lang_float
, (maybe
),
2575 lang_float_flag
= maybe
;
2579 DEFUN (lang_leave_output_section_statement
, (fill
, memspec
),
2581 CONST
char *memspec
)
2583 current_section
->fill
= fill
;
2584 current_section
->region
= lang_memory_region_lookup (memspec
);
2585 stat_ptr
= &statement_list
;
2587 /* We remember if we are closing a .data section, since we use it to
2588 store constructors in */
2589 if (strcmp (current_section
->name
, ".data") == 0)
2591 end_of_data_section_statement_list
= statement_list
;
2597 Create an absolute symbol with the given name with the value of the
2598 address of first byte of the section named.
2600 If the symbol already exists, then do nothing.
2603 DEFUN (lang_abs_symbol_at_beginning_of
, (section
, name
),
2604 CONST
char *section AND
2607 if (ldsym_undefined (name
))
2609 asection
*s
= bfd_get_section_by_name (output_bfd
, section
);
2610 asymbol
*def
= create_symbol (name
,
2611 BSF_GLOBAL
| BSF_EXPORT
,
2614 if (s
!= (asection
*) NULL
)
2616 def
->value
= s
->vma
;
2626 Create an absolute symbol with the given name with the value of the
2627 address of the first byte after the end of the section named.
2629 If the symbol already exists, then do nothing.
2632 DEFUN (lang_abs_symbol_at_end_of
, (section
, name
),
2633 CONST
char *section AND
2636 if (ldsym_undefined (name
))
2638 asection
*s
= bfd_get_section_by_name (output_bfd
, section
);
2640 /* Add a symbol called _end */
2641 asymbol
*def
= create_symbol (name
,
2642 BSF_GLOBAL
| BSF_EXPORT
,
2645 if (s
!= (asection
*) NULL
)
2647 def
->value
= s
->vma
+ s
->_raw_size
;
2657 DEFUN (lang_statement_append
, (list
, element
, field
),
2658 lang_statement_list_type
* list AND
2659 lang_statement_union_type
* element AND
2660 lang_statement_union_type
** field
)
2662 *(list
->tail
) = element
;
2666 /* Set the output format type */
2668 DEFUN (lang_add_output_format
, (format
),
2671 output_target
= format
;