1 /* Linker command language support.
2 Copyright 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GLD, the Gnu Linker.
6 GLD is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 1, or (at your option)
11 GLD is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GLD; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
37 #define SHORT_SIZE (2)
41 static void print_statements
PARAMS ((void));
42 static void print_statement
PARAMS ((lang_statement_union_type
*,
43 lang_output_section_statement_type
*));
44 static lang_statement_union_type
*new_statement
PARAMS ((enum statement_enum
,
46 lang_statement_list_type
*));
50 static struct obstack stat_obstack
;
52 #define obstack_chunk_alloc ldmalloc
53 #define obstack_chunk_free free
54 static CONST
char *startup_file
;
55 static lang_statement_list_type input_file_chain
;
57 /* Points to the last statement in the .data section, so we can add
58 stuff to the data section without pain */
59 static lang_statement_list_type end_of_data_section_statement_list
;
61 /* List of statements needed to handle constructors */
62 extern lang_statement_list_type constructor_list
;
64 static boolean placed_commons
= false;
65 static lang_output_section_statement_type
*default_common_section
;
66 static boolean map_option_f
;
67 static bfd_vma print_dot
;
68 static lang_input_statement_type
*first_file
;
69 static lang_statement_list_type lang_output_section_statement
;
70 static CONST
char *current_target
;
71 static CONST
char *output_target
;
72 static size_t longest_section_name
= 8;
73 static section_userdata_type common_section_userdata
;
74 static lang_statement_list_type statement_list
;
78 lang_output_section_statement_type
*abs_output_section
;
79 lang_statement_list_type
*stat_ptr
= &statement_list
;
80 lang_input_statement_type
*script_file
= 0;
81 lang_statement_list_type file_chain
=
83 CONST
char *entry_symbol
= 0;
84 bfd_size_type largest_section
= 0;
85 boolean lang_has_input_file
= false;
86 lang_output_section_statement_type
*create_object_symbols
= 0;
87 boolean had_output_filename
= false;
88 boolean lang_float_flag
= false;
91 extern char *default_target
;
93 extern char *current_file
;
94 extern bfd
*output_bfd
;
95 extern enum bfd_architecture ldfile_output_architecture
;
96 extern unsigned long ldfile_output_machine
;
97 extern char *ldfile_output_machine_name
;
98 extern ldsym_type
*symbol_head
;
99 extern unsigned int commons_pending
;
100 extern args_type command_line
;
101 extern ld_config_type config
;
102 extern boolean write_map
;
103 extern int g_switch_value
;
106 etree_type
*base
; /* Relocation base - or null */
110 #define cat(a,b) a##b
112 #define cat(a,b) a/**/b
115 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
117 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
119 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
121 void lang_add_data
PARAMS ((int type
, union etree_union
* exp
));
127 return obstack_alloc (&stat_obstack
, size
);
133 fprintf (config
.map_file
, "%5x", (unsigned) value
);
136 print_alignment (value
)
139 fprintf (config
.map_file
, "2**%1u", value
);
142 DEFUN (print_fill
, (value
),
145 fprintf (config
.map_file
, "%04x", (unsigned) value
);
151 CONST
char *CONST name
;
153 fprintf (config
.map_file
, "%*s", -longest_section_name
, name
);
156 /*----------------------------------------------------------------------
157 lang_for_each_statement walks the parse tree and calls the provided
158 function for each node
162 lang_for_each_statement_worker (func
, s
)
164 lang_statement_union_type
*s
;
166 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
170 switch (s
->header
.type
)
172 case lang_constructors_statement_enum
:
173 lang_for_each_statement_worker (func
, constructor_list
.head
);
175 case lang_output_section_statement_enum
:
176 lang_for_each_statement_worker
178 s
->output_section_statement
.children
.head
);
180 case lang_wild_statement_enum
:
181 lang_for_each_statement_worker
183 s
->wild_statement
.children
.head
);
185 case lang_data_statement_enum
:
186 case lang_object_symbols_statement_enum
:
187 case lang_output_statement_enum
:
188 case lang_target_statement_enum
:
189 case lang_input_section_enum
:
190 case lang_input_statement_enum
:
191 case lang_assignment_statement_enum
:
192 case lang_padding_statement_enum
:
193 case lang_address_statement_enum
:
203 lang_for_each_statement (func
)
206 lang_for_each_statement_worker (func
,
207 statement_list
.head
);
210 /*----------------------------------------------------------------------*/
212 lang_list_init (list
)
213 lang_statement_list_type
*list
;
215 list
->head
= (lang_statement_union_type
*) NULL
;
216 list
->tail
= &list
->head
;
219 /*----------------------------------------------------------------------
221 build a new statement node for the parse tree
226 lang_statement_union_type
*
227 new_statement (type
, size
, list
)
228 enum statement_enum type
;
230 lang_statement_list_type
* list
;
232 lang_statement_union_type
*new = (lang_statement_union_type
*)
235 new->header
.type
= type
;
236 new->header
.next
= (lang_statement_union_type
*) NULL
;
237 lang_statement_append (list
, new, &new->header
.next
);
242 Build a new input file node for the language. There are several ways
243 in which we treat an input file, eg, we only look at symbols, or
244 prefix it with a -l etc.
246 We can be supplied with requests for input files more than once;
247 they may, for example be split over serveral lines like foo.o(.text)
248 foo.o(.data) etc, so when asked for a file we check that we havn't
249 got it already so we don't duplicate the bfd.
252 static lang_input_statement_type
*
253 new_afile (name
, file_type
, target
)
254 CONST
char *CONST name
;
255 CONST lang_input_file_enum_type file_type
;
256 CONST
char *CONST target
;
259 lang_input_statement_type
*p
= new_stat (lang_input_statement
,
262 lang_has_input_file
= true;
264 p
->complained
= false;
267 case lang_input_file_is_symbols_only_enum
:
269 p
->is_archive
= false;
271 p
->local_sym_name
= name
;
272 p
->just_syms_flag
= true;
273 p
->search_dirs_flag
= false;
275 case lang_input_file_is_fake_enum
:
277 p
->is_archive
= false;
279 p
->local_sym_name
= name
;
280 p
->just_syms_flag
= false;
281 p
->search_dirs_flag
= false;
283 case lang_input_file_is_l_enum
:
284 p
->is_archive
= true;
287 p
->local_sym_name
= concat ("-l", name
, "");
288 p
->just_syms_flag
= false;
289 p
->search_dirs_flag
= true;
291 case lang_input_file_is_search_file_enum
:
292 case lang_input_file_is_marker_enum
:
294 p
->is_archive
= false;
296 p
->local_sym_name
= name
;
297 p
->just_syms_flag
= false;
298 p
->search_dirs_flag
= true;
300 case lang_input_file_is_file_enum
:
302 p
->is_archive
= false;
304 p
->local_sym_name
= name
;
305 p
->just_syms_flag
= false;
306 p
->search_dirs_flag
= false;
311 p
->asymbols
= (asymbol
**) NULL
;
312 p
->superfile
= (lang_input_statement_type
*) NULL
;
313 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
314 p
->next
= (lang_statement_union_type
*) NULL
;
316 p
->common_output_section
= (asection
*) NULL
;
317 lang_statement_append (&input_file_chain
,
318 (lang_statement_union_type
*) p
,
323 lang_input_statement_type
*
324 lang_add_input_file (name
, file_type
, target
)
326 lang_input_file_enum_type file_type
;
329 /* Look it up or build a new one */
330 lang_has_input_file
= true;
332 lang_input_statement_type
*p
;
334 for (p
= (lang_input_statement_type
*) input_file_chain
.head
;
335 p
!= (lang_input_statement_type
*) NULL
;
336 p
= (lang_input_statement_type
*) (p
->next_real_file
))
338 /* Sometimes we have incomplete entries in here */
339 if (p
->filename
!= (char *) NULL
)
341 if (strcmp (name
, p
->filename
) == 0)
347 return new_afile (name
, file_type
, target
);
351 lang_add_keepsyms_file (filename
)
352 CONST
char *filename
;
354 extern strip_symbols_type strip_symbols
;
355 if (keepsyms_file
!= 0)
356 info ("%X%P: error: duplicated keep-symbols-file value\n");
357 keepsyms_file
= filename
;
358 if (strip_symbols
!= STRIP_NONE
)
359 info ("%P: `-keep-only-symbols-file' overrides `-s' and `-S'\n");
360 strip_symbols
= STRIP_SOME
;
363 /* Build enough state so that the parser can build its tree */
367 obstack_begin (&stat_obstack
, 1000);
369 stat_ptr
= &statement_list
;
371 lang_list_init (stat_ptr
);
373 lang_list_init (&input_file_chain
);
374 lang_list_init (&lang_output_section_statement
);
375 lang_list_init (&file_chain
);
376 first_file
= lang_add_input_file ((char *) NULL
,
377 lang_input_file_is_marker_enum
,
379 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
381 abs_output_section
->bfd_section
= &bfd_abs_section
;
385 /*----------------------------------------------------------------------
386 A region is an area of memory declared with the
387 MEMORY { name:org=exp, len=exp ... }
390 We maintain a list of all the regions here
392 If no regions are specified in the script, then the default is used
393 which is created when looked up to be the entire data space
396 static lang_memory_region_type
*lang_memory_region_list
;
397 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
399 lang_memory_region_type
*
400 lang_memory_region_lookup (name
)
401 CONST
char *CONST name
;
404 lang_memory_region_type
*p
= lang_memory_region_list
;
406 for (p
= lang_memory_region_list
;
407 p
!= (lang_memory_region_type
*) NULL
;
410 if (strcmp (p
->name
, name
) == 0)
415 if (strcmp (name
, "*default*") == 0)
417 /* This is the default region, dig out first one on the list */
418 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
420 return lang_memory_region_list
;
424 lang_memory_region_type
*new =
425 (lang_memory_region_type
*) stat_alloc ((bfd_size_type
) (sizeof (lang_memory_region_type
)));
427 new->name
= buystring (name
);
428 new->next
= (lang_memory_region_type
*) NULL
;
430 *lang_memory_region_list_tail
= new;
431 lang_memory_region_list_tail
= &new->next
;
433 new->length
= ~(bfd_size_type
)0;
435 new->had_full_message
= false;
442 lang_output_section_statement_type
*
443 lang_output_section_find (name
)
444 CONST
char *CONST name
;
446 lang_statement_union_type
*u
;
447 lang_output_section_statement_type
*lookup
;
449 for (u
= lang_output_section_statement
.head
;
450 u
!= (lang_statement_union_type
*) NULL
;
453 lookup
= &u
->output_section_statement
;
454 if (strcmp (name
, lookup
->name
) == 0)
459 return (lang_output_section_statement_type
*) NULL
;
462 lang_output_section_statement_type
*
463 lang_output_section_statement_lookup (name
)
464 CONST
char *CONST name
;
466 lang_output_section_statement_type
*lookup
;
468 lookup
= lang_output_section_find (name
);
469 if (lookup
== (lang_output_section_statement_type
*) NULL
)
472 lookup
= (lang_output_section_statement_type
*)
473 new_stat (lang_output_section_statement
, stat_ptr
);
474 lookup
->region
= (lang_memory_region_type
*) NULL
;
476 lookup
->block_value
= 1;
479 lookup
->next
= (lang_statement_union_type
*) NULL
;
480 lookup
->bfd_section
= (asection
*) NULL
;
481 lookup
->processed
= false;
482 lookup
->loadable
= 1;
483 lookup
->addr_tree
= (etree_type
*) NULL
;
484 lang_list_init (&lookup
->children
);
486 lookup
->memspec
= (CONST
char *) NULL
;
488 lookup
->subsection_alignment
= -1;
489 lookup
->section_alignment
= -1;
490 lookup
->load_base
= (union etree_union
*) NULL
;
492 lang_statement_append (&lang_output_section_statement
,
493 (lang_statement_union_type
*) lookup
,
501 print_flags (ignore_flags
)
504 fprintf (config
.map_file
, "(");
506 if (flags
->flag_read
)
507 fprintf (outfile
, "R");
508 if (flags
->flag_write
)
509 fprintf (outfile
, "W");
510 if (flags
->flag_executable
)
511 fprintf (outfile
, "X");
512 if (flags
->flag_loadable
)
513 fprintf (outfile
, "L");
515 fprintf (config
.map_file
, ")");
521 lang_memory_region_type
*m
;
523 fprintf (config
.map_file
, "**MEMORY CONFIGURATION**\n\n");
525 fprintf (config
.map_file
, "name\t\torigin\t\tlength\t\tattributes\n");
527 fprintf (config
.map_file
,
528 "name\t\torigin length r_size c_size is attributes\n");
531 for (m
= lang_memory_region_list
;
532 m
!= (lang_memory_region_type
*) NULL
;
535 fprintf (config
.map_file
, "%-16s", m
->name
);
536 print_address (m
->origin
);
538 print_address ((bfd_vma
)m
->length
);
540 print_address ((bfd_vma
)m
->old_length
);
542 print_address (m
->current
- m
->origin
);
545 fprintf(config
.map_file
," %2d%% ", ( m
->current
- m
->origin
) * 100 / m
->old_length
);
546 print_flags (&m
->flags
);
547 fprintf (config
.map_file
, "\n");
549 fprintf (config
.map_file
, "\n\n**LINK EDITOR MEMORY MAP**\n\n");
550 fprintf (config
.map_file
, "output input virtual\n");
551 fprintf (config
.map_file
, "section section address tsize\n\n");
562 lang_output_section_statement_type
* s
;
564 /* asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
565 section_userdata_type
*new =
566 (section_userdata_type
*)
567 stat_alloc ((bfd_size_type
) (sizeof (section_userdata_type
)));
569 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
570 if (s
->bfd_section
== (asection
*) NULL
)
571 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
572 if (s
->bfd_section
== (asection
*) NULL
)
574 einfo ("%P%F: output format %s cannot represent section called %s\n",
575 output_bfd
->xvec
->name
, s
->name
);
577 s
->bfd_section
->output_section
= s
->bfd_section
;
578 /* s->bfd_section->flags = s->flags;*/
580 /* We initialize an output sections output offset to minus its own */
581 /* vma to allow us to output a section through itself */
582 s
->bfd_section
->output_offset
= 0;
583 get_userdata (s
->bfd_section
) = (PTR
) new;
587 /***********************************************************************
590 These expand statements like *(.text) and foo.o to a list of
591 explicit actions, like foo.o(.text), bar.o(.text) and
594 The toplevel routine, wild, takes a statement, section, file and
595 target. If either the section or file is null it is taken to be the
596 wildcard. Seperate lang_input_section statements are created for
597 each part of the expanstion, and placed after the statement provided.
602 wild_doit (ptr
, section
, output
, file
)
603 lang_statement_list_type
* ptr
;
605 lang_output_section_statement_type
* output
;
606 lang_input_statement_type
* file
;
608 if (output
->bfd_section
== (asection
*) NULL
)
611 /* Initialize the vma and size to the existing section. This will
612 be overriden in lang_size_sections unless SEC_NEVER_LOAD gets
614 if (section
!= (asection
*) NULL
)
616 bfd_set_section_vma (0, output
->bfd_section
,
617 bfd_section_vma (0, section
));
618 output
->bfd_section
->_raw_size
= section
->_raw_size
;
622 if (section
!= (asection
*) NULL
623 && section
->output_section
== (asection
*) NULL
)
625 /* Add a section reference to the list */
626 lang_input_section_type
*new = new_stat (lang_input_section
, ptr
);
628 new->section
= section
;
630 section
->output_section
= output
->bfd_section
;
632 /* Be selective about what the output section inherits from the
635 if ((section
->flags
& SEC_SHARED_LIBRARY
) != 0)
636 section
->output_section
->flags
|= section
->flags
;
638 section
->output_section
->flags
|= section
->flags
& ~SEC_NEVER_LOAD
;
640 if (!output
->loadable
)
642 /* Turn off load flag */
643 output
->bfd_section
->flags
&= ~SEC_LOAD
;
644 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
646 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
648 output
->bfd_section
->alignment_power
= section
->alignment_power
;
650 /* If supplied an aligmnet, then force it */
651 if (output
->section_alignment
!= -1)
653 output
->bfd_section
->alignment_power
= output
->section_alignment
;
659 our_bfd_get_section_by_name (abfd
, section
)
663 return bfd_get_section_by_name (abfd
, section
);
667 wild_section (ptr
, section
, file
, output
)
668 lang_wild_statement_type
* ptr
;
670 lang_input_statement_type
* file
;
671 lang_output_section_statement_type
* output
;
675 if (file
->just_syms_flag
== false)
677 if (section
== (char *) NULL
)
679 /* Do the creation to all sections in the file */
680 for (s
= file
->the_bfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
683 if ((s
->flags
& SEC_IS_COMMON
) == 0)
685 wild_doit (&ptr
->children
, s
, output
, file
);
691 /* Do the creation to the named section only */
692 wild_doit (&ptr
->children
,
693 our_bfd_get_section_by_name (file
->the_bfd
, section
),
699 /* passed a file name (which must have been seen already and added to
700 the statement tree. We will see if it has been opened already and
701 had its symbols read. If not then we'll read it.
703 Archives are pecuilar here. We may open them once, but if they do
704 not define anything we need at the time, they won't have all their
705 symbols read. If we need them later, we'll have to redo it.
708 lang_input_statement_type
*
710 CONST
char *CONST name
;
712 lang_input_statement_type
*search
;
714 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
715 search
!= (lang_input_statement_type
*) NULL
;
716 search
= (lang_input_statement_type
*) search
->next_real_file
)
718 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
722 if (search
->filename
!= (char *) NULL
&& name
!= (char *) NULL
)
724 if (strcmp (search
->filename
, name
) == 0)
726 ldmain_open_file_read_symbol (search
);
732 /* There isn't an afile entry for this file yet, this must be
733 because the name has only appeared inside a load script and not
734 on the command line */
735 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
);
736 ldmain_open_file_read_symbol (search
);
743 wild (s
, section
, file
, target
, output
)
744 lang_wild_statement_type
* s
;
745 CONST
char *CONST section
;
746 CONST
char *CONST file
;
747 CONST
char *CONST target
;
748 lang_output_section_statement_type
* output
;
750 lang_input_statement_type
*f
;
752 if (file
== (char *) NULL
)
754 /* Perform the iteration over all files in the list */
755 for (f
= (lang_input_statement_type
*) file_chain
.head
;
756 f
!= (lang_input_statement_type
*) NULL
;
757 f
= (lang_input_statement_type
*) f
->next
)
759 wild_section (s
, section
, f
, output
);
761 /* Once more for the script file */
762 wild_section(s
, section
, script_file
, output
);
766 /* Perform the iteration over a single file */
767 wild_section (s
, section
, lookup_name (file
), output
);
769 if (section
!= (char *) NULL
770 && strcmp (section
, "COMMON") == 0
771 && default_common_section
== (lang_output_section_statement_type
*) NULL
)
773 /* Remember the section that common is going to incase we later
774 get something which doesn't know where to put it */
775 default_common_section
= output
;
780 read in all the files
784 CONST
char *CONST name
;
786 extern unsigned long ldfile_output_machine
;
787 extern enum bfd_architecture ldfile_output_architecture
;
789 extern CONST
char *output_filename
;
792 if (output_target
== (char *) NULL
)
794 if (current_target
!= (char *) NULL
)
795 output_target
= current_target
;
797 output_target
= default_target
;
799 output
= bfd_openw (name
, output_target
);
800 output_filename
= name
;
802 if (output
== (bfd
*) NULL
)
804 if (bfd_error
== invalid_target
)
806 einfo ("%P%F: target %s not found\n", output_target
);
808 einfo ("%P%F: cannot open output file %s: %E\n", name
);
811 /* output->flags |= D_PAGED;*/
813 if (! bfd_set_format (output
, bfd_object
))
814 einfo ("%P%F:%s: can not make object file: %E\n", name
);
815 if (! bfd_set_arch_mach (output
,
816 ldfile_output_architecture
,
817 ldfile_output_machine
))
818 einfo ("%P%F:%s: can not set architecture: %E\n", name
);
820 bfd_set_gp_size (output
, g_switch_value
);
828 ldlang_open_output (statement
)
829 lang_statement_union_type
* statement
;
831 switch (statement
->header
.type
)
833 case lang_output_statement_enum
:
834 output_bfd
= open_output (statement
->output_statement
.name
);
835 ldemul_set_output_arch ();
836 if (config
.magic_demand_paged
&& !config
.relocateable_output
)
837 output_bfd
->flags
|= D_PAGED
;
839 output_bfd
->flags
&= ~D_PAGED
;
840 if (config
.text_read_only
)
841 output_bfd
->flags
|= WP_TEXT
;
843 output_bfd
->flags
&= ~WP_TEXT
;
846 case lang_target_statement_enum
:
847 current_target
= statement
->target_statement
.target
;
855 open_input_bfds (statement
)
856 lang_statement_union_type
* statement
;
858 switch (statement
->header
.type
)
860 case lang_target_statement_enum
:
861 current_target
= statement
->target_statement
.target
;
863 case lang_wild_statement_enum
:
864 /* Maybe we should load the file's symbols */
865 if (statement
->wild_statement
.filename
)
867 (void) lookup_name (statement
->wild_statement
.filename
);
870 case lang_input_statement_enum
:
871 if (statement
->input_statement
.real
== true)
873 statement
->input_statement
.target
= current_target
;
874 lookup_name (statement
->input_statement
.filename
);
882 /* If there are [COMMONS] statements, put a wild one into the bss section */
885 lang_reasonable_defaults ()
891 lang_output_section_statement_lookup (".text");
892 lang_output_section_statement_lookup (".data");
894 default_common_section
=
895 lang_output_section_statement_lookup (".bss");
898 if (placed_commons
== false)
900 lang_wild_statement_type
*new =
901 new_stat (lang_wild_statement
,
902 &default_common_section
->children
);
904 new->section_name
= "COMMON";
905 new->filename
= (char *) NULL
;
906 lang_list_init (&new->children
);
913 Add the supplied name to the symbol table as an undefined reference.
914 Remove items from the chain as we open input bfds
916 typedef struct ldlang_undef_chain_list
918 struct ldlang_undef_chain_list
*next
;
920 } ldlang_undef_chain_list_type
;
922 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
925 ldlang_add_undef (name
)
926 CONST
char *CONST name
;
928 ldlang_undef_chain_list_type
*new =
929 (ldlang_undef_chain_list_type
930 *) stat_alloc ((bfd_size_type
) (sizeof (ldlang_undef_chain_list_type
)));
932 new->next
= ldlang_undef_chain_list_head
;
933 ldlang_undef_chain_list_head
= new;
935 new->name
= buystring (name
);
938 /* Run through the list of undefineds created above and place them
939 into the linker hash table as undefined symbols belonging to the
943 lang_place_undefineds ()
945 ldlang_undef_chain_list_type
*ptr
= ldlang_undef_chain_list_head
;
947 while (ptr
!= (ldlang_undef_chain_list_type
*) NULL
)
950 asymbol
**def_ptr
= (asymbol
**) stat_alloc ((bfd_size_type
) (sizeof (asymbol
**)));
952 def
= (asymbol
*) bfd_make_empty_symbol (script_file
->the_bfd
);
954 def
->name
= ptr
->name
;
955 def
->section
= &bfd_und_section
;
956 enter_global_ref (def_ptr
, ptr
->name
);
961 /* Copy important data from out internal form to the bfd way. Also
962 create a section for the dummy file
966 lang_create_output_section_statements ()
968 lang_statement_union_type
*os
;
970 for (os
= lang_output_section_statement
.head
;
971 os
!= (lang_statement_union_type
*) NULL
;
972 os
= os
->output_section_statement
.next
)
974 lang_output_section_statement_type
*s
=
975 &os
->output_section_statement
;
983 lang_init_script_file ()
985 script_file
= lang_add_input_file ("command line",
986 lang_input_file_is_fake_enum
,
988 script_file
->the_bfd
= bfd_create ("command line", output_bfd
);
989 script_file
->symbol_count
= 0;
990 script_file
->the_bfd
->sections
= 0;
992 /* The user data of a bfd points to the input statement attatched */
993 script_file
->the_bfd
->usrdata
= (void *)script_file
;
994 script_file
->common_section
=
995 bfd_make_section(script_file
->the_bfd
,"COMMON");
998 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
1000 abs_output_section
->bfd_section
= &bfd_abs_section
;
1004 /* Open input files and attatch to output sections */
1006 map_input_to_output_sections (s
, target
, output_section_statement
)
1007 lang_statement_union_type
* s
;
1009 lang_output_section_statement_type
* output_section_statement
;
1011 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1013 switch (s
->header
.type
)
1017 case lang_wild_statement_enum
:
1018 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1019 s
->wild_statement
.filename
, target
,
1020 output_section_statement
);
1023 case lang_constructors_statement_enum
:
1024 map_input_to_output_sections (constructor_list
.head
,
1026 output_section_statement
);
1028 case lang_output_section_statement_enum
:
1029 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1031 &s
->output_section_statement
);
1033 case lang_output_statement_enum
:
1035 case lang_target_statement_enum
:
1036 target
= s
->target_statement
.target
;
1038 case lang_fill_statement_enum
:
1039 case lang_input_section_enum
:
1040 case lang_object_symbols_statement_enum
:
1041 case lang_data_statement_enum
:
1042 case lang_assignment_statement_enum
:
1043 case lang_padding_statement_enum
:
1045 case lang_afile_asection_pair_statement_enum
:
1048 case lang_address_statement_enum
:
1049 /* Mark the specified section with the supplied address */
1051 lang_output_section_statement_type
*os
=
1052 lang_output_section_statement_lookup
1053 (s
->address_statement
.section_name
);
1055 os
->addr_tree
= s
->address_statement
.address
;
1056 if (os
->bfd_section
== (asection
*) NULL
)
1058 einfo ("%P%F: cannot set the address of undefined section %s\n",
1059 s
->address_statement
.section_name
);
1063 case lang_input_statement_enum
:
1064 /* A standard input statement, has no wildcards */
1065 /* ldmain_open_file_read_symbol(&s->input_statement);*/
1076 print_output_section_statement (output_section_statement
)
1077 lang_output_section_statement_type
* output_section_statement
;
1079 asection
*section
= output_section_statement
->bfd_section
;
1082 print_section (output_section_statement
->name
);
1087 print_dot
= section
->vma
;
1091 print_address (section
->vma
);
1093 print_size (section
->_raw_size
);
1095 print_size(section
->_cooked_size
);
1097 print_alignment (section
->alignment_power
);
1100 fprintf (config
.map_file
, "%s flags", output_section_statement
->region
->name
);
1101 print_flags (stdout
, &output_section_statement
->flags
);
1103 if (section
->flags
& SEC_LOAD
)
1104 fprintf (config
.map_file
, "load ");
1105 if (section
->flags
& SEC_ALLOC
)
1106 fprintf (config
.map_file
, "alloc ");
1107 if (section
->flags
& SEC_RELOC
)
1108 fprintf (config
.map_file
, "reloc ");
1109 if (section
->flags
& SEC_HAS_CONTENTS
)
1110 fprintf (config
.map_file
, "contents ");
1115 fprintf (config
.map_file
, "No attached output section");
1118 if (output_section_statement
->load_base
)
1120 int b
= exp_get_value_int(output_section_statement
->load_base
,
1121 0, "output base", lang_final_phase_enum
);
1122 printf("Output address %08x\n", b
);
1124 if (output_section_statement
->section_alignment
>= 0
1125 || output_section_statement
->section_alignment
>= 0)
1127 printf("\t\t\t\t\tforced alignment ");
1128 if ( output_section_statement
->section_alignment
>= 0)
1130 printf("section 2**%d ",output_section_statement
->section_alignment
);
1132 if ( output_section_statement
->subsection_alignment
>= 0)
1134 printf("subsection 2**%d ",output_section_statement
->subsection_alignment
);
1139 print_statement (output_section_statement
->children
.head
,
1140 output_section_statement
);
1145 print_assignment (assignment
, output_section
)
1146 lang_assignment_statement_type
* assignment
;
1147 lang_output_section_statement_type
* output_section
;
1149 etree_value_type result
;
1155 print_address (print_dot
);
1157 result
= exp_fold_tree (assignment
->exp
->assign
.src
,
1159 lang_final_phase_enum
,
1165 print_address (result
.value
);
1169 fprintf (config
.map_file
, "*undefined*");
1172 exp_print_tree (assignment
->exp
);
1174 fprintf (config
.map_file
, "\n");
1178 print_input_statement (statm
)
1179 lang_input_statement_type
* statm
;
1181 if (statm
->filename
!= (char *) NULL
)
1183 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1192 fprintf (config
.map_file
, " ");
1194 fprintf (config
.map_file
, " ");
1195 print_address (outside_symbol_address (q
));
1196 fprintf (config
.map_file
, " %s", q
->name
? q
->name
: " ");
1201 print_input_section (in
)
1202 lang_input_section_type
* in
;
1204 asection
*i
= in
->section
;
1205 int size
= i
->reloc_done
?
1206 bfd_get_section_size_after_reloc (i
) :
1207 bfd_get_section_size_before_reloc (i
);
1212 fprintf (config
.map_file
, " ");
1213 print_section (i
->name
);
1214 fprintf (config
.map_file
, " ");
1215 if (i
->output_section
)
1217 print_address (i
->output_section
->vma
+ i
->output_offset
);
1218 fprintf (config
.map_file
, " ");
1219 print_size (i
->_raw_size
);
1220 fprintf (config
.map_file
, " ");
1221 print_size(i
->_cooked_size
);
1222 fprintf (config
.map_file
, " ");
1223 print_alignment (i
->alignment_power
);
1224 fprintf (config
.map_file
, " ");
1228 bfd
*abfd
= in
->ifile
->the_bfd
;
1230 if (in
->ifile
->just_syms_flag
== true)
1232 fprintf (config
.map_file
, "symbols only ");
1235 fprintf (config
.map_file
, " %s ", abfd
->xvec
->name
);
1236 if (abfd
->my_archive
!= (bfd
*) NULL
)
1238 fprintf (config
.map_file
, "[%s]%s", abfd
->my_archive
->filename
,
1243 fprintf (config
.map_file
, "%s", abfd
->filename
);
1245 fprintf (config
.map_file
, "(overhead %d bytes)", (int) bfd_alloc_size (abfd
));
1248 /* Find all the symbols in this file defined in this section */
1250 if (in
->ifile
->symbol_count
)
1254 for (p
= in
->ifile
->asymbols
; *p
; p
++)
1258 if (bfd_get_section (q
) == i
&& q
->flags
& BSF_GLOBAL
)
1271 print_dot
= outside_section_address (i
) + size
;
1275 fprintf (config
.map_file
, "No output section allocated\n");
1281 print_fill_statement (fill
)
1282 lang_fill_statement_type
* fill
;
1284 fprintf (config
.map_file
, "FILL mask ");
1285 print_fill (fill
->fill
);
1289 print_data_statement (data
)
1290 lang_data_statement_type
* data
;
1292 /* bfd_vma value; */
1297 /* ASSERT(print_dot == data->output_vma);*/
1299 print_address (data
->output_vma
+ data
->output_section
->vma
);
1301 print_address (data
->value
);
1306 fprintf (config
.map_file
, "BYTE ");
1307 print_dot
+= BYTE_SIZE
;
1310 fprintf (config
.map_file
, "SHORT ");
1311 print_dot
+= SHORT_SIZE
;
1314 fprintf (config
.map_file
, "LONG ");
1315 print_dot
+= LONG_SIZE
;
1319 exp_print_tree (data
->exp
);
1321 fprintf (config
.map_file
, "\n");
1326 print_padding_statement (s
)
1327 lang_padding_statement_type
* s
;
1331 print_section ("*fill*");
1333 print_address (s
->output_offset
+ s
->output_section
->vma
);
1335 print_size (s
->size
);
1337 print_fill (s
->fill
);
1340 print_dot
= s
->output_offset
+ s
->output_section
->vma
+ s
->size
;
1345 print_wild_statement (w
, os
)
1346 lang_wild_statement_type
* w
;
1347 lang_output_section_statement_type
* os
;
1349 fprintf (config
.map_file
, " from ");
1350 if (w
->filename
!= (char *) NULL
)
1352 fprintf (config
.map_file
, "%s", w
->filename
);
1356 fprintf (config
.map_file
, "*");
1358 if (w
->section_name
!= (char *) NULL
)
1360 fprintf (config
.map_file
, "(%s)", w
->section_name
);
1364 fprintf (config
.map_file
, "(*)");
1367 print_statement (w
->children
.head
, os
);
1371 print_statement (s
, os
)
1372 lang_statement_union_type
* s
;
1373 lang_output_section_statement_type
* os
;
1377 switch (s
->header
.type
)
1379 case lang_constructors_statement_enum
:
1380 fprintf (config
.map_file
, "constructors:\n");
1381 print_statement (constructor_list
.head
, os
);
1383 case lang_wild_statement_enum
:
1384 print_wild_statement (&s
->wild_statement
, os
);
1387 fprintf (config
.map_file
, "Fail with %d\n", s
->header
.type
);
1390 case lang_address_statement_enum
:
1391 fprintf (config
.map_file
, "address\n");
1393 case lang_object_symbols_statement_enum
:
1394 fprintf (config
.map_file
, "object symbols\n");
1396 case lang_fill_statement_enum
:
1397 print_fill_statement (&s
->fill_statement
);
1399 case lang_data_statement_enum
:
1400 print_data_statement (&s
->data_statement
);
1402 case lang_input_section_enum
:
1403 print_input_section (&s
->input_section
);
1405 case lang_padding_statement_enum
:
1406 print_padding_statement (&s
->padding_statement
);
1408 case lang_output_section_statement_enum
:
1409 print_output_section_statement (&s
->output_section_statement
);
1411 case lang_assignment_statement_enum
:
1412 print_assignment (&s
->assignment_statement
,
1415 case lang_target_statement_enum
:
1416 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1418 case lang_output_statement_enum
:
1419 fprintf (config
.map_file
, "OUTPUT(%s %s)\n",
1420 s
->output_statement
.name
,
1421 output_target
? output_target
: "");
1423 case lang_input_statement_enum
:
1424 print_input_statement (&s
->input_statement
);
1426 case lang_afile_asection_pair_statement_enum
:
1438 print_statement (statement_list
.head
,
1439 abs_output_section
);
1444 DEFUN (insert_pad
, (this_ptr
, fill
, power
, output_section_statement
, dot
),
1445 lang_statement_union_type
** this_ptr AND
1447 unsigned int power AND
1448 asection
* output_section_statement AND
1451 /* Align this section first to the
1452 input sections requirement, then
1453 to the output section's requirement.
1454 If this alignment is > than any seen before,
1455 then record it too. Perform the alignment by
1456 inserting a magic 'padding' statement.
1459 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
1461 if (alignment_needed
!= 0)
1463 lang_statement_union_type
*new =
1464 (lang_statement_union_type
*)
1465 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1467 /* Link into existing chain */
1468 new->header
.next
= *this_ptr
;
1470 new->header
.type
= lang_padding_statement_enum
;
1471 new->padding_statement
.output_section
= output_section_statement
;
1472 new->padding_statement
.output_offset
=
1473 dot
- output_section_statement
->vma
;
1474 new->padding_statement
.fill
= fill
;
1475 new->padding_statement
.size
= alignment_needed
;
1479 /* Remember the most restrictive alignment */
1480 if (power
> output_section_statement
->alignment_power
)
1482 output_section_statement
->alignment_power
= power
;
1484 output_section_statement
->_raw_size
+= alignment_needed
;
1485 return alignment_needed
+ dot
;
1489 /* Work out how much this section will move the dot point */
1491 DEFUN (size_input_section
, (this_ptr
, output_section_statement
, fill
, dot
, relax
),
1492 lang_statement_union_type
** this_ptr AND
1493 lang_output_section_statement_type
* output_section_statement AND
1494 unsigned short fill AND
1498 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1499 asection
*i
= is
->section
;
1501 if (is
->ifile
->just_syms_flag
== false)
1503 if (output_section_statement
->subsection_alignment
!= -1)
1504 i
->alignment_power
=
1505 output_section_statement
->subsection_alignment
;
1507 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
1508 output_section_statement
->bfd_section
, dot
);
1510 /* remember the largest size so we can malloc the largest area
1511 needed for the output stage. Only remember the size of sections
1512 which we will actually allocate */
1513 if ((i
->flags
& SEC_HAS_CONTENTS
) != 0
1514 && (bfd_get_section_size_before_reloc (i
) > largest_section
))
1516 largest_section
= bfd_get_section_size_before_reloc (i
);
1519 /* Remember where in the output section this input section goes */
1521 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1523 /* Mark how big the output section must be to contain this now
1527 dot
+= i
->_cooked_size
;
1531 dot
+= i
->_raw_size
;
1533 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
1537 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
1543 /* Sizing happens in two passes, first pass we allocate worst case
1544 stuff. The second pass (if relaxing), we use what we learnt to
1545 change the size of some relocs from worst case to better
1547 static boolean had_relax
;
1550 DEFUN (lang_size_sections
, (s
, output_section_statement
, prev
, fill
, dot
, relax
),
1551 lang_statement_union_type
* s AND
1552 lang_output_section_statement_type
* output_section_statement AND
1553 lang_statement_union_type
** prev AND
1554 unsigned short fill AND
1558 /* Size up the sections from their constituent parts */
1559 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1561 switch (s
->header
.type
)
1564 case lang_output_section_statement_enum
:
1567 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
1569 /* If this is a shared library section, don't change the size
1571 if (os
->bfd_section
->flags
& SEC_SHARED_LIBRARY
)
1574 if (os
->bfd_section
== &bfd_abs_section
)
1576 /* No matter what happens, an abs section starts at zero */
1577 bfd_set_section_vma (0, os
->bfd_section
, 0);
1581 if (os
->addr_tree
== (etree_type
*) NULL
)
1583 /* No address specified for this section, get one
1584 from the region specification
1586 if (os
->region
== (lang_memory_region_type
*) NULL
)
1588 os
->region
= lang_memory_region_lookup ("*default*");
1590 dot
= os
->region
->current
;
1596 r
= exp_fold_tree (os
->addr_tree
,
1598 lang_allocating_phase_enum
,
1600 if (r
.valid
== false)
1602 einfo ("%F%S: non constant address expression for section %s\n",
1607 /* The section starts here */
1608 /* First, align to what the section needs */
1611 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
1612 bfd_set_section_vma (0, os
->bfd_section
, dot
);
1614 if (os
->load_base
) {
1615 os
->bfd_section
->lma
1616 = exp_get_value_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
1621 os
->bfd_section
->output_offset
= 0;
1623 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
1624 os
->fill
, dot
, relax
);
1625 /* Ignore the size of the input sections, use the vma and size to */
1629 after
= ALIGN_N (os
->bfd_section
->vma
+
1630 os
->bfd_section
->_raw_size
,
1634 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
1635 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1636 os
->processed
= true;
1638 /* Replace into region ? */
1639 if (os
->addr_tree
== (etree_type
*) NULL
1640 && os
->region
!= (lang_memory_region_type
*) NULL
)
1642 os
->region
->current
= dot
;
1643 /* Make sure this isn't silly */
1644 if (( os
->region
->current
1645 > os
->region
->origin
+ os
->region
->length
)
1646 || ( os
->region
->origin
> os
->region
->current
))
1648 einfo ("%X%P: region %s is full (%B section %s)\n",
1650 os
->bfd_section
->owner
,
1651 os
->bfd_section
->name
);
1652 /* Reset the region pointer */
1653 os
->region
->current
= 0;
1661 case lang_constructors_statement_enum
:
1662 dot
= lang_size_sections (constructor_list
.head
,
1663 output_section_statement
,
1664 &s
->wild_statement
.children
.head
,
1669 case lang_data_statement_enum
:
1671 unsigned int size
= 0;
1673 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1674 s
->data_statement
.output_section
=
1675 output_section_statement
->bfd_section
;
1677 switch (s
->data_statement
.type
)
1691 output_section_statement
->bfd_section
->_raw_size
+= size
;
1695 case lang_wild_statement_enum
:
1697 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
1698 output_section_statement
,
1699 &s
->wild_statement
.children
.head
,
1705 case lang_object_symbols_statement_enum
:
1706 create_object_symbols
= output_section_statement
;
1708 case lang_output_statement_enum
:
1709 case lang_target_statement_enum
:
1711 case lang_input_section_enum
:
1716 if( relax_section (prev
))
1722 (*prev
)->input_section
.section
->_cooked_size
=
1723 (*prev
)->input_section
.section
->_raw_size
;
1726 dot
= size_input_section (prev
,
1727 output_section_statement
,
1728 output_section_statement
->fill
,
1731 case lang_input_statement_enum
:
1733 case lang_fill_statement_enum
:
1734 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
1736 fill
= s
->fill_statement
.fill
;
1738 case lang_assignment_statement_enum
:
1740 bfd_vma newdot
= dot
;
1742 exp_fold_tree (s
->assignment_statement
.exp
,
1743 output_section_statement
,
1744 lang_allocating_phase_enum
,
1748 if (newdot
!= dot
&& !relax
)
1749 /* We've been moved ! so insert a pad */
1751 lang_statement_union_type
*new =
1752 (lang_statement_union_type
*)
1753 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1755 /* Link into existing chain */
1756 new->header
.next
= *prev
;
1758 new->header
.type
= lang_padding_statement_enum
;
1759 new->padding_statement
.output_section
=
1760 output_section_statement
->bfd_section
;
1761 new->padding_statement
.output_offset
=
1762 dot
- output_section_statement
->bfd_section
->vma
;
1763 new->padding_statement
.fill
= fill
;
1764 new->padding_statement
.size
= newdot
- dot
;
1765 output_section_statement
->bfd_section
->_raw_size
+=
1766 new->padding_statement
.size
;
1775 /* This can only get here when relaxing is turned on */
1776 case lang_padding_statement_enum
:
1778 case lang_address_statement_enum
:
1781 prev
= &s
->header
.next
;
1787 DEFUN (lang_do_assignments
, (s
, output_section_statement
, fill
, dot
),
1788 lang_statement_union_type
* s AND
1789 lang_output_section_statement_type
* output_section_statement AND
1790 unsigned short fill AND
1794 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1796 switch (s
->header
.type
)
1798 case lang_constructors_statement_enum
:
1799 dot
= lang_do_assignments (constructor_list
.head
,
1800 output_section_statement
,
1805 case lang_output_section_statement_enum
:
1807 lang_output_section_statement_type
*os
=
1808 &(s
->output_section_statement
);
1810 dot
= os
->bfd_section
->vma
;
1811 (void) lang_do_assignments (os
->children
.head
, os
, os
->fill
, dot
);
1812 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1815 case lang_wild_statement_enum
:
1817 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
1818 output_section_statement
,
1823 case lang_object_symbols_statement_enum
:
1824 case lang_output_statement_enum
:
1825 case lang_target_statement_enum
:
1827 case lang_common_statement_enum
:
1830 case lang_data_statement_enum
:
1832 etree_value_type value
;
1834 value
= exp_fold_tree (s
->data_statement
.exp
,
1836 lang_final_phase_enum
, dot
, &dot
);
1837 s
->data_statement
.value
= value
.value
;
1838 if (value
.valid
== false)
1839 einfo ("%F%P: invalid data statement\n");
1841 switch (s
->data_statement
.type
)
1854 case lang_input_section_enum
:
1856 asection
*in
= s
->input_section
.section
;
1858 dot
+= bfd_get_section_size_before_reloc (in
);
1862 case lang_input_statement_enum
:
1864 case lang_fill_statement_enum
:
1865 fill
= s
->fill_statement
.fill
;
1867 case lang_assignment_statement_enum
:
1869 exp_fold_tree (s
->assignment_statement
.exp
,
1870 output_section_statement
,
1871 lang_final_phase_enum
,
1877 case lang_padding_statement_enum
:
1878 dot
+= s
->padding_statement
.size
;
1883 case lang_address_statement_enum
:
1894 lang_relocate_globals ()
1897 Each ldsym_type maintains a chain of pointers to asymbols which
1898 references the definition. Replace each pointer to the referenence
1899 with a pointer to only one place, preferably the definition. If
1900 the defintion isn't available then the common symbol, and if
1901 there isn't one of them then choose one reference.
1904 FOR_EACH_LDSYM (lgs
)
1908 /* Skip indirect symbols. */
1909 if (lgs
->flags
& SYM_INDIRECT
)
1912 if (lgs
->sdefs_chain
)
1914 it
= *(lgs
->sdefs_chain
);
1916 else if (lgs
->scoms_chain
!= (asymbol
**) NULL
)
1918 it
= *(lgs
->scoms_chain
);
1920 else if (lgs
->srefs_chain
!= (asymbol
**) NULL
)
1922 it
= *(lgs
->srefs_chain
);
1926 /* This can happen when the command line asked for a symbol to
1928 it
= (asymbol
*) NULL
;
1930 if (it
!= (asymbol
*) NULL
)
1933 asymbol
**ptr
= lgs
->srefs_chain
;;
1934 if (lgs
->flags
& SYM_WARNING
)
1936 produce_warnings (lgs
, it
);
1939 while (ptr
!= (asymbol
**) NULL
1942 asymbol
*ref
= *ptr
;
1945 ptr
= (asymbol
**) (ref
->udata
);
1957 int warn
= config
.relocateable_output
!= true;
1958 if (entry_symbol
== (char *) NULL
)
1960 /* No entry has been specified, look for start, but don't warn */
1961 entry_symbol
= "start";
1964 lgs
= ldsym_get_soft (entry_symbol
);
1965 if (lgs
&& lgs
->sdefs_chain
)
1967 asymbol
*sy
= *(lgs
->sdefs_chain
);
1969 /* We can set the entry address*/
1970 bfd_set_start_address (output_bfd
,
1971 outside_symbol_address (sy
));
1976 /* Cannot find anything reasonable,
1977 use the first address in the text section
1979 asection
*ts
= bfd_get_section_by_name (output_bfd
, ".text");
1983 einfo ("%P: warning: cannot find entry symbol %s, defaulting to %V\n",
1984 entry_symbol
, ts
->vma
);
1986 bfd_set_start_address (output_bfd
, ts
->vma
);
1991 einfo ("%P: warning: cannot find entry symbol %s, not setting start address\n",
1997 /* By now we know the target architecture, and we may have an */
1998 /* ldfile_output_machine_name */
2002 lang_statement_union_type
*file
;
2004 unsigned long input_machine
;
2005 enum bfd_architecture input_architecture
;
2006 CONST bfd_arch_info_type
*compatible
;
2008 for (file
= file_chain
.head
;
2009 file
!= (lang_statement_union_type
*) NULL
;
2010 file
= file
->input_statement
.next
)
2012 input_bfd
= file
->input_statement
.the_bfd
;
2014 input_machine
= bfd_get_mach (input_bfd
);
2015 input_architecture
= bfd_get_arch (input_bfd
);
2018 /* Inspect the architecture and ensure we're linking like with
2021 compatible
= bfd_arch_get_compatible (input_bfd
,
2026 ldfile_output_machine
= compatible
->mach
;
2027 ldfile_output_architecture
= compatible
->arch
;
2032 info ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2033 bfd_printable_name (input_bfd
), input_bfd
,
2034 bfd_printable_name (output_bfd
));
2036 if (! bfd_set_arch_mach (output_bfd
,
2039 einfo ("%P%F:%s: can't set architecture: %E\n",
2040 bfd_get_filename (output_bfd
));
2047 * run through all the global common symbols and tie them
2048 * to the output section requested.
2050 As an experiment we do this 4 times, once for all the byte sizes,
2051 then all the two bytes, all the four bytes and then everything else
2060 if (config
.relocateable_output
== false ||
2061 command_line
.force_common_definition
== true)
2063 for (power
= 1; (config
.sort_common
== true && power
== 1) || (power
<= 16); power
<<= 1)
2065 for (lgs
= symbol_head
;
2066 lgs
!= (ldsym_type
*) NULL
;
2070 unsigned int power_of_two
;
2074 if (lgs
->scoms_chain
!= (asymbol
**) NULL
)
2076 com
= *(lgs
->scoms_chain
);
2106 if (config
.sort_common
== false || align
== power
)
2110 /* Change from a common symbol into a definition of
2112 lgs
->sdefs_chain
= lgs
->scoms_chain
;
2113 lgs
->scoms_chain
= (asymbol
**) NULL
;
2116 /* Point to the correct common section */
2117 symbfd
= bfd_asymbol_bfd (com
);
2118 if (com
->section
== &bfd_com_section
)
2120 ((lang_input_statement_type
*) symbfd
->usrdata
)
2127 name
= bfd_get_section_name (symbfd
,
2129 newsec
= bfd_get_section_by_name (symbfd
,
2131 /* BFD backend must provide this section. */
2132 if (newsec
== (asection
*) NULL
)
2133 einfo ("%P%F: no output section %s", name
);
2134 com
->section
= newsec
;
2137 /* Fix the size of the common section */
2139 com
->section
->_raw_size
=
2140 ALIGN_N (com
->section
->_raw_size
, align
);
2142 /* Remember if this is the biggest alignment ever seen */
2143 if (power_of_two
> com
->section
->alignment_power
)
2145 com
->section
->alignment_power
= power_of_two
;
2148 /* Symbol stops being common and starts being global, but
2149 we remember that it was common once. */
2151 com
->flags
= BSF_EXPORT
| BSF_GLOBAL
| BSF_OLD_COMMON
;
2152 com
->value
= com
->section
->_raw_size
;
2154 if (write_map
&& config
.map_file
)
2156 fprintf (config
.map_file
, "Allocating common %s: %x at %x %s\n",
2159 (unsigned) com
->value
,
2160 bfd_asymbol_bfd(com
)->filename
);
2163 com
->section
->_raw_size
+= size
;
2176 run through the input files and ensure that every input
2177 section has somewhere to go. If one is found without
2178 a destination then create an input request and place it
2179 into the statement tree.
2183 lang_place_orphans ()
2185 lang_input_statement_type
*file
;
2187 for (file
= (lang_input_statement_type
*) file_chain
.head
;
2188 file
!= (lang_input_statement_type
*) NULL
;
2189 file
= (lang_input_statement_type
*) file
->next
)
2193 for (s
= file
->the_bfd
->sections
;
2194 s
!= (asection
*) NULL
;
2197 if (s
->output_section
== (asection
*) NULL
)
2199 /* This section of the file is not attatched, root
2200 around for a sensible place for it to go */
2202 if (file
->common_section
== s
)
2204 /* This is a lonely common section which must
2205 have come from an archive. We attatch to the
2206 section with the wildcard */
2207 if (config
.relocateable_output
!= true
2208 && command_line
.force_common_definition
== false)
2210 if (default_common_section
==
2211 (lang_output_section_statement_type
*) NULL
)
2213 info ("%P: no [COMMON] command, defaulting to .bss\n");
2215 default_common_section
=
2216 lang_output_section_statement_lookup (".bss");
2219 wild_doit (&default_common_section
->children
, s
,
2220 default_common_section
, file
);
2225 lang_output_section_statement_type
*os
=
2226 lang_output_section_statement_lookup (s
->name
);
2228 wild_doit (&os
->children
, s
, os
, file
);
2237 lang_set_flags (ptr
, flags
)
2241 boolean state
= false;
2256 /* ptr->flag_read = state; */
2259 /* ptr->flag_write = state; */
2262 /* ptr->flag_executable= state;*/
2266 /* ptr->flag_loadable= state;*/
2269 einfo ("%P%F: invalid syntax in flags\n");
2279 lang_for_each_file (func
)
2280 void (*func
) PARAMS ((lang_input_statement_type
*));
2282 lang_input_statement_type
*f
;
2284 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2285 f
!= (lang_input_statement_type
*) NULL
;
2286 f
= (lang_input_statement_type
*) f
->next
)
2294 lang_for_each_input_section (func
)
2295 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
2297 lang_input_statement_type
*f
;
2299 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2300 f
!= (lang_input_statement_type
*) NULL
;
2301 f
= (lang_input_statement_type
*) f
->next
)
2305 for (s
= f
->the_bfd
->sections
;
2306 s
!= (asection
*) NULL
;
2309 func (f
->the_bfd
, s
);
2317 ldlang_add_file (entry
)
2318 lang_input_statement_type
* entry
;
2321 lang_statement_append (&file_chain
,
2322 (lang_statement_union_type
*) entry
,
2327 lang_add_output (name
)
2330 lang_output_statement_type
*new = new_stat (lang_output_statement
,
2334 had_output_filename
= true;
2338 static lang_output_section_statement_type
*current_section
;
2340 static int topower(x
)
2345 if (x
< 0) return -1;
2346 for (l
= 0; l
< 32; l
++)
2348 if (i
>= x
) return l
;
2354 lang_enter_output_section_statement (output_section_statement_name
,
2355 address_exp
, flags
, block_value
,
2356 align
, subalign
, base
)
2357 char *output_section_statement_name
;
2358 etree_type
* address_exp
;
2360 bfd_vma block_value
;
2362 etree_type
*subalign
;
2365 lang_output_section_statement_type
*os
;
2369 lang_output_section_statement_lookup (output_section_statement_name
);
2373 /* Add this statement to tree */
2374 /* add_statement(lang_output_section_statement_enum,
2375 output_section_statement);*/
2376 /* Make next things chain into subchain of this */
2378 if (os
->addr_tree
==
2379 (etree_type
*) NULL
)
2385 if (flags
& SEC_NEVER_LOAD
)
2389 os
->block_value
= block_value
? block_value
: 1;
2390 stat_ptr
= &os
->children
;
2392 os
->subsection_alignment
= topower(
2393 exp_get_value_int(subalign
, -1,
2394 "subsection alignment",
2396 os
->section_alignment
= topower(
2397 exp_get_value_int(align
, -1,
2398 "section alignment", 0));
2400 os
->load_base
= base
;
2407 if (had_output_filename
== false)
2409 extern CONST
char *output_filename
;
2411 lang_add_output (output_filename
);
2415 /* Reset the current counters in the regions */
2417 reset_memory_regions ()
2419 lang_memory_region_type
*p
= lang_memory_region_list
;
2421 for (p
= lang_memory_region_list
;
2422 p
!= (lang_memory_region_type
*) NULL
;
2425 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
2426 p
->current
= p
->origin
;
2433 DEFUN (create_symbol
, (name
, flags
, section
),
2434 CONST
char *name AND
2438 extern lang_input_statement_type
*script_file
;
2439 asymbol
**def_ptr
= (asymbol
**) stat_alloc ((bfd_size_type
) (sizeof (asymbol
**)));
2441 /* Add this definition to script file */
2442 asymbol
*def
= (asymbol
*) bfd_make_empty_symbol (script_file
->the_bfd
);
2443 def
->name
= buystring (name
);
2446 def
->section
= section
;
2448 enter_global_ref (def_ptr
, name
);
2455 lang_reasonable_defaults ();
2456 current_target
= default_target
;
2458 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
2459 /* For each output section statement, create a section in the output
2461 lang_create_output_section_statements ();
2463 /* Create a dummy bfd for the script */
2464 lang_init_script_file ();
2466 /* Add to the hash table all undefineds on the command line */
2467 lang_place_undefineds ();
2469 /* Create a bfd for each input file */
2470 current_target
= default_target
;
2471 lang_for_each_statement (open_input_bfds
);
2473 /* Run through the contours of the script and attatch input sections
2474 to the correct output sections
2476 find_constructors ();
2477 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
2478 (lang_output_section_statement_type
*) NULL
);
2481 /* Find any sections not attatched explicitly and handle them */
2482 lang_place_orphans ();
2484 /* Size up the common data */
2487 ldemul_before_allocation ();
2497 lang_size_sections (statement_list
.head
,
2498 (lang_output_section_statement_type
*) NULL
,
2499 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2500 /* FIXME. Until the code in relax is fixed so that it only reads in
2501 stuff once, we cant iterate since there is no way for the linker to
2502 know what has been patched and what hasn't */
2508 /* Now run around and relax if we can */
2509 if (command_line
.relax
)
2511 /* First time round is a trial run to get the 'worst case' addresses of the
2512 objects if there was no relaxing */
2513 lang_size_sections (statement_list
.head
,
2514 (lang_output_section_statement_type
*) NULL
,
2515 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2519 /* Move the global symbols around so the second pass of relaxing can
2521 lang_relocate_globals ();
2523 reset_memory_regions ();
2525 /* Do all the assignments, now that we know the final restingplaces
2526 of all the symbols */
2528 lang_do_assignments (statement_list
.head
,
2533 /* Perform another relax pass - this time we know where the
2534 globals are, so can make better guess */
2535 lang_size_sections (statement_list
.head
,
2536 (lang_output_section_statement_type
*) NULL
,
2537 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2545 /* Size up the sections */
2546 lang_size_sections (statement_list
.head
,
2548 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2553 /* See if anything special should be done now we know how big
2555 ldemul_after_allocation ();
2557 /* Do all the assignments, now that we know the final restingplaces
2558 of all the symbols */
2560 lang_do_assignments (statement_list
.head
,
2565 /* Move the global symbols around */
2566 lang_relocate_globals ();
2568 /* Make sure that we're not mixing architectures */
2576 /* EXPORTED TO YACC */
2579 lang_add_wild (section_name
, filename
)
2580 CONST
char *CONST section_name
;
2581 CONST
char *CONST filename
;
2583 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
2586 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
2588 placed_commons
= true;
2590 if (filename
!= (char *) NULL
)
2592 lang_has_input_file
= true;
2594 new->section_name
= section_name
;
2595 new->filename
= filename
;
2596 lang_list_init (&new->children
);
2600 lang_section_start (name
, address
)
2602 etree_type
* address
;
2604 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
2606 ad
->section_name
= name
;
2607 ad
->address
= address
;
2611 lang_add_entry (name
)
2614 entry_symbol
= name
;
2618 lang_add_target (name
)
2621 lang_target_statement_type
*new = new_stat (lang_target_statement
,
2637 map_option_f
= true;
2648 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
2655 lang_add_data (type
, exp
)
2657 union etree_union
*exp
;
2660 lang_data_statement_type
*new = new_stat (lang_data_statement
,
2669 lang_add_assignment (exp
)
2672 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
2679 lang_add_attribute (attribute
)
2680 enum statement_enum attribute
;
2682 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
2689 if (startup_file
!= (char *) NULL
)
2691 einfo ("%P%Fmultiple STARTUP files\n");
2693 first_file
->filename
= name
;
2694 first_file
->local_sym_name
= name
;
2696 startup_file
= name
;
2703 lang_float_flag
= maybe
;
2707 lang_leave_output_section_statement (fill
, memspec
)
2709 CONST
char *memspec
;
2711 current_section
->fill
= fill
;
2712 current_section
->region
= lang_memory_region_lookup (memspec
);
2713 stat_ptr
= &statement_list
;
2715 /* We remember if we are closing a .data section, since we use it to
2716 store constructors in */
2717 if (strcmp (current_section
->name
, ".data") == 0)
2719 end_of_data_section_statement_list
= statement_list
;
2725 Create an absolute symbol with the given name with the value of the
2726 address of first byte of the section named.
2728 If the symbol already exists, then do nothing.
2731 lang_abs_symbol_at_beginning_of (section
, name
)
2732 CONST
char *section
;
2735 if (ldsym_undefined (name
))
2737 asection
*s
= bfd_get_section_by_name (output_bfd
, section
);
2738 asymbol
*def
= create_symbol (name
,
2739 BSF_GLOBAL
| BSF_EXPORT
,
2742 if (s
!= (asection
*) NULL
)
2744 def
->value
= s
->vma
;
2754 Create an absolute symbol with the given name with the value of the
2755 address of the first byte after the end of the section named.
2757 If the symbol already exists, then do nothing.
2760 lang_abs_symbol_at_end_of (section
, name
)
2761 CONST
char *section
;
2764 if (ldsym_undefined (name
))
2766 asection
*s
= bfd_get_section_by_name (output_bfd
, section
);
2768 /* Add a symbol called _end */
2769 asymbol
*def
= create_symbol (name
,
2770 BSF_GLOBAL
| BSF_EXPORT
,
2773 if (s
!= (asection
*) NULL
)
2775 def
->value
= s
->vma
+ s
->_raw_size
;
2785 lang_statement_append (list
, element
, field
)
2786 lang_statement_list_type
* list
;
2787 lang_statement_union_type
* element
;
2788 lang_statement_union_type
** field
;
2790 *(list
->tail
) = element
;
2794 /* Set the output format type. -oformat overrides scripts. */
2796 lang_add_output_format (format
, from_script
)
2800 if (!from_script
|| output_target
== NULL
)
2801 output_target
= format
;