1 /* Linker command language support.
2 Copyright (C) 1991, 92, 93, 94, 95, 1996 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #include "libiberty.h"
37 static lang_statement_union_type
*new_statement
PARAMS ((enum statement_enum
,
39 lang_statement_list_type
*));
43 static struct obstack stat_obstack
;
45 #define obstack_chunk_alloc xmalloc
46 #define obstack_chunk_free free
47 static CONST
char *startup_file
;
48 static lang_statement_list_type input_file_chain
;
49 static boolean placed_commons
= false;
50 static lang_output_section_statement_type
*default_common_section
;
51 static boolean map_option_f
;
52 static bfd_vma print_dot
;
53 static lang_input_statement_type
*first_file
;
54 static lang_statement_list_type lang_output_section_statement
;
55 static CONST
char *current_target
;
56 static CONST
char *output_target
;
57 static int longest_section_name
= 8;
58 static lang_statement_list_type statement_list
;
59 static struct lang_phdr
*lang_phdr_list
;
61 static void print_size
PARAMS ((size_t value
));
62 static void print_alignment
PARAMS ((unsigned int value
));
63 static void print_fill
PARAMS ((fill_type value
));
64 static void print_section
PARAMS ((const char *name
));
65 static void lang_for_each_statement_worker
66 PARAMS ((void (*func
) (lang_statement_union_type
*),
67 lang_statement_union_type
*s
));
68 static lang_input_statement_type
*new_afile
69 PARAMS ((const char *name
, lang_input_file_enum_type file_type
,
70 const char *target
, boolean add_to_list
));
71 static void print_flags
PARAMS ((int *ignore_flags
));
72 static void init_os
PARAMS ((lang_output_section_statement_type
*s
));
73 static void wild_section
PARAMS ((lang_wild_statement_type
*ptr
,
75 lang_input_statement_type
*file
,
76 lang_output_section_statement_type
*output
));
77 static lang_input_statement_type
*lookup_name
PARAMS ((const char *name
));
78 static void load_symbols
PARAMS ((lang_input_statement_type
*entry
,
79 lang_statement_list_type
*));
80 static void wild
PARAMS ((lang_wild_statement_type
*s
,
81 const char *section
, const char *file
,
83 lang_output_section_statement_type
*output
));
84 static bfd
*open_output
PARAMS ((const char *name
));
85 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*statement
));
86 static void open_input_bfds
87 PARAMS ((lang_statement_union_type
*statement
, boolean
));
88 static void lang_reasonable_defaults
PARAMS ((void));
89 static void lang_place_undefineds
PARAMS ((void));
90 static void map_input_to_output_sections
91 PARAMS ((lang_statement_union_type
*s
,
93 lang_output_section_statement_type
*output_section_statement
));
94 static void print_output_section_statement
95 PARAMS ((lang_output_section_statement_type
*output_section_statement
));
96 static void print_assignment
97 PARAMS ((lang_assignment_statement_type
*assignment
,
98 lang_output_section_statement_type
*output_section
));
99 static void print_input_statement
PARAMS ((lang_input_statement_type
*statm
));
100 static void print_input_section
PARAMS ((lang_input_section_type
*in
));
101 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*fill
));
102 static void print_data_statement
PARAMS ((lang_data_statement_type
*data
));
103 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*reloc
));
104 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*s
));
105 static void print_wild_statement
106 PARAMS ((lang_wild_statement_type
*w
,
107 lang_output_section_statement_type
*os
));
108 static void print_group
109 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
110 static void print_statement
PARAMS ((lang_statement_union_type
*s
,
111 lang_output_section_statement_type
*os
));
112 static void print_statement_list
PARAMS ((lang_statement_union_type
*s
,
113 lang_output_section_statement_type
*os
));
114 static void print_statements
PARAMS ((void));
115 static bfd_vma insert_pad
PARAMS ((lang_statement_union_type
**this_ptr
,
116 fill_type fill
, unsigned int power
,
117 asection
*output_section_statement
,
119 static bfd_vma size_input_section
120 PARAMS ((lang_statement_union_type
**this_ptr
,
121 lang_output_section_statement_type
*output_section_statement
,
122 fill_type fill
, bfd_vma dot
, boolean relax
));
123 static void lang_finish
PARAMS ((void));
124 static void lang_check
PARAMS ((void));
125 static void lang_common
PARAMS ((void));
126 static boolean lang_one_common
PARAMS ((struct bfd_link_hash_entry
*, PTR
));
127 static void lang_place_orphans
PARAMS ((void));
128 static int topower
PARAMS ((int));
129 static void lang_set_startof
PARAMS ((void));
130 static void reset_memory_regions
PARAMS ((void));
131 static void lang_record_phdrs
PARAMS ((void));
134 lang_output_section_statement_type
*abs_output_section
;
135 lang_statement_list_type
*stat_ptr
= &statement_list
;
136 lang_statement_list_type file_chain
= { 0 };
137 const char *entry_symbol
= NULL
;
138 boolean entry_from_cmdline
;
139 boolean lang_has_input_file
= false;
140 boolean had_output_filename
= false;
141 boolean lang_float_flag
= false;
142 boolean delete_output_file_on_failure
= false;
144 etree_type
*base
; /* Relocation base - or null */
147 #if defined(__STDC__) || defined(ALMOST_STDC)
148 #define cat(a,b) a##b
150 #define cat(a,b) a/**/b
153 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
155 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
157 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
163 return obstack_alloc (&stat_obstack
, size
);
170 fprintf (config
.map_file
, "%5x", (unsigned) value
);
174 print_alignment (value
)
177 fprintf (config
.map_file
, "2**%1u", value
);
184 fprintf (config
.map_file
, "%04x", (unsigned) value
);
191 fprintf (config
.map_file
, "%*s", -longest_section_name
, name
);
194 /*----------------------------------------------------------------------
195 lang_for_each_statement walks the parse tree and calls the provided
196 function for each node
200 lang_for_each_statement_worker (func
, s
)
201 void (*func
) PARAMS ((lang_statement_union_type
*));
202 lang_statement_union_type
*s
;
204 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
208 switch (s
->header
.type
)
210 case lang_constructors_statement_enum
:
211 lang_for_each_statement_worker (func
, constructor_list
.head
);
213 case lang_output_section_statement_enum
:
214 lang_for_each_statement_worker
216 s
->output_section_statement
.children
.head
);
218 case lang_wild_statement_enum
:
219 lang_for_each_statement_worker
221 s
->wild_statement
.children
.head
);
223 case lang_group_statement_enum
:
224 lang_for_each_statement_worker (func
,
225 s
->group_statement
.children
.head
);
227 case lang_data_statement_enum
:
228 case lang_reloc_statement_enum
:
229 case lang_object_symbols_statement_enum
:
230 case lang_output_statement_enum
:
231 case lang_target_statement_enum
:
232 case lang_input_section_enum
:
233 case lang_input_statement_enum
:
234 case lang_assignment_statement_enum
:
235 case lang_padding_statement_enum
:
236 case lang_address_statement_enum
:
246 lang_for_each_statement (func
)
247 void (*func
) PARAMS ((lang_statement_union_type
*));
249 lang_for_each_statement_worker (func
,
250 statement_list
.head
);
253 /*----------------------------------------------------------------------*/
255 lang_list_init (list
)
256 lang_statement_list_type
*list
;
258 list
->head
= (lang_statement_union_type
*) NULL
;
259 list
->tail
= &list
->head
;
262 /*----------------------------------------------------------------------
264 build a new statement node for the parse tree
269 lang_statement_union_type
*
270 new_statement (type
, size
, list
)
271 enum statement_enum type
;
273 lang_statement_list_type
* list
;
275 lang_statement_union_type
*new = (lang_statement_union_type
*)
278 new->header
.type
= type
;
279 new->header
.next
= (lang_statement_union_type
*) NULL
;
280 lang_statement_append (list
, new, &new->header
.next
);
285 Build a new input file node for the language. There are several ways
286 in which we treat an input file, eg, we only look at symbols, or
287 prefix it with a -l etc.
289 We can be supplied with requests for input files more than once;
290 they may, for example be split over serveral lines like foo.o(.text)
291 foo.o(.data) etc, so when asked for a file we check that we havn't
292 got it already so we don't duplicate the bfd.
295 static lang_input_statement_type
*
296 new_afile (name
, file_type
, target
, add_to_list
)
298 lang_input_file_enum_type file_type
;
302 lang_input_statement_type
*p
;
305 p
= new_stat (lang_input_statement
, stat_ptr
);
308 p
= ((lang_input_statement_type
*)
309 stat_alloc (sizeof (lang_input_statement_type
)));
310 p
->header
.next
= NULL
;
313 lang_has_input_file
= true;
315 p
->complained
= false;
318 case lang_input_file_is_symbols_only_enum
:
320 p
->is_archive
= false;
322 p
->local_sym_name
= name
;
323 p
->just_syms_flag
= true;
324 p
->search_dirs_flag
= false;
326 case lang_input_file_is_fake_enum
:
328 p
->is_archive
= false;
330 p
->local_sym_name
= name
;
331 p
->just_syms_flag
= false;
332 p
->search_dirs_flag
= false;
334 case lang_input_file_is_l_enum
:
335 p
->is_archive
= true;
338 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
339 p
->just_syms_flag
= false;
340 p
->search_dirs_flag
= true;
342 case lang_input_file_is_marker_enum
:
344 p
->is_archive
= false;
346 p
->local_sym_name
= name
;
347 p
->just_syms_flag
= false;
348 p
->search_dirs_flag
= true;
350 case lang_input_file_is_search_file_enum
:
352 p
->is_archive
= false;
354 p
->local_sym_name
= name
;
355 p
->just_syms_flag
= false;
356 p
->search_dirs_flag
= true;
358 case lang_input_file_is_file_enum
:
360 p
->is_archive
= false;
362 p
->local_sym_name
= name
;
363 p
->just_syms_flag
= false;
364 p
->search_dirs_flag
= false;
369 p
->the_bfd
= (bfd
*) NULL
;
370 p
->asymbols
= (asymbol
**) NULL
;
371 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
372 p
->next
= (lang_statement_union_type
*) NULL
;
374 p
->common_output_section
= (asection
*) NULL
;
375 p
->dynamic
= config
.dynamic_link
;
376 p
->whole_archive
= whole_archive
;
378 lang_statement_append (&input_file_chain
,
379 (lang_statement_union_type
*) p
,
384 lang_input_statement_type
*
385 lang_add_input_file (name
, file_type
, target
)
387 lang_input_file_enum_type file_type
;
390 lang_has_input_file
= true;
391 return new_afile (name
, file_type
, target
, true);
394 /* Build enough state so that the parser can build its tree */
398 obstack_begin (&stat_obstack
, 1000);
400 stat_ptr
= &statement_list
;
402 lang_list_init (stat_ptr
);
404 lang_list_init (&input_file_chain
);
405 lang_list_init (&lang_output_section_statement
);
406 lang_list_init (&file_chain
);
407 first_file
= lang_add_input_file ((char *) NULL
,
408 lang_input_file_is_marker_enum
,
410 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
412 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
416 /*----------------------------------------------------------------------
417 A region is an area of memory declared with the
418 MEMORY { name:org=exp, len=exp ... }
421 We maintain a list of all the regions here
423 If no regions are specified in the script, then the default is used
424 which is created when looked up to be the entire data space
427 static lang_memory_region_type
*lang_memory_region_list
;
428 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
430 lang_memory_region_type
*
431 lang_memory_region_lookup (name
)
432 CONST
char *CONST name
;
435 lang_memory_region_type
*p
= lang_memory_region_list
;
437 for (p
= lang_memory_region_list
;
438 p
!= (lang_memory_region_type
*) NULL
;
441 if (strcmp (p
->name
, name
) == 0)
448 /* This code used to always use the first region in the list as the
449 default region. I changed it to instead use a region
450 encompassing all of memory as the default region. This permits
451 NOLOAD sections to work reasonably without requiring a region.
452 People should specify what region they mean, if they really want
454 if (strcmp (name
, "*default*") == 0)
456 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
458 return lang_memory_region_list
;
464 lang_memory_region_type
*new =
465 (lang_memory_region_type
*) stat_alloc (sizeof (lang_memory_region_type
));
467 new->name
= buystring (name
);
468 new->next
= (lang_memory_region_type
*) NULL
;
470 *lang_memory_region_list_tail
= new;
471 lang_memory_region_list_tail
= &new->next
;
473 new->length
= ~(bfd_size_type
)0;
475 new->had_full_message
= false;
482 lang_output_section_statement_type
*
483 lang_output_section_find (name
)
484 CONST
char *CONST name
;
486 lang_statement_union_type
*u
;
487 lang_output_section_statement_type
*lookup
;
489 for (u
= lang_output_section_statement
.head
;
490 u
!= (lang_statement_union_type
*) NULL
;
493 lookup
= &u
->output_section_statement
;
494 if (strcmp (name
, lookup
->name
) == 0)
499 return (lang_output_section_statement_type
*) NULL
;
502 lang_output_section_statement_type
*
503 lang_output_section_statement_lookup (name
)
504 CONST
char *CONST name
;
506 lang_output_section_statement_type
*lookup
;
508 lookup
= lang_output_section_find (name
);
509 if (lookup
== (lang_output_section_statement_type
*) NULL
)
512 lookup
= (lang_output_section_statement_type
*)
513 new_stat (lang_output_section_statement
, stat_ptr
);
514 lookup
->region
= (lang_memory_region_type
*) NULL
;
516 lookup
->block_value
= 1;
519 lookup
->next
= (lang_statement_union_type
*) NULL
;
520 lookup
->bfd_section
= (asection
*) NULL
;
521 lookup
->processed
= false;
522 lookup
->loadable
= 1;
523 lookup
->addr_tree
= (etree_type
*) NULL
;
524 lang_list_init (&lookup
->children
);
526 lookup
->memspec
= (CONST
char *) NULL
;
528 lookup
->subsection_alignment
= -1;
529 lookup
->section_alignment
= -1;
530 lookup
->load_base
= (union etree_union
*) NULL
;
531 lookup
->phdrs
= NULL
;
533 lang_statement_append (&lang_output_section_statement
,
534 (lang_statement_union_type
*) lookup
,
542 print_flags (ignore_flags
)
545 fprintf (config
.map_file
, "(");
547 if (flags
->flag_read
)
548 fprintf (outfile
, "R");
549 if (flags
->flag_write
)
550 fprintf (outfile
, "W");
551 if (flags
->flag_executable
)
552 fprintf (outfile
, "X");
553 if (flags
->flag_loadable
)
554 fprintf (outfile
, "L");
556 fprintf (config
.map_file
, ")");
562 lang_memory_region_type
*m
;
564 fprintf (config
.map_file
, "**MEMORY CONFIGURATION**\n\n");
566 fprintf (config
.map_file
, "name\t\torigin\t\tlength\t\tattributes\n");
568 fprintf (config
.map_file
,
569 "name\t\torigin length r_size c_size is attributes\n");
572 for (m
= lang_memory_region_list
;
573 m
!= (lang_memory_region_type
*) NULL
;
576 fprintf (config
.map_file
, "%-16s", m
->name
);
577 print_address (m
->origin
);
579 print_address ((bfd_vma
)m
->length
);
581 print_address ((bfd_vma
)m
->old_length
);
583 print_address (m
->current
- m
->origin
);
586 fprintf (config
.map_file
, " %2d%% ",
587 (int) ((m
->current
- m
->origin
) * 100 / m
->old_length
));
588 print_flags (&m
->flags
);
589 fprintf (config
.map_file
, "\n");
591 fprintf (config
.map_file
, "\n\n**LINK EDITOR MEMORY MAP**\n\n");
592 fprintf (config
.map_file
, "output input virtual\n");
593 fprintf (config
.map_file
, "section section address tsize\n\n");
604 lang_output_section_statement_type
* s
;
606 /* asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
607 section_userdata_type
*new =
608 (section_userdata_type
*)
609 stat_alloc (sizeof (section_userdata_type
));
611 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
612 if (s
->bfd_section
== (asection
*) NULL
)
613 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
614 if (s
->bfd_section
== (asection
*) NULL
)
616 einfo ("%P%F: output format %s cannot represent section called %s\n",
617 output_bfd
->xvec
->name
, s
->name
);
619 s
->bfd_section
->output_section
= s
->bfd_section
;
621 /* We initialize an output sections output offset to minus its own */
622 /* vma to allow us to output a section through itself */
623 s
->bfd_section
->output_offset
= 0;
624 get_userdata (s
->bfd_section
) = (PTR
) new;
628 /***********************************************************************
631 These expand statements like *(.text) and foo.o to a list of
632 explicit actions, like foo.o(.text), bar.o(.text) and
635 The toplevel routine, wild, takes a statement, section, file and
636 target. If either the section or file is null it is taken to be the
637 wildcard. Seperate lang_input_section statements are created for
638 each part of the expanstion, and placed after the statement provided.
643 wild_doit (ptr
, section
, output
, file
)
644 lang_statement_list_type
* ptr
;
646 lang_output_section_statement_type
* output
;
647 lang_input_statement_type
* file
;
649 if (output
->bfd_section
== (asection
*) NULL
)
652 if (section
!= (asection
*) NULL
653 && section
->output_section
== (asection
*) NULL
)
655 /* Add a section reference to the list */
656 lang_input_section_type
*new = new_stat (lang_input_section
, ptr
);
658 new->section
= section
;
660 section
->output_section
= output
->bfd_section
;
662 /* We don't copy the SEC_NEVER_LOAD flag from an input section to
663 an output section, because we want to be able to include a
664 SEC_NEVER_LOAD section in the middle of an otherwise loaded
665 section (I don't know why we want to do this, but we do).
666 build_link_order in ldwrite.c handles this case by turning the
667 embedded SEC_NEVER_LOAD section into a fill. */
668 section
->output_section
->flags
|=
669 section
->flags
& (flagword
) (~ SEC_NEVER_LOAD
);
671 if (!output
->loadable
)
673 /* Turn off load flag */
674 output
->bfd_section
->flags
&= ~SEC_LOAD
;
675 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
677 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
679 output
->bfd_section
->alignment_power
= section
->alignment_power
;
681 /* If supplied an aligmnet, then force it */
682 if (output
->section_alignment
!= -1)
684 output
->bfd_section
->alignment_power
= output
->section_alignment
;
690 wild_section (ptr
, section
, file
, output
)
691 lang_wild_statement_type
*ptr
;
693 lang_input_statement_type
*file
;
694 lang_output_section_statement_type
*output
;
696 if (file
->just_syms_flag
== false)
698 register asection
*s
;
700 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
702 /* Attach all sections named SECTION. If SECTION is NULL,
703 then attach all sections.
705 Previously, if SECTION was NULL, this code did not call
706 wild_doit if the SEC_IS_COMMON flag was set for the
707 section. I did not understand that, and I took it out.
711 || strcmp (bfd_get_section_name (file
->the_bfd
, s
),
713 wild_doit (&ptr
->children
, s
, output
, file
);
718 /* passed a file name (which must have been seen already and added to
719 the statement tree. We will see if it has been opened already and
720 had its symbols read. If not then we'll read it.
722 Archives are pecuilar here. We may open them once, but if they do
723 not define anything we need at the time, they won't have all their
724 symbols read. If we need them later, we'll have to redo it. */
725 static lang_input_statement_type
*
729 lang_input_statement_type
*search
;
731 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
732 search
!= (lang_input_statement_type
*) NULL
;
733 search
= (lang_input_statement_type
*) search
->next_real_file
)
735 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
737 if (search
->filename
!= (char *) NULL
738 && name
!= (char *) NULL
739 && strcmp (search
->filename
, name
) == 0)
743 if (search
== (lang_input_statement_type
*) NULL
)
744 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
747 /* If we have already added this file, or this file is not real
748 (FIXME: can that ever actually happen?) or the name is NULL
749 (FIXME: can that ever actually happen?) don't add this file. */
752 || search
->filename
== (const char *) NULL
)
755 load_symbols (search
, (lang_statement_list_type
*) NULL
);
760 /* Get the symbols for an input file. */
763 load_symbols (entry
, place
)
764 lang_input_statement_type
*entry
;
765 lang_statement_list_type
*place
;
772 ldfile_open_file (entry
);
774 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
775 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
778 lang_statement_list_type
*hold
;
780 err
= bfd_get_error ();
781 if (err
== bfd_error_file_ambiguously_recognized
)
785 einfo ("%B: file not recognized: %E\n", entry
->the_bfd
);
786 einfo ("%B: matching formats:", entry
->the_bfd
);
787 for (p
= matching
; *p
!= NULL
; p
++)
791 else if (err
!= bfd_error_file_not_recognized
793 einfo ("%F%B: file not recognized: %E\n", entry
->the_bfd
);
795 /* Try to interpret the file as a linker script. */
797 bfd_close (entry
->the_bfd
);
798 entry
->the_bfd
= NULL
;
800 ldfile_open_command_file (entry
->filename
);
805 ldfile_assumed_script
= true;
806 parser_input
= input_script
;
808 ldfile_assumed_script
= false;
815 /* We don't call ldlang_add_file for an archive. Instead, the
816 add_symbols entry point will call ldlang_add_file, via the
817 add_archive_element callback, for each element of the archive
819 switch (bfd_get_format (entry
->the_bfd
))
825 ldlang_add_file (entry
);
826 if (trace_files
|| trace_file_tries
)
827 info_msg ("%I\n", entry
);
831 if (entry
->whole_archive
)
833 bfd
*member
= bfd_openr_next_archived_file (entry
->the_bfd
,
835 while (member
!= NULL
)
837 if (! bfd_check_format (member
, bfd_object
))
838 einfo ("%F%B: object %B in archive is not object\n",
839 entry
->the_bfd
, member
);
840 if (! ((*link_info
.callbacks
->add_archive_element
)
841 (&link_info
, member
, "-whole-archive")))
843 if (! bfd_link_add_symbols (member
, &link_info
))
844 einfo ("%F%B: could not read symbols: %E\n", member
);
845 member
= bfd_openr_next_archived_file (entry
->the_bfd
,
849 entry
->loaded
= true;
855 if (! bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
856 einfo ("%F%B: could not read symbols: %E\n", entry
->the_bfd
);
858 entry
->loaded
= true;
862 wild (s
, section
, file
, target
, output
)
863 lang_wild_statement_type
* s
;
867 lang_output_section_statement_type
* output
;
869 lang_input_statement_type
*f
;
871 if (file
== (char *) NULL
)
873 /* Perform the iteration over all files in the list */
874 for (f
= (lang_input_statement_type
*) file_chain
.head
;
875 f
!= (lang_input_statement_type
*) NULL
;
876 f
= (lang_input_statement_type
*) f
->next
)
878 wild_section (s
, section
, f
, output
);
883 /* Perform the iteration over a single file */
884 f
= lookup_name (file
);
885 if (f
->the_bfd
== NULL
886 || ! bfd_check_format (f
->the_bfd
, bfd_archive
))
887 wild_section (s
, section
, f
, output
);
892 /* This is an archive file. We must map each member of the
893 archive separately. */
894 member
= bfd_openr_next_archived_file (f
->the_bfd
, (bfd
*) NULL
);
895 while (member
!= NULL
)
897 /* When lookup_name is called, it will call the
898 add_symbols entry point for the archive. For each
899 element of the archive which is included, BFD will
900 call ldlang_add_file, which will set the usrdata
901 field of the member to the lang_input_statement. */
902 if (member
->usrdata
!= NULL
)
904 wild_section (s
, section
,
905 (lang_input_statement_type
*) member
->usrdata
,
909 member
= bfd_openr_next_archived_file (f
->the_bfd
, member
);
913 if (section
!= (char *) NULL
914 && strcmp (section
, "COMMON") == 0
915 && default_common_section
== (lang_output_section_statement_type
*) NULL
)
917 /* Remember the section that common is going to incase we later
918 get something which doesn't know where to put it */
919 default_common_section
= output
;
924 read in all the files
933 if (output_target
== (char *) NULL
)
935 if (current_target
!= (char *) NULL
)
936 output_target
= current_target
;
938 output_target
= default_target
;
940 output
= bfd_openw (name
, output_target
);
942 if (output
== (bfd
*) NULL
)
944 if (bfd_get_error () == bfd_error_invalid_target
)
946 einfo ("%P%F: target %s not found\n", output_target
);
948 einfo ("%P%F: cannot open output file %s: %E\n", name
);
951 delete_output_file_on_failure
= 1;
953 /* output->flags |= D_PAGED;*/
955 if (! bfd_set_format (output
, bfd_object
))
956 einfo ("%P%F:%s: can not make object file: %E\n", name
);
957 if (! bfd_set_arch_mach (output
,
958 ldfile_output_architecture
,
959 ldfile_output_machine
))
960 einfo ("%P%F:%s: can not set architecture: %E\n", name
);
962 link_info
.hash
= bfd_link_hash_table_create (output
);
963 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
964 einfo ("%P%F: can not create link hash table: %E\n");
966 bfd_set_gp_size (output
, g_switch_value
);
974 ldlang_open_output (statement
)
975 lang_statement_union_type
* statement
;
977 switch (statement
->header
.type
)
979 case lang_output_statement_enum
:
980 ASSERT (output_bfd
== (bfd
*) NULL
);
981 output_bfd
= open_output (statement
->output_statement
.name
);
982 ldemul_set_output_arch ();
983 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
984 output_bfd
->flags
|= D_PAGED
;
986 output_bfd
->flags
&= ~D_PAGED
;
987 if (config
.text_read_only
)
988 output_bfd
->flags
|= WP_TEXT
;
990 output_bfd
->flags
&= ~WP_TEXT
;
991 if (config
.traditional_format
)
992 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
994 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
997 case lang_target_statement_enum
:
998 current_target
= statement
->target_statement
.target
;
1005 /* Open all the input files. */
1008 open_input_bfds (s
, force
)
1009 lang_statement_union_type
*s
;
1012 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1014 switch (s
->header
.type
)
1016 case lang_constructors_statement_enum
:
1017 open_input_bfds (constructor_list
.head
, force
);
1019 case lang_output_section_statement_enum
:
1020 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
1022 case lang_wild_statement_enum
:
1023 /* Maybe we should load the file's symbols */
1024 if (s
->wild_statement
.filename
)
1025 (void) lookup_name (s
->wild_statement
.filename
);
1026 open_input_bfds (s
->wild_statement
.children
.head
, force
);
1028 case lang_group_statement_enum
:
1030 struct bfd_link_hash_entry
*undefs
;
1032 /* We must continually search the entries in the group
1033 until no new symbols are added to the list of undefined
1038 undefs
= link_info
.hash
->undefs_tail
;
1039 open_input_bfds (s
->group_statement
.children
.head
, true);
1041 while (undefs
!= link_info
.hash
->undefs_tail
);
1044 case lang_target_statement_enum
:
1045 current_target
= s
->target_statement
.target
;
1047 case lang_input_statement_enum
:
1048 if (s
->input_statement
.real
== true)
1050 lang_statement_list_type add
;
1052 s
->input_statement
.target
= current_target
;
1054 /* If we are being called from within a group, and this
1055 is an archive which has already been searched, then
1056 force it to be researched. */
1058 && s
->input_statement
.loaded
1059 && bfd_check_format (s
->input_statement
.the_bfd
,
1061 s
->input_statement
.loaded
= false;
1063 lang_list_init (&add
);
1065 load_symbols (&s
->input_statement
, &add
);
1067 if (add
.head
!= NULL
)
1069 *add
.tail
= s
->next
;
1080 /* If there are [COMMONS] statements, put a wild one into the bss section */
1083 lang_reasonable_defaults ()
1086 lang_output_section_statement_lookup (".text");
1087 lang_output_section_statement_lookup (".data");
1089 default_common_section
=
1090 lang_output_section_statement_lookup (".bss");
1093 if (placed_commons
== false)
1095 lang_wild_statement_type
*new =
1096 new_stat (lang_wild_statement
,
1097 &default_common_section
->children
);
1099 new->section_name
= "COMMON";
1100 new->filename
= (char *) NULL
;
1101 lang_list_init (&new->children
);
1108 Add the supplied name to the symbol table as an undefined reference.
1109 Remove items from the chain as we open input bfds
1111 typedef struct ldlang_undef_chain_list
1113 struct ldlang_undef_chain_list
*next
;
1115 } ldlang_undef_chain_list_type
;
1117 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
1120 ldlang_add_undef (name
)
1121 CONST
char *CONST name
;
1123 ldlang_undef_chain_list_type
*new =
1124 ((ldlang_undef_chain_list_type
*)
1125 stat_alloc (sizeof (ldlang_undef_chain_list_type
)));
1127 new->next
= ldlang_undef_chain_list_head
;
1128 ldlang_undef_chain_list_head
= new;
1130 new->name
= buystring (name
);
1133 /* Run through the list of undefineds created above and place them
1134 into the linker hash table as undefined symbols belonging to the
1138 lang_place_undefineds ()
1140 ldlang_undef_chain_list_type
*ptr
;
1142 for (ptr
= ldlang_undef_chain_list_head
;
1143 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
1146 struct bfd_link_hash_entry
*h
;
1148 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
1149 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1150 einfo ("%P%F: bfd_link_hash_lookup failed: %E");
1151 if (h
->type
== bfd_link_hash_new
)
1153 h
->type
= bfd_link_hash_undefined
;
1154 h
->u
.undef
.abfd
= NULL
;
1155 bfd_link_add_undef (link_info
.hash
, h
);
1160 /* Open input files and attatch to output sections */
1162 map_input_to_output_sections (s
, target
, output_section_statement
)
1163 lang_statement_union_type
* s
;
1165 lang_output_section_statement_type
* output_section_statement
;
1167 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1169 switch (s
->header
.type
)
1173 case lang_wild_statement_enum
:
1174 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1175 s
->wild_statement
.filename
, target
,
1176 output_section_statement
);
1179 case lang_constructors_statement_enum
:
1180 map_input_to_output_sections (constructor_list
.head
,
1182 output_section_statement
);
1184 case lang_output_section_statement_enum
:
1185 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1187 &s
->output_section_statement
);
1189 case lang_output_statement_enum
:
1191 case lang_target_statement_enum
:
1192 target
= s
->target_statement
.target
;
1194 case lang_group_statement_enum
:
1195 map_input_to_output_sections (s
->group_statement
.children
.head
,
1197 output_section_statement
);
1199 case lang_fill_statement_enum
:
1200 case lang_input_section_enum
:
1201 case lang_object_symbols_statement_enum
:
1202 case lang_data_statement_enum
:
1203 case lang_reloc_statement_enum
:
1204 case lang_assignment_statement_enum
:
1205 case lang_padding_statement_enum
:
1206 case lang_input_statement_enum
:
1207 if (output_section_statement
!= NULL
1208 && output_section_statement
->bfd_section
== NULL
)
1209 init_os (output_section_statement
);
1211 case lang_afile_asection_pair_statement_enum
:
1214 case lang_address_statement_enum
:
1215 /* Mark the specified section with the supplied address */
1217 lang_output_section_statement_type
*os
=
1218 lang_output_section_statement_lookup
1219 (s
->address_statement
.section_name
);
1221 if (os
->bfd_section
== NULL
)
1223 os
->addr_tree
= s
->address_statement
.address
;
1231 print_output_section_statement (output_section_statement
)
1232 lang_output_section_statement_type
* output_section_statement
;
1234 asection
*section
= output_section_statement
->bfd_section
;
1237 print_section (output_section_statement
->name
);
1242 print_dot
= section
->vma
;
1246 print_address (section
->vma
);
1248 print_size (section
->_raw_size
);
1250 print_size(section
->_cooked_size
);
1252 print_alignment (section
->alignment_power
);
1255 fprintf (config
.map_file
, "%s flags", output_section_statement
->region
->name
);
1256 print_flags (stdout
, &output_section_statement
->flags
);
1258 if (section
->flags
& SEC_LOAD
)
1259 fprintf (config
.map_file
, "load ");
1260 if (section
->flags
& SEC_ALLOC
)
1261 fprintf (config
.map_file
, "alloc ");
1262 if (section
->flags
& SEC_RELOC
)
1263 fprintf (config
.map_file
, "reloc ");
1264 if (section
->flags
& SEC_HAS_CONTENTS
)
1265 fprintf (config
.map_file
, "contents ");
1270 fprintf (config
.map_file
, " (no attached output section)");
1273 if (output_section_statement
->load_base
)
1275 bfd_vma b
= exp_get_abs_int(output_section_statement
->load_base
,
1276 0, "output base", lang_final_phase_enum
);
1277 fprintf (config
.map_file
, "Output address ");
1278 fprintf_vma (config
.map_file
, b
);
1279 fprintf (config
.map_file
, "\n");
1281 if (output_section_statement
->section_alignment
>= 0
1282 || output_section_statement
->subsection_alignment
>= 0)
1284 fprintf (config
.map_file
, "\t\t\t\t\tforced alignment ");
1285 if (output_section_statement
->section_alignment
>= 0)
1287 fprintf (config
.map_file
, "section 2**%d ",output_section_statement
->section_alignment
);
1289 if ( output_section_statement
->subsection_alignment
>= 0)
1291 fprintf (config
.map_file
, "subsection 2**%d ",output_section_statement
->subsection_alignment
);
1296 print_statement_list (output_section_statement
->children
.head
,
1297 output_section_statement
);
1302 print_assignment (assignment
, output_section
)
1303 lang_assignment_statement_type
* assignment
;
1304 lang_output_section_statement_type
* output_section
;
1306 etree_value_type result
;
1312 print_address (print_dot
);
1314 result
= exp_fold_tree (assignment
->exp
->assign
.src
,
1316 lang_final_phase_enum
,
1322 print_address (result
.value
);
1326 fprintf (config
.map_file
, "*undefined*");
1329 exp_print_tree (assignment
->exp
);
1331 fprintf (config
.map_file
, "\n");
1335 print_input_statement (statm
)
1336 lang_input_statement_type
* statm
;
1338 if (statm
->filename
!= (char *) NULL
)
1340 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1344 /* Print all the defined symbols for the abfd provided by in the supplied
1349 print_one_symbol (hash_entry
, ptr
)
1350 struct bfd_link_hash_entry
*hash_entry
;
1353 asection
* sec
= (asection
*)ptr
;
1355 if (hash_entry
->type
== bfd_link_hash_defined
1356 || hash_entry
->type
== bfd_link_hash_defweak
)
1358 if (sec
== hash_entry
->u
.def
.section
) {
1360 fprintf (config
.map_file
, " ");
1362 fprintf (config
.map_file
, " ");
1363 print_address (hash_entry
->u
.def
.value
+ outside_section_address (sec
));
1364 fprintf (config
.map_file
, " %s", hash_entry
->root
.string
);
1373 print_input_section (in
)
1374 lang_input_section_type
* in
;
1376 asection
*i
= in
->section
;
1377 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
1382 fprintf (config
.map_file
, " ");
1383 print_section (i
->name
);
1384 fprintf (config
.map_file
, " ");
1385 if (i
->output_section
)
1387 print_address (i
->output_section
->vma
+ i
->output_offset
);
1388 fprintf (config
.map_file
, " ");
1389 print_size (i
->_raw_size
);
1390 fprintf (config
.map_file
, " ");
1391 print_size(i
->_cooked_size
);
1392 fprintf (config
.map_file
, " ");
1393 print_alignment (i
->alignment_power
);
1394 fprintf (config
.map_file
, " ");
1398 bfd
*abfd
= in
->ifile
->the_bfd
;
1400 if (in
->ifile
->just_syms_flag
== true)
1402 fprintf (config
.map_file
, "symbols only ");
1405 fprintf (config
.map_file
, " %s ", abfd
->xvec
->name
);
1406 if (abfd
->my_archive
!= (bfd
*) NULL
)
1408 fprintf (config
.map_file
, "[%s]%s", abfd
->my_archive
->filename
,
1413 fprintf (config
.map_file
, "%s", abfd
->filename
);
1415 fprintf (config
.map_file
, "(overhead %d bytes)", (int) bfd_alloc_size (abfd
));
1418 /* Print all the symbols */
1419 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
1427 print_dot
= outside_section_address (i
) + size
;
1431 fprintf (config
.map_file
, "No output section allocated\n");
1437 print_fill_statement (fill
)
1438 lang_fill_statement_type
* fill
;
1440 fprintf (config
.map_file
, "FILL mask ");
1441 print_fill (fill
->fill
);
1445 print_data_statement (data
)
1446 lang_data_statement_type
* data
;
1448 /* bfd_vma value; */
1453 /* ASSERT(print_dot == data->output_vma);*/
1455 /* data->output_section may be NULL if called from gdb. */
1456 if (data
->output_section
)
1457 print_address (data
->output_vma
+ data
->output_section
->vma
);
1459 print_address (data
->output_vma
);
1461 print_address (data
->value
);
1466 fprintf (config
.map_file
, "BYTE ");
1467 print_dot
+= BYTE_SIZE
;
1470 fprintf (config
.map_file
, "SHORT ");
1471 print_dot
+= SHORT_SIZE
;
1474 fprintf (config
.map_file
, "LONG ");
1475 print_dot
+= LONG_SIZE
;
1478 fprintf (config
.map_file
, "QUAD ");
1479 print_dot
+= QUAD_SIZE
;
1483 exp_print_tree (data
->exp
);
1485 fprintf (config
.map_file
, "\n");
1488 /* Print a reloc statement. */
1491 print_reloc_statement (reloc
)
1492 lang_reloc_statement_type
*reloc
;
1499 /* ASSERT(print_dot == data->output_vma);*/
1501 /* reloc->output_section may be NULL if called from gdb. */
1502 if (reloc
->output_section
)
1503 print_address (reloc
->output_vma
+ reloc
->output_section
->vma
);
1505 print_address (reloc
->output_vma
);
1507 print_address (reloc
->addend_value
);
1510 fprintf (config
.map_file
, "RELOC %s ", reloc
->howto
->name
);
1512 print_dot
+= bfd_get_reloc_size (reloc
->howto
);
1514 exp_print_tree (reloc
->addend_exp
);
1516 fprintf (config
.map_file
, "\n");
1520 print_padding_statement (s
)
1521 lang_padding_statement_type
* s
;
1525 print_section ("*fill*");
1527 /* s->output_section may be NULL if called from gdb. */
1528 if (s
->output_section
)
1529 print_address (s
->output_offset
+ s
->output_section
->vma
);
1531 print_address (s
->output_offset
);
1533 print_size (s
->size
);
1535 print_fill (s
->fill
);
1538 print_dot
= s
->output_offset
+ s
->size
;
1539 /* s->output_section may be NULL if called from gdb. */
1540 if (s
->output_section
)
1541 print_dot
+= s
->output_section
->vma
;
1545 print_wild_statement (w
, os
)
1546 lang_wild_statement_type
* w
;
1547 lang_output_section_statement_type
* os
;
1549 fprintf (config
.map_file
, " from ");
1550 if (w
->filename
!= (char *) NULL
)
1552 fprintf (config
.map_file
, "%s", w
->filename
);
1556 fprintf (config
.map_file
, "*");
1558 if (w
->section_name
!= (char *) NULL
)
1560 fprintf (config
.map_file
, "(%s)", w
->section_name
);
1564 fprintf (config
.map_file
, "(*)");
1567 print_statement_list (w
->children
.head
, os
);
1571 /* Print a group statement. */
1575 lang_group_statement_type
*s
;
1576 lang_output_section_statement_type
*os
;
1578 fprintf (config
.map_file
, "START GROUP\n");
1579 print_statement_list (s
->children
.head
, os
);
1580 fprintf (config
.map_file
, "END GROUP\n");
1583 /* Print the list of statements in S.
1584 This can be called for any statement type. */
1587 print_statement_list (s
, os
)
1588 lang_statement_union_type
* s
;
1589 lang_output_section_statement_type
* os
;
1593 print_statement (s
, os
);
1598 /* Print the first statement in statement list S.
1599 This can be called for any statement type. */
1602 print_statement (s
, os
)
1603 lang_statement_union_type
* s
;
1604 lang_output_section_statement_type
* os
;
1606 switch (s
->header
.type
)
1608 case lang_constructors_statement_enum
:
1609 fprintf (config
.map_file
, "constructors:\n");
1610 print_statement_list (constructor_list
.head
, os
);
1612 case lang_wild_statement_enum
:
1613 print_wild_statement (&s
->wild_statement
, os
);
1616 fprintf (config
.map_file
, "Fail with %d\n", s
->header
.type
);
1619 case lang_address_statement_enum
:
1620 fprintf (config
.map_file
, "address\n");
1622 case lang_object_symbols_statement_enum
:
1623 fprintf (config
.map_file
, "object symbols\n");
1625 case lang_fill_statement_enum
:
1626 print_fill_statement (&s
->fill_statement
);
1628 case lang_data_statement_enum
:
1629 print_data_statement (&s
->data_statement
);
1631 case lang_reloc_statement_enum
:
1632 print_reloc_statement (&s
->reloc_statement
);
1634 case lang_input_section_enum
:
1635 print_input_section (&s
->input_section
);
1637 case lang_padding_statement_enum
:
1638 print_padding_statement (&s
->padding_statement
);
1640 case lang_output_section_statement_enum
:
1641 print_output_section_statement (&s
->output_section_statement
);
1643 case lang_assignment_statement_enum
:
1644 print_assignment (&s
->assignment_statement
,
1647 case lang_target_statement_enum
:
1648 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1650 case lang_output_statement_enum
:
1651 fprintf (config
.map_file
, "OUTPUT(%s %s)\n",
1652 s
->output_statement
.name
,
1653 output_target
? output_target
: "");
1655 case lang_input_statement_enum
:
1656 print_input_statement (&s
->input_statement
);
1658 case lang_group_statement_enum
:
1659 print_group (&s
->group_statement
, os
);
1661 case lang_afile_asection_pair_statement_enum
:
1671 print_statement_list (statement_list
.head
,
1672 abs_output_section
);
1676 /* Print the first N statements in statement list S to STDERR.
1677 If N == 0, nothing is printed.
1678 If N < 0, the entire list is printed.
1679 Intended to be called from GDB. */
1682 dprint_statement (s
, n
)
1683 lang_statement_union_type
* s
;
1686 FILE *map_save
= config
.map_file
;
1688 config
.map_file
= stderr
;
1691 print_statement_list (s
, abs_output_section
);
1696 print_statement (s
, abs_output_section
);
1701 config
.map_file
= map_save
;
1705 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
1706 lang_statement_union_type
** this_ptr
;
1709 asection
* output_section_statement
;
1712 /* Align this section first to the
1713 input sections requirement, then
1714 to the output section's requirement.
1715 If this alignment is > than any seen before,
1716 then record it too. Perform the alignment by
1717 inserting a magic 'padding' statement.
1720 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
1722 if (alignment_needed
!= 0)
1724 lang_statement_union_type
*new =
1725 ((lang_statement_union_type
*)
1726 stat_alloc (sizeof (lang_padding_statement_type
)));
1728 /* Link into existing chain */
1729 new->header
.next
= *this_ptr
;
1731 new->header
.type
= lang_padding_statement_enum
;
1732 new->padding_statement
.output_section
= output_section_statement
;
1733 new->padding_statement
.output_offset
=
1734 dot
- output_section_statement
->vma
;
1735 new->padding_statement
.fill
= fill
;
1736 new->padding_statement
.size
= alignment_needed
;
1740 /* Remember the most restrictive alignment */
1741 if (power
> output_section_statement
->alignment_power
)
1743 output_section_statement
->alignment_power
= power
;
1745 output_section_statement
->_raw_size
+= alignment_needed
;
1746 return alignment_needed
+ dot
;
1750 /* Work out how much this section will move the dot point */
1752 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
1753 lang_statement_union_type
** this_ptr
;
1754 lang_output_section_statement_type
* output_section_statement
;
1759 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1760 asection
*i
= is
->section
;
1762 if (is
->ifile
->just_syms_flag
== false)
1764 if (output_section_statement
->subsection_alignment
!= -1)
1765 i
->alignment_power
=
1766 output_section_statement
->subsection_alignment
;
1768 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
1769 output_section_statement
->bfd_section
, dot
);
1771 /* Remember where in the output section this input section goes */
1773 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1775 /* Mark how big the output section must be to contain this now
1777 if (i
->_cooked_size
!= 0)
1778 dot
+= i
->_cooked_size
;
1780 dot
+= i
->_raw_size
;
1781 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
1785 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
1791 /* This variable indicates whether bfd_relax_section should be called
1794 static boolean relax_again
;
1796 /* Set the sizes for all the output sections. */
1799 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
1800 lang_statement_union_type
* s
;
1801 lang_output_section_statement_type
* output_section_statement
;
1802 lang_statement_union_type
** prev
;
1807 /* Size up the sections from their constituent parts */
1808 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1810 switch (s
->header
.type
)
1813 case lang_output_section_statement_enum
:
1816 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
1818 if (os
->bfd_section
== NULL
)
1820 /* This section was never actually created. */
1824 /* If this is a COFF shared library section, use the size and
1825 address from the input section. FIXME: This is COFF
1826 specific; it would be cleaner if there were some other way
1827 to do this, but nothing simple comes to mind. */
1828 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
1832 if (os
->children
.head
== NULL
1833 || os
->children
.head
->next
!= NULL
1834 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
1835 einfo ("%P%X: Internal error on COFF shared library section %s",
1838 input
= os
->children
.head
->input_section
.section
;
1839 bfd_set_section_vma (os
->bfd_section
->owner
,
1841 bfd_section_vma (input
->owner
, input
));
1842 os
->bfd_section
->_raw_size
= input
->_raw_size
;
1846 if (bfd_is_abs_section (os
->bfd_section
))
1848 /* No matter what happens, an abs section starts at zero */
1849 ASSERT (os
->bfd_section
->vma
== 0);
1853 if (os
->addr_tree
== (etree_type
*) NULL
)
1855 /* No address specified for this section, get one
1856 from the region specification
1858 if (os
->region
== (lang_memory_region_type
*) NULL
)
1860 os
->region
= lang_memory_region_lookup ("*default*");
1862 dot
= os
->region
->current
;
1863 if (os
->section_alignment
== -1)
1864 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
1870 r
= exp_fold_tree (os
->addr_tree
,
1872 lang_allocating_phase_enum
,
1874 if (r
.valid
== false)
1876 einfo ("%F%S: non constant address expression for section %s\n",
1881 /* The section starts here */
1882 /* First, align to what the section needs */
1884 if (os
->section_alignment
!= -1)
1885 dot
= align_power (dot
, os
->section_alignment
);
1887 bfd_set_section_vma (0, os
->bfd_section
, dot
);
1889 os
->bfd_section
->output_offset
= 0;
1892 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
1893 os
->fill
, dot
, relax
);
1894 /* Ignore the size of the input sections, use the vma and size to */
1897 after
= ALIGN_N (os
->bfd_section
->vma
+
1898 os
->bfd_section
->_raw_size
,
1899 /* The coercion here is important, see ld.h. */
1900 (bfd_vma
) os
->block_value
);
1902 if (bfd_is_abs_section (os
->bfd_section
))
1903 ASSERT (after
== os
->bfd_section
->vma
);
1905 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
1906 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1907 os
->processed
= true;
1909 /* Replace into region ? */
1910 if (os
->region
!= (lang_memory_region_type
*) NULL
)
1912 os
->region
->current
= dot
;
1913 /* Make sure this isn't silly. */
1914 if ((os
->region
->current
< os
->region
->origin
)
1915 || (os
->region
->current
1916 > os
->region
->origin
+ os
->region
->length
))
1918 if (os
->addr_tree
!= (etree_type
*) NULL
)
1920 einfo ("%X%P: address 0x%v of %B section %s is not within region %s\n",
1921 os
->region
->current
,
1922 os
->bfd_section
->owner
,
1923 os
->bfd_section
->name
,
1928 einfo ("%X%P: region %s is full (%B section %s)\n",
1930 os
->bfd_section
->owner
,
1931 os
->bfd_section
->name
);
1933 /* Reset the region pointer. */
1934 os
->region
->current
= os
->region
->origin
;
1940 case lang_constructors_statement_enum
:
1941 dot
= lang_size_sections (constructor_list
.head
,
1942 output_section_statement
,
1943 &s
->wild_statement
.children
.head
,
1948 case lang_data_statement_enum
:
1950 unsigned int size
= 0;
1952 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1953 s
->data_statement
.output_section
=
1954 output_section_statement
->bfd_section
;
1956 switch (s
->data_statement
.type
)
1973 output_section_statement
->bfd_section
->_raw_size
+= size
;
1974 /* The output section gets contents, and then we inspect for
1975 any flags set in the input script which override any ALLOC */
1976 output_section_statement
->bfd_section
->flags
|= SEC_HAS_CONTENTS
;
1977 if (!(output_section_statement
->flags
& SEC_NEVER_LOAD
)) {
1978 output_section_statement
->bfd_section
->flags
|= SEC_ALLOC
| SEC_LOAD
;
1983 case lang_reloc_statement_enum
:
1987 s
->reloc_statement
.output_vma
=
1988 dot
- output_section_statement
->bfd_section
->vma
;
1989 s
->reloc_statement
.output_section
=
1990 output_section_statement
->bfd_section
;
1991 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
1993 output_section_statement
->bfd_section
->_raw_size
+= size
;
1997 case lang_wild_statement_enum
:
1999 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
2000 output_section_statement
,
2001 &s
->wild_statement
.children
.head
,
2007 case lang_object_symbols_statement_enum
:
2008 link_info
.create_object_symbols_section
=
2009 output_section_statement
->bfd_section
;
2011 case lang_output_statement_enum
:
2012 case lang_target_statement_enum
:
2014 case lang_input_section_enum
:
2018 i
= (*prev
)->input_section
.section
;
2020 i
->_cooked_size
= i
->_raw_size
;
2025 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
2026 einfo ("%P%F: can't relax section: %E\n");
2030 dot
= size_input_section (prev
,
2031 output_section_statement
,
2032 output_section_statement
->fill
,
2036 case lang_input_statement_enum
:
2038 case lang_fill_statement_enum
:
2039 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
2041 fill
= s
->fill_statement
.fill
;
2043 case lang_assignment_statement_enum
:
2045 bfd_vma newdot
= dot
;
2047 exp_fold_tree (s
->assignment_statement
.exp
,
2048 output_section_statement
,
2049 lang_allocating_phase_enum
,
2053 if (newdot
!= dot
&& !relax
)
2055 /* The assignment changed dot. Insert a pad. */
2056 if (output_section_statement
== abs_output_section
)
2058 /* If we don't have an output section, then just adjust
2059 the default memory address. */
2060 lang_memory_region_lookup ("*default*")->current
= newdot
;
2064 lang_statement_union_type
*new =
2065 ((lang_statement_union_type
*)
2066 stat_alloc (sizeof (lang_padding_statement_type
)));
2068 /* Link into existing chain */
2069 new->header
.next
= *prev
;
2071 new->header
.type
= lang_padding_statement_enum
;
2072 new->padding_statement
.output_section
=
2073 output_section_statement
->bfd_section
;
2074 new->padding_statement
.output_offset
=
2075 dot
- output_section_statement
->bfd_section
->vma
;
2076 new->padding_statement
.fill
= fill
;
2077 new->padding_statement
.size
= newdot
- dot
;
2078 output_section_statement
->bfd_section
->_raw_size
+=
2079 new->padding_statement
.size
;
2087 case lang_padding_statement_enum
:
2088 /* If we are relaxing, and this is not the first pass, some
2089 padding statements may have been inserted during previous
2090 passes. We may have to move the padding statement to a new
2091 location if dot has a different value at this point in this
2092 pass than it did at this point in the previous pass. */
2093 s
->padding_statement
.output_offset
=
2094 dot
- output_section_statement
->bfd_section
->vma
;
2095 dot
+= s
->padding_statement
.size
;
2096 output_section_statement
->bfd_section
->_raw_size
+=
2097 s
->padding_statement
.size
;
2100 case lang_group_statement_enum
:
2101 dot
= lang_size_sections (s
->group_statement
.children
.head
,
2102 output_section_statement
,
2103 &s
->group_statement
.children
.head
,
2111 /* This can only get here when relaxing is turned on */
2113 case lang_address_statement_enum
:
2116 prev
= &s
->header
.next
;
2122 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
2123 lang_statement_union_type
* s
;
2124 lang_output_section_statement_type
* output_section_statement
;
2128 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
2130 switch (s
->header
.type
)
2132 case lang_constructors_statement_enum
:
2133 dot
= lang_do_assignments (constructor_list
.head
,
2134 output_section_statement
,
2139 case lang_output_section_statement_enum
:
2141 lang_output_section_statement_type
*os
=
2142 &(s
->output_section_statement
);
2144 if (os
->bfd_section
!= NULL
)
2146 dot
= os
->bfd_section
->vma
;
2147 (void) lang_do_assignments (os
->children
.head
, os
,
2149 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
2153 /* If nothing has been placed into the output section then
2154 it won't have a bfd_section. */
2155 if (os
->bfd_section
)
2157 os
->bfd_section
->lma
2158 = exp_get_abs_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
2163 case lang_wild_statement_enum
:
2165 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
2166 output_section_statement
,
2171 case lang_object_symbols_statement_enum
:
2172 case lang_output_statement_enum
:
2173 case lang_target_statement_enum
:
2175 case lang_common_statement_enum
:
2178 case lang_data_statement_enum
:
2180 etree_value_type value
;
2182 value
= exp_fold_tree (s
->data_statement
.exp
,
2184 lang_final_phase_enum
, dot
, &dot
);
2185 s
->data_statement
.value
= value
.value
;
2186 if (value
.valid
== false)
2187 einfo ("%F%P: invalid data statement\n");
2189 switch (s
->data_statement
.type
)
2206 case lang_reloc_statement_enum
:
2208 etree_value_type value
;
2210 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
2212 lang_final_phase_enum
, dot
, &dot
);
2213 s
->reloc_statement
.addend_value
= value
.value
;
2214 if (value
.valid
== false)
2215 einfo ("%F%P: invalid reloc statement\n");
2217 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
);
2220 case lang_input_section_enum
:
2222 asection
*in
= s
->input_section
.section
;
2224 if (in
->_cooked_size
!= 0)
2225 dot
+= in
->_cooked_size
;
2227 dot
+= in
->_raw_size
;
2231 case lang_input_statement_enum
:
2233 case lang_fill_statement_enum
:
2234 fill
= s
->fill_statement
.fill
;
2236 case lang_assignment_statement_enum
:
2238 exp_fold_tree (s
->assignment_statement
.exp
,
2239 output_section_statement
,
2240 lang_final_phase_enum
,
2246 case lang_padding_statement_enum
:
2247 dot
+= s
->padding_statement
.size
;
2250 case lang_group_statement_enum
:
2251 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
2252 output_section_statement
,
2260 case lang_address_statement_enum
:
2268 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
2269 operator .startof. (section_name), it produces an undefined symbol
2270 .startof.section_name. Similarly, when it sees
2271 .sizeof. (section_name), it produces an undefined symbol
2272 .sizeof.section_name. For all the output sections, we look for
2273 such symbols, and set them to the correct value. */
2280 if (link_info
.relocateable
)
2283 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
2285 const char *secname
;
2287 struct bfd_link_hash_entry
*h
;
2289 secname
= bfd_get_section_name (output_bfd
, s
);
2290 buf
= xmalloc (10 + strlen (secname
));
2292 sprintf (buf
, ".startof.%s", secname
);
2293 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
2294 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
2296 h
->type
= bfd_link_hash_defined
;
2297 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, s
);
2298 h
->u
.def
.section
= bfd_abs_section_ptr
;
2301 sprintf (buf
, ".sizeof.%s", secname
);
2302 h
= bfd_link_hash_lookup (link_info
.hash
, buf
, false, false, true);
2303 if (h
!= NULL
&& h
->type
== bfd_link_hash_undefined
)
2305 h
->type
= bfd_link_hash_defined
;
2306 if (s
->_cooked_size
!= 0)
2307 h
->u
.def
.value
= s
->_cooked_size
;
2309 h
->u
.def
.value
= s
->_raw_size
;
2310 h
->u
.def
.section
= bfd_abs_section_ptr
;
2320 struct bfd_link_hash_entry
*h
;
2323 if (link_info
.relocateable
|| link_info
.shared
)
2328 if (entry_symbol
== (char *) NULL
)
2330 /* No entry has been specified. Look for start, but don't warn
2331 if we don't find it. */
2332 entry_symbol
= "start";
2336 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
2337 if (h
!= (struct bfd_link_hash_entry
*) NULL
2338 && (h
->type
== bfd_link_hash_defined
2339 || h
->type
== bfd_link_hash_defweak
)
2340 && h
->u
.def
.section
->output_section
!= NULL
)
2344 val
= (h
->u
.def
.value
2345 + bfd_get_section_vma (output_bfd
,
2346 h
->u
.def
.section
->output_section
)
2347 + h
->u
.def
.section
->output_offset
);
2348 if (! bfd_set_start_address (output_bfd
, val
))
2349 einfo ("%P%F:%s: can't set start address\n", entry_symbol
);
2355 /* Can't find the entry symbol. Use the first address in the
2357 ts
= bfd_get_section_by_name (output_bfd
, ".text");
2358 if (ts
!= (asection
*) NULL
)
2361 einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
2362 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
2363 if (! bfd_set_start_address (output_bfd
,
2364 bfd_get_section_vma (output_bfd
, ts
)))
2365 einfo ("%P%F: can't set start address\n");
2370 einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2376 /* Check that the architecture of all the input files is compatible
2377 with the output file. Also call the backend to let it do any
2378 other checking that is needed. */
2383 lang_statement_union_type
*file
;
2385 CONST bfd_arch_info_type
*compatible
;
2387 for (file
= file_chain
.head
;
2388 file
!= (lang_statement_union_type
*) NULL
;
2389 file
= file
->input_statement
.next
)
2391 input_bfd
= file
->input_statement
.the_bfd
;
2392 compatible
= bfd_arch_get_compatible (input_bfd
,
2394 if (compatible
== NULL
)
2395 einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2396 bfd_printable_name (input_bfd
), input_bfd
,
2397 bfd_printable_name (output_bfd
));
2400 bfd_merge_private_bfd_data (input_bfd
, output_bfd
);
2404 /* Look through all the global common symbols and attach them to the
2405 correct section. The -sort-common command line switch may be used
2406 to roughly sort the entries by size. */
2411 if (link_info
.relocateable
2412 && ! command_line
.force_common_definition
)
2415 if (! config
.sort_common
)
2416 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
2421 for (power
= 4; power
>= 0; power
--)
2422 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
2427 /* Place one common symbol in the correct section. */
2430 lang_one_common (h
, info
)
2431 struct bfd_link_hash_entry
*h
;
2434 unsigned int power_of_two
;
2438 if (h
->type
!= bfd_link_hash_common
)
2442 power_of_two
= h
->u
.c
.p
->alignment_power
;
2444 if (config
.sort_common
2445 && power_of_two
< (unsigned int) *(int *) info
)
2448 section
= h
->u
.c
.p
->section
;
2450 /* Increase the size of the section. */
2451 section
->_raw_size
= ALIGN_N (section
->_raw_size
,
2452 (bfd_size_type
) (1 << power_of_two
));
2454 /* Adjust the alignment if necessary. */
2455 if (power_of_two
> section
->alignment_power
)
2456 section
->alignment_power
= power_of_two
;
2458 /* Change the symbol from common to defined. */
2459 h
->type
= bfd_link_hash_defined
;
2460 h
->u
.def
.section
= section
;
2461 h
->u
.def
.value
= section
->_raw_size
;
2463 /* Increase the size of the section. */
2464 section
->_raw_size
+= size
;
2466 /* Make sure the section is allocated in memory. */
2467 section
->flags
|= SEC_ALLOC
;
2469 if (config
.map_file
!= NULL
)
2470 fprintf (config
.map_file
, "Allocating common %s: %lx at %lx %s\n",
2471 h
->root
.string
, (unsigned long) size
,
2472 (unsigned long) h
->u
.def
.value
, section
->owner
->filename
);
2478 run through the input files and ensure that every input
2479 section has somewhere to go. If one is found without
2480 a destination then create an input request and place it
2481 into the statement tree.
2485 lang_place_orphans ()
2487 lang_input_statement_type
*file
;
2489 for (file
= (lang_input_statement_type
*) file_chain
.head
;
2490 file
!= (lang_input_statement_type
*) NULL
;
2491 file
= (lang_input_statement_type
*) file
->next
)
2495 for (s
= file
->the_bfd
->sections
;
2496 s
!= (asection
*) NULL
;
2499 if (s
->output_section
== (asection
*) NULL
)
2501 /* This section of the file is not attatched, root
2502 around for a sensible place for it to go */
2504 if (file
->just_syms_flag
)
2506 /* We are only retrieving symbol values from this
2507 file. We want the symbols to act as though the
2508 values in the file are absolute. */
2509 s
->output_section
= bfd_abs_section_ptr
;
2510 s
->output_offset
= s
->vma
;
2512 else if (file
->common_section
== s
)
2514 /* This is a lonely common section which must
2515 have come from an archive. We attatch to the
2516 section with the wildcard */
2517 if (! link_info
.relocateable
2518 && ! command_line
.force_common_definition
)
2520 if (default_common_section
==
2521 (lang_output_section_statement_type
*) NULL
)
2523 info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2525 default_common_section
=
2526 lang_output_section_statement_lookup (".bss");
2529 wild_doit (&default_common_section
->children
, s
,
2530 default_common_section
, file
);
2533 else if (ldemul_place_orphan (file
, s
))
2537 lang_output_section_statement_type
*os
=
2538 lang_output_section_statement_lookup (s
->name
);
2540 wild_doit (&os
->children
, s
, os
, file
);
2549 lang_set_flags (ptr
, flags
)
2553 boolean state
= false;
2568 /* ptr->flag_read = state; */
2571 /* ptr->flag_write = state; */
2574 /* ptr->flag_executable= state;*/
2578 /* ptr->flag_loadable= state;*/
2581 einfo ("%P%F: invalid syntax in flags\n");
2588 /* Call a function on each input file. This function will be called
2589 on an archive, but not on the elements. */
2592 lang_for_each_input_file (func
)
2593 void (*func
) PARAMS ((lang_input_statement_type
*));
2595 lang_input_statement_type
*f
;
2597 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
2599 f
= (lang_input_statement_type
*) f
->next_real_file
)
2603 /* Call a function on each file. The function will be called on all
2604 the elements of an archive which are included in the link, but will
2605 not be called on the archive file itself. */
2608 lang_for_each_file (func
)
2609 void (*func
) PARAMS ((lang_input_statement_type
*));
2611 lang_input_statement_type
*f
;
2613 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2614 f
!= (lang_input_statement_type
*) NULL
;
2615 f
= (lang_input_statement_type
*) f
->next
)
2626 lang_for_each_input_section (func
)
2627 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
2629 lang_input_statement_type
*f
;
2631 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2632 f
!= (lang_input_statement_type
*) NULL
;
2633 f
= (lang_input_statement_type
*) f
->next
)
2637 for (s
= f
->the_bfd
->sections
;
2638 s
!= (asection
*) NULL
;
2641 func (f
->the_bfd
, s
);
2649 ldlang_add_file (entry
)
2650 lang_input_statement_type
* entry
;
2654 lang_statement_append (&file_chain
,
2655 (lang_statement_union_type
*) entry
,
2658 /* The BFD linker needs to have a list of all input BFDs involved in
2660 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
2661 ASSERT (entry
->the_bfd
!= output_bfd
);
2662 for (pp
= &link_info
.input_bfds
;
2663 *pp
!= (bfd
*) NULL
;
2664 pp
= &(*pp
)->link_next
)
2666 *pp
= entry
->the_bfd
;
2667 entry
->the_bfd
->usrdata
= (PTR
) entry
;
2668 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
2672 lang_add_output (name
, from_script
)
2676 /* Make -o on command line override OUTPUT in script. */
2677 if (had_output_filename
== false || !from_script
)
2679 output_filename
= name
;
2680 had_output_filename
= true;
2685 static lang_output_section_statement_type
*current_section
;
2697 for (l
= 0; l
< 32; l
++)
2699 if (i
>= (unsigned int) x
)
2707 lang_enter_output_section_statement (output_section_statement_name
,
2708 address_exp
, flags
, block_value
,
2709 align
, subalign
, ebase
)
2710 const char *output_section_statement_name
;
2711 etree_type
* address_exp
;
2713 bfd_vma block_value
;
2715 etree_type
*subalign
;
2718 lang_output_section_statement_type
*os
;
2722 lang_output_section_statement_lookup (output_section_statement_name
);
2726 /* Add this statement to tree */
2727 /* add_statement(lang_output_section_statement_enum,
2728 output_section_statement);*/
2729 /* Make next things chain into subchain of this */
2731 if (os
->addr_tree
==
2732 (etree_type
*) NULL
)
2738 if (flags
& SEC_NEVER_LOAD
)
2742 os
->block_value
= block_value
? block_value
: 1;
2743 stat_ptr
= &os
->children
;
2745 os
->subsection_alignment
= topower(
2746 exp_get_value_int(subalign
, -1,
2747 "subsection alignment",
2749 os
->section_alignment
= topower(
2750 exp_get_value_int(align
, -1,
2751 "section alignment", 0));
2753 os
->load_base
= ebase
;
2760 lang_output_statement_type
*new =
2761 new_stat (lang_output_statement
, stat_ptr
);
2763 new->name
= output_filename
;
2766 /* Reset the current counters in the regions */
2768 reset_memory_regions ()
2770 lang_memory_region_type
*p
= lang_memory_region_list
;
2772 for (p
= lang_memory_region_list
;
2773 p
!= (lang_memory_region_type
*) NULL
;
2776 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
2777 p
->current
= p
->origin
;
2784 lang_reasonable_defaults ();
2785 current_target
= default_target
;
2787 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
2789 ldemul_create_output_section_statements ();
2791 /* Add to the hash table all undefineds on the command line */
2792 lang_place_undefineds ();
2794 /* Create a bfd for each input file */
2795 current_target
= default_target
;
2796 open_input_bfds (statement_list
.head
, false);
2798 ldemul_after_open ();
2800 /* Build all sets based on the information gathered from the input
2802 ldctor_build_sets ();
2804 /* Size up the common data */
2807 /* Run through the contours of the script and attatch input sections
2808 to the correct output sections
2810 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
2811 (lang_output_section_statement_type
*) NULL
);
2814 /* Find any sections not attatched explicitly and handle them */
2815 lang_place_orphans ();
2817 ldemul_before_allocation ();
2819 /* We must record the program headers before we try to fix the
2820 section positions, since they will affect SIZEOF_HEADERS. */
2821 lang_record_phdrs ();
2823 /* Now run around and relax if we can */
2824 if (command_line
.relax
)
2826 /* First time round is a trial run to get the 'worst case'
2827 addresses of the objects if there was no relaxing. */
2828 lang_size_sections (statement_list
.head
,
2830 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2832 /* Keep relaxing until bfd_relax_section gives up. */
2835 reset_memory_regions ();
2837 relax_again
= false;
2839 /* Do all the assignments with our current guesses as to
2841 lang_do_assignments (statement_list
.head
,
2843 (fill_type
) 0, (bfd_vma
) 0);
2845 /* Perform another relax pass - this time we know where the
2846 globals are, so can make better guess. */
2847 lang_size_sections (statement_list
.head
,
2849 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2851 while (relax_again
);
2855 /* Size up the sections. */
2856 lang_size_sections (statement_list
.head
,
2858 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2861 /* See if anything special should be done now we know how big
2863 ldemul_after_allocation ();
2865 /* Fix any .startof. or .sizeof. symbols. */
2866 lang_set_startof ();
2868 /* Do all the assignments, now that we know the final restingplaces
2869 of all the symbols */
2871 lang_do_assignments (statement_list
.head
,
2873 (fill_type
) 0, (bfd_vma
) 0);
2875 /* Make sure that we're not mixing architectures */
2885 /* EXPORTED TO YACC */
2888 lang_add_wild (section_name
, filename
)
2889 CONST
char *CONST section_name
;
2890 CONST
char *CONST filename
;
2892 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
2895 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
2897 placed_commons
= true;
2899 if (filename
!= (char *) NULL
)
2901 lang_has_input_file
= true;
2903 new->section_name
= section_name
;
2904 new->filename
= filename
;
2905 lang_list_init (&new->children
);
2909 lang_section_start (name
, address
)
2911 etree_type
* address
;
2913 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
2915 ad
->section_name
= name
;
2916 ad
->address
= address
;
2919 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
2920 because of a -e argument on the command line, or zero if this is
2921 called by ENTRY in a linker script. Command line arguments take
2924 /* WINDOWS_NT. When an entry point has been specified, we will also force
2925 this symbol to be defined by calling ldlang_add_undef (equivalent to
2926 having switch -u entry_name on the command line). The reason we do
2927 this is so that the user doesn't have to because they would have to use
2928 the -u switch if they were specifying an entry point other than
2929 _mainCRTStartup. Specifically, if creating a windows application, entry
2930 point _WinMainCRTStartup must be specified.
2931 What I have found for non console applications (entry not _mainCRTStartup)
2932 is that the .obj that contains mainCRTStartup is brought in since it is
2933 the first encountered in libc.lib and it has other symbols in it which will
2934 be pulled in by the link process. To avoid this, adding -u with the entry
2935 point name specified forces the correct .obj to be used. We can avoid
2936 making the user do this by always adding the entry point name as an
2937 undefined symbol. */
2940 lang_add_entry (name
, cmdline
)
2944 if (entry_symbol
== NULL
2946 || ! entry_from_cmdline
)
2948 entry_symbol
= name
;
2949 entry_from_cmdline
= cmdline
;
2952 /* don't do this yet. It seems to work (the executables run), but the
2953 image created is very different from what I was getting before indicating
2954 that something else is being pulled in. When everything else is working,
2955 then try to put this back in to see if it will do the right thing for
2956 other more complicated applications */
2957 ldlang_add_undef (name
);
2962 lang_add_target (name
)
2965 lang_target_statement_type
*new = new_stat (lang_target_statement
,
2981 map_option_f
= true;
2992 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
2999 lang_add_data (type
, exp
)
3001 union etree_union
*exp
;
3004 lang_data_statement_type
*new = new_stat (lang_data_statement
,
3012 /* Create a new reloc statement. RELOC is the BFD relocation type to
3013 generate. HOWTO is the corresponding howto structure (we could
3014 look this up, but the caller has already done so). SECTION is the
3015 section to generate a reloc against, or NAME is the name of the
3016 symbol to generate a reloc against. Exactly one of SECTION and
3017 NAME must be NULL. ADDEND is an expression for the addend. */
3020 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
3021 bfd_reloc_code_real_type reloc
;
3022 reloc_howto_type
*howto
;
3025 union etree_union
*addend
;
3027 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
3031 p
->section
= section
;
3033 p
->addend_exp
= addend
;
3035 p
->addend_value
= 0;
3036 p
->output_section
= NULL
;
3041 lang_add_assignment (exp
)
3044 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
3051 lang_add_attribute (attribute
)
3052 enum statement_enum attribute
;
3054 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
3061 if (startup_file
!= (char *) NULL
)
3063 einfo ("%P%Fmultiple STARTUP files\n");
3065 first_file
->filename
= name
;
3066 first_file
->local_sym_name
= name
;
3067 first_file
->real
= true;
3069 startup_file
= name
;
3076 lang_float_flag
= maybe
;
3080 lang_leave_output_section_statement (fill
, memspec
)
3082 CONST
char *memspec
;
3084 current_section
->fill
= fill
;
3085 current_section
->region
= lang_memory_region_lookup (memspec
);
3086 stat_ptr
= &statement_list
;
3090 Create an absolute symbol with the given name with the value of the
3091 address of first byte of the section named.
3093 If the symbol already exists, then do nothing.
3096 lang_abs_symbol_at_beginning_of (secname
, name
)
3097 const char *secname
;
3100 struct bfd_link_hash_entry
*h
;
3102 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
3103 if (h
== (struct bfd_link_hash_entry
*) NULL
)
3104 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
3106 if (h
->type
== bfd_link_hash_new
3107 || h
->type
== bfd_link_hash_undefined
)
3111 h
->type
= bfd_link_hash_defined
;
3113 sec
= bfd_get_section_by_name (output_bfd
, secname
);
3114 if (sec
== (asection
*) NULL
)
3117 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
3119 h
->u
.def
.section
= bfd_abs_section_ptr
;
3124 Create an absolute symbol with the given name with the value of the
3125 address of the first byte after the end of the section named.
3127 If the symbol already exists, then do nothing.
3130 lang_abs_symbol_at_end_of (secname
, name
)
3131 const char *secname
;
3134 struct bfd_link_hash_entry
*h
;
3136 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
3137 if (h
== (struct bfd_link_hash_entry
*) NULL
)
3138 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
3140 if (h
->type
== bfd_link_hash_new
3141 || h
->type
== bfd_link_hash_undefined
)
3145 h
->type
= bfd_link_hash_defined
;
3147 sec
= bfd_get_section_by_name (output_bfd
, secname
);
3148 if (sec
== (asection
*) NULL
)
3151 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
3152 + bfd_section_size (output_bfd
, sec
));
3154 h
->u
.def
.section
= bfd_abs_section_ptr
;
3159 lang_statement_append (list
, element
, field
)
3160 lang_statement_list_type
* list
;
3161 lang_statement_union_type
* element
;
3162 lang_statement_union_type
** field
;
3164 *(list
->tail
) = element
;
3168 /* Set the output format type. -oformat overrides scripts. */
3171 lang_add_output_format (format
, big
, little
, from_script
)
3177 if (output_target
== NULL
|| !from_script
)
3179 if (command_line
.endian
== ENDIAN_BIG
3182 else if (command_line
.endian
== ENDIAN_LITTLE
3186 output_target
= format
;
3190 /* Enter a group. This creates a new lang_group_statement, and sets
3191 stat_ptr to build new statements within the group. */
3196 lang_group_statement_type
*g
;
3198 g
= new_stat (lang_group_statement
, stat_ptr
);
3199 lang_list_init (&g
->children
);
3200 stat_ptr
= &g
->children
;
3203 /* Leave a group. This just resets stat_ptr to start writing to the
3204 regular list of statements again. Note that this will not work if
3205 groups can occur inside anything else which can adjust stat_ptr,
3206 but currently they can't. */
3211 stat_ptr
= &statement_list
;
3214 /* Add a new program header. This is called for each entry in a PHDRS
3215 command in a linker script. */
3218 lang_new_phdr (name
, type
, filehdr
, phdrs
, at
, flags
)
3226 struct lang_phdr
*n
, **pp
;
3228 n
= (struct lang_phdr
*) stat_alloc (sizeof (struct lang_phdr
));
3231 n
->type
= exp_get_value_int (type
, 0, "program header type",
3232 lang_final_phase_enum
);
3233 n
->filehdr
= filehdr
;
3238 for (pp
= &lang_phdr_list
; *pp
!= NULL
; pp
= &(*pp
)->next
)
3243 /* Record that a section should be placed in a phdr. */
3246 lang_section_in_phdr (name
)
3249 struct lang_output_section_phdr_list
*n
;
3251 n
= ((struct lang_output_section_phdr_list
*)
3252 stat_alloc (sizeof (struct lang_output_section_phdr_list
)));
3255 n
->next
= current_section
->phdrs
;
3256 current_section
->phdrs
= n
;
3259 /* Record the program header information in the output BFD. FIXME: We
3260 should not be calling an ELF specific function here. */
3263 lang_record_phdrs ()
3267 struct lang_output_section_phdr_list
*last
;
3268 struct lang_phdr
*l
;
3269 lang_statement_union_type
*u
;
3272 secs
= xmalloc (alc
* sizeof (asection
*));
3274 for (l
= lang_phdr_list
; l
!= NULL
; l
= l
->next
)
3281 for (u
= lang_output_section_statement
.head
;
3283 u
= u
->output_section_statement
.next
)
3285 lang_output_section_statement_type
*os
;
3286 struct lang_output_section_phdr_list
*pl
;
3288 os
= &u
->output_section_statement
;
3296 || os
->bfd_section
== NULL
3297 || (os
->bfd_section
->flags
& SEC_ALLOC
) == 0)
3302 if (os
->bfd_section
== NULL
)
3305 for (; pl
!= NULL
; pl
= pl
->next
)
3307 if (strcmp (pl
->name
, l
->name
) == 0)
3312 secs
= xrealloc (secs
, alc
* sizeof (asection
*));
3314 secs
[c
] = os
->bfd_section
;
3321 if (l
->flags
== NULL
)
3324 flags
= exp_get_vma (l
->flags
, 0, "phdr flags",
3325 lang_final_phase_enum
);
3330 at
= exp_get_vma (l
->at
, 0, "phdr load address",
3331 lang_final_phase_enum
);
3333 if (! bfd_record_phdr (output_bfd
, l
->type
,
3334 l
->flags
== NULL
? false : true,
3336 l
->at
== NULL
? false : true,
3337 at
, l
->filehdr
, l
->phdrs
, c
, secs
))
3338 einfo ("%F%P: bfd_record_phdr failed: %E\n");
3343 /* Make sure all the phdr assignments succeeded. */
3344 for (u
= lang_output_section_statement
.head
;
3346 u
= u
->output_section_statement
.next
)
3348 struct lang_output_section_phdr_list
*pl
;
3350 if (u
->output_section_statement
.bfd_section
== NULL
)
3353 for (pl
= u
->output_section_statement
.phdrs
;
3356 if (! pl
->used
&& strcmp (pl
->name
, "NONE") != 0)
3357 einfo ("%X%P: section `%s' assigned to non-existent phdr `%s'\n",
3358 u
->output_section_statement
.name
, pl
->name
);