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
;
48 /* Points to the last statement in the .data section, so we can add
49 stuff to the data section without pain */
50 static lang_statement_list_type end_of_data_section_statement_list
;
52 /* List of statements needed to handle constructors */
53 extern lang_statement_list_type constructor_list
;
55 static boolean placed_commons
= false;
56 static lang_output_section_statement_type
*default_common_section
;
57 static boolean map_option_f
;
58 static bfd_vma print_dot
;
59 static lang_input_statement_type
*first_file
;
60 static lang_statement_list_type lang_output_section_statement
;
61 static CONST
char *current_target
;
62 static CONST
char *output_target
;
63 static size_t longest_section_name
= 8;
64 static asection common_section
;
65 static section_userdata_type common_section_userdata
;
66 static lang_statement_list_type statement_list
;
70 lang_output_section_statement_type
*abs_output_section
;
71 lang_statement_list_type
*stat_ptr
= &statement_list
;
72 lang_input_statement_type
*script_file
= 0;
73 boolean option_longmap
= false;
74 lang_statement_list_type file_chain
= {0};
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;
82 extern char *default_target
;
84 extern unsigned int undefined_global_sym_count
;
85 extern char *current_file
;
86 extern bfd
*output_bfd
;
87 extern enum bfd_architecture ldfile_output_architecture
;
88 extern unsigned long ldfile_output_machine
;
89 extern char *ldfile_output_machine_name
;
90 extern ldsym_type
*symbol_head
;
91 extern unsigned int commons_pending
;
92 extern args_type command_line
;
93 extern ld_config_type config
;
94 extern boolean had_script
;
95 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(print_size
,(value
),
116 fprintf(config
.map_file
, "%5x", (unsigned)value
);
119 DEFUN(print_alignment
,(value
),
122 fprintf(config
.map_file
, "2**%1u",value
);
125 DEFUN(print_fill
,(value
),
128 fprintf(config
.map_file
, "%04x",(unsigned)value
);
133 DEFUN(print_section
,(name
),
134 CONST
char *CONST name
)
136 fprintf(config
.map_file
, "%*s", -longest_section_name
, name
);
139 /*----------------------------------------------------------------------
140 lang_for_each_statement walks the parse tree and calls the provided
141 function for each node
145 DEFUN(lang_for_each_statement_worker
,(func
, s
),
147 lang_statement_union_type
*s
)
149 for (; s
!= (lang_statement_union_type
*)NULL
; s
= s
->next
)
153 switch (s
->header
.type
) {
154 case lang_constructors_statement_enum
:
155 lang_for_each_statement_worker(func
, constructor_list
.head
);
157 case lang_output_section_statement_enum
:
158 lang_for_each_statement_worker
160 s
->output_section_statement
.children
.head
);
162 case lang_wild_statement_enum
:
163 lang_for_each_statement_worker
165 s
->wild_statement
.children
.head
);
167 case lang_data_statement_enum
:
168 case lang_object_symbols_statement_enum
:
169 case lang_output_statement_enum
:
170 case lang_target_statement_enum
:
171 case lang_input_section_enum
:
172 case lang_input_statement_enum
:
173 case lang_fill_statement_enum
:
174 case lang_assignment_statement_enum
:
175 case lang_padding_statement_enum
:
176 case lang_address_statement_enum
:
186 DEFUN(lang_for_each_statement
,(func
),
189 lang_for_each_statement_worker(func
,
190 statement_list
.head
);
192 /*----------------------------------------------------------------------*/
194 DEFUN(lang_list_init
,(list
),
195 lang_statement_list_type
*list
)
197 list
->head
= (lang_statement_union_type
*)NULL
;
198 list
->tail
= &list
->head
;
202 /*----------------------------------------------------------------------
204 build a new statement node for the parse tree
209 lang_statement_union_type
*
210 DEFUN(new_statement
,(type
, size
, list
),
211 enum statement_enum type AND
212 bfd_size_type size AND
213 lang_statement_list_type
*list
)
215 lang_statement_union_type
*new = (lang_statement_union_type
*)
217 new->header
.type
= type
;
218 new->header
.next
= (lang_statement_union_type
*)NULL
;
219 lang_statement_append(list
, new, &new->header
.next
);
224 Build a new input file node for the language. There are several ways
225 in which we treat an input file, eg, we only look at symbols, or
226 prefix it with a -l etc.
228 We can be supplied with requests for input files more than once;
229 they may, for example be split over serveral lines like foo.o(.text)
230 foo.o(.data) etc, so when asked for a file we check that we havn't
231 got it already so we don't duplicate the bfd.
234 static lang_input_statement_type
*
235 DEFUN(new_afile
, (name
, file_type
, target
),
236 CONST
char *CONST name AND
237 CONST lang_input_file_enum_type file_type AND
238 CONST
char *CONST target
)
240 lang_input_statement_type
*p
= new_stat(lang_input_statement
,
242 lang_has_input_file
= true;
245 case lang_input_file_is_symbols_only_enum
:
247 p
->is_archive
=false;
249 p
->local_sym_name
= name
;
250 p
->just_syms_flag
= true;
251 p
->search_dirs_flag
= false;
253 case lang_input_file_is_fake_enum
:
255 p
->is_archive
=false;
257 p
->local_sym_name
= name
;
258 p
->just_syms_flag
= false;
259 p
->search_dirs_flag
=false;
261 case lang_input_file_is_l_enum
:
262 p
->is_archive
= true;
265 p
->local_sym_name
= concat("-l",name
,"");
266 p
->just_syms_flag
= false;
267 p
->search_dirs_flag
= true;
269 case lang_input_file_is_search_file_enum
:
270 case lang_input_file_is_marker_enum
:
272 p
->is_archive
=false;
274 p
->local_sym_name
= name
;
275 p
->just_syms_flag
= false;
276 p
->search_dirs_flag
=true;
278 case lang_input_file_is_file_enum
:
280 p
->is_archive
=false;
282 p
->local_sym_name
= name
;
283 p
->just_syms_flag
= false;
284 p
->search_dirs_flag
=false;
289 p
->asymbols
= (asymbol
**)NULL
;
290 p
->superfile
= (lang_input_statement_type
*)NULL
;
291 p
->next_real_file
= (lang_statement_union_type
*)NULL
;
292 p
->next
= (lang_statement_union_type
*)NULL
;
294 p
->common_output_section
= (asection
*)NULL
;
295 lang_statement_append(&input_file_chain
,
296 (lang_statement_union_type
*)p
,
303 lang_input_statement_type
*
304 DEFUN(lang_add_input_file
,(name
, file_type
, target
),
306 lang_input_file_enum_type file_type AND
309 /* Look it up or build a new one */
310 lang_has_input_file
= true;
312 lang_input_statement_type
*p
;
314 for (p
= (lang_input_statement_type
*)input_file_chain
.head
;
315 p
!= (lang_input_statement_type
*)NULL
;
316 p
= (lang_input_statement_type
*)(p
->next_real_file
))
318 /* Sometimes we have incomplete entries in here */
319 if (p
->filename
!= (char *)NULL
) {
320 if(strcmp(name
,p
->filename
) == 0) return p
;
325 return new_afile(name
, file_type
, target
);
329 /* Build enough state so that the parser can build its tree */
331 DEFUN_VOID(lang_init
)
334 stat_ptr
= &statement_list
;
335 lang_list_init(stat_ptr
);
337 lang_list_init(&input_file_chain
);
338 lang_list_init(&lang_output_section_statement
);
339 lang_list_init(&file_chain
);
340 first_file
= lang_add_input_file((char *)NULL
,
341 lang_input_file_is_marker_enum
,
346 /*----------------------------------------------------------------------
347 A region is an area of memory declared with the
348 MEMORY { name:org=exp, len=exp ... }
351 We maintain a list of all the regions here
353 If no regions are specified in the script, then the default is used
354 which is created when looked up to be the entire data space
357 static lang_memory_region_type
*lang_memory_region_list
;
358 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
360 lang_memory_region_type
*
361 DEFUN(lang_memory_region_lookup
,(name
),
362 CONST
char *CONST name
)
365 lang_memory_region_type
*p
= lang_memory_region_list
;
366 for (p
= lang_memory_region_list
;
367 p
!= ( lang_memory_region_type
*)NULL
;
369 if (strcmp(p
->name
, name
) == 0) {
373 if (strcmp(name
,"*default*")==0) {
374 /* This is the default region, dig out first one on the list */
375 if (lang_memory_region_list
!= (lang_memory_region_type
*)NULL
){
376 return lang_memory_region_list
;
380 lang_memory_region_type
*new =
381 (lang_memory_region_type
*)ldmalloc((bfd_size_type
)(sizeof(lang_memory_region_type
)));
382 new->name
= buystring(name
);
383 new->next
= (lang_memory_region_type
*)NULL
;
385 *lang_memory_region_list_tail
= new;
386 lang_memory_region_list_tail
= &new->next
;
395 lang_output_section_statement_type
*
396 DEFUN(lang_output_section_find
,(name
),
397 CONST
char * CONST name
)
399 lang_statement_union_type
*u
;
400 lang_output_section_statement_type
*lookup
;
402 for (u
= lang_output_section_statement
.head
;
403 u
!= (lang_statement_union_type
*)NULL
;
406 lookup
= &u
->output_section_statement
;
407 if (strcmp(name
, lookup
->name
)==0) {
411 return (lang_output_section_statement_type
*)NULL
;
414 lang_output_section_statement_type
*
415 DEFUN(lang_output_section_statement_lookup
,(name
),
416 CONST
char * CONST name
)
418 lang_output_section_statement_type
*lookup
;
419 lookup
=lang_output_section_find(name
);
420 if (lookup
== (lang_output_section_statement_type
*)NULL
) {
422 lookup
=(lang_output_section_statement_type
*)
423 new_stat(lang_output_section_statement
, stat_ptr
);
424 lookup
->region
= (lang_memory_region_type
*)NULL
;
426 lookup
->block_value
= 1;
429 lookup
->next
= (lang_statement_union_type
*)NULL
;
430 lookup
->bfd_section
= (asection
*)NULL
;
431 lookup
->processed
= false;
432 lookup
->addr_tree
= (etree_type
*)NULL
;
433 lang_list_init(&lookup
->children
);
435 lang_statement_append(&lang_output_section_statement
,
436 (lang_statement_union_type
*)lookup
,
447 DEFUN(print_flags
, ( ignore_flags
),
450 fprintf(config
.map_file
, "(");
452 if (flags
->flag_read
) fprintf(outfile
,"R");
453 if (flags
->flag_write
) fprintf(outfile
,"W");
454 if (flags
->flag_executable
) fprintf(outfile
,"X");
455 if (flags
->flag_loadable
) fprintf(outfile
,"L");
457 fprintf(config
.map_file
, ")");
463 lang_memory_region_type
*m
;
464 fprintf(config
.map_file
,"**MEMORY CONFIGURATION**\n\n");
466 fprintf(config
.map_file
,"name\t\torigin\t\tlength\t\tattributes\n");
468 fprintf(config
.map_file
,"name\t\torigin length\t\tattributes\n");
470 for (m
= lang_memory_region_list
;
471 m
!= (lang_memory_region_type
*)NULL
;
474 fprintf(config
.map_file
,"%-16s", m
->name
);
475 print_address(m
->origin
);
477 print_address(m
->length
);
479 print_flags( &m
->flags
);
480 fprintf(config
.map_file
,"\n");
482 fprintf(config
.map_file
,"\n\n**LINK EDITOR MEMORY MAP**\n\n");
483 fprintf(config
.map_file
,"output input virtual\n");
484 fprintf(config
.map_file
,"section section address tsize\n\n");
495 lang_output_section_statement_type
*s
)
497 asection
*section
= bfd_get_section_by_name(output_bfd
, s
->name
);
498 section_userdata_type
*new =
499 (section_userdata_type
*)
500 ldmalloc((bfd_size_type
)(sizeof(section_userdata_type
)));
502 s
->bfd_section
= bfd_get_section_by_name(output_bfd
, s
->name
);
503 if (s
->bfd_section
== (asection
*)NULL
)
504 s
->bfd_section
= bfd_make_section(output_bfd
, s
->name
);
505 if (s
->bfd_section
== (asection
*)NULL
) {
506 einfo("%P%F output format %s cannot represent section called %s\n",
507 output_bfd
->xvec
->name
, s
->name
);
509 s
->bfd_section
->output_section
= s
->bfd_section
;
510 /* s->bfd_section->flags = s->flags;*/
512 /* We initialize an output sections output offset to minus its own */
513 /* vma to allow us to output a section through itself */
514 s
->bfd_section
->output_offset
= 0;
515 get_userdata( s
->bfd_section
) = (PTR
)new;
519 /***********************************************************************
522 These expand statements like *(.text) and foo.o to a list of
523 explicit actions, like foo.o(.text), bar.o(.text) and
526 The toplevel routine, wild, takes a statement, section, file and
527 target. If either the section or file is null it is taken to be the
528 wildcard. Seperate lang_input_section statements are created for
529 each part of the expanstion, and placed after the statement provided.
534 DEFUN(wild_doit
,(ptr
, section
, output
, file
),
535 lang_statement_list_type
*ptr AND
536 asection
*section AND
537 lang_output_section_statement_type
*output AND
538 lang_input_statement_type
*file
)
540 if(output
->bfd_section
== (asection
*)NULL
)
545 if (section
!= (asection
*)NULL
546 && section
->output_section
== (asection
*)NULL
) {
547 /* Add a section reference to the list */
548 lang_input_section_type
*new = new_stat(lang_input_section
, ptr
);
550 new->section
= section
;
552 section
->output_section
= output
->bfd_section
;
553 section
->output_section
->flags
|= section
->flags
;
554 if (section
->alignment_power
> output
->bfd_section
->alignment_power
) {
555 output
->bfd_section
->alignment_power
= section
->alignment_power
;
561 DEFUN(our_bfd_get_section_by_name
,(abfd
, section
),
565 return bfd_get_section_by_name(abfd
, section
);
569 DEFUN(wild_section
,(ptr
, section
, file
, output
),
570 lang_wild_statement_type
*ptr AND
571 CONST
char *section AND
572 lang_input_statement_type
*file AND
573 lang_output_section_statement_type
*output
)
576 if (file
->just_syms_flag
== false) {
577 if (section
== (char *)NULL
) {
578 /* Do the creation to all sections in the file */
579 for (s
= file
->the_bfd
->sections
; s
!= (asection
*)NULL
; s
=s
->next
) {
580 wild_doit(&ptr
->children
, s
, output
, file
);
584 /* Do the creation to the named section only */
585 wild_doit(&ptr
->children
,
586 our_bfd_get_section_by_name(file
->the_bfd
, section
),
593 /* passed a file name (which must have been seen already and added to
594 the statement tree. We will see if it has been opened already and
595 had its symbols read. If not then we'll read it.
597 Archives are pecuilar here. We may open them once, but if they do
598 not define anything we need at the time, they won't have all their
599 symbols read. If we need them later, we'll have to redo it.
602 lang_input_statement_type
*
603 DEFUN(lookup_name
,(name
),
604 CONST
char * CONST name
)
606 lang_input_statement_type
*search
;
607 for(search
= (lang_input_statement_type
*)input_file_chain
.head
;
608 search
!= (lang_input_statement_type
*)NULL
;
609 search
= (lang_input_statement_type
*)search
->next_real_file
)
611 if (search
->filename
== (char *)NULL
&& name
== (char *)NULL
) {
614 if (search
->filename
!= (char *)NULL
&& name
!= (char *)NULL
) {
615 if (strcmp(search
->filename
, name
) == 0) {
616 ldmain_open_file_read_symbol(search
);
622 /* There isn't an afile entry for this file yet, this must be
623 because the name has only appeared inside a load script and not
624 on the command line */
625 search
= new_afile(name
, lang_input_file_is_file_enum
, default_target
);
626 ldmain_open_file_read_symbol(search
);
633 DEFUN(wild
,(s
, section
, file
, target
, output
),
634 lang_wild_statement_type
*s AND
635 CONST
char *CONST section AND
636 CONST
char *CONST file AND
637 CONST
char *CONST target AND
638 lang_output_section_statement_type
*output
)
640 lang_input_statement_type
*f
;
641 if (file
== (char *)NULL
) {
642 /* Perform the iteration over all files in the list */
643 for (f
= (lang_input_statement_type
*)file_chain
.head
;
644 f
!= (lang_input_statement_type
*)NULL
;
645 f
= (lang_input_statement_type
*)f
->next
) {
646 wild_section(s
, section
, f
, output
);
650 /* Perform the iteration over a single file */
651 wild_section( s
, section
, lookup_name(file
), output
);
653 if (section
!= (char *)NULL
654 && strcmp(section
,"COMMON") == 0
655 && default_common_section
== (lang_output_section_statement_type
*)NULL
)
657 /* Remember the section that common is going to incase we later
658 get something which doesn't know where to put it */
659 default_common_section
= output
;
664 read in all the files
667 DEFUN(open_output
,(name
),
668 CONST
char *CONST name
)
670 extern CONST
char *output_filename
;
672 if (output_target
== (char *)NULL
) {
673 if (current_target
!= (char *)NULL
)
674 output_target
= current_target
;
676 output_target
= default_target
;
678 output
= bfd_openw(name
, output_target
);
679 output_filename
= name
;
681 if (output
== (bfd
*)NULL
)
683 if (bfd_error
== invalid_target
) {
684 einfo("%P%F target %s not found\n", output_target
);
686 einfo("%P%F problem opening output file %s, %E", name
);
689 /* output->flags |= D_PAGED;*/
690 bfd_set_format(output
, bfd_object
);
698 DEFUN(ldlang_open_output
,(statement
),
699 lang_statement_union_type
*statement
)
701 switch (statement
->header
.type
)
703 case lang_output_statement_enum
:
704 output_bfd
= open_output(statement
->output_statement
.name
);
705 ldemul_set_output_arch();
706 if (config
.magic_demand_paged
&& !config
.relocateable_output
)
707 output_bfd
->flags
|= D_PAGED
;
709 output_bfd
->flags
&= ~D_PAGED
;
710 if (config
.text_read_only
)
711 output_bfd
->flags
|= WP_TEXT
;
713 output_bfd
->flags
&= ~WP_TEXT
;
716 case lang_target_statement_enum
:
717 current_target
= statement
->target_statement
.target
;
725 DEFUN(open_input_bfds
,(statement
),
726 lang_statement_union_type
*statement
)
728 switch (statement
->header
.type
)
730 case lang_target_statement_enum
:
731 current_target
= statement
->target_statement
.target
;
733 case lang_wild_statement_enum
:
734 /* Maybe we should load the file's symbols */
735 if (statement
->wild_statement
.filename
)
737 (void) lookup_name(statement
->wild_statement
.filename
);
740 case lang_input_statement_enum
:
741 if (statement
->input_statement
.real
== true)
743 statement
->input_statement
.target
= current_target
;
744 lookup_name(statement
->input_statement
.filename
);
751 /* If there are [COMMONS] statements, put a wild one into the bss section */
754 lang_reasonable_defaults()
757 abs_output_section
= lang_output_section_statement_lookup(BFD_ABS_SECTION_NAME
);
759 abs_output_section
->bfd_section
= &bfd_abs_section
;
763 lang_output_section_statement_lookup(".text");
764 lang_output_section_statement_lookup(".data");
766 default_common_section
=
767 lang_output_section_statement_lookup(".bss");
770 if (placed_commons
== false) {
771 lang_wild_statement_type
*new =
772 new_stat(lang_wild_statement
,
773 &default_common_section
->children
);
774 new->section_name
= "COMMON";
775 new->filename
= (char *)NULL
;
776 lang_list_init(&new->children
);
783 Add the supplied name to the symbol table as an undefined reference.
784 Remove items from the chain as we open input bfds
786 typedef struct ldlang_undef_chain_list
{
787 struct ldlang_undef_chain_list
*next
;
789 } ldlang_undef_chain_list_type
;
791 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
794 DEFUN(ldlang_add_undef
,(name
),
795 CONST
char *CONST name
)
797 ldlang_undef_chain_list_type
*new =
798 (ldlang_undef_chain_list_type
799 *)ldmalloc((bfd_size_type
)(sizeof(ldlang_undef_chain_list_type
)));
801 new->next
= ldlang_undef_chain_list_head
;
802 ldlang_undef_chain_list_head
= new;
804 new->name
= buystring(name
);
806 /* Run through the list of undefineds created above and place them
807 into the linker hash table as undefined symbols belonging to the
811 DEFUN_VOID(lang_place_undefineds
)
813 ldlang_undef_chain_list_type
*ptr
= ldlang_undef_chain_list_head
;
814 while (ptr
!= (ldlang_undef_chain_list_type
*)NULL
) {
815 ldsym_type
*sy
= ldsym_get(ptr
->name
);
817 asymbol
**def_ptr
= (asymbol
**)ldmalloc((bfd_size_type
)(sizeof(asymbol
**)));
818 def
= (asymbol
*)bfd_make_empty_symbol(script_file
->the_bfd
);
820 def
->name
= ptr
->name
;
821 def
->section
= &bfd_und_section
;
822 Q_enter_global_ref(def_ptr
);
829 /* Copy important data from out internal form to the bfd way. Also
830 create a section for the dummy file
834 DEFUN_VOID(lang_create_output_section_statements
)
836 lang_statement_union_type
*os
;
837 for (os
= lang_output_section_statement
.head
;
838 os
!= (lang_statement_union_type
*)NULL
;
839 os
= os
->output_section_statement
.next
) {
840 lang_output_section_statement_type
*s
=
841 &os
->output_section_statement
;
848 DEFUN_VOID(lang_init_script_file
)
850 script_file
= lang_add_input_file("script file",
851 lang_input_file_is_fake_enum
,
853 script_file
->the_bfd
= bfd_create("script file", output_bfd
);
854 script_file
->symbol_count
= 0;
855 script_file
->the_bfd
->sections
= output_bfd
->sections
;
861 /* Open input files and attatch to output sections */
863 DEFUN(map_input_to_output_sections
,(s
, target
, output_section_statement
),
864 lang_statement_union_type
*s AND
865 CONST
char *target AND
866 lang_output_section_statement_type
*output_section_statement
)
868 for (; s
!= (lang_statement_union_type
*)NULL
; s
= s
->next
)
870 switch (s
->header
.type
) {
873 case lang_wild_statement_enum
:
874 wild(&s
->wild_statement
, s
->wild_statement
.section_name
,
875 s
->wild_statement
.filename
, target
,
876 output_section_statement
);
879 case lang_constructors_statement_enum
:
880 map_input_to_output_sections(constructor_list
.head
,
882 output_section_statement
);
884 case lang_output_section_statement_enum
:
885 map_input_to_output_sections(s
->output_section_statement
.children
.head
,
887 &s
->output_section_statement
);
889 case lang_output_statement_enum
:
891 case lang_target_statement_enum
:
892 target
= s
->target_statement
.target
;
894 case lang_fill_statement_enum
:
895 case lang_input_section_enum
:
896 case lang_object_symbols_statement_enum
:
897 case lang_data_statement_enum
:
898 case lang_assignment_statement_enum
:
899 case lang_padding_statement_enum
:
901 case lang_afile_asection_pair_statement_enum
:
904 case lang_address_statement_enum
:
905 /* Mark the specified section with the supplied address */
907 lang_output_section_statement_type
*os
=
908 lang_output_section_statement_lookup
909 (s
->address_statement
.section_name
);
910 os
->addr_tree
= s
->address_statement
.address
;
911 if (os
->bfd_section
== (asection
*)NULL
) {
912 einfo("%P%F can't set the address of undefined section %s\n",
913 s
->address_statement
.section_name
);
917 case lang_input_statement_enum
:
918 /* A standard input statement, has no wildcards */
919 /* ldmain_open_file_read_symbol(&s->input_statement);*/
930 DEFUN(print_output_section_statement
,(output_section_statement
),
931 lang_output_section_statement_type
*output_section_statement
)
933 asection
*section
= output_section_statement
->bfd_section
;
935 print_section(output_section_statement
->name
);
938 print_dot
= section
->vma
;
942 print_address(section
->vma
);
944 print_size(bfd_get_section_size_before_reloc(section
));
946 print_alignment(section
->alignment_power
);
949 fprintf(config
.map_file
, "%s flags", output_section_statement
->region
->name
);
950 print_flags(stdout
, &output_section_statement
->flags
);
952 if (section
->flags
& SEC_LOAD
)
953 fprintf(config
.map_file
, "load ");
954 if (section
->flags
& SEC_ALLOC
)
955 fprintf(config
.map_file
, "alloc ");
956 if (section
->flags
& SEC_RELOC
)
957 fprintf(config
.map_file
, "reloc ");
958 if (section
->flags
& SEC_HAS_CONTENTS
)
959 fprintf(config
.map_file
, "contents ");
963 fprintf(config
.map_file
, "No attached output section");
966 print_statement(output_section_statement
->children
.head
,
967 output_section_statement
);
972 DEFUN(print_assignment
,(assignment
, output_section
),
973 lang_assignment_statement_type
*assignment AND
974 lang_output_section_statement_type
*output_section
)
976 etree_value_type result
;
981 print_address(print_dot
);
983 result
= exp_fold_tree(assignment
->exp
->assign
.src
,
985 lang_final_phase_enum
,
990 print_address(result
.value
);
994 fprintf(config
.map_file
, "*undefined*");
997 exp_print_tree(assignment
->exp
);
999 fprintf(config
.map_file
, "\n");
1003 DEFUN(print_input_statement
,(statm
),
1004 lang_input_statement_type
*statm
)
1006 if (statm
->filename
!= (char *)NULL
) {
1007 fprintf(config
.map_file
, "LOAD %s\n",statm
->filename
);
1012 DEFUN(print_symbol
,(q
),
1016 fprintf(config
.map_file
, " ");
1018 fprintf(config
.map_file
, " ");
1019 print_address(outside_symbol_address(q
));
1020 fprintf(config
.map_file
, " %s", q
->name
? q
->name
: " ");
1025 DEFUN(print_input_section
,(in
),
1026 lang_input_section_type
*in
)
1028 asection
*i
= in
->section
;
1029 int size
= i
->reloc_done
?
1030 bfd_get_section_size_after_reloc(i
) :
1031 bfd_get_section_size_before_reloc(i
);
1036 fprintf(config
.map_file
, " ");
1037 print_section(i
->name
);
1038 fprintf(config
.map_file
, " ");
1039 if (i
->output_section
) {
1040 print_address(i
->output_section
->vma
+ i
->output_offset
);
1041 fprintf(config
.map_file
, " ");
1043 fprintf(config
.map_file
, " ");
1044 print_alignment(i
->alignment_power
);
1045 fprintf(config
.map_file
, " ");
1048 bfd
*abfd
= in
->ifile
->the_bfd
;
1049 if (in
->ifile
->just_syms_flag
== true) {
1050 fprintf(config
.map_file
, "symbols only ");
1053 fprintf(config
.map_file
, " %s ",abfd
->xvec
->name
);
1054 if(abfd
->my_archive
!= (bfd
*)NULL
) {
1055 fprintf(config
.map_file
, "[%s]%s", abfd
->my_archive
->filename
,
1059 fprintf(config
.map_file
, "%s", abfd
->filename
);
1061 fprintf(config
.map_file
, "(overhead %d bytes)", (int)bfd_alloc_size(abfd
));
1064 /* Find all the symbols in this file defined in this section */
1067 for (p
= in
->ifile
->asymbols
; *p
; p
++) {
1070 if (bfd_get_section(q
) == i
&& q
->flags
& BSF_GLOBAL
) {
1081 print_dot
= outside_section_address(i
) + size
;
1084 fprintf(config
.map_file
, "No output section allocated\n");
1090 DEFUN(print_fill_statement
,(fill
),
1091 lang_fill_statement_type
*fill
)
1093 fprintf(config
.map_file
, "FILL mask ");
1094 print_fill( fill
->fill
);
1098 DEFUN(print_data_statement
,(data
),
1099 lang_data_statement_type
*data
)
1101 /* bfd_vma value; */
1106 /* ASSERT(print_dot == data->output_vma);*/
1108 print_address(data
->output_vma
+ data
->output_section
->vma
);
1110 print_address(data
->value
);
1112 switch (data
->type
) {
1114 fprintf(config
.map_file
, "BYTE ");
1115 print_dot
+= BYTE_SIZE
;
1118 fprintf(config
.map_file
, "SHORT ");
1119 print_dot
+= SHORT_SIZE
;
1122 fprintf(config
.map_file
, "LONG ");
1123 print_dot
+= LONG_SIZE
;
1127 exp_print_tree(data
->exp
);
1129 fprintf(config
.map_file
, "\n");
1134 DEFUN(print_padding_statement
,(s
),
1135 lang_padding_statement_type
*s
)
1139 print_section("*fill*");
1141 print_address(s
->output_offset
+ s
->output_section
->vma
);
1143 print_size(s
->size
);
1145 print_fill(s
->fill
);
1148 print_dot
= s
->output_offset
+ s
->output_section
->vma
+ s
->size
;
1153 DEFUN(print_wild_statement
,(w
,os
),
1154 lang_wild_statement_type
*w AND
1155 lang_output_section_statement_type
*os
)
1157 fprintf(config
.map_file
, " from ");
1158 if (w
->filename
!= (char *)NULL
) {
1159 fprintf(config
.map_file
, "%s",w
->filename
);
1162 fprintf(config
.map_file
, "*");
1164 if (w
->section_name
!= (char *)NULL
) {
1165 fprintf(config
.map_file
, "(%s)",w
->section_name
);
1168 fprintf(config
.map_file
, "(*)");
1171 print_statement(w
->children
.head
, os
);
1175 DEFUN(print_statement
,(s
, os
),
1176 lang_statement_union_type
*s AND
1177 lang_output_section_statement_type
*os
)
1181 switch (s
->header
.type
)
1183 case lang_constructors_statement_enum
:
1184 fprintf(config
.map_file
, "constructors:\n");
1185 print_statement(constructor_list
.head
, os
);
1187 case lang_wild_statement_enum
:
1188 print_wild_statement(&s
->wild_statement
, os
);
1191 fprintf(config
.map_file
, "Fail with %d\n",s
->header
.type
);
1194 case lang_address_statement_enum
:
1195 fprintf(config
.map_file
, "address\n");
1198 case lang_object_symbols_statement_enum
:
1199 fprintf(config
.map_file
, "object symbols\n");
1201 case lang_fill_statement_enum
:
1202 print_fill_statement(&s
->fill_statement
);
1204 case lang_data_statement_enum
:
1205 print_data_statement(&s
->data_statement
);
1207 case lang_input_section_enum
:
1208 print_input_section(&s
->input_section
);
1210 case lang_padding_statement_enum
:
1211 print_padding_statement(&s
->padding_statement
);
1213 case lang_output_section_statement_enum
:
1214 print_output_section_statement(&s
->output_section_statement
);
1216 case lang_assignment_statement_enum
:
1217 print_assignment(&s
->assignment_statement
,
1220 case lang_target_statement_enum
:
1221 fprintf(config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1223 case lang_output_statement_enum
:
1224 fprintf(config
.map_file
, "OUTPUT(%s %s)\n",
1225 s
->output_statement
.name
,
1228 case lang_input_statement_enum
:
1229 print_input_statement(&s
->input_statement
);
1231 case lang_afile_asection_pair_statement_enum
:
1241 DEFUN_VOID(print_statements
)
1243 print_statement(statement_list
.head
,
1244 abs_output_section
);
1249 DEFUN(insert_pad
,(this_ptr
, fill
, power
, output_section_statement
, dot
),
1250 lang_statement_union_type
**this_ptr AND
1252 unsigned int power AND
1253 asection
* output_section_statement AND
1256 /* Align this section first to the
1257 input sections requirement, then
1258 to the output section's requirement.
1259 If this alignment is > than any seen before,
1260 then record it too. Perform the alignment by
1261 inserting a magic 'padding' statement.
1264 unsigned int alignment_needed
= align_power(dot
, power
) - dot
;
1266 if (alignment_needed
!= 0)
1268 lang_statement_union_type
*new =
1269 (lang_statement_union_type
*)
1270 ldmalloc((bfd_size_type
)(sizeof(lang_padding_statement_type
)));
1271 /* Link into existing chain */
1272 new->header
.next
= *this_ptr
;
1274 new->header
.type
= lang_padding_statement_enum
;
1275 new->padding_statement
.output_section
= output_section_statement
;
1276 new->padding_statement
.output_offset
=
1277 dot
- output_section_statement
->vma
;
1278 new->padding_statement
.fill
= fill
;
1279 new->padding_statement
.size
= alignment_needed
;
1283 /* Remember the most restrictive alignment */
1284 if (power
> output_section_statement
->alignment_power
) {
1285 output_section_statement
->alignment_power
= power
;
1287 output_section_statement
->_raw_size
+= alignment_needed
;
1288 return alignment_needed
+ dot
;
1292 /* Work out how much this section will move the dot point */
1294 DEFUN(size_input_section
, (this_ptr
, output_section_statement
, fill
, dot
),
1295 lang_statement_union_type
**this_ptr AND
1296 lang_output_section_statement_type
*output_section_statement AND
1297 unsigned short fill AND
1300 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1301 asection
*i
= is
->section
;
1303 if (is
->ifile
->just_syms_flag
== false) {
1304 dot
= insert_pad(this_ptr
, fill
, i
->alignment_power
,
1305 output_section_statement
->bfd_section
, dot
);
1307 /* remember the largest size so we can malloc the largest area
1308 needed for the output stage. Only remember the size of sections
1309 which we will actually allocate */
1311 (SEC_HAS_CONTENTS
| SEC_LOAD
)) == (SEC_HAS_CONTENTS
| SEC_LOAD
))
1312 && (bfd_get_section_size_before_reloc(i
) > largest_section
)) {
1313 largest_section
= bfd_get_section_size_before_reloc(i
);
1316 /* Remember where in the output section this input section goes */
1318 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1320 /* Mark how big the output section must be to contain this now */
1321 dot
+= bfd_get_section_size_before_reloc(i
);
1322 output_section_statement
->bfd_section
->_raw_size
=
1323 dot
- output_section_statement
->bfd_section
->vma
;
1327 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
1334 /* Work out the size of the output sections
1335 from the sizes of the input sections */
1337 DEFUN(lang_size_sections
,(s
, output_section_statement
, prev
, fill
,
1339 lang_statement_union_type
*s AND
1340 lang_output_section_statement_type
* output_section_statement AND
1341 lang_statement_union_type
**prev AND
1342 unsigned short fill AND
1346 /* Size up the sections from their constituent parts */
1347 for (; s
!= (lang_statement_union_type
*)NULL
; s
= s
->next
)
1349 switch (s
->header
.type
) {
1352 case lang_output_section_statement_enum
:
1355 lang_output_section_statement_type
*os
=
1356 &(s
->output_section_statement
);
1357 /* The start of a section */
1359 if (os
->addr_tree
== (etree_type
*)NULL
) {
1360 /* No address specified for this section, get one
1361 from the region specification
1363 if (os
->region
== (lang_memory_region_type
*)NULL
) {
1364 os
->region
= lang_memory_region_lookup("*default*");
1366 dot
= os
->region
->current
;
1369 etree_value_type r
;
1370 r
= exp_fold_tree(os
->addr_tree
,
1371 (lang_output_section_statement_type
*)NULL
,
1372 lang_allocating_phase_enum
,
1374 if (r
.valid
== false) {
1375 einfo("%F%S: non constant address expression for section %s\n",
1380 /* The section starts here */
1381 /* First, align to what the section needs */
1383 dot
= align_power(dot
, os
->bfd_section
->alignment_power
);
1384 os
->bfd_section
->vma
= dot
;
1385 os
->bfd_section
->output_offset
= 0;
1387 (void) lang_size_sections(os
->children
.head
, os
, &os
->children
.head
,
1389 /* Ignore the size of the input sections, use the vma and size to */
1393 after
= ALIGN(os
->bfd_section
->vma
+
1394 os
->bfd_section
->size
,
1398 os
->bfd_section
->size
= after
- os
->bfd_section
->vma
;
1399 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->size
;
1400 os
->processed
= true;
1402 /* Replace into region ? */
1403 if (os
->addr_tree
== (etree_type
*)NULL
1404 && os
->region
!=(lang_memory_region_type
*)NULL
) {
1405 os
->region
->current
= dot
;
1410 case lang_constructors_statement_enum
:
1411 dot
= lang_size_sections(constructor_list
.head
,
1412 output_section_statement
,
1413 &s
->wild_statement
.children
.head
,
1418 case lang_data_statement_enum
:
1420 unsigned int size
= 0;
1421 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1422 s
->data_statement
.output_section
=
1423 output_section_statement
->bfd_section
;
1425 switch (s
->data_statement
.type
) {
1438 output_section_statement
->bfd_section
->size
+= size
;
1442 case lang_wild_statement_enum
:
1444 dot
= lang_size_sections(s
->wild_statement
.children
.head
,
1445 output_section_statement
,
1446 &s
->wild_statement
.children
.head
,
1452 case lang_object_symbols_statement_enum
:
1453 create_object_symbols
= output_section_statement
;
1455 case lang_output_statement_enum
:
1456 case lang_target_statement_enum
:
1458 case lang_input_section_enum
:
1459 dot
= size_input_section(prev
,
1460 output_section_statement
,
1461 output_section_statement
->fill
, dot
);
1463 case lang_input_statement_enum
:
1465 case lang_fill_statement_enum
:
1466 fill
= s
->fill_statement
.fill
;
1468 case lang_assignment_statement_enum
:
1470 bfd_vma newdot
= dot
;
1471 exp_fold_tree(s
->assignment_statement
.exp
,
1472 output_section_statement
,
1473 lang_allocating_phase_enum
,
1477 if (newdot
!= dot
&& )
1478 /* We've been moved ! so insert a pad */
1480 lang_statement_union_type
*new =
1481 (lang_statement_union_type
*)
1482 ldmalloc((bfd_size_type
)(sizeof(lang_padding_statement_type
)));
1483 /* Link into existing chain */
1484 new->header
.next
= *prev
;
1486 new->header
.type
= lang_padding_statement_enum
;
1487 new->padding_statement
.output_section
=
1488 output_section_statement
->bfd_section
;
1489 new->padding_statement
.output_offset
=
1490 dot
- output_section_statement
->bfd_section
->vma
;
1491 new->padding_statement
.fill
= fill
;
1492 new->padding_statement
.size
= newdot
- dot
;
1493 output_section_statement
->bfd_section
->size
+=
1494 new->padding_statement
.size
;
1500 case lang_padding_statement_enum
:
1506 case lang_address_statement_enum
:
1509 prev
= &s
->header
.next
;
1514 /* Sizing happens in two passes, first pass we allocate worst case
1515 stuff. The second pass (if relaxing), we use what we learnt to
1516 change the size of some relocs from worst case to better
1518 static boolean had_relax
;
1521 DEFUN(lang_size_sections
,(s
, output_section_statement
, prev
, fill
,
1523 lang_statement_union_type
*s AND
1524 lang_output_section_statement_type
* output_section_statement AND
1525 lang_statement_union_type
**prev AND
1526 unsigned short fill AND
1530 /* Size up the sections from their constituent parts */
1531 for (; s
!= (lang_statement_union_type
*)NULL
; s
= s
->next
)
1533 switch (s
->header
.type
) {
1535 case lang_output_section_statement_enum
:
1538 lang_output_section_statement_type
*os
=
1539 &(s
->output_section_statement
);
1540 /* The start of a section */
1542 if (os
->addr_tree
== (etree_type
*)NULL
) {
1543 /* No address specified for this section, get one
1544 from the region specification
1546 if (os
->region
== (lang_memory_region_type
*)NULL
) {
1547 os
->region
= lang_memory_region_lookup("*default*");
1549 dot
= os
->region
->current
;
1552 etree_value_type r
;
1553 r
= exp_fold_tree(os
->addr_tree
,
1555 lang_allocating_phase_enum
,
1557 if (r
.valid
== false) {
1558 einfo("%F%S: non constant address expression for section %s\n",
1563 /* The section starts here */
1564 /* First, align to what the section needs */
1566 dot
= align_power(dot
, os
->bfd_section
->alignment_power
);
1567 os
->bfd_section
->vma
= dot
;
1568 os
->bfd_section
->output_offset
= 0;
1570 (void) lang_size_sections(os
->children
.head
, os
, &os
->children
.head
,
1571 os
->fill
, dot
, relax
);
1572 /* Ignore the size of the input sections, use the vma and size to */
1576 after
= ALIGN(os
->bfd_section
->vma
+
1577 os
->bfd_section
->_raw_size
,
1581 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
1582 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1583 os
->processed
= true;
1585 /* Replace into region ? */
1586 if (os
->addr_tree
== (etree_type
*)NULL
1587 && os
->region
!=(lang_memory_region_type
*)NULL
) {
1588 os
->region
->current
= dot
;
1589 /* Make sure this isn't silly */
1590 if (os
->region
->current
>
1591 os
->region
->origin
+
1594 einfo("%X%P: Region %s is full (%B section %s)\n",
1596 os
->bfd_section
->owner
,
1597 os
->bfd_section
->name
);
1598 /* Reset the region pointer */
1599 os
->region
->current
= 0;
1606 case lang_constructors_statement_enum
:
1607 dot
= lang_size_sections(constructor_list
.head
,
1608 output_section_statement
,
1609 &s
->wild_statement
.children
.head
,
1614 case lang_data_statement_enum
:
1616 unsigned int size
= 0;
1617 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1618 s
->data_statement
.output_section
=
1619 output_section_statement
->bfd_section
;
1621 switch (s
->data_statement
.type
) {
1634 output_section_statement
->bfd_section
->_raw_size
+= size
;
1638 case lang_wild_statement_enum
:
1640 dot
= lang_size_sections(s
->wild_statement
.children
.head
,
1641 output_section_statement
,
1642 &s
->wild_statement
.children
.head
,
1648 case lang_object_symbols_statement_enum
:
1649 create_object_symbols
= output_section_statement
;
1651 case lang_output_statement_enum
:
1652 case lang_target_statement_enum
:
1654 case lang_input_section_enum
:
1660 had_relax
|= relax_section(prev
);
1665 dot
= size_input_section(prev
,
1666 output_section_statement
,
1667 output_section_statement
->fill
, dot
);
1669 case lang_input_statement_enum
:
1671 case lang_fill_statement_enum
:
1672 fill
= s
->fill_statement
.fill
;
1674 case lang_assignment_statement_enum
:
1676 bfd_vma newdot
= dot
;
1677 exp_fold_tree(s
->assignment_statement
.exp
,
1678 output_section_statement
,
1679 lang_allocating_phase_enum
,
1683 if (newdot
!= dot
&& !relax
)
1684 /* We've been moved ! so insert a pad */
1686 lang_statement_union_type
*new =
1687 (lang_statement_union_type
*)
1688 ldmalloc((bfd_size_type
)(sizeof(lang_padding_statement_type
)));
1689 /* Link into existing chain */
1690 new->header
.next
= *prev
;
1692 new->header
.type
= lang_padding_statement_enum
;
1693 new->padding_statement
.output_section
=
1694 output_section_statement
->bfd_section
;
1695 new->padding_statement
.output_offset
=
1696 dot
- output_section_statement
->bfd_section
->vma
;
1697 new->padding_statement
.fill
= fill
;
1698 new->padding_statement
.size
= newdot
- dot
;
1699 output_section_statement
->bfd_section
->_raw_size
+=
1700 new->padding_statement
.size
;
1709 /* This can only get here when relaxing is turned on */
1710 case lang_padding_statement_enum
:
1712 case lang_address_statement_enum
:
1715 prev
= &s
->header
.next
;
1722 DEFUN(lang_do_assignments
,(s
, output_section_statement
, fill
, dot
),
1723 lang_statement_union_type
*s AND
1724 lang_output_section_statement_type
* output_section_statement AND
1725 unsigned short fill AND
1729 for (; s
!= (lang_statement_union_type
*)NULL
; s
= s
->next
)
1731 switch (s
->header
.type
) {
1732 case lang_constructors_statement_enum
:
1733 dot
= lang_do_assignments(constructor_list
.head
,
1734 output_section_statement
,
1739 case lang_output_section_statement_enum
:
1741 lang_output_section_statement_type
*os
=
1742 &(s
->output_section_statement
);
1743 dot
= os
->bfd_section
->vma
;
1744 (void) lang_do_assignments(os
->children
.head
, os
, os
->fill
, dot
);
1745 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1748 case lang_wild_statement_enum
:
1750 dot
= lang_do_assignments(s
->wild_statement
.children
.head
,
1751 output_section_statement
,
1756 case lang_object_symbols_statement_enum
:
1757 case lang_output_statement_enum
:
1758 case lang_target_statement_enum
:
1760 case lang_common_statement_enum
:
1763 case lang_data_statement_enum
:
1765 etree_value_type value
;
1766 value
= exp_fold_tree(s
->data_statement
.exp
,
1767 0, lang_final_phase_enum
, dot
, &dot
);
1768 s
->data_statement
.value
= value
.value
;
1769 if (value
.valid
== false) einfo("%F%P: Invalid data statement\n");
1771 switch (s
->data_statement
.type
) {
1783 case lang_input_section_enum
:
1785 asection
*in
= s
->input_section
.section
;
1786 dot
+= bfd_get_section_size_before_reloc(in
);
1790 case lang_input_statement_enum
:
1792 case lang_fill_statement_enum
:
1793 fill
= s
->fill_statement
.fill
;
1795 case lang_assignment_statement_enum
:
1797 exp_fold_tree(s
->assignment_statement
.exp
,
1798 output_section_statement
,
1799 lang_final_phase_enum
,
1805 case lang_padding_statement_enum
:
1806 dot
+= s
->padding_statement
.size
;
1811 case lang_address_statement_enum
:
1822 DEFUN_VOID(lang_relocate_globals
)
1826 Each ldsym_type maintains a chain of pointers to asymbols which
1827 references the definition. Replace each pointer to the referenence
1828 with a pointer to only one place, preferably the definition. If
1829 the defintion isn't available then the common symbol, and if
1830 there isn't one of them then choose one reference.
1833 FOR_EACH_LDSYM(lgs
) {
1835 if (lgs
->sdefs_chain
) {
1836 it
= *(lgs
->sdefs_chain
);
1838 else if (lgs
->scoms_chain
!= (asymbol
**)NULL
) {
1839 it
= *(lgs
->scoms_chain
);
1841 else if (lgs
->srefs_chain
!= (asymbol
**)NULL
) {
1842 it
= *(lgs
->srefs_chain
);
1845 /* This can happen when the command line asked for a symbol to
1847 it
= (asymbol
*)NULL
;
1849 if (it
!= (asymbol
*)NULL
)
1851 asymbol
**ptr
= lgs
->srefs_chain
;;
1852 if (lgs
->flags
& SYM_WARNING
)
1854 produce_warnings(lgs
, it
);
1857 while (ptr
!= (asymbol
**)NULL
) {
1858 asymbol
*ref
= *ptr
;
1860 ptr
= (asymbol
**)(ref
->udata
);
1869 DEFUN_VOID(lang_finish
)
1873 if (entry_symbol
== (char *)NULL
) {
1874 /* No entry has been specified, look for start */
1875 entry_symbol
= "start";
1877 lgs
= ldsym_get_soft(entry_symbol
);
1878 if (lgs
&& lgs
->sdefs_chain
) {
1879 asymbol
*sy
= *(lgs
->sdefs_chain
);
1880 /* We can set the entry address*/
1881 bfd_set_start_address(output_bfd
,
1882 outside_symbol_address(sy
));
1886 /* Can't find anything reasonable,
1887 use the first address in the text section
1889 asection
*ts
= bfd_get_section_by_name(output_bfd
, ".text");
1891 bfd_set_start_address(output_bfd
, ts
->vma
);
1896 /* By now we know the target architecture, and we may have an */
1897 /* ldfile_output_machine_name */
1899 DEFUN_VOID(lang_check
)
1901 lang_statement_union_type
*file
;
1904 unsigned long input_machine
;
1905 enum bfd_architecture input_architecture
;
1907 CONST bfd_arch_info_type
*compatible
;
1909 for (file
= file_chain
.head
;
1910 file
!= (lang_statement_union_type
*)NULL
;
1911 file
=file
->input_statement
.next
)
1913 unsigned long ldfile_new_output_machine
= 0;
1914 enum bfd_architecture ldfile_new_output_architecture
= bfd_arch_unknown
;
1916 input_bfd
= file
->input_statement
.the_bfd
;
1918 input_machine
= bfd_get_mach(input_bfd
);
1919 input_architecture
= bfd_get_arch(input_bfd
);
1922 /* Inspect the architecture and ensure we're linking like with
1925 compatible
=bfd_arch_get_compatible(input_bfd
,
1930 ldfile_output_machine
= compatible
->mach
;
1931 ldfile_output_architecture
= compatible
->arch
;
1936 info("%P: warning, %s architecture of input file `%B' incompatible with %s output\n",
1937 bfd_printable_name(input_bfd
), input_bfd
,
1938 bfd_printable_name(output_bfd
));
1940 bfd_set_arch_mach(output_bfd
,
1941 ldfile_new_output_architecture
,
1942 ldfile_new_output_machine
);
1950 * run through all the global common symbols and tie them
1951 * to the output section requested.
1953 As an experiment we do this 4 times, once for all the byte sizes,
1954 then all the two bytes, all the four bytes and then everything else
1958 DEFUN_VOID(lang_common
)
1962 if (config
.relocateable_output
== false ||
1963 command_line
.force_common_definition
== true) {
1964 for (power
= 1; (config
.sort_common
== true && power
== 1) || (power
<= 16); power
<<=1) {
1965 for (lgs
= symbol_head
;
1966 lgs
!= (ldsym_type
*)NULL
;
1970 unsigned int power_of_two
;
1973 if (lgs
->scoms_chain
!= (asymbol
**)NULL
) {
1974 com
= *(lgs
->scoms_chain
);
2003 if (config
.sort_common
== false || align
== power
) {
2004 /* Change from a common symbol into a definition of
2006 lgs
->sdefs_chain
= lgs
->scoms_chain
;
2007 lgs
->scoms_chain
= (asymbol
**)NULL
;
2009 /* Point to the correct common section */
2011 ((lang_input_statement_type
*)
2012 (com
->the_bfd
->usrdata
))->common_section
;
2013 /* Fix the size of the common section */
2015 com
->section
->_raw_size
=
2016 ALIGN(com
->section
->_raw_size
, align
);
2018 /* Remember if this is the biggest alignment ever seen */
2019 if (power_of_two
> com
->section
->alignment_power
) {
2020 com
->section
->alignment_power
= power_of_two
;
2023 /* Symbol stops being common and starts being global, but
2024 we remember that it was common once. */
2026 com
->flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_OLD_COMMON
;
2027 com
->value
= com
->section
->_raw_size
;
2031 fprintf (config
.map_file
, "Allocating common %s: %x at %x %s\n",
2034 (unsigned) com
->value
,
2035 com
->the_bfd
->filename
);
2038 com
->section
->_raw_size
+= size
;
2051 run through the input files and ensure that every input
2052 section has somewhere to go. If one is found without
2053 a destination then create an input request and place it
2054 into the statement tree.
2058 DEFUN_VOID(lang_place_orphans
)
2060 lang_input_statement_type
*file
;
2061 for (file
= (lang_input_statement_type
*)file_chain
.head
;
2062 file
!= (lang_input_statement_type
*)NULL
;
2063 file
= (lang_input_statement_type
*)file
->next
) {
2065 for (s
= file
->the_bfd
->sections
;
2066 s
!= (asection
*)NULL
;
2068 if ( s
->output_section
== (asection
*)NULL
) {
2069 /* This section of the file is not attatched, root
2070 around for a sensible place for it to go */
2072 if (file
->common_section
== s
) {
2073 /* This is a lonely common section which must
2074 have come from an archive. We attatch to the
2075 section with the wildcard */
2076 if (config
.relocateable_output
!= true
2077 && command_line
.force_common_definition
== false) {
2078 if (default_common_section
==
2079 (lang_output_section_statement_type
*)NULL
) {
2080 info("%P: No [COMMON] command, defaulting to .bss\n");
2082 default_common_section
=
2083 lang_output_section_statement_lookup(".bss");
2086 wild_doit(&default_common_section
->children
, s
,
2087 default_common_section
, file
);
2091 lang_output_section_statement_type
*os
=
2092 lang_output_section_statement_lookup(s
->name
);
2094 wild_doit(&os
->children
, s
, os
, file
);
2103 DEFUN(lang_set_flags
,(ptr
, flags
),
2107 boolean state
= true;
2111 if (*flags
== '!') {
2118 /* ptr->flag_read = state; */
2121 /* ptr->flag_write = state; */
2124 /* ptr->flag_executable= state;*/
2128 /* ptr->flag_loadable= state;*/
2131 einfo("%P%F illegal syntax in flags\n");
2141 DEFUN(lang_for_each_file
,(func
),
2142 PROTO(void, (*func
),(lang_input_statement_type
*)))
2144 lang_input_statement_type
*f
;
2145 for (f
= (lang_input_statement_type
*)file_chain
.head
;
2146 f
!= (lang_input_statement_type
*)NULL
;
2147 f
= (lang_input_statement_type
*)f
->next
)
2155 DEFUN(lang_for_each_input_section
, (func
),
2156 PROTO(void ,(*func
),(bfd
*ab
, asection
*as
)))
2158 lang_input_statement_type
*f
;
2159 for (f
= (lang_input_statement_type
*)file_chain
.head
;
2160 f
!= (lang_input_statement_type
*)NULL
;
2161 f
= (lang_input_statement_type
*)f
->next
)
2164 for (s
= f
->the_bfd
->sections
;
2165 s
!= (asection
*)NULL
;
2167 func(f
->the_bfd
, s
);
2175 DEFUN(ldlang_add_file
,(entry
),
2176 lang_input_statement_type
*entry
)
2179 lang_statement_append(&file_chain
,
2180 (lang_statement_union_type
*)entry
,
2187 DEFUN(lang_add_output
,(name
),
2190 lang_output_statement_type
*new = new_stat(lang_output_statement
,
2193 had_output_filename
= true;
2197 static lang_output_section_statement_type
*current_section
;
2200 DEFUN(lang_enter_output_section_statement
,
2201 (output_section_statement_name
,
2205 char *output_section_statement_name AND
2206 etree_type
*address_exp AND
2208 bfd_vma block_value
)
2210 lang_output_section_statement_type
*os
;
2213 lang_output_section_statement_lookup(output_section_statement_name
);
2217 /* Add this statement to tree */
2218 /* add_statement(lang_output_section_statement_enum,
2219 output_section_statement);*/
2220 /* Make next things chain into subchain of this */
2222 if (os
->addr_tree
==
2223 (etree_type
*)NULL
) {
2228 os
->block_value
= block_value
;
2229 stat_ptr
= & os
->children
;
2235 DEFUN_VOID(lang_final
)
2237 if (had_output_filename
== false) {
2238 extern CONST
char *output_filename
;
2239 lang_add_output(output_filename
);
2245 /* Reset the current counters in the regions */
2247 DEFUN_VOID(reset_memory_regions
)
2249 lang_memory_region_type
*p
= lang_memory_region_list
;
2250 for (p
= lang_memory_region_list
;
2251 p
!= ( lang_memory_region_type
*)NULL
;
2254 p
->current
= p
->origin
;
2260 DEFUN(create_symbol
,(name
, flags
, section
),
2261 CONST
char *name AND
2265 extern lang_input_statement_type
*script_file
;
2266 asymbol
**def_ptr
= (asymbol
**)ldmalloc((bfd_size_type
)(sizeof(asymbol
**)));
2267 /* Add this definition to script file */
2268 asymbol
*def
= (asymbol
*)bfd_make_empty_symbol(script_file
->the_bfd
);
2269 def
->name
= buystring(name
);
2272 def
->section
= section
;
2275 Q_enter_global_ref(def_ptr
);
2282 DEFUN_VOID(lang_process
)
2284 if (had_script
== false) {
2285 parse_line(ldemul_get_script());
2287 lang_reasonable_defaults();
2288 current_target
= default_target
;
2290 lang_for_each_statement(ldlang_open_output
); /* Open the output file */
2291 /* For each output section statement, create a section in the output
2293 lang_create_output_section_statements();
2295 /* Create a dummy bfd for the script */
2296 lang_init_script_file();
2298 /* Add to the hash table all undefineds on the command line */
2299 lang_place_undefineds();
2301 /* Create a bfd for each input file */
2302 current_target
= default_target
;
2303 lang_for_each_statement(open_input_bfds
);
2305 common_section
.userdata
= (PTR
)&common_section_userdata
;
2308 /* Run through the contours of the script and attatch input sections
2309 to the correct output sections
2311 find_constructors();
2312 map_input_to_output_sections(statement_list
.head
, (char *)NULL
,
2313 ( lang_output_section_statement_type
*)NULL
);
2316 /* Find any sections not attatched explicitly and handle them */
2317 lang_place_orphans();
2319 /* Size up the common data */
2322 ldemul_before_allocation();
2325 /* Size up the sections */
2326 lang_size_sections(statement_list
.head
,
2328 &(statement_list
.head
), 0, (bfd_vma
)0, false);
2331 /* Now run around and relax if we can */
2332 if (command_line
.relax
)
2334 reset_memory_regions();
2336 /* Move the global symbols around */
2337 lang_relocate_globals();
2345 lang_size_sections(statement_list
.head
,
2346 (lang_output_section_statement_type
*)NULL
,
2347 &(statement_list
.head
), 0, (bfd_vma
)0, true);
2348 /* FIXME. Until the code in relax is fixed so that it only reads in
2349 stuff once, we cant iterate since there is no way for the linker to
2350 know what has been patched and what hasn't */
2361 /* See if anything special should be done now we know how big
2363 ldemul_after_allocation();
2365 /* Do all the assignments, now that we know the final restingplaces
2366 of all the symbols */
2368 lang_do_assignments(statement_list
.head
,
2373 /* Move the global symbols around */
2374 lang_relocate_globals();
2376 /* Make sure that we're not mixing architectures */
2385 /* EXPORTED TO YACC */
2388 DEFUN(lang_add_wild
,(section_name
, filename
),
2389 CONST
char *CONST section_name AND
2390 CONST
char *CONST filename
)
2392 lang_wild_statement_type
*new = new_stat(lang_wild_statement
,
2395 if (section_name
!= (char *)NULL
&& strcmp(section_name
,"COMMON") == 0)
2397 placed_commons
= true;
2399 if (filename
!= (char *)NULL
) {
2400 lang_has_input_file
= true;
2402 new->section_name
= section_name
;
2403 new->filename
= filename
;
2404 lang_list_init(&new->children
);
2407 DEFUN(lang_section_start
,(name
, address
),
2408 CONST
char *name AND
2409 etree_type
*address
)
2411 lang_address_statement_type
*ad
=new_stat(lang_address_statement
, stat_ptr
);
2412 ad
->section_name
= name
;
2413 ad
->address
= address
;
2417 DEFUN(lang_add_entry
,(name
),
2420 entry_symbol
= name
;
2424 DEFUN(lang_add_target
,(name
),
2427 lang_target_statement_type
*new = new_stat(lang_target_statement
,
2437 DEFUN(lang_add_map
,(name
),
2443 map_option_f
= true;
2451 DEFUN(lang_add_fill
,(exp
),
2454 lang_fill_statement_type
*new = new_stat(lang_fill_statement
,
2460 DEFUN(lang_add_data
,(type
, exp
),
2462 union etree_union
*exp
)
2465 lang_data_statement_type
*new = new_stat(lang_data_statement
,
2472 DEFUN(lang_add_assignment
,(exp
),
2475 lang_assignment_statement_type
*new = new_stat(lang_assignment_statement
,
2481 DEFUN(lang_add_attribute
,(attribute
),
2482 enum statement_enum attribute
)
2484 new_statement(attribute
, sizeof(lang_statement_union_type
),stat_ptr
);
2490 DEFUN(lang_startup
,(name
),
2493 if (startup_file
!= (char *)NULL
) {
2494 einfo("%P%FMultiple STARTUP files\n");
2496 first_file
->filename
= name
;
2497 first_file
->local_sym_name
= name
;
2502 DEFUN(lang_float
,(maybe
),
2505 lang_float_flag
= maybe
;
2509 DEFUN(lang_leave_output_section_statement
,(fill
, memspec
),
2511 CONST
char *memspec
)
2513 current_section
->fill
= fill
;
2514 current_section
->region
= lang_memory_region_lookup(memspec
);
2515 stat_ptr
= &statement_list
;
2517 /* We remember if we are closing a .data section, since we use it to
2518 store constructors in */
2519 if (strcmp(current_section
->name
, ".data") ==0) {
2520 end_of_data_section_statement_list
= statement_list
;
2525 Create an absolute symbol with the given name with the value of the
2526 address of first byte of the section named.
2528 If the symbol already exists, then do nothing.
2531 DEFUN(lang_abs_symbol_at_beginning_of
,(section
, name
),
2532 CONST
char *section AND
2535 if (ldsym_undefined(name
)) {
2536 asection
*s
= bfd_get_section_by_name(output_bfd
, section
);
2537 asymbol
*def
= create_symbol(name
,
2538 BSF_GLOBAL
| BSF_EXPORT
,
2542 if (s
!= (asection
*)NULL
) {
2543 def
->value
= s
->vma
;
2552 Create an absolute symbol with the given name with the value of the
2553 address of the first byte after the end of the section named.
2555 If the symbol already exists, then do nothing.
2558 DEFUN(lang_abs_symbol_at_end_of
,(section
, name
),
2559 CONST
char *section AND
2562 if (ldsym_undefined(name
)){
2563 asection
*s
= bfd_get_section_by_name(output_bfd
, section
);
2564 /* Add a symbol called _end */
2565 asymbol
*def
= create_symbol(name
,
2566 BSF_GLOBAL
| BSF_EXPORT
,
2569 if (s
!= (asection
*)NULL
) {
2570 def
->value
= s
->vma
+ s
->_raw_size
;
2579 DEFUN(lang_statement_append
,(list
, element
, field
),
2580 lang_statement_list_type
*list AND
2581 lang_statement_union_type
*element AND
2582 lang_statement_union_type
**field
)
2584 *(list
->tail
) = element
;
2588 /* Set the output format type */
2590 DEFUN(lang_add_output_format
,(format
),
2593 output_target
= format
;