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. */
39 PROTO(static void, print_statements
,(void));
40 PROTO(static void, print_statement
,(lang_statement_union_type
*,
41 lang_output_section_statement_type
*));
45 static CONST
char *startup_file
;
46 static lang_statement_list_type input_file_chain
;
47 static boolean placed_commons
= false;
48 static lang_output_section_statement_type
*default_common_section
;
49 static boolean map_option_f
;
50 static bfd_vma print_dot
;
51 static lang_input_statement_type
*first_file
;
52 static lang_statement_list_type lang_output_section_statement
;
53 static CONST
char *current_target
;
54 static CONST
char *output_target
;
55 static size_t longest_section_name
= 8;
56 static asection common_section
;
57 static section_userdata_type common_section_userdata
;
58 static lang_statement_list_type statement_list
;
61 lang_statement_list_type
*stat_ptr
= &statement_list
;
62 lang_input_statement_type
*script_file
= 0;
63 boolean option_longmap
= false;
64 lang_statement_list_type file_chain
= {0};
65 CONST
char *entry_symbol
= 0;
66 bfd_size_type largest_section
= 0;
67 boolean lang_has_input_file
= false;
68 lang_output_section_statement_type
*create_object_symbols
= 0;
69 boolean had_output_filename
= false;
70 boolean lang_float_flag
= false;
72 extern char *default_target
;
74 extern unsigned int undefined_global_sym_count
;
75 extern char *current_file
;
76 extern bfd
*output_bfd
;
77 extern enum bfd_architecture ldfile_output_architecture
;
78 extern unsigned long ldfile_output_machine
;
79 extern char *ldfile_output_machine_name
;
80 extern ldsym_type
*symbol_head
;
81 extern unsigned int commons_pending
;
82 extern args_type command_line
;
83 extern ld_config_type config
;
84 extern boolean had_script
;
85 extern boolean write_map
;
91 #define cat(a,b) a/**/b
94 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
96 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
98 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
101 DEFUN(print_size
,(value
),
104 printf("%5x", (unsigned)value
);
107 DEFUN(print_alignment
,(value
),
110 printf("2**%1u",value
);
113 DEFUN(print_fill
,(value
),
116 printf("%04x",(unsigned)value
);
121 DEFUN(print_section
,(name
),
122 CONST
char *CONST name
)
124 printf("%*s", -longest_section_name
, name
);
127 /*----------------------------------------------------------------------
128 lang_for_each_statement walks the parse tree and calls the provided
129 function for each node
133 DEFUN(lang_for_each_statement_worker
,(func
, s
),
135 lang_statement_union_type
*s
)
137 for (; s
!= (lang_statement_union_type
*)NULL
; s
= s
->next
)
141 switch (s
->header
.type
) {
142 case lang_output_section_statement_enum
:
143 lang_for_each_statement_worker
145 s
->output_section_statement
.children
.head
);
147 case lang_wild_statement_enum
:
148 lang_for_each_statement_worker
150 s
->wild_statement
.children
.head
);
152 case lang_data_statement_enum
:
153 case lang_object_symbols_statement_enum
:
154 case lang_output_statement_enum
:
155 case lang_target_statement_enum
:
156 case lang_input_section_enum
:
157 case lang_input_statement_enum
:
158 case lang_fill_statement_enum
:
159 case lang_assignment_statement_enum
:
160 case lang_padding_statement_enum
:
161 case lang_address_statement_enum
:
171 DEFUN(lang_for_each_statement
,(func
),
174 lang_for_each_statement_worker(func
,
175 statement_list
.head
);
177 /*----------------------------------------------------------------------*/
179 DEFUN(lang_list_init
,(list
),
180 lang_statement_list_type
*list
)
182 list
->head
= (lang_statement_union_type
*)NULL
;
183 list
->tail
= &list
->head
;
187 /*----------------------------------------------------------------------
189 build a new statement node for the parse tree
194 lang_statement_union_type
*
195 DEFUN(new_statement
,(type
, size
, list
),
196 enum statement_enum type AND
197 bfd_size_type size AND
198 lang_statement_list_type
*list
)
200 lang_statement_union_type
*new = (lang_statement_union_type
*)
202 new->header
.type
= type
;
203 new->header
.next
= (lang_statement_union_type
*)NULL
;
204 lang_statement_append(list
, new, &new->header
.next
);
209 Build a new input file node for the language. There are several ways
210 in which we treat an input file, eg, we only look at symbols, or
211 prefix it with a -l etc.
213 We can be supplied with requests for input files more than once;
214 they may, for example be split over serveral lines like foo.o(.text)
215 foo.o(.data) etc, so when asked for a file we check that we havn't
216 got it already so we don't duplicate the bfd.
219 static lang_input_statement_type
*
220 DEFUN(new_afile
, (name
, file_type
, target
),
221 CONST
char *CONST name AND
222 CONST lang_input_file_enum_type file_type AND
223 CONST
char *CONST target
)
225 lang_input_statement_type
*p
= new_stat(lang_input_statement
,
227 lang_has_input_file
= true;
230 case lang_input_file_is_symbols_only_enum
:
232 p
->is_archive
=false;
234 p
->local_sym_name
= name
;
235 p
->just_syms_flag
= true;
236 p
->search_dirs_flag
= false;
238 case lang_input_file_is_fake_enum
:
240 p
->is_archive
=false;
242 p
->local_sym_name
= name
;
243 p
->just_syms_flag
= false;
244 p
->search_dirs_flag
=false;
246 case lang_input_file_is_l_enum
:
247 p
->is_archive
= true;
250 p
->local_sym_name
= concat("-l",name
,"");
251 p
->just_syms_flag
= false;
252 p
->search_dirs_flag
= true;
254 case lang_input_file_is_search_file_enum
:
255 case lang_input_file_is_marker_enum
:
257 p
->is_archive
=false;
259 p
->local_sym_name
= name
;
260 p
->just_syms_flag
= false;
261 p
->search_dirs_flag
=true;
263 case lang_input_file_is_file_enum
:
265 p
->is_archive
=false;
267 p
->local_sym_name
= name
;
268 p
->just_syms_flag
= false;
269 p
->search_dirs_flag
=false;
274 p
->asymbols
= (asymbol
**)NULL
;
275 p
->superfile
= (lang_input_statement_type
*)NULL
;
276 p
->next_real_file
= (lang_statement_union_type
*)NULL
;
277 p
->next
= (lang_statement_union_type
*)NULL
;
279 p
->common_output_section
= (asection
*)NULL
;
280 lang_statement_append(&input_file_chain
,
281 (lang_statement_union_type
*)p
,
288 lang_input_statement_type
*
289 DEFUN(lang_add_input_file
,(name
, file_type
, target
),
291 lang_input_file_enum_type file_type AND
294 /* Look it up or build a new one */
295 lang_has_input_file
= true;
297 lang_input_statement_type
*p
;
299 for (p
= (lang_input_statement_type
*)input_file_chain
.head
;
300 p
!= (lang_input_statement_type
*)NULL
;
301 p
= (lang_input_statement_type
*)(p
->next_real_file
))
303 /* Sometimes we have incomplete entries in here */
304 if (p
->filename
!= (char *)NULL
) {
305 if(strcmp(name
,p
->filename
) == 0) return p
;
310 return new_afile(name
, file_type
, target
);
314 /* Build enough state so that the parser can build its tree */
316 DEFUN_VOID(lang_init
)
319 stat_ptr
= &statement_list
;
320 lang_list_init(stat_ptr
);
322 lang_list_init(&input_file_chain
);
323 lang_list_init(&lang_output_section_statement
);
324 lang_list_init(&file_chain
);
325 first_file
= lang_add_input_file((char *)NULL
,
326 lang_input_file_is_marker_enum
,
331 /*----------------------------------------------------------------------
332 A region is an area of memory declared with the
333 MEMORY { name:org=exp, len=exp ... }
336 We maintain a list of all the regions here
338 If no regions are specified in the script, then the default is used
339 which is created when looked up to be the entire data space
342 static lang_memory_region_type
*lang_memory_region_list
;
343 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
345 lang_memory_region_type
*
346 DEFUN(lang_memory_region_lookup
,(name
),
347 CONST
char *CONST name
)
350 lang_memory_region_type
*p
= lang_memory_region_list
;
351 for (p
= lang_memory_region_list
;
352 p
!= ( lang_memory_region_type
*)NULL
;
354 if (strcmp(p
->name
, name
) == 0) {
358 if (strcmp(name
,"*default*")==0) {
359 /* This is the default region, dig out first one on the list */
360 if (lang_memory_region_list
!= (lang_memory_region_type
*)NULL
){
361 return lang_memory_region_list
;
365 lang_memory_region_type
*new =
366 (lang_memory_region_type
*)ldmalloc((bfd_size_type
)(sizeof(lang_memory_region_type
)));
367 new->name
= buystring(name
);
368 new->next
= (lang_memory_region_type
*)NULL
;
370 *lang_memory_region_list_tail
= new;
371 lang_memory_region_list_tail
= &new->next
;
380 lang_output_section_statement_type
*
381 DEFUN(lang_output_section_find
,(name
),
382 CONST
char * CONST name
)
384 lang_statement_union_type
*u
;
385 lang_output_section_statement_type
*lookup
;
387 for (u
= lang_output_section_statement
.head
;
388 u
!= (lang_statement_union_type
*)NULL
;
391 lookup
= &u
->output_section_statement
;
392 if (strcmp(name
, lookup
->name
)==0) {
396 return (lang_output_section_statement_type
*)NULL
;
399 lang_output_section_statement_type
*
400 DEFUN(lang_output_section_statement_lookup
,(name
),
401 CONST
char * CONST name
)
403 lang_output_section_statement_type
*lookup
;
404 lookup
=lang_output_section_find(name
);
405 if (lookup
== (lang_output_section_statement_type
*)NULL
) {
407 lookup
=(lang_output_section_statement_type
*)
408 new_stat(lang_output_section_statement
, stat_ptr
);
409 lookup
->region
= (lang_memory_region_type
*)NULL
;
411 lookup
->block_value
= 1;
414 lookup
->next
= (lang_statement_union_type
*)NULL
;
415 lookup
->bfd_section
= (asection
*)NULL
;
416 lookup
->processed
= false;
417 lookup
->addr_tree
= (etree_type
*)NULL
;
418 lang_list_init(&lookup
->children
);
420 lang_statement_append(&lang_output_section_statement
,
421 (lang_statement_union_type
*)lookup
,
432 DEFUN(print_flags
, (outfile
, ignore_flags
),
434 lang_section_flags_type
*ignore_flags
)
436 fprintf(outfile
,"(");
438 if (flags
->flag_read
) fprintf(outfile
,"R");
439 if (flags
->flag_write
) fprintf(outfile
,"W");
440 if (flags
->flag_executable
) fprintf(outfile
,"X");
441 if (flags
->flag_loadable
) fprintf(outfile
,"L");
443 fprintf(outfile
,")");
447 DEFUN(lang_map
,(outfile
),
450 lang_memory_region_type
*m
;
451 fprintf(outfile
,"**MEMORY CONFIGURATION**\n\n");
453 fprintf(outfile
,"name\t\torigin\t\tlength\t\tattributes\n");
455 fprintf(outfile
,"name\t\torigin length\t\tattributes\n");
457 for (m
= lang_memory_region_list
;
458 m
!= (lang_memory_region_type
*)NULL
;
461 fprintf(outfile
,"%-16s", m
->name
);
462 print_address(m
->origin
);
464 print_address(m
->length
);
466 print_flags(outfile
, &m
->flags
);
467 fprintf(outfile
,"\n");
469 fprintf(outfile
,"\n\n**LINK EDITOR MEMORY MAP**\n\n");
470 fprintf(outfile
,"output input virtual\n");
471 fprintf(outfile
,"section section address tsize\n\n");
482 lang_output_section_statement_type
*s
)
484 section_userdata_type
*new =
485 (section_userdata_type
*)
486 ldmalloc((bfd_size_type
)(sizeof(section_userdata_type
)));
488 s
->bfd_section
= bfd_make_section(output_bfd
, s
->name
);
489 if (s
->bfd_section
== (asection
*)NULL
) {
490 info("%P%F output format %s cannot represent section called %s\n",
491 output_bfd
->xvec
->name
,
494 s
->bfd_section
->output_section
= s
->bfd_section
;
495 s
->bfd_section
->flags
= SEC_NO_FLAGS
;
496 /* We initialize an output sections output offset to minus its own */
497 /* vma to allow us to output a section through itself */
498 s
->bfd_section
->output_offset
= 0;
499 get_userdata( s
->bfd_section
) = (PTR
)new;
502 /***********************************************************************
505 These expand statements like *(.text) and foo.o to a list of
506 explicit actions, like foo.o(.text), bar.o(.text) and
509 The toplevel routine, wild, takes a statement, section, file and
510 target. If either the section or file is null it is taken to be the
511 wildcard. Seperate lang_input_section statements are created for
512 each part of the expanstion, and placed after the statement provided.
517 DEFUN(wild_doit
,(ptr
, section
, output
, file
),
518 lang_statement_list_type
*ptr AND
519 asection
*section AND
520 lang_output_section_statement_type
*output AND
521 lang_input_statement_type
*file
)
523 if(output
->bfd_section
== (asection
*)NULL
)
528 if (section
!= (asection
*)NULL
529 && section
->output_section
== (asection
*)NULL
) {
530 /* Add a section reference to the list */
531 lang_input_section_type
*new = new_stat(lang_input_section
, ptr
);
533 new->section
= section
;
535 section
->output_section
= output
->bfd_section
;
536 section
->output_section
->flags
|= section
->flags
;
537 if (section
->alignment_power
> output
->bfd_section
->alignment_power
) {
538 output
->bfd_section
->alignment_power
= section
->alignment_power
;
544 DEFUN(our_bfd_get_section_by_name
,(abfd
, section
),
548 return bfd_get_section_by_name(abfd
, section
);
552 DEFUN(wild_section
,(ptr
, section
, file
, output
),
553 lang_wild_statement_type
*ptr AND
554 CONST
char *section AND
555 lang_input_statement_type
*file AND
556 lang_output_section_statement_type
*output
)
559 if (file
->just_syms_flag
== false) {
560 if (section
== (char *)NULL
) {
561 /* Do the creation to all sections in the file */
562 for (s
= file
->the_bfd
->sections
; s
!= (asection
*)NULL
; s
=s
->next
) {
563 wild_doit(&ptr
->children
, s
, output
, file
);
567 /* Do the creation to the named section only */
568 wild_doit(&ptr
->children
,
569 our_bfd_get_section_by_name(file
->the_bfd
, section
),
576 /* passed a file name (which must have been seen already and added to
577 the statement tree. We will see if it has been opened already and
578 had its symbols read. If not then we'll read it.
580 Archives are pecuilar here. We may open them once, but if they do
581 not define anything we need at the time, they won't have all their
582 symbols read. If we need them later, we'll have to redo it.
585 lang_input_statement_type
*
586 DEFUN(lookup_name
,(name
),
587 CONST
char * CONST name
)
589 lang_input_statement_type
*search
;
590 for(search
= (lang_input_statement_type
*)input_file_chain
.head
;
591 search
!= (lang_input_statement_type
*)NULL
;
592 search
= (lang_input_statement_type
*)search
->next_real_file
)
594 if (search
->filename
== (char *)NULL
&& name
== (char *)NULL
) {
597 if (search
->filename
!= (char *)NULL
&& name
!= (char *)NULL
) {
598 if (strcmp(search
->filename
, name
) == 0) {
599 ldmain_open_file_read_symbol(search
);
605 /* There isn't an afile entry for this file yet, this must be
606 because the name has only appeared inside a load script and not
607 on the command line */
608 search
= new_afile(name
, lang_input_file_is_file_enum
, default_target
);
609 ldmain_open_file_read_symbol(search
);
616 DEFUN(wild
,(s
, section
, file
, target
, output
),
617 lang_wild_statement_type
*s AND
618 CONST
char *CONST section AND
619 CONST
char *CONST file AND
620 CONST
char *CONST target AND
621 lang_output_section_statement_type
*output
)
623 lang_input_statement_type
*f
;
624 if (file
== (char *)NULL
) {
625 /* Perform the iteration over all files in the list */
626 for (f
= (lang_input_statement_type
*)file_chain
.head
;
627 f
!= (lang_input_statement_type
*)NULL
;
628 f
= (lang_input_statement_type
*)f
->next
) {
629 wild_section(s
, section
, f
, output
);
633 /* Perform the iteration over a single file */
634 wild_section( s
, section
, lookup_name(file
), output
);
636 if (section
!= (char *)NULL
637 && strcmp(section
,"COMMON") == 0
638 && default_common_section
== (lang_output_section_statement_type
*)NULL
)
640 /* Remember the section that common is going to incase we later
641 get something which doesn't know where to put it */
642 default_common_section
= output
;
647 read in all the files
650 DEFUN(open_output
,(name
),
651 CONST
char *CONST name
)
653 extern CONST
char *output_filename
;
655 if (output_target
== (char *)NULL
) {
656 if (current_target
!= (char *)NULL
)
657 output_target
= current_target
;
659 output_target
= default_target
;
661 output
= bfd_openw(name
, output_target
);
662 output_filename
= name
;
664 if (output
== (bfd
*)NULL
)
666 if (bfd_error
== invalid_target
) {
667 info("%P%F target %s not found\n", output_target
);
669 info("%P%F problem opening output file %s, %E", name
);
672 output
->flags
|= D_PAGED
;
673 bfd_set_format(output
, bfd_object
);
681 DEFUN(ldlang_open_output
,(statement
),
682 lang_statement_union_type
*statement
)
684 switch (statement
->header
.type
)
686 case lang_output_statement_enum
:
687 output_bfd
= open_output(statement
->output_statement
.name
);
688 ldemul_set_output_arch();
691 case lang_target_statement_enum
:
692 current_target
= statement
->target_statement
.target
;
700 DEFUN(open_input_bfds
,(statement
),
701 lang_statement_union_type
*statement
)
703 switch (statement
->header
.type
)
705 case lang_target_statement_enum
:
706 current_target
= statement
->target_statement
.target
;
708 case lang_wild_statement_enum
:
709 /* Maybe we should load the file's symbols */
710 if (statement
->wild_statement
.filename
)
712 (void) lookup_name(statement
->wild_statement
.filename
);
715 case lang_input_statement_enum
:
716 if (statement
->input_statement
.real
== true)
718 statement
->input_statement
.target
= current_target
;
719 lookup_name(statement
->input_statement
.filename
);
726 /* If there are [COMMONS] statements, put a wild one into the bss section */
729 lang_reasonable_defaults()
732 lang_output_section_statement_lookup(".text");
733 lang_output_section_statement_lookup(".data");
735 default_common_section
=
736 lang_output_section_statement_lookup(".bss");
739 if (placed_commons
== false) {
740 lang_wild_statement_type
*new =
741 new_stat(lang_wild_statement
,
742 &default_common_section
->children
);
743 new->section_name
= "COMMON";
744 new->filename
= (char *)NULL
;
745 lang_list_init(&new->children
);
752 Add the supplied name to the symbol table as an undefined reference.
753 Remove items from the chain as we open input bfds
755 typedef struct ldlang_undef_chain_list_struct
{
756 struct ldlang_undef_chain_list_struct
*next
;
758 } ldlang_undef_chain_list_type
;
760 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
763 DEFUN(ldlang_add_undef
,(name
),
764 CONST
char *CONST name
)
766 ldlang_undef_chain_list_type
*new =
767 (ldlang_undef_chain_list_type
768 *)ldmalloc((bfd_size_type
)(sizeof(ldlang_undef_chain_list_type
)));
770 new->next
= ldlang_undef_chain_list_head
;
771 ldlang_undef_chain_list_head
= new;
773 new->name
= buystring(name
);
775 /* Run through the list of undefineds created above and place them
776 into the linker hash table as undefined symbols belonging to the
780 DEFUN_VOID(lang_place_undefineds
)
782 ldlang_undef_chain_list_type
*ptr
= ldlang_undef_chain_list_head
;
783 while (ptr
!= (ldlang_undef_chain_list_type
*)NULL
) {
784 ldsym_type
*sy
= ldsym_get(ptr
->name
);
786 asymbol
**def_ptr
= (asymbol
**)ldmalloc((bfd_size_type
)(sizeof(asymbol
**)));
787 def
= (asymbol
*)bfd_make_empty_symbol(script_file
->the_bfd
);
789 def
->name
= ptr
->name
;
790 def
->flags
= BSF_UNDEFINED
;
791 def
->section
= (asection
*)NULL
;
792 Q_enter_global_ref(def_ptr
);
799 /* Copy important data from out internal form to the bfd way. Also
800 create a section for the dummy file
804 DEFUN_VOID(lang_create_output_section_statements
)
806 lang_statement_union_type
*os
;
807 for (os
= lang_output_section_statement
.head
;
808 os
!= (lang_statement_union_type
*)NULL
;
809 os
= os
->output_section_statement
.next
) {
810 lang_output_section_statement_type
*s
=
811 &os
->output_section_statement
;
818 DEFUN_VOID(lang_init_script_file
)
820 script_file
= lang_add_input_file("script file",
821 lang_input_file_is_fake_enum
,
823 script_file
->the_bfd
= bfd_create("script file", output_bfd
);
824 script_file
->symbol_count
= 0;
825 script_file
->the_bfd
->sections
= output_bfd
->sections
;
831 /* Open input files and attatch to output sections */
833 DEFUN(map_input_to_output_sections
,(s
, target
, output_section_statement
),
834 lang_statement_union_type
*s AND
835 CONST
char *target AND
836 lang_output_section_statement_type
*output_section_statement
)
838 for (; s
!= (lang_statement_union_type
*)NULL
; s
= s
->next
)
840 switch (s
->header
.type
) {
841 case lang_wild_statement_enum
:
842 wild(&s
->wild_statement
, s
->wild_statement
.section_name
,
843 s
->wild_statement
.filename
, target
,
844 output_section_statement
);
848 case lang_output_section_statement_enum
:
849 map_input_to_output_sections(s
->output_section_statement
.children
.head
,
851 &s
->output_section_statement
);
853 case lang_output_statement_enum
:
855 case lang_target_statement_enum
:
856 target
= s
->target_statement
.target
;
858 case lang_fill_statement_enum
:
859 case lang_input_section_enum
:
860 case lang_object_symbols_statement_enum
:
861 case lang_data_statement_enum
:
862 case lang_assignment_statement_enum
:
863 case lang_padding_statement_enum
:
865 case lang_afile_asection_pair_statement_enum
:
868 case lang_address_statement_enum
:
869 /* Mark the specified section with the supplied address */
871 lang_output_section_statement_type
*os
=
872 lang_output_section_statement_lookup
873 (s
->address_statement
.section_name
);
874 os
->addr_tree
= s
->address_statement
.address
;
875 if (os
->bfd_section
== (asection
*)NULL
) {
876 info("%P%F can't set the address of undefined section %s\n",
877 s
->address_statement
.section_name
);
881 case lang_input_statement_enum
:
882 /* A standard input statement, has no wildcards */
883 /* ldmain_open_file_read_symbol(&s->input_statement);*/
894 DEFUN(print_output_section_statement
,(output_section_statement
),
895 lang_output_section_statement_type
*output_section_statement
)
897 asection
*section
= output_section_statement
->bfd_section
;
899 print_section(output_section_statement
->name
);
902 print_dot
= section
->vma
;
906 print_address(section
->vma
);
908 print_size(section
->size
);
910 print_alignment(section
->alignment_power
);
913 printf("%s flags", output_section_statement
->region
->name
);
914 print_flags(stdout
, &output_section_statement
->flags
);
919 printf("No attached output section");
922 print_statement(output_section_statement
->children
.head
,
923 output_section_statement
);
928 DEFUN(print_assignment
,(assignment
, output_section
),
929 lang_assignment_statement_type
*assignment AND
930 lang_output_section_statement_type
*output_section
)
932 etree_value_type result
;
937 print_address(print_dot
);
939 result
= exp_fold_tree(assignment
->exp
->assign
.src
,
941 lang_final_phase_enum
,
946 print_address(result
.value
);
950 printf("*undefined*");
953 exp_print_tree(stdout
, assignment
->exp
);
958 DEFUN(print_input_statement
,(statm
),
959 lang_input_statement_type
*statm
)
961 if (statm
->filename
!= (char *)NULL
) {
962 printf("LOAD %s\n",statm
->filename
);
967 DEFUN(print_symbol
,(q
),
974 print_address(outside_symbol_address(q
));
975 printf(" %s", q
->name
? q
->name
: " ");
980 DEFUN(print_input_section
,(in
),
981 lang_input_section_type
*in
)
983 asection
*i
= in
->section
;
988 print_section(i
->name
);
990 if (i
->output_section
) {
991 print_address(i
->output_section
->vma
+ i
->output_offset
);
995 print_alignment(i
->alignment_power
);
999 bfd
*abfd
= in
->ifile
->the_bfd
;
1000 if (in
->ifile
->just_syms_flag
== true) {
1001 printf("symbols only ");
1004 printf(" %s ",abfd
->xvec
->name
);
1005 if(abfd
->my_archive
!= (bfd
*)NULL
) {
1006 printf("[%s]%s", abfd
->my_archive
->filename
,
1010 printf("%s", abfd
->filename
);
1012 printf("(overhead %d bytes)", (int)bfd_alloc_size(abfd
));
1015 /* Find all the symbols in this file defined in this section */
1018 for (p
= in
->ifile
->asymbols
; *p
; p
++) {
1021 if (bfd_get_section(q
) == i
&& q
->flags
& BSF_GLOBAL
) {
1032 print_dot
= outside_section_address(i
) + i
->size
;
1035 printf("No output section allocated\n");
1041 DEFUN(print_fill_statement
,(fill
),
1042 lang_fill_statement_type
*fill
)
1044 printf("FILL mask ");
1045 print_fill( fill
->fill
);
1049 DEFUN(print_data_statement
,(data
),
1050 lang_data_statement_type
*data
)
1052 /* bfd_vma value; */
1057 /* ASSERT(print_dot == data->output_vma);*/
1059 print_address(data
->output_vma
);
1061 print_address(data
->value
);
1063 switch (data
->type
) {
1066 print_dot
+= BYTE_SIZE
;
1070 print_dot
+= SHORT_SIZE
;
1074 print_dot
+= LONG_SIZE
;
1078 exp_print_tree(stdout
, data
->exp
);
1085 DEFUN(print_padding_statement
,(s
),
1086 lang_padding_statement_type
*s
)
1090 print_section("*fill*");
1092 print_address(s
->output_offset
+ s
->output_section
->vma
);
1094 print_size(s
->size
);
1096 print_fill(s
->fill
);
1101 DEFUN(print_wild_statement
,(w
,os
),
1102 lang_wild_statement_type
*w AND
1103 lang_output_section_statement_type
*os
)
1106 if (w
->filename
!= (char *)NULL
) {
1107 printf("%s",w
->filename
);
1112 if (w
->section_name
!= (char *)NULL
) {
1113 printf("(%s)",w
->section_name
);
1119 print_statement(w
->children
.head
, os
);
1123 DEFUN(print_statement
,(s
, os
),
1124 lang_statement_union_type
*s AND
1125 lang_output_section_statement_type
*os
)
1128 switch (s
->header
.type
) {
1129 case lang_wild_statement_enum
:
1130 print_wild_statement(&s
->wild_statement
, os
);
1133 printf("Fail with %d\n",s
->header
.type
);
1136 case lang_address_statement_enum
:
1137 printf("address\n");
1140 case lang_object_symbols_statement_enum
:
1141 printf("object symbols\n");
1143 case lang_fill_statement_enum
:
1144 print_fill_statement(&s
->fill_statement
);
1146 case lang_data_statement_enum
:
1147 print_data_statement(&s
->data_statement
);
1149 case lang_input_section_enum
:
1150 print_input_section(&s
->input_section
);
1152 case lang_padding_statement_enum
:
1153 print_padding_statement(&s
->padding_statement
);
1155 case lang_output_section_statement_enum
:
1156 print_output_section_statement(&s
->output_section_statement
);
1158 case lang_assignment_statement_enum
:
1159 print_assignment(&s
->assignment_statement
,
1164 case lang_target_statement_enum
:
1165 printf("TARGET(%s)\n", s
->target_statement
.target
);
1167 case lang_output_statement_enum
:
1168 printf("OUTPUT(%s %s)\n",
1169 s
->output_statement
.name
,
1172 case lang_input_statement_enum
:
1173 print_input_statement(&s
->input_statement
);
1175 case lang_afile_asection_pair_statement_enum
:
1185 DEFUN_VOID(print_statements
)
1187 print_statement(statement_list
.head
,
1188 (lang_output_section_statement_type
*)NULL
);
1192 DEFUN(insert_pad
,(this_ptr
, fill
, power
, output_section_statement
, dot
),
1193 lang_statement_union_type
**this_ptr AND
1195 unsigned int power AND
1196 asection
* output_section_statement AND
1199 /* Align this section first to the
1200 input sections requirement, then
1201 to the output section's requirement.
1202 If this alignment is > than any seen before,
1203 then record it too. Perform the alignment by
1204 inserting a magic 'padding' statement.
1207 unsigned int alignment_needed
= align_power(dot
, power
) - dot
;
1209 if (alignment_needed
!= 0)
1211 lang_statement_union_type
*new =
1212 (lang_statement_union_type
*)
1213 ldmalloc((bfd_size_type
)(sizeof(lang_padding_statement_type
)));
1214 /* Link into existing chain */
1215 new->header
.next
= *this_ptr
;
1217 new->header
.type
= lang_padding_statement_enum
;
1218 new->padding_statement
.output_section
= output_section_statement
;
1219 new->padding_statement
.output_offset
=
1220 dot
- output_section_statement
->vma
;
1221 new->padding_statement
.fill
= fill
;
1222 new->padding_statement
.size
= alignment_needed
;
1226 /* Remember the most restrictive alignment */
1227 if (power
> output_section_statement
->alignment_power
) {
1228 output_section_statement
->alignment_power
= power
;
1230 output_section_statement
->size
+= alignment_needed
;
1231 return alignment_needed
+ dot
;
1235 /* Work out how much this section will move the dot point */
1237 DEFUN(size_input_section
, (this_ptr
, output_section_statement
, fill
, dot
),
1238 lang_statement_union_type
**this_ptr AND
1239 lang_output_section_statement_type
*output_section_statement AND
1240 unsigned short fill AND
1243 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1244 asection
*i
= is
->section
;
1246 if (is
->ifile
->just_syms_flag
== false) {
1247 dot
= insert_pad(this_ptr
, fill
, i
->alignment_power
,
1248 output_section_statement
->bfd_section
, dot
);
1250 /* remember the largest size so we can malloc the largest area */
1251 /* needed for the output stage */
1252 if (i
->size
> largest_section
) {
1253 largest_section
= i
->size
;
1256 /* Remember where in the output section this input section goes */
1258 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1260 /* Mark how big the output section must be to contain this now */
1262 output_section_statement
->bfd_section
->size
=
1263 dot
- output_section_statement
->bfd_section
->vma
;
1267 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
1274 /* Work out the size of the output sections
1275 from the sizes of the input sections */
1277 DEFUN(lang_size_sections
,(s
, output_section_statement
, prev
, fill
, dot
),
1278 lang_statement_union_type
*s AND
1279 lang_output_section_statement_type
* output_section_statement AND
1280 lang_statement_union_type
**prev AND
1281 unsigned short fill AND
1284 /* Size up the sections from their constituent parts */
1285 for (; s
!= (lang_statement_union_type
*)NULL
; s
= s
->next
)
1287 switch (s
->header
.type
) {
1288 case lang_output_section_statement_enum
:
1291 lang_output_section_statement_type
*os
=
1292 &(s
->output_section_statement
);
1293 /* The start of a section */
1295 if (os
->addr_tree
== (etree_type
*)NULL
) {
1296 /* No address specified for this section, get one
1297 from the region specification
1299 if (os
->region
== (lang_memory_region_type
*)NULL
) {
1300 os
->region
= lang_memory_region_lookup("*default*");
1302 dot
= os
->region
->current
;
1305 etree_value_type r
;
1306 r
= exp_fold_tree(os
->addr_tree
,
1307 (lang_output_section_statement_type
*)NULL
,
1308 lang_allocating_phase_enum
,
1310 if (r
.valid
== false) {
1311 info("%F%S: non constant address expression for section %s\n",
1316 /* The section starts here */
1317 /* First, align to what the section needs */
1319 dot
= align_power(dot
, os
->bfd_section
->alignment_power
);
1320 os
->bfd_section
->vma
= dot
;
1321 os
->bfd_section
->output_offset
= 0;
1323 (void) lang_size_sections(os
->children
.head
, os
, &os
->children
.head
,
1325 /* Ignore the size of the input sections, use the vma and size to */
1329 after
= ALIGN(os
->bfd_section
->vma
+
1330 os
->bfd_section
->size
,
1334 os
->bfd_section
->size
= after
- os
->bfd_section
->vma
;
1335 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->size
;
1336 os
->processed
= true;
1338 /* Replace into region ? */
1339 if (os
->addr_tree
== (etree_type
*)NULL
1340 && os
->region
!=(lang_memory_region_type
*)NULL
) {
1341 os
->region
->current
= dot
;
1347 case lang_data_statement_enum
:
1350 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1351 s
->data_statement
.output_section
=
1352 output_section_statement
->bfd_section
;
1354 switch (s
->data_statement
.type
) {
1367 output_section_statement
->bfd_section
->size
+= size
;
1371 case lang_wild_statement_enum
:
1373 dot
= lang_size_sections(s
->wild_statement
.children
.head
,
1374 output_section_statement
,
1375 &s
->wild_statement
.children
.head
,
1381 case lang_object_symbols_statement_enum
:
1382 create_object_symbols
= output_section_statement
;
1384 case lang_output_statement_enum
:
1385 case lang_target_statement_enum
:
1387 case lang_input_section_enum
:
1388 dot
= size_input_section(prev
,
1389 output_section_statement
,
1390 output_section_statement
->fill
, dot
);
1392 case lang_input_statement_enum
:
1394 case lang_fill_statement_enum
:
1395 fill
= s
->fill_statement
.fill
;
1397 case lang_assignment_statement_enum
:
1399 bfd_vma newdot
= dot
;
1400 exp_fold_tree(s
->assignment_statement
.exp
,
1401 output_section_statement
,
1402 lang_allocating_phase_enum
,
1407 /* We've been moved ! so insert a pad */
1409 lang_statement_union_type
*new =
1410 (lang_statement_union_type
*)
1411 ldmalloc((bfd_size_type
)(sizeof(lang_padding_statement_type
)));
1412 /* Link into existing chain */
1413 new->header
.next
= *prev
;
1415 new->header
.type
= lang_padding_statement_enum
;
1416 new->padding_statement
.output_section
=
1417 output_section_statement
->bfd_section
;
1418 new->padding_statement
.output_offset
=
1419 dot
- output_section_statement
->bfd_section
->vma
;
1420 new->padding_statement
.fill
= fill
;
1421 new->padding_statement
.size
= newdot
- dot
;
1422 output_section_statement
->bfd_section
->size
+=
1423 new->padding_statement
.size
;
1429 case lang_padding_statement_enum
:
1435 case lang_address_statement_enum
:
1438 prev
= &s
->header
.next
;
1445 DEFUN(lang_do_assignments
,(s
, output_section_statement
, fill
, dot
),
1446 lang_statement_union_type
*s AND
1447 lang_output_section_statement_type
* output_section_statement AND
1448 unsigned short fill AND
1452 for (; s
!= (lang_statement_union_type
*)NULL
; s
= s
->next
)
1454 switch (s
->header
.type
) {
1455 case lang_output_section_statement_enum
:
1457 lang_output_section_statement_type
*os
=
1458 &(s
->output_section_statement
);
1459 dot
= os
->bfd_section
->vma
;
1460 (void) lang_do_assignments(os
->children
.head
, os
, os
->fill
, dot
);
1461 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->size
;
1464 case lang_wild_statement_enum
:
1466 dot
= lang_do_assignments(s
->wild_statement
.children
.head
,
1467 output_section_statement
,
1472 case lang_object_symbols_statement_enum
:
1473 case lang_output_statement_enum
:
1474 case lang_target_statement_enum
:
1476 case lang_common_statement_enum
:
1479 case lang_data_statement_enum
:
1481 etree_value_type value
;
1482 value
= exp_fold_tree(s
->data_statement
.exp
,
1483 0, lang_final_phase_enum
, dot
, &dot
);
1484 s
->data_statement
.value
= value
.value
;
1485 if (value
.valid
== false) info("%F%P: Invalid data statement\n");
1487 switch (s
->data_statement
.type
) {
1499 case lang_input_section_enum
:
1501 asection
*in
= s
->input_section
.section
;
1506 case lang_input_statement_enum
:
1508 case lang_fill_statement_enum
:
1509 fill
= s
->fill_statement
.fill
;
1511 case lang_assignment_statement_enum
:
1513 exp_fold_tree(s
->assignment_statement
.exp
,
1514 output_section_statement
,
1515 lang_final_phase_enum
,
1521 case lang_padding_statement_enum
:
1522 dot
+= s
->padding_statement
.size
;
1527 case lang_address_statement_enum
:
1538 DEFUN_VOID(lang_relocate_globals
)
1542 Each ldsym_type maintains a chain of pointers to asymbols which
1543 references the definition. Replace each pointer to the referenence
1544 with a pointer to only one place, preferably the definition. If
1545 the defintion isn't available then the common symbol, and if
1546 there isn't one of them then choose one reference.
1549 FOR_EACH_LDSYM(lgs
) {
1551 if (lgs
->sdefs_chain
) {
1552 it
= *(lgs
->sdefs_chain
);
1554 else if (lgs
->scoms_chain
!= (asymbol
**)NULL
) {
1555 it
= *(lgs
->scoms_chain
);
1557 else if (lgs
->srefs_chain
!= (asymbol
**)NULL
) {
1558 it
= *(lgs
->srefs_chain
);
1561 /* This can happen when the command line asked for a symbol to
1563 it
= (asymbol
*)NULL
;
1565 if (it
!= (asymbol
*)NULL
)
1567 asymbol
**ptr
= lgs
->srefs_chain
;
1569 while (ptr
!= (asymbol
**)NULL
) {
1570 asymbol
*ref
= *ptr
;
1572 ptr
= (asymbol
**)(ref
->udata
);
1581 DEFUN_VOID(lang_finish
)
1585 if (entry_symbol
== (char *)NULL
) {
1586 /* No entry has been specified, look for start */
1587 entry_symbol
= "start";
1589 lgs
= ldsym_get_soft(entry_symbol
);
1590 if (lgs
&& lgs
->sdefs_chain
) {
1591 asymbol
*sy
= *(lgs
->sdefs_chain
);
1592 /* We can set the entry address*/
1593 bfd_set_start_address(output_bfd
,
1594 outside_symbol_address(sy
));
1598 /* Can't find anything reasonable,
1599 use the first address in the text section
1601 asection
*ts
= bfd_get_section_by_name(output_bfd
, ".text");
1603 bfd_set_start_address(output_bfd
, ts
->vma
);
1608 /* By now we know the target architecture, and we may have an */
1609 /* ldfile_output_machine_name */
1611 DEFUN_VOID(lang_check
)
1613 lang_statement_union_type
*file
;
1614 unsigned long max_machine
= bfd_get_machine(output_bfd
);
1615 unsigned long max_machine_seen
= 0;
1617 unsigned long input_machine
;
1618 char *out_arch
, *out_arch2
;
1620 for (file
= file_chain
.head
;
1621 file
!= (lang_statement_union_type
*)NULL
;
1622 file
=file
->input_statement
.next
)
1624 input_bfd
= file
->input_statement
.the_bfd
;
1625 input_machine
= bfd_get_machine(input_bfd
);
1627 if ( input_machine
> max_machine_seen
){
1628 max_machine_seen
= input_machine
;
1631 /* Inspect the architecture and ensure we're linking like with like */
1632 if ( (input_machine
> max_machine
)
1633 || !bfd_arch_compatible( input_bfd
,
1635 &ldfile_output_architecture
,
1637 enum bfd_architecture this_architecture
=
1638 bfd_get_architecture(file
->input_statement
.the_bfd
);
1639 unsigned long this_machine
=
1641 bfd_get_machine(file
->input_statement
.the_bfd
);
1643 /* Result of bfd_printable_arch_mach is not guaranteed to stick
1644 around after next call, so we have to copy it. */
1645 out_arch
= bfd_printable_arch_mach(ldfile_output_architecture
,
1646 ldfile_output_machine
);
1647 out_arch2
= ldmalloc (strlen (out_arch
)+1);
1648 strcpy (out_arch2
, out_arch
);
1650 info("%P: warning, %s architecture of input file `%B' incompatible with %s output\n",
1651 bfd_printable_arch_mach(this_architecture
, this_machine
),
1655 ldfile_output_architecture
= this_architecture
;
1656 ldfile_output_machine
= this_machine
;
1657 bfd_set_arch_mach(output_bfd
,
1658 ldfile_output_architecture
,
1659 ldfile_output_machine
);
1662 bfd_set_arch_mach(output_bfd
,ldfile_output_architecture
,max_machine_seen
);
1667 * run through all the global common symbols and tie them
1668 * to the output section requested.
1670 As an experiment we do this 4 times, once for all the byte sizes,
1671 then all the two bytes, all the four bytes and then everything else
1675 DEFUN_VOID(lang_common
)
1679 if (config
.relocateable_output
== false ||
1680 command_line
.force_common_definition
== true) {
1681 for (power
= 1; (config
.sort_common
== true && power
== 1) || (power
<= 16); power
<<=1) {
1682 for (lgs
= symbol_head
;
1683 lgs
!= (ldsym_type
*)NULL
;
1687 unsigned int power_of_two
;
1690 if (lgs
->scoms_chain
!= (asymbol
**)NULL
) {
1691 com
= *(lgs
->scoms_chain
);
1720 if (config
.sort_common
== false || align
== power
) {
1721 /* Change from a common symbol into a definition of
1723 lgs
->sdefs_chain
= lgs
->scoms_chain
;
1724 lgs
->scoms_chain
= (asymbol
**)NULL
;
1726 /* Point to the correct common section */
1728 ((lang_input_statement_type
*)
1729 (com
->the_bfd
->usrdata
))->common_section
;
1730 /* Fix the size of the common section */
1731 com
->section
->size
= ALIGN(com
->section
->size
, align
);
1733 /* Remember if this is the biggest alignment ever seen */
1734 if (power_of_two
> com
->section
->alignment_power
) {
1735 com
->section
->alignment_power
= power_of_two
;
1738 /* Symbol stops being common and starts being global, but
1739 we remember that it was common once. */
1741 com
->flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_OLD_COMMON
;
1742 com
->value
= com
->section
->size
;
1746 printf ("Allocating common %s: %x at %x %s\n",
1749 (unsigned) com
->value
,
1750 com
->the_bfd
->filename
);
1753 com
->section
->size
+= size
;
1766 run through the input files and ensure that every input
1767 section has somewhere to go. If one is found without
1768 a destination then create an input request and place it
1769 into the statement tree.
1773 DEFUN_VOID(lang_place_orphans
)
1775 lang_input_statement_type
*file
;
1776 for (file
= (lang_input_statement_type
*)file_chain
.head
;
1777 file
!= (lang_input_statement_type
*)NULL
;
1778 file
= (lang_input_statement_type
*)file
->next
) {
1780 for (s
= file
->the_bfd
->sections
;
1781 s
!= (asection
*)NULL
;
1783 if ( s
->output_section
== (asection
*)NULL
) {
1784 /* This section of the file is not attatched, root
1785 around for a sensible place for it to go */
1787 if (file
->common_section
== s
) {
1788 /* This is a lonely common section which must
1789 have come from an archive. We attatch to the
1790 section with the wildcard */
1791 if (config
.relocateable_output
!= true
1792 && command_line
.force_common_definition
== false) {
1793 if (default_common_section
==
1794 (lang_output_section_statement_type
*)NULL
) {
1795 info("%P: No [COMMON] command, defaulting to .bss\n");
1797 default_common_section
=
1798 lang_output_section_statement_lookup(".bss");
1801 wild_doit(&default_common_section
->children
, s
,
1802 default_common_section
, file
);
1806 lang_output_section_statement_type
*os
=
1807 lang_output_section_statement_lookup(s
->name
);
1809 wild_doit(&os
->children
, s
, os
, file
);
1818 DEFUN(lang_set_flags
,(ptr
, flags
),
1819 lang_section_flags_type
*ptr AND
1822 boolean state
= true;
1823 ptr
->flag_read
= false;
1824 ptr
->flag_write
= false;
1825 ptr
->flag_executable
= false;
1826 ptr
->flag_loadable
= false;
1829 if (*flags
== '!') {
1836 ptr
->flag_read
= state
;
1839 ptr
->flag_write
= state
;
1842 ptr
->flag_executable
= state
;
1846 ptr
->flag_loadable
= state
;
1849 info("%P%F illegal syntax in flags\n");
1859 DEFUN(lang_for_each_file
,(func
),
1860 PROTO(void, (*func
),(lang_input_statement_type
*)))
1862 lang_input_statement_type
*f
;
1863 for (f
= (lang_input_statement_type
*)file_chain
.head
;
1864 f
!= (lang_input_statement_type
*)NULL
;
1865 f
= (lang_input_statement_type
*)f
->next
)
1873 DEFUN(lang_for_each_input_section
, (func
),
1874 PROTO(void ,(*func
),(bfd
*ab
, asection
*as
)))
1876 lang_input_statement_type
*f
;
1877 for (f
= (lang_input_statement_type
*)file_chain
.head
;
1878 f
!= (lang_input_statement_type
*)NULL
;
1879 f
= (lang_input_statement_type
*)f
->next
)
1882 for (s
= f
->the_bfd
->sections
;
1883 s
!= (asection
*)NULL
;
1885 func(f
->the_bfd
, s
);
1893 DEFUN(ldlang_add_file
,(entry
),
1894 lang_input_statement_type
*entry
)
1897 lang_statement_append(&file_chain
,
1898 (lang_statement_union_type
*)entry
,
1905 DEFUN(lang_add_output
,(name
),
1908 lang_output_statement_type
*new = new_stat(lang_output_statement
,
1911 had_output_filename
= true;
1915 static lang_output_section_statement_type
*current_section
;
1918 DEFUN(lang_enter_output_section_statement
,
1919 (output_section_statement_name
,
1922 char *output_section_statement_name AND
1923 etree_type
*address_exp AND
1924 bfd_vma block_value
)
1926 lang_output_section_statement_type
*os
;
1929 lang_output_section_statement_lookup(output_section_statement_name
);
1932 /* Add this statement to tree */
1933 /* add_statement(lang_output_section_statement_enum,
1934 output_section_statement);*/
1935 /* Make next things chain into subchain of this */
1937 if (os
->addr_tree
==
1938 (etree_type
*)NULL
) {
1942 os
->block_value
= block_value
;
1943 stat_ptr
= & os
->children
;
1949 DEFUN_VOID(lang_final
)
1951 if (had_output_filename
== false) {
1952 extern CONST
char *output_filename
;
1953 lang_add_output(output_filename
);
1962 DEFUN(create_symbol
,(name
, flags
, section
),
1963 CONST
char *name AND
1967 extern lang_input_statement_type
*script_file
;
1968 asymbol
**def_ptr
= (asymbol
**)ldmalloc((bfd_size_type
)(sizeof(asymbol
**)));
1969 /* Add this definition to script file */
1970 asymbol
*def
= (asymbol
*)bfd_make_empty_symbol(script_file
->the_bfd
);
1971 def
->name
= buystring(name
);
1974 def
->section
= section
;
1977 Q_enter_global_ref(def_ptr
);
1983 DEFUN_VOID(lang_process
)
1985 if (had_script
== false) {
1986 parse_line(ldemul_get_script());
1988 lang_reasonable_defaults();
1989 current_target
= default_target
;
1991 lang_for_each_statement(ldlang_open_output
); /* Open the output file */
1992 /* For each output section statement, create a section in the output
1994 lang_create_output_section_statements();
1996 /* Create a dummy bfd for the script */
1997 lang_init_script_file();
1999 /* Add to the hash table all undefineds on the command line */
2000 lang_place_undefineds();
2002 /* Create a bfd for each input file */
2003 current_target
= default_target
;
2004 lang_for_each_statement(open_input_bfds
);
2006 common_section
.userdata
= (PTR
)&common_section_userdata
;
2008 /* Run through the contours of the script and attatch input sections
2009 to the correct output sections
2011 map_input_to_output_sections(statement_list
.head
, (char *)NULL
,
2012 ( lang_output_section_statement_type
*)NULL
);
2014 /* Find any sections not attatched explicitly and handle them */
2015 lang_place_orphans();
2017 /* Size up the common data */
2020 ldemul_before_allocation();
2022 /* Size up the sections */
2023 lang_size_sections(statement_list
.head
,
2024 (lang_output_section_statement_type
*)NULL
,
2025 &(statement_list
.head
), 0, (bfd_vma
)0);
2027 /* See if anything special should be done now we know how big
2029 ldemul_after_allocation();
2031 /* Do all the assignments, now that we know the final restingplaces
2032 of all the symbols */
2034 lang_do_assignments(statement_list
.head
,
2035 (lang_output_section_statement_type
*)NULL
,
2038 /* Make sure that we're not mixing architectures */
2042 /* Move the global symbols around */
2043 lang_relocate_globals();
2050 /* EXPORTED TO YACC */
2053 DEFUN(lang_add_wild
,(section_name
, filename
),
2054 CONST
char *CONST section_name AND
2055 CONST
char *CONST filename
)
2057 lang_wild_statement_type
*new = new_stat(lang_wild_statement
,
2060 if (section_name
!= (char *)NULL
&& strcmp(section_name
,"COMMON") == 0)
2062 placed_commons
= true;
2064 if (filename
!= (char *)NULL
) {
2065 lang_has_input_file
= true;
2067 new->section_name
= section_name
;
2068 new->filename
= filename
;
2069 lang_list_init(&new->children
);
2072 DEFUN(lang_section_start
,(name
, address
),
2073 CONST
char *name AND
2074 etree_type
*address
)
2076 lang_address_statement_type
*ad
=new_stat(lang_address_statement
, stat_ptr
);
2077 ad
->section_name
= name
;
2078 ad
->address
= address
;
2082 DEFUN(lang_add_entry
,(name
),
2085 entry_symbol
= name
;
2089 DEFUN(lang_add_target
,(name
),
2092 lang_target_statement_type
*new = new_stat(lang_target_statement
,
2102 DEFUN(lang_add_map
,(name
),
2108 map_option_f
= true;
2116 DEFUN(lang_add_fill
,(exp
),
2119 lang_fill_statement_type
*new = new_stat(lang_fill_statement
,
2125 DEFUN(lang_add_data
,(type
, exp
),
2127 union etree_union
*exp
)
2130 lang_data_statement_type
*new = new_stat(lang_data_statement
,
2137 DEFUN(lang_add_assignment
,(exp
),
2140 lang_assignment_statement_type
*new = new_stat(lang_assignment_statement
,
2146 DEFUN(lang_add_attribute
,(attribute
),
2147 enum statement_enum attribute
)
2149 new_statement(attribute
, sizeof(lang_statement_union_type
),stat_ptr
);
2155 DEFUN(lang_startup
,(name
),
2158 if (startup_file
!= (char *)NULL
) {
2159 info("%P%FMultiple STARTUP files\n");
2161 first_file
->filename
= name
;
2162 first_file
->local_sym_name
= name
;
2167 DEFUN(lang_float
,(maybe
),
2170 lang_float_flag
= maybe
;
2174 DEFUN(lang_leave_output_section_statement
,(fill
, memspec
),
2176 CONST
char *memspec
)
2178 current_section
->fill
= fill
;
2179 current_section
->region
= lang_memory_region_lookup(memspec
);
2180 stat_ptr
= &statement_list
;
2183 Create an absolute symbol with the given name with the value of the
2184 address of first byte of the section named.
2186 If the symbol already exists, then do nothing.
2189 DEFUN(lang_abs_symbol_at_beginning_of
,(section
, name
),
2190 CONST
char *section AND
2193 if (ldsym_undefined(name
)) {
2194 extern bfd
*output_bfd
;
2195 extern asymbol
*create_symbol();
2196 asection
*s
= bfd_get_section_by_name(output_bfd
, section
);
2197 asymbol
*def
= create_symbol(name
,
2198 BSF_GLOBAL
| BSF_EXPORT
|
2201 if (s
!= (asection
*)NULL
) {
2202 def
->value
= s
->vma
;
2211 Create an absolute symbol with the given name with the value of the
2212 address of the first byte after the end of the section named.
2214 If the symbol already exists, then do nothing.
2217 DEFUN(lang_abs_symbol_at_end_of
,(section
, name
),
2218 CONST
char *section AND
2221 if (ldsym_undefined(name
)){
2222 extern bfd
*output_bfd
;
2223 extern asymbol
*create_symbol();
2224 asection
*s
= bfd_get_section_by_name(output_bfd
, section
);
2225 /* Add a symbol called _end */
2226 asymbol
*def
= create_symbol(name
,
2227 BSF_GLOBAL
| BSF_EXPORT
|
2230 if (s
!= (asection
*)NULL
) {
2231 def
->value
= s
->vma
+ s
->size
;
2240 DEFUN(lang_statement_append
,(list
, element
, field
),
2241 lang_statement_list_type
*list AND
2242 lang_statement_union_type
*element AND
2243 lang_statement_union_type
**field
)
2245 *(list
->tail
) = element
;
2249 /* Set the output format type */
2251 DEFUN(lang_add_output_format
,(format
),
2254 output_target
= format
;