1 /* Linker command language support.
2 Copyright (C) 1991, 92, 93, 94, 1995 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. */
22 #include "libiberty.h"
37 static void print_statements
PARAMS ((void));
38 static void print_statement
PARAMS ((lang_statement_union_type
*,
39 lang_output_section_statement_type
*));
40 static lang_statement_union_type
*new_statement
PARAMS ((enum statement_enum
,
42 lang_statement_list_type
*));
46 static struct obstack stat_obstack
;
48 #define obstack_chunk_alloc xmalloc
49 #define obstack_chunk_free free
50 static CONST
char *startup_file
;
51 static lang_statement_list_type input_file_chain
;
52 static boolean placed_commons
= false;
53 static lang_output_section_statement_type
*default_common_section
;
54 static boolean map_option_f
;
55 static bfd_vma print_dot
;
56 static lang_input_statement_type
*first_file
;
57 static lang_statement_list_type lang_output_section_statement
;
58 static CONST
char *current_target
;
59 static CONST
char *output_target
;
60 static int longest_section_name
= 8;
61 static lang_statement_list_type statement_list
;
63 static void print_size
PARAMS ((size_t value
));
64 static void print_alignment
PARAMS ((unsigned int value
));
65 static void print_fill
PARAMS ((fill_type value
));
66 static void print_section
PARAMS ((const char *name
));
67 static void lang_for_each_statement_worker
68 PARAMS ((void (*func
) (lang_statement_union_type
*),
69 lang_statement_union_type
*s
));
70 static lang_input_statement_type
*new_afile
71 PARAMS ((const char *name
, lang_input_file_enum_type file_type
,
72 const char *target
, boolean add_to_list
));
73 static void print_flags
PARAMS ((int *ignore_flags
));
74 static void init_os
PARAMS ((lang_output_section_statement_type
*s
));
75 static void wild_section
PARAMS ((lang_wild_statement_type
*ptr
,
77 lang_input_statement_type
*file
,
78 lang_output_section_statement_type
*output
));
79 static lang_input_statement_type
*lookup_name
PARAMS ((const char *name
));
80 static void load_symbols
PARAMS ((lang_input_statement_type
*entry
,
81 lang_statement_list_type
*));
82 static void wild
PARAMS ((lang_wild_statement_type
*s
,
83 const char *section
, const char *file
,
85 lang_output_section_statement_type
*output
));
86 static bfd
*open_output
PARAMS ((const char *name
));
87 static void ldlang_open_output
PARAMS ((lang_statement_union_type
*statement
));
88 static void open_input_bfds
89 PARAMS ((lang_statement_union_type
*statement
, boolean
));
90 static void lang_reasonable_defaults
PARAMS ((void));
91 static void lang_place_undefineds
PARAMS ((void));
92 static void map_input_to_output_sections
93 PARAMS ((lang_statement_union_type
*s
,
95 lang_output_section_statement_type
*output_section_statement
));
96 static void print_output_section_statement
97 PARAMS ((lang_output_section_statement_type
*output_section_statement
));
98 static void print_assignment
99 PARAMS ((lang_assignment_statement_type
*assignment
,
100 lang_output_section_statement_type
*output_section
));
101 static void print_input_statement
PARAMS ((lang_input_statement_type
*statm
));
102 static void print_input_section
PARAMS ((lang_input_section_type
*in
));
103 static void print_fill_statement
PARAMS ((lang_fill_statement_type
*fill
));
104 static void print_data_statement
PARAMS ((lang_data_statement_type
*data
));
105 static void print_reloc_statement
PARAMS ((lang_reloc_statement_type
*reloc
));
106 static void print_padding_statement
PARAMS ((lang_padding_statement_type
*s
));
107 static void print_wild_statement
108 PARAMS ((lang_wild_statement_type
*w
,
109 lang_output_section_statement_type
*os
));
110 static void print_group
111 PARAMS ((lang_group_statement_type
*, lang_output_section_statement_type
*));
112 static void print_statement
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 reset_memory_regions
PARAMS ((void));
132 lang_output_section_statement_type
*abs_output_section
;
133 lang_statement_list_type
*stat_ptr
= &statement_list
;
134 lang_statement_list_type file_chain
= { 0 };
135 static const char *entry_symbol
= 0;
136 boolean lang_has_input_file
= false;
137 boolean had_output_filename
= false;
138 boolean lang_float_flag
= false;
139 boolean delete_output_file_on_failure
= false;
141 etree_type
*base
; /* Relocation base - or null */
144 #if defined(__STDC__) || defined(ALMOST_STDC)
145 #define cat(a,b) a##b
147 #define cat(a,b) a/**/b
150 #define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
152 #define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
154 #define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
160 return obstack_alloc (&stat_obstack
, size
);
167 fprintf (config
.map_file
, "%5x", (unsigned) value
);
171 print_alignment (value
)
174 fprintf (config
.map_file
, "2**%1u", value
);
181 fprintf (config
.map_file
, "%04x", (unsigned) value
);
188 fprintf (config
.map_file
, "%*s", -longest_section_name
, name
);
191 /*----------------------------------------------------------------------
192 lang_for_each_statement walks the parse tree and calls the provided
193 function for each node
197 lang_for_each_statement_worker (func
, s
)
198 void (*func
) PARAMS ((lang_statement_union_type
*));
199 lang_statement_union_type
*s
;
201 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
205 switch (s
->header
.type
)
207 case lang_constructors_statement_enum
:
208 lang_for_each_statement_worker (func
, constructor_list
.head
);
210 case lang_output_section_statement_enum
:
211 lang_for_each_statement_worker
213 s
->output_section_statement
.children
.head
);
215 case lang_wild_statement_enum
:
216 lang_for_each_statement_worker
218 s
->wild_statement
.children
.head
);
220 case lang_group_statement_enum
:
221 lang_for_each_statement_worker (func
,
222 s
->group_statement
.children
.head
);
224 case lang_data_statement_enum
:
225 case lang_reloc_statement_enum
:
226 case lang_object_symbols_statement_enum
:
227 case lang_output_statement_enum
:
228 case lang_target_statement_enum
:
229 case lang_input_section_enum
:
230 case lang_input_statement_enum
:
231 case lang_assignment_statement_enum
:
232 case lang_padding_statement_enum
:
233 case lang_address_statement_enum
:
243 lang_for_each_statement (func
)
244 void (*func
) PARAMS ((lang_statement_union_type
*));
246 lang_for_each_statement_worker (func
,
247 statement_list
.head
);
250 /*----------------------------------------------------------------------*/
252 lang_list_init (list
)
253 lang_statement_list_type
*list
;
255 list
->head
= (lang_statement_union_type
*) NULL
;
256 list
->tail
= &list
->head
;
259 /*----------------------------------------------------------------------
261 build a new statement node for the parse tree
266 lang_statement_union_type
*
267 new_statement (type
, size
, list
)
268 enum statement_enum type
;
270 lang_statement_list_type
* list
;
272 lang_statement_union_type
*new = (lang_statement_union_type
*)
275 new->header
.type
= type
;
276 new->header
.next
= (lang_statement_union_type
*) NULL
;
277 lang_statement_append (list
, new, &new->header
.next
);
282 Build a new input file node for the language. There are several ways
283 in which we treat an input file, eg, we only look at symbols, or
284 prefix it with a -l etc.
286 We can be supplied with requests for input files more than once;
287 they may, for example be split over serveral lines like foo.o(.text)
288 foo.o(.data) etc, so when asked for a file we check that we havn't
289 got it already so we don't duplicate the bfd.
292 static lang_input_statement_type
*
293 new_afile (name
, file_type
, target
, add_to_list
)
295 lang_input_file_enum_type file_type
;
299 lang_input_statement_type
*p
;
302 p
= new_stat (lang_input_statement
, stat_ptr
);
305 p
= ((lang_input_statement_type
*)
306 stat_alloc (sizeof (lang_input_statement_type
)));
307 p
->header
.next
= NULL
;
310 lang_has_input_file
= true;
312 p
->complained
= false;
315 case lang_input_file_is_symbols_only_enum
:
317 p
->is_archive
= false;
319 p
->local_sym_name
= name
;
320 p
->just_syms_flag
= true;
321 p
->search_dirs_flag
= false;
323 case lang_input_file_is_fake_enum
:
325 p
->is_archive
= false;
327 p
->local_sym_name
= name
;
328 p
->just_syms_flag
= false;
329 p
->search_dirs_flag
= false;
331 case lang_input_file_is_l_enum
:
332 p
->is_archive
= true;
335 p
->local_sym_name
= concat ("-l", name
, (const char *) NULL
);
336 p
->just_syms_flag
= false;
337 p
->search_dirs_flag
= true;
339 case lang_input_file_is_marker_enum
:
341 p
->is_archive
= false;
343 p
->local_sym_name
= name
;
344 p
->just_syms_flag
= false;
345 p
->search_dirs_flag
= true;
347 case lang_input_file_is_search_file_enum
:
349 p
->is_archive
= false;
351 p
->local_sym_name
= name
;
352 p
->just_syms_flag
= false;
353 p
->search_dirs_flag
= true;
355 case lang_input_file_is_file_enum
:
357 p
->is_archive
= false;
359 p
->local_sym_name
= name
;
360 p
->just_syms_flag
= false;
361 p
->search_dirs_flag
= false;
366 p
->the_bfd
= (bfd
*) NULL
;
367 p
->asymbols
= (asymbol
**) NULL
;
368 p
->next_real_file
= (lang_statement_union_type
*) NULL
;
369 p
->next
= (lang_statement_union_type
*) NULL
;
371 p
->common_output_section
= (asection
*) NULL
;
373 lang_statement_append (&input_file_chain
,
374 (lang_statement_union_type
*) p
,
379 lang_input_statement_type
*
380 lang_add_input_file (name
, file_type
, target
)
382 lang_input_file_enum_type file_type
;
385 lang_has_input_file
= true;
386 return new_afile (name
, file_type
, target
, true);
389 /* Build enough state so that the parser can build its tree */
393 obstack_begin (&stat_obstack
, 1000);
395 stat_ptr
= &statement_list
;
397 lang_list_init (stat_ptr
);
399 lang_list_init (&input_file_chain
);
400 lang_list_init (&lang_output_section_statement
);
401 lang_list_init (&file_chain
);
402 first_file
= lang_add_input_file ((char *) NULL
,
403 lang_input_file_is_marker_enum
,
405 abs_output_section
= lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME
);
407 abs_output_section
->bfd_section
= bfd_abs_section_ptr
;
411 /*----------------------------------------------------------------------
412 A region is an area of memory declared with the
413 MEMORY { name:org=exp, len=exp ... }
416 We maintain a list of all the regions here
418 If no regions are specified in the script, then the default is used
419 which is created when looked up to be the entire data space
422 static lang_memory_region_type
*lang_memory_region_list
;
423 static lang_memory_region_type
**lang_memory_region_list_tail
= &lang_memory_region_list
;
425 lang_memory_region_type
*
426 lang_memory_region_lookup (name
)
427 CONST
char *CONST name
;
430 lang_memory_region_type
*p
= lang_memory_region_list
;
432 for (p
= lang_memory_region_list
;
433 p
!= (lang_memory_region_type
*) NULL
;
436 if (strcmp (p
->name
, name
) == 0)
441 if (strcmp (name
, "*default*") == 0)
443 /* This is the default region, dig out first one on the list */
444 if (lang_memory_region_list
!= (lang_memory_region_type
*) NULL
)
446 return lang_memory_region_list
;
450 lang_memory_region_type
*new =
451 (lang_memory_region_type
*) stat_alloc ((bfd_size_type
) (sizeof (lang_memory_region_type
)));
453 new->name
= buystring (name
);
454 new->next
= (lang_memory_region_type
*) NULL
;
456 *lang_memory_region_list_tail
= new;
457 lang_memory_region_list_tail
= &new->next
;
459 new->length
= ~(bfd_size_type
)0;
461 new->had_full_message
= false;
468 lang_output_section_statement_type
*
469 lang_output_section_find (name
)
470 CONST
char *CONST name
;
472 lang_statement_union_type
*u
;
473 lang_output_section_statement_type
*lookup
;
475 for (u
= lang_output_section_statement
.head
;
476 u
!= (lang_statement_union_type
*) NULL
;
479 lookup
= &u
->output_section_statement
;
480 if (strcmp (name
, lookup
->name
) == 0)
485 return (lang_output_section_statement_type
*) NULL
;
488 lang_output_section_statement_type
*
489 lang_output_section_statement_lookup (name
)
490 CONST
char *CONST name
;
492 lang_output_section_statement_type
*lookup
;
494 lookup
= lang_output_section_find (name
);
495 if (lookup
== (lang_output_section_statement_type
*) NULL
)
498 lookup
= (lang_output_section_statement_type
*)
499 new_stat (lang_output_section_statement
, stat_ptr
);
500 lookup
->region
= (lang_memory_region_type
*) NULL
;
502 lookup
->block_value
= 1;
505 lookup
->next
= (lang_statement_union_type
*) NULL
;
506 lookup
->bfd_section
= (asection
*) NULL
;
507 lookup
->processed
= false;
508 lookup
->loadable
= 1;
509 lookup
->addr_tree
= (etree_type
*) NULL
;
510 lang_list_init (&lookup
->children
);
512 lookup
->memspec
= (CONST
char *) NULL
;
514 lookup
->subsection_alignment
= -1;
515 lookup
->section_alignment
= -1;
516 lookup
->load_base
= (union etree_union
*) NULL
;
518 lang_statement_append (&lang_output_section_statement
,
519 (lang_statement_union_type
*) lookup
,
527 print_flags (ignore_flags
)
530 fprintf (config
.map_file
, "(");
532 if (flags
->flag_read
)
533 fprintf (outfile
, "R");
534 if (flags
->flag_write
)
535 fprintf (outfile
, "W");
536 if (flags
->flag_executable
)
537 fprintf (outfile
, "X");
538 if (flags
->flag_loadable
)
539 fprintf (outfile
, "L");
541 fprintf (config
.map_file
, ")");
547 lang_memory_region_type
*m
;
549 fprintf (config
.map_file
, "**MEMORY CONFIGURATION**\n\n");
551 fprintf (config
.map_file
, "name\t\torigin\t\tlength\t\tattributes\n");
553 fprintf (config
.map_file
,
554 "name\t\torigin length r_size c_size is attributes\n");
557 for (m
= lang_memory_region_list
;
558 m
!= (lang_memory_region_type
*) NULL
;
561 fprintf (config
.map_file
, "%-16s", m
->name
);
562 print_address (m
->origin
);
564 print_address ((bfd_vma
)m
->length
);
566 print_address ((bfd_vma
)m
->old_length
);
568 print_address (m
->current
- m
->origin
);
571 fprintf (config
.map_file
, " %2d%% ",
572 (int) ((m
->current
- m
->origin
) * 100 / m
->old_length
));
573 print_flags (&m
->flags
);
574 fprintf (config
.map_file
, "\n");
576 fprintf (config
.map_file
, "\n\n**LINK EDITOR MEMORY MAP**\n\n");
577 fprintf (config
.map_file
, "output input virtual\n");
578 fprintf (config
.map_file
, "section section address tsize\n\n");
589 lang_output_section_statement_type
* s
;
591 /* asection *section = bfd_get_section_by_name(output_bfd, s->name);*/
592 section_userdata_type
*new =
593 (section_userdata_type
*)
594 stat_alloc ((bfd_size_type
) (sizeof (section_userdata_type
)));
596 s
->bfd_section
= bfd_get_section_by_name (output_bfd
, s
->name
);
597 if (s
->bfd_section
== (asection
*) NULL
)
598 s
->bfd_section
= bfd_make_section (output_bfd
, s
->name
);
599 if (s
->bfd_section
== (asection
*) NULL
)
601 einfo ("%P%F: output format %s cannot represent section called %s\n",
602 output_bfd
->xvec
->name
, s
->name
);
604 s
->bfd_section
->output_section
= s
->bfd_section
;
605 /* s->bfd_section->flags = s->flags;*/
607 /* We initialize an output sections output offset to minus its own */
608 /* vma to allow us to output a section through itself */
609 s
->bfd_section
->output_offset
= 0;
610 get_userdata (s
->bfd_section
) = (PTR
) new;
614 /***********************************************************************
617 These expand statements like *(.text) and foo.o to a list of
618 explicit actions, like foo.o(.text), bar.o(.text) and
621 The toplevel routine, wild, takes a statement, section, file and
622 target. If either the section or file is null it is taken to be the
623 wildcard. Seperate lang_input_section statements are created for
624 each part of the expanstion, and placed after the statement provided.
629 wild_doit (ptr
, section
, output
, file
)
630 lang_statement_list_type
* ptr
;
632 lang_output_section_statement_type
* output
;
633 lang_input_statement_type
* file
;
635 if (output
->bfd_section
== (asection
*) NULL
)
638 if (section
!= (asection
*) NULL
639 && section
->output_section
== (asection
*) NULL
)
641 /* Add a section reference to the list */
642 lang_input_section_type
*new = new_stat (lang_input_section
, ptr
);
644 new->section
= section
;
646 section
->output_section
= output
->bfd_section
;
648 /* We don't copy the SEC_NEVER_LOAD flag from an input section to
649 an output section, because we want to be able to include a
650 SEC_NEVER_LOAD section in the middle of an otherwise loaded
651 section (I don't know why we want to do this, but we do).
652 build_link_order in ldwrite.c handles this case by turning the
653 embedded SEC_NEVER_LOAD section into a fill. */
654 section
->output_section
->flags
|=
655 section
->flags
& (flagword
) (~ SEC_NEVER_LOAD
);
657 if (!output
->loadable
)
659 /* Turn off load flag */
660 output
->bfd_section
->flags
&= ~SEC_LOAD
;
661 output
->bfd_section
->flags
|= SEC_NEVER_LOAD
;
663 if (section
->alignment_power
> output
->bfd_section
->alignment_power
)
665 output
->bfd_section
->alignment_power
= section
->alignment_power
;
667 /* If supplied an aligmnet, then force it */
668 if (output
->section_alignment
!= -1)
670 output
->bfd_section
->alignment_power
= output
->section_alignment
;
676 wild_section (ptr
, section
, file
, output
)
677 lang_wild_statement_type
*ptr
;
679 lang_input_statement_type
*file
;
680 lang_output_section_statement_type
*output
;
682 if (file
->just_syms_flag
== false)
684 register asection
*s
;
686 for (s
= file
->the_bfd
->sections
; s
!= NULL
; s
= s
->next
)
688 /* Attach all sections named SECTION. If SECTION is NULL,
689 then attach all sections.
691 Previously, if SECTION was NULL, this code did not call
692 wild_doit if the SEC_IS_COMMON flag was set for the
693 section. I did not understand that, and I took it out.
697 || strcmp (bfd_get_section_name (file
->the_bfd
, s
),
699 wild_doit (&ptr
->children
, s
, output
, file
);
704 /* passed a file name (which must have been seen already and added to
705 the statement tree. We will see if it has been opened already and
706 had its symbols read. If not then we'll read it.
708 Archives are pecuilar here. We may open them once, but if they do
709 not define anything we need at the time, they won't have all their
710 symbols read. If we need them later, we'll have to redo it. */
711 static lang_input_statement_type
*
715 lang_input_statement_type
*search
;
717 for (search
= (lang_input_statement_type
*) input_file_chain
.head
;
718 search
!= (lang_input_statement_type
*) NULL
;
719 search
= (lang_input_statement_type
*) search
->next_real_file
)
721 if (search
->filename
== (char *) NULL
&& name
== (char *) NULL
)
723 if (search
->filename
!= (char *) NULL
724 && name
!= (char *) NULL
725 && strcmp (search
->filename
, name
) == 0)
729 if (search
== (lang_input_statement_type
*) NULL
)
730 search
= new_afile (name
, lang_input_file_is_file_enum
, default_target
,
733 /* If we have already added this file, or this file is not real
734 (FIXME: can that ever actually happen?) or the name is NULL
735 (FIXME: can that ever actually happen?) don't add this file. */
738 || search
->filename
== (const char *) NULL
)
741 load_symbols (search
, (lang_statement_list_type
*) NULL
);
746 /* Get the symbols for an input file. */
749 load_symbols (entry
, place
)
750 lang_input_statement_type
*entry
;
751 lang_statement_list_type
*place
;
758 ldfile_open_file (entry
);
760 if (! bfd_check_format (entry
->the_bfd
, bfd_archive
)
761 && ! bfd_check_format_matches (entry
->the_bfd
, bfd_object
, &matching
))
764 lang_statement_list_type
*hold
;
766 err
= bfd_get_error ();
767 if (err
== bfd_error_file_ambiguously_recognized
)
771 einfo ("%B: file not recognized: %E\n", entry
->the_bfd
);
772 einfo ("%B: matching formats:", entry
->the_bfd
);
773 for (p
= matching
; *p
!= NULL
; p
++)
777 else if (err
!= bfd_error_file_not_recognized
779 einfo ("%F%B: file not recognized: %E\n", entry
->the_bfd
);
781 /* Try to interpret the file as a linker script. */
783 bfd_close (entry
->the_bfd
);
784 entry
->the_bfd
= NULL
;
786 ldfile_open_command_file (entry
->filename
);
791 ldfile_assumed_script
= true;
792 parser_input
= input_script
;
794 ldfile_assumed_script
= false;
801 /* We don't call ldlang_add_file for an archive. Instead, the
802 add_symbols entry point will call ldlang_add_file, via the
803 add_archive_element callback, for each element of the archive
805 if (bfd_get_format (entry
->the_bfd
) == bfd_object
)
807 ldlang_add_file (entry
);
808 if (trace_files
|| trace_file_tries
)
809 info_msg ("%I\n", entry
);
812 if (! bfd_link_add_symbols (entry
->the_bfd
, &link_info
))
813 einfo ("%F%B: could not read symbols: %E\n", entry
->the_bfd
);
815 entry
->loaded
= true;
819 wild (s
, section
, file
, target
, output
)
820 lang_wild_statement_type
* s
;
824 lang_output_section_statement_type
* output
;
826 lang_input_statement_type
*f
;
828 if (file
== (char *) NULL
)
830 /* Perform the iteration over all files in the list */
831 for (f
= (lang_input_statement_type
*) file_chain
.head
;
832 f
!= (lang_input_statement_type
*) NULL
;
833 f
= (lang_input_statement_type
*) f
->next
)
835 wild_section (s
, section
, f
, output
);
840 /* Perform the iteration over a single file */
841 wild_section (s
, section
, lookup_name (file
), output
);
843 if (section
!= (char *) NULL
844 && strcmp (section
, "COMMON") == 0
845 && default_common_section
== (lang_output_section_statement_type
*) NULL
)
847 /* Remember the section that common is going to incase we later
848 get something which doesn't know where to put it */
849 default_common_section
= output
;
854 read in all the files
863 if (output_target
== (char *) NULL
)
865 if (current_target
!= (char *) NULL
)
866 output_target
= current_target
;
868 output_target
= default_target
;
870 output
= bfd_openw (name
, output_target
);
872 if (output
== (bfd
*) NULL
)
874 if (bfd_get_error () == bfd_error_invalid_target
)
876 einfo ("%P%F: target %s not found\n", output_target
);
878 einfo ("%P%F: cannot open output file %s: %E\n", name
);
881 delete_output_file_on_failure
= 1;
883 /* output->flags |= D_PAGED;*/
885 if (! bfd_set_format (output
, bfd_object
))
886 einfo ("%P%F:%s: can not make object file: %E\n", name
);
887 if (! bfd_set_arch_mach (output
,
888 ldfile_output_architecture
,
889 ldfile_output_machine
))
890 einfo ("%P%F:%s: can not set architecture: %E\n", name
);
892 link_info
.hash
= bfd_link_hash_table_create (output
);
893 if (link_info
.hash
== (struct bfd_link_hash_table
*) NULL
)
894 einfo ("%P%F: can not create link hash table: %E\n");
896 bfd_set_gp_size (output
, g_switch_value
);
904 ldlang_open_output (statement
)
905 lang_statement_union_type
* statement
;
907 switch (statement
->header
.type
)
909 case lang_output_statement_enum
:
910 ASSERT (output_bfd
== (bfd
*) NULL
);
911 output_bfd
= open_output (statement
->output_statement
.name
);
912 ldemul_set_output_arch ();
913 if (config
.magic_demand_paged
&& !link_info
.relocateable
)
914 output_bfd
->flags
|= D_PAGED
;
916 output_bfd
->flags
&= ~D_PAGED
;
917 if (config
.text_read_only
)
918 output_bfd
->flags
|= WP_TEXT
;
920 output_bfd
->flags
&= ~WP_TEXT
;
921 if (config
.traditional_format
)
922 output_bfd
->flags
|= BFD_TRADITIONAL_FORMAT
;
924 output_bfd
->flags
&= ~BFD_TRADITIONAL_FORMAT
;
927 case lang_target_statement_enum
:
928 current_target
= statement
->target_statement
.target
;
935 /* Open all the input files. */
938 open_input_bfds (s
, force
)
939 lang_statement_union_type
*s
;
942 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
944 switch (s
->header
.type
)
946 case lang_constructors_statement_enum
:
947 open_input_bfds (constructor_list
.head
, force
);
949 case lang_output_section_statement_enum
:
950 open_input_bfds (s
->output_section_statement
.children
.head
, force
);
952 case lang_wild_statement_enum
:
953 /* Maybe we should load the file's symbols */
954 if (s
->wild_statement
.filename
)
955 (void) lookup_name (s
->wild_statement
.filename
);
956 open_input_bfds (s
->wild_statement
.children
.head
, force
);
958 case lang_group_statement_enum
:
960 struct bfd_link_hash_entry
*undefs
;
962 /* We must continually search the entries in the group
963 until no new symbols are added to the list of undefined
968 undefs
= link_info
.hash
->undefs_tail
;
969 open_input_bfds (s
->group_statement
.children
.head
, true);
971 while (undefs
!= link_info
.hash
->undefs_tail
);
974 case lang_target_statement_enum
:
975 current_target
= s
->target_statement
.target
;
977 case lang_input_statement_enum
:
978 if (s
->input_statement
.real
== true)
980 lang_statement_list_type add
;
982 s
->input_statement
.target
= current_target
;
984 /* If we are being called from within a group, and this
985 is an archive which has already been searched, then
986 force it to be researched. */
988 && s
->input_statement
.loaded
989 && bfd_check_format (s
->input_statement
.the_bfd
,
991 s
->input_statement
.loaded
= false;
993 lang_list_init (&add
);
995 load_symbols (&s
->input_statement
, &add
);
997 if (add
.head
!= NULL
)
1010 /* If there are [COMMONS] statements, put a wild one into the bss section */
1013 lang_reasonable_defaults ()
1016 lang_output_section_statement_lookup (".text");
1017 lang_output_section_statement_lookup (".data");
1019 default_common_section
=
1020 lang_output_section_statement_lookup (".bss");
1023 if (placed_commons
== false)
1025 lang_wild_statement_type
*new =
1026 new_stat (lang_wild_statement
,
1027 &default_common_section
->children
);
1029 new->section_name
= "COMMON";
1030 new->filename
= (char *) NULL
;
1031 lang_list_init (&new->children
);
1038 Add the supplied name to the symbol table as an undefined reference.
1039 Remove items from the chain as we open input bfds
1041 typedef struct ldlang_undef_chain_list
1043 struct ldlang_undef_chain_list
*next
;
1045 } ldlang_undef_chain_list_type
;
1047 static ldlang_undef_chain_list_type
*ldlang_undef_chain_list_head
;
1050 ldlang_add_undef (name
)
1051 CONST
char *CONST name
;
1053 ldlang_undef_chain_list_type
*new =
1054 (ldlang_undef_chain_list_type
1055 *) stat_alloc ((bfd_size_type
) (sizeof (ldlang_undef_chain_list_type
)));
1057 new->next
= ldlang_undef_chain_list_head
;
1058 ldlang_undef_chain_list_head
= new;
1060 new->name
= buystring (name
);
1063 /* Run through the list of undefineds created above and place them
1064 into the linker hash table as undefined symbols belonging to the
1068 lang_place_undefineds ()
1070 ldlang_undef_chain_list_type
*ptr
;
1072 for (ptr
= ldlang_undef_chain_list_head
;
1073 ptr
!= (ldlang_undef_chain_list_type
*) NULL
;
1076 struct bfd_link_hash_entry
*h
;
1078 h
= bfd_link_hash_lookup (link_info
.hash
, ptr
->name
, true, false, true);
1079 if (h
== (struct bfd_link_hash_entry
*) NULL
)
1080 einfo ("%P%F: bfd_link_hash_lookup failed: %E");
1081 if (h
->type
== bfd_link_hash_new
)
1083 h
->type
= bfd_link_hash_undefined
;
1084 h
->u
.undef
.abfd
= NULL
;
1085 bfd_link_add_undef (link_info
.hash
, h
);
1090 /* Open input files and attatch to output sections */
1092 map_input_to_output_sections (s
, target
, output_section_statement
)
1093 lang_statement_union_type
* s
;
1095 lang_output_section_statement_type
* output_section_statement
;
1097 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1099 switch (s
->header
.type
)
1103 case lang_wild_statement_enum
:
1104 wild (&s
->wild_statement
, s
->wild_statement
.section_name
,
1105 s
->wild_statement
.filename
, target
,
1106 output_section_statement
);
1109 case lang_constructors_statement_enum
:
1110 map_input_to_output_sections (constructor_list
.head
,
1112 output_section_statement
);
1114 case lang_output_section_statement_enum
:
1115 map_input_to_output_sections (s
->output_section_statement
.children
.head
,
1117 &s
->output_section_statement
);
1119 case lang_output_statement_enum
:
1121 case lang_target_statement_enum
:
1122 target
= s
->target_statement
.target
;
1124 case lang_group_statement_enum
:
1125 map_input_to_output_sections (s
->group_statement
.children
.head
,
1127 output_section_statement
);
1129 case lang_fill_statement_enum
:
1130 case lang_input_section_enum
:
1131 case lang_object_symbols_statement_enum
:
1132 case lang_data_statement_enum
:
1133 case lang_reloc_statement_enum
:
1134 case lang_assignment_statement_enum
:
1135 case lang_padding_statement_enum
:
1136 case lang_input_statement_enum
:
1137 if (output_section_statement
!= NULL
1138 && output_section_statement
->bfd_section
== NULL
)
1139 init_os (output_section_statement
);
1141 case lang_afile_asection_pair_statement_enum
:
1144 case lang_address_statement_enum
:
1145 /* Mark the specified section with the supplied address */
1147 lang_output_section_statement_type
*os
=
1148 lang_output_section_statement_lookup
1149 (s
->address_statement
.section_name
);
1151 if (os
->bfd_section
== NULL
)
1153 os
->addr_tree
= s
->address_statement
.address
;
1161 print_output_section_statement (output_section_statement
)
1162 lang_output_section_statement_type
* output_section_statement
;
1164 asection
*section
= output_section_statement
->bfd_section
;
1167 print_section (output_section_statement
->name
);
1172 print_dot
= section
->vma
;
1176 print_address (section
->vma
);
1178 print_size (section
->_raw_size
);
1180 print_size(section
->_cooked_size
);
1182 print_alignment (section
->alignment_power
);
1185 fprintf (config
.map_file
, "%s flags", output_section_statement
->region
->name
);
1186 print_flags (stdout
, &output_section_statement
->flags
);
1188 if (section
->flags
& SEC_LOAD
)
1189 fprintf (config
.map_file
, "load ");
1190 if (section
->flags
& SEC_ALLOC
)
1191 fprintf (config
.map_file
, "alloc ");
1192 if (section
->flags
& SEC_RELOC
)
1193 fprintf (config
.map_file
, "reloc ");
1194 if (section
->flags
& SEC_HAS_CONTENTS
)
1195 fprintf (config
.map_file
, "contents ");
1200 fprintf (config
.map_file
, " (no attached output section)");
1203 if (output_section_statement
->load_base
)
1205 int b
= exp_get_abs_int(output_section_statement
->load_base
,
1206 0, "output base", lang_final_phase_enum
);
1207 fprintf (config
.map_file
, "Output address %08x\n", b
);
1209 if (output_section_statement
->section_alignment
>= 0
1210 || output_section_statement
->section_alignment
>= 0)
1212 fprintf (config
.map_file
, "\t\t\t\t\tforced alignment ");
1213 if (output_section_statement
->section_alignment
>= 0)
1215 fprintf (config
.map_file
, "section 2**%d ",output_section_statement
->section_alignment
);
1217 if ( output_section_statement
->subsection_alignment
>= 0)
1219 fprintf (config
.map_file
, "subsection 2**%d ",output_section_statement
->subsection_alignment
);
1224 print_statement (output_section_statement
->children
.head
,
1225 output_section_statement
);
1230 print_assignment (assignment
, output_section
)
1231 lang_assignment_statement_type
* assignment
;
1232 lang_output_section_statement_type
* output_section
;
1234 etree_value_type result
;
1240 print_address (print_dot
);
1242 result
= exp_fold_tree (assignment
->exp
->assign
.src
,
1244 lang_final_phase_enum
,
1250 print_address (result
.value
);
1254 fprintf (config
.map_file
, "*undefined*");
1257 exp_print_tree (assignment
->exp
);
1259 fprintf (config
.map_file
, "\n");
1263 print_input_statement (statm
)
1264 lang_input_statement_type
* statm
;
1266 if (statm
->filename
!= (char *) NULL
)
1268 fprintf (config
.map_file
, "LOAD %s\n", statm
->filename
);
1272 /* Print all the defined symbols for the abfd provided by in the supplied
1277 print_one_symbol (hash_entry
, ptr
)
1278 struct bfd_link_hash_entry
*hash_entry
;
1281 asection
* sec
= (asection
*)ptr
;
1283 if (hash_entry
->type
== bfd_link_hash_defined
1284 || hash_entry
->type
== bfd_link_hash_defweak
)
1286 if (sec
== hash_entry
->u
.def
.section
) {
1288 fprintf (config
.map_file
, " ");
1290 fprintf (config
.map_file
, " ");
1291 print_address (hash_entry
->u
.def
.value
+ outside_section_address (sec
));
1292 fprintf (config
.map_file
, " %s", hash_entry
->root
.string
);
1301 print_input_section (in
)
1302 lang_input_section_type
* in
;
1304 asection
*i
= in
->section
;
1305 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
1310 fprintf (config
.map_file
, " ");
1311 print_section (i
->name
);
1312 fprintf (config
.map_file
, " ");
1313 if (i
->output_section
)
1315 print_address (i
->output_section
->vma
+ i
->output_offset
);
1316 fprintf (config
.map_file
, " ");
1317 print_size (i
->_raw_size
);
1318 fprintf (config
.map_file
, " ");
1319 print_size(i
->_cooked_size
);
1320 fprintf (config
.map_file
, " ");
1321 print_alignment (i
->alignment_power
);
1322 fprintf (config
.map_file
, " ");
1326 bfd
*abfd
= in
->ifile
->the_bfd
;
1328 if (in
->ifile
->just_syms_flag
== true)
1330 fprintf (config
.map_file
, "symbols only ");
1333 fprintf (config
.map_file
, " %s ", abfd
->xvec
->name
);
1334 if (abfd
->my_archive
!= (bfd
*) NULL
)
1336 fprintf (config
.map_file
, "[%s]%s", abfd
->my_archive
->filename
,
1341 fprintf (config
.map_file
, "%s", abfd
->filename
);
1343 fprintf (config
.map_file
, "(overhead %d bytes)", (int) bfd_alloc_size (abfd
));
1346 /* Print all the symbols */
1347 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
1355 print_dot
= outside_section_address (i
) + size
;
1359 fprintf (config
.map_file
, "No output section allocated\n");
1365 print_fill_statement (fill
)
1366 lang_fill_statement_type
* fill
;
1368 fprintf (config
.map_file
, "FILL mask ");
1369 print_fill (fill
->fill
);
1373 print_data_statement (data
)
1374 lang_data_statement_type
* data
;
1376 /* bfd_vma value; */
1381 /* ASSERT(print_dot == data->output_vma);*/
1383 print_address (data
->output_vma
+ data
->output_section
->vma
);
1385 print_address (data
->value
);
1390 fprintf (config
.map_file
, "BYTE ");
1391 print_dot
+= BYTE_SIZE
;
1394 fprintf (config
.map_file
, "SHORT ");
1395 print_dot
+= SHORT_SIZE
;
1398 fprintf (config
.map_file
, "LONG ");
1399 print_dot
+= LONG_SIZE
;
1402 fprintf (config
.map_file
, "QUAD ");
1403 print_dot
+= QUAD_SIZE
;
1407 exp_print_tree (data
->exp
);
1409 fprintf (config
.map_file
, "\n");
1412 /* Print a reloc statement. */
1415 print_reloc_statement (reloc
)
1416 lang_reloc_statement_type
*reloc
;
1423 /* ASSERT(print_dot == data->output_vma);*/
1425 print_address (reloc
->output_vma
+ reloc
->output_section
->vma
);
1427 print_address (reloc
->addend_value
);
1430 fprintf (config
.map_file
, "RELOC %s ", reloc
->howto
->name
);
1432 print_dot
+= bfd_get_reloc_size (reloc
->howto
);
1434 exp_print_tree (reloc
->addend_exp
);
1436 fprintf (config
.map_file
, "\n");
1440 print_padding_statement (s
)
1441 lang_padding_statement_type
* s
;
1445 print_section ("*fill*");
1447 print_address (s
->output_offset
+ s
->output_section
->vma
);
1449 print_size (s
->size
);
1451 print_fill (s
->fill
);
1454 print_dot
= s
->output_offset
+ s
->output_section
->vma
+ s
->size
;
1459 print_wild_statement (w
, os
)
1460 lang_wild_statement_type
* w
;
1461 lang_output_section_statement_type
* os
;
1463 fprintf (config
.map_file
, " from ");
1464 if (w
->filename
!= (char *) NULL
)
1466 fprintf (config
.map_file
, "%s", w
->filename
);
1470 fprintf (config
.map_file
, "*");
1472 if (w
->section_name
!= (char *) NULL
)
1474 fprintf (config
.map_file
, "(%s)", w
->section_name
);
1478 fprintf (config
.map_file
, "(*)");
1481 print_statement (w
->children
.head
, os
);
1485 /* Print a group statement. */
1489 lang_group_statement_type
*s
;
1490 lang_output_section_statement_type
*os
;
1492 fprintf (config
.map_file
, "START GROUP\n");
1493 print_statement (s
->children
.head
, os
);
1494 fprintf (config
.map_file
, "END GROUP\n");
1498 print_statement (s
, os
)
1499 lang_statement_union_type
* s
;
1500 lang_output_section_statement_type
* os
;
1504 switch (s
->header
.type
)
1506 case lang_constructors_statement_enum
:
1507 fprintf (config
.map_file
, "constructors:\n");
1508 print_statement (constructor_list
.head
, os
);
1510 case lang_wild_statement_enum
:
1511 print_wild_statement (&s
->wild_statement
, os
);
1514 fprintf (config
.map_file
, "Fail with %d\n", s
->header
.type
);
1517 case lang_address_statement_enum
:
1518 fprintf (config
.map_file
, "address\n");
1520 case lang_object_symbols_statement_enum
:
1521 fprintf (config
.map_file
, "object symbols\n");
1523 case lang_fill_statement_enum
:
1524 print_fill_statement (&s
->fill_statement
);
1526 case lang_data_statement_enum
:
1527 print_data_statement (&s
->data_statement
);
1529 case lang_reloc_statement_enum
:
1530 print_reloc_statement (&s
->reloc_statement
);
1532 case lang_input_section_enum
:
1533 print_input_section (&s
->input_section
);
1535 case lang_padding_statement_enum
:
1536 print_padding_statement (&s
->padding_statement
);
1538 case lang_output_section_statement_enum
:
1539 print_output_section_statement (&s
->output_section_statement
);
1541 case lang_assignment_statement_enum
:
1542 print_assignment (&s
->assignment_statement
,
1545 case lang_target_statement_enum
:
1546 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1548 case lang_output_statement_enum
:
1549 fprintf (config
.map_file
, "OUTPUT(%s %s)\n",
1550 s
->output_statement
.name
,
1551 output_target
? output_target
: "");
1553 case lang_input_statement_enum
:
1554 print_input_statement (&s
->input_statement
);
1556 case lang_group_statement_enum
:
1557 print_group (&s
->group_statement
, os
);
1559 case lang_afile_asection_pair_statement_enum
:
1571 print_statement (statement_list
.head
,
1572 abs_output_section
);
1577 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
1578 lang_statement_union_type
** this_ptr
;
1581 asection
* output_section_statement
;
1584 /* Align this section first to the
1585 input sections requirement, then
1586 to the output section's requirement.
1587 If this alignment is > than any seen before,
1588 then record it too. Perform the alignment by
1589 inserting a magic 'padding' statement.
1592 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
1594 if (alignment_needed
!= 0)
1596 lang_statement_union_type
*new =
1597 (lang_statement_union_type
*)
1598 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1600 /* Link into existing chain */
1601 new->header
.next
= *this_ptr
;
1603 new->header
.type
= lang_padding_statement_enum
;
1604 new->padding_statement
.output_section
= output_section_statement
;
1605 new->padding_statement
.output_offset
=
1606 dot
- output_section_statement
->vma
;
1607 new->padding_statement
.fill
= fill
;
1608 new->padding_statement
.size
= alignment_needed
;
1612 /* Remember the most restrictive alignment */
1613 if (power
> output_section_statement
->alignment_power
)
1615 output_section_statement
->alignment_power
= power
;
1617 output_section_statement
->_raw_size
+= alignment_needed
;
1618 return alignment_needed
+ dot
;
1622 /* Work out how much this section will move the dot point */
1624 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
1625 lang_statement_union_type
** this_ptr
;
1626 lang_output_section_statement_type
* output_section_statement
;
1631 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1632 asection
*i
= is
->section
;
1634 if (is
->ifile
->just_syms_flag
== false)
1636 if (output_section_statement
->subsection_alignment
!= -1)
1637 i
->alignment_power
=
1638 output_section_statement
->subsection_alignment
;
1640 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
1641 output_section_statement
->bfd_section
, dot
);
1643 /* Remember where in the output section this input section goes */
1645 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1647 /* Mark how big the output section must be to contain this now
1649 if (i
->_cooked_size
!= 0)
1650 dot
+= i
->_cooked_size
;
1652 dot
+= i
->_raw_size
;
1653 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
1657 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
1663 /* This variable indicates whether bfd_relax_section should be called
1666 static boolean relax_again
;
1668 /* Set the sizes for all the output sections. */
1671 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
1672 lang_statement_union_type
* s
;
1673 lang_output_section_statement_type
* output_section_statement
;
1674 lang_statement_union_type
** prev
;
1679 /* Size up the sections from their constituent parts */
1680 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1682 switch (s
->header
.type
)
1685 case lang_output_section_statement_enum
:
1688 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
1690 if (os
->bfd_section
== NULL
)
1692 /* This section was never actually created. */
1696 /* If this is a COFF shared library section, use the size and
1697 address from the input section. FIXME: This is COFF
1698 specific; it would be cleaner if there were some other way
1699 to do this, but nothing simple comes to mind. */
1700 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
1704 if (os
->children
.head
== NULL
1705 || os
->children
.head
->next
!= NULL
1706 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
1707 einfo ("%P%X: Internal error on COFF shared library section %s",
1710 input
= os
->children
.head
->input_section
.section
;
1711 bfd_set_section_vma (os
->bfd_section
->owner
,
1713 bfd_section_vma (input
->owner
, input
));
1714 os
->bfd_section
->_raw_size
= input
->_raw_size
;
1718 if (bfd_is_abs_section (os
->bfd_section
))
1720 /* No matter what happens, an abs section starts at zero */
1721 ASSERT (os
->bfd_section
->vma
== 0);
1725 if (os
->addr_tree
== (etree_type
*) NULL
)
1727 /* No address specified for this section, get one
1728 from the region specification
1730 if (os
->region
== (lang_memory_region_type
*) NULL
)
1732 os
->region
= lang_memory_region_lookup ("*default*");
1734 dot
= os
->region
->current
;
1735 if (os
->section_alignment
== -1)
1736 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
1742 r
= exp_fold_tree (os
->addr_tree
,
1744 lang_allocating_phase_enum
,
1746 if (r
.valid
== false)
1748 einfo ("%F%S: non constant address expression for section %s\n",
1753 /* The section starts here */
1754 /* First, align to what the section needs */
1756 if (os
->section_alignment
!= -1)
1757 dot
= align_power (dot
, os
->section_alignment
);
1759 bfd_set_section_vma (0, os
->bfd_section
, dot
);
1761 os
->bfd_section
->output_offset
= 0;
1764 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
1765 os
->fill
, dot
, relax
);
1766 /* Ignore the size of the input sections, use the vma and size to */
1769 after
= ALIGN_N (os
->bfd_section
->vma
+
1770 os
->bfd_section
->_raw_size
,
1771 /* The coercion here is important, see ld.h. */
1772 (bfd_vma
) os
->block_value
);
1774 if (bfd_is_abs_section (os
->bfd_section
))
1775 ASSERT (after
== os
->bfd_section
->vma
);
1777 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
1778 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1779 os
->processed
= true;
1781 /* Replace into region ? */
1782 if (os
->region
!= (lang_memory_region_type
*) NULL
)
1784 os
->region
->current
= dot
;
1785 /* Make sure this isn't silly. */
1786 if ((os
->region
->current
< os
->region
->origin
)
1787 || (os
->region
->current
1788 > os
->region
->origin
+ os
->region
->length
))
1790 if (os
->addr_tree
!= (etree_type
*) NULL
)
1792 einfo ("%X%P: address 0x%v of %B section %s is not within region %s\n",
1793 os
->region
->current
,
1794 os
->bfd_section
->owner
,
1795 os
->bfd_section
->name
,
1800 einfo ("%X%P: region %s is full (%B section %s)\n",
1802 os
->bfd_section
->owner
,
1803 os
->bfd_section
->name
);
1805 /* Reset the region pointer. */
1806 os
->region
->current
= os
->region
->origin
;
1812 case lang_constructors_statement_enum
:
1813 dot
= lang_size_sections (constructor_list
.head
,
1814 output_section_statement
,
1815 &s
->wild_statement
.children
.head
,
1820 case lang_data_statement_enum
:
1822 unsigned int size
= 0;
1824 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1825 s
->data_statement
.output_section
=
1826 output_section_statement
->bfd_section
;
1828 switch (s
->data_statement
.type
)
1845 output_section_statement
->bfd_section
->_raw_size
+= size
;
1849 case lang_reloc_statement_enum
:
1853 s
->reloc_statement
.output_vma
=
1854 dot
- output_section_statement
->bfd_section
->vma
;
1855 s
->reloc_statement
.output_section
=
1856 output_section_statement
->bfd_section
;
1857 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
1859 output_section_statement
->bfd_section
->_raw_size
+= size
;
1863 case lang_wild_statement_enum
:
1865 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
1866 output_section_statement
,
1867 &s
->wild_statement
.children
.head
,
1873 case lang_object_symbols_statement_enum
:
1874 link_info
.create_object_symbols_section
=
1875 output_section_statement
->bfd_section
;
1877 case lang_output_statement_enum
:
1878 case lang_target_statement_enum
:
1880 case lang_input_section_enum
:
1884 i
= (*prev
)->input_section
.section
;
1886 i
->_cooked_size
= i
->_raw_size
;
1891 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
1892 einfo ("%P%F: can't relax section: %E\n");
1896 dot
= size_input_section (prev
,
1897 output_section_statement
,
1898 output_section_statement
->fill
,
1902 case lang_input_statement_enum
:
1904 case lang_fill_statement_enum
:
1905 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
1907 fill
= s
->fill_statement
.fill
;
1909 case lang_assignment_statement_enum
:
1911 bfd_vma newdot
= dot
;
1913 exp_fold_tree (s
->assignment_statement
.exp
,
1914 output_section_statement
,
1915 lang_allocating_phase_enum
,
1919 if (newdot
!= dot
&& !relax
)
1921 /* The assignment changed dot. Insert a pad. */
1922 if (output_section_statement
== abs_output_section
)
1924 /* If we don't have an output section, then just adjust
1925 the default memory address. */
1926 lang_memory_region_lookup ("*default*")->current
= newdot
;
1930 lang_statement_union_type
*new =
1931 ((lang_statement_union_type
*)
1932 stat_alloc (sizeof (lang_padding_statement_type
)));
1934 /* Link into existing chain */
1935 new->header
.next
= *prev
;
1937 new->header
.type
= lang_padding_statement_enum
;
1938 new->padding_statement
.output_section
=
1939 output_section_statement
->bfd_section
;
1940 new->padding_statement
.output_offset
=
1941 dot
- output_section_statement
->bfd_section
->vma
;
1942 new->padding_statement
.fill
= fill
;
1943 new->padding_statement
.size
= newdot
- dot
;
1944 output_section_statement
->bfd_section
->_raw_size
+=
1945 new->padding_statement
.size
;
1953 case lang_padding_statement_enum
:
1954 /* If we are relaxing, and this is not the first pass, some
1955 padding statements may have been inserted during previous
1956 passes. We may have to move the padding statement to a new
1957 location if dot has a different value at this point in this
1958 pass than it did at this point in the previous pass. */
1959 s
->padding_statement
.output_offset
=
1960 dot
- output_section_statement
->bfd_section
->vma
;
1961 dot
+= s
->padding_statement
.size
;
1964 case lang_group_statement_enum
:
1965 dot
= lang_size_sections (s
->group_statement
.children
.head
,
1966 output_section_statement
,
1967 &s
->group_statement
.children
.head
,
1975 /* This can only get here when relaxing is turned on */
1977 case lang_address_statement_enum
:
1980 prev
= &s
->header
.next
;
1986 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
1987 lang_statement_union_type
* s
;
1988 lang_output_section_statement_type
* output_section_statement
;
1992 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1994 switch (s
->header
.type
)
1996 case lang_constructors_statement_enum
:
1997 dot
= lang_do_assignments (constructor_list
.head
,
1998 output_section_statement
,
2003 case lang_output_section_statement_enum
:
2005 lang_output_section_statement_type
*os
=
2006 &(s
->output_section_statement
);
2008 if (os
->bfd_section
!= NULL
)
2010 dot
= os
->bfd_section
->vma
;
2011 (void) lang_do_assignments (os
->children
.head
, os
,
2013 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
2017 /* If nothing has been placed into the output section then
2018 it won't have a bfd_section. */
2019 if (os
->bfd_section
)
2021 os
->bfd_section
->lma
2022 = exp_get_abs_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
2027 case lang_wild_statement_enum
:
2029 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
2030 output_section_statement
,
2035 case lang_object_symbols_statement_enum
:
2036 case lang_output_statement_enum
:
2037 case lang_target_statement_enum
:
2039 case lang_common_statement_enum
:
2042 case lang_data_statement_enum
:
2044 etree_value_type value
;
2046 value
= exp_fold_tree (s
->data_statement
.exp
,
2048 lang_final_phase_enum
, dot
, &dot
);
2049 s
->data_statement
.value
= value
.value
;
2050 if (value
.valid
== false)
2051 einfo ("%F%P: invalid data statement\n");
2053 switch (s
->data_statement
.type
)
2070 case lang_reloc_statement_enum
:
2072 etree_value_type value
;
2074 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
2076 lang_final_phase_enum
, dot
, &dot
);
2077 s
->reloc_statement
.addend_value
= value
.value
;
2078 if (value
.valid
== false)
2079 einfo ("%F%P: invalid reloc statement\n");
2081 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
);
2084 case lang_input_section_enum
:
2086 asection
*in
= s
->input_section
.section
;
2088 if (in
->_cooked_size
!= 0)
2089 dot
+= in
->_cooked_size
;
2091 dot
+= in
->_raw_size
;
2095 case lang_input_statement_enum
:
2097 case lang_fill_statement_enum
:
2098 fill
= s
->fill_statement
.fill
;
2100 case lang_assignment_statement_enum
:
2102 exp_fold_tree (s
->assignment_statement
.exp
,
2103 output_section_statement
,
2104 lang_final_phase_enum
,
2110 case lang_padding_statement_enum
:
2111 dot
+= s
->padding_statement
.size
;
2114 case lang_group_statement_enum
:
2115 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
2116 output_section_statement
,
2124 case lang_address_statement_enum
:
2135 struct bfd_link_hash_entry
*h
;
2138 if (link_info
.relocateable
|| link_info
.shared
)
2143 if (entry_symbol
== (char *) NULL
)
2145 /* No entry has been specified. Look for start, but don't warn
2146 if we don't find it. */
2147 entry_symbol
= "start";
2151 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
2152 if (h
!= (struct bfd_link_hash_entry
*) NULL
2153 && (h
->type
== bfd_link_hash_defined
2154 || h
->type
== bfd_link_hash_defweak
))
2158 val
= (h
->u
.def
.value
2159 + bfd_get_section_vma (output_bfd
,
2160 h
->u
.def
.section
->output_section
)
2161 + h
->u
.def
.section
->output_offset
);
2162 if (! bfd_set_start_address (output_bfd
, val
))
2163 einfo ("%P%F:%s: can't set start address\n", entry_symbol
);
2169 /* Can't find the entry symbol. Use the first address in the
2171 ts
= bfd_get_section_by_name (output_bfd
, ".text");
2172 if (ts
!= (asection
*) NULL
)
2175 einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
2176 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
2177 if (! bfd_set_start_address (output_bfd
,
2178 bfd_get_section_vma (output_bfd
, ts
)))
2179 einfo ("%P%F: can't set start address\n");
2184 einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2190 /* Check that the architecture of all the input files is compatible
2191 with the output file. */
2196 lang_statement_union_type
*file
;
2198 CONST bfd_arch_info_type
*compatible
;
2200 for (file
= file_chain
.head
;
2201 file
!= (lang_statement_union_type
*) NULL
;
2202 file
= file
->input_statement
.next
)
2204 input_bfd
= file
->input_statement
.the_bfd
;
2205 compatible
= bfd_arch_get_compatible (input_bfd
,
2207 if (compatible
== NULL
)
2208 einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2209 bfd_printable_name (input_bfd
), input_bfd
,
2210 bfd_printable_name (output_bfd
));
2214 /* Look through all the global common symbols and attach them to the
2215 correct section. The -sort-common command line switch may be used
2216 to roughly sort the entries by size. */
2221 if (link_info
.relocateable
2222 && ! command_line
.force_common_definition
)
2225 if (! config
.sort_common
)
2226 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
2231 for (power
= 1; power
< 4; power
++)
2232 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
2237 /* Place one common symbol in the correct section. */
2240 lang_one_common (h
, info
)
2241 struct bfd_link_hash_entry
*h
;
2244 unsigned int power_of_two
;
2248 if (h
->type
!= bfd_link_hash_common
)
2252 power_of_two
= h
->u
.c
.alignment_power
;
2254 if (config
.sort_common
2255 && power_of_two
< *(unsigned int *) info
2256 && *(unsigned int *) info
< 4)
2259 section
= h
->u
.c
.section
;
2261 /* Increase the size of the section. */
2262 section
->_raw_size
= ALIGN_N (section
->_raw_size
,
2263 (bfd_size_type
) (1 << power_of_two
));
2265 /* Adjust the alignment if necessary. */
2266 if (power_of_two
> section
->alignment_power
)
2267 section
->alignment_power
= power_of_two
;
2269 /* Change the symbol from common to defined. */
2270 h
->type
= bfd_link_hash_defined
;
2271 h
->u
.def
.section
= section
;
2272 h
->u
.def
.value
= section
->_raw_size
;
2274 /* Increase the size of the section. */
2275 section
->_raw_size
+= size
;
2277 /* Make sure the section is allocated in memory. */
2278 section
->flags
|= SEC_ALLOC
;
2280 if (config
.map_file
!= NULL
)
2281 fprintf (config
.map_file
, "Allocating common %s: %lx at %lx %s\n",
2282 h
->root
.string
, (unsigned long) size
,
2283 (unsigned long) h
->u
.def
.value
, section
->owner
->filename
);
2289 run through the input files and ensure that every input
2290 section has somewhere to go. If one is found without
2291 a destination then create an input request and place it
2292 into the statement tree.
2296 lang_place_orphans ()
2298 lang_input_statement_type
*file
;
2300 for (file
= (lang_input_statement_type
*) file_chain
.head
;
2301 file
!= (lang_input_statement_type
*) NULL
;
2302 file
= (lang_input_statement_type
*) file
->next
)
2306 for (s
= file
->the_bfd
->sections
;
2307 s
!= (asection
*) NULL
;
2310 if (s
->output_section
== (asection
*) NULL
)
2312 /* This section of the file is not attatched, root
2313 around for a sensible place for it to go */
2315 if (file
->just_syms_flag
)
2317 /* We are only retrieving symbol values from this
2318 file. We want the symbols to act as though the
2319 values in the file are absolute. */
2320 s
->output_section
= bfd_abs_section_ptr
;
2321 s
->output_offset
= s
->vma
;
2323 else if (file
->common_section
== s
)
2325 /* This is a lonely common section which must
2326 have come from an archive. We attatch to the
2327 section with the wildcard */
2328 if (! link_info
.relocateable
2329 && ! command_line
.force_common_definition
)
2331 if (default_common_section
==
2332 (lang_output_section_statement_type
*) NULL
)
2334 info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2336 default_common_section
=
2337 lang_output_section_statement_lookup (".bss");
2340 wild_doit (&default_common_section
->children
, s
,
2341 default_common_section
, file
);
2344 else if (ldemul_place_orphan (file
, s
))
2348 lang_output_section_statement_type
*os
=
2349 lang_output_section_statement_lookup (s
->name
);
2351 wild_doit (&os
->children
, s
, os
, file
);
2360 lang_set_flags (ptr
, flags
)
2364 boolean state
= false;
2379 /* ptr->flag_read = state; */
2382 /* ptr->flag_write = state; */
2385 /* ptr->flag_executable= state;*/
2389 /* ptr->flag_loadable= state;*/
2392 einfo ("%P%F: invalid syntax in flags\n");
2399 /* Call a function on each input file. This function will be called
2400 on an archive, but not on the elements. */
2403 lang_for_each_input_file (func
)
2404 void (*func
) PARAMS ((lang_input_statement_type
*));
2406 lang_input_statement_type
*f
;
2408 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
2410 f
= (lang_input_statement_type
*) f
->next_real_file
)
2414 /* Call a function on each file. The function will be called on all
2415 the elements of an archive which are included in the link, but will
2416 not be called on the archive file itself. */
2419 lang_for_each_file (func
)
2420 void (*func
) PARAMS ((lang_input_statement_type
*));
2422 lang_input_statement_type
*f
;
2424 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2425 f
!= (lang_input_statement_type
*) NULL
;
2426 f
= (lang_input_statement_type
*) f
->next
)
2437 lang_for_each_input_section (func
)
2438 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
2440 lang_input_statement_type
*f
;
2442 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2443 f
!= (lang_input_statement_type
*) NULL
;
2444 f
= (lang_input_statement_type
*) f
->next
)
2448 for (s
= f
->the_bfd
->sections
;
2449 s
!= (asection
*) NULL
;
2452 func (f
->the_bfd
, s
);
2460 ldlang_add_file (entry
)
2461 lang_input_statement_type
* entry
;
2465 lang_statement_append (&file_chain
,
2466 (lang_statement_union_type
*) entry
,
2469 /* The BFD linker needs to have a list of all input BFDs involved in
2471 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
2472 ASSERT (entry
->the_bfd
!= output_bfd
);
2473 for (pp
= &link_info
.input_bfds
;
2474 *pp
!= (bfd
*) NULL
;
2475 pp
= &(*pp
)->link_next
)
2477 *pp
= entry
->the_bfd
;
2478 entry
->the_bfd
->usrdata
= (PTR
) entry
;
2479 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
2483 lang_add_output (name
, from_script
)
2487 /* Make -o on command line override OUTPUT in script. */
2488 if (had_output_filename
== false || !from_script
)
2490 output_filename
= name
;
2491 had_output_filename
= true;
2496 static lang_output_section_statement_type
*current_section
;
2498 static int topower(x
)
2503 if (x
< 0) return -1;
2504 for (l
= 0; l
< 32; l
++)
2506 if (i
>= x
) return l
;
2512 lang_enter_output_section_statement (output_section_statement_name
,
2513 address_exp
, flags
, block_value
,
2514 align
, subalign
, ebase
)
2515 const char *output_section_statement_name
;
2516 etree_type
* address_exp
;
2518 bfd_vma block_value
;
2520 etree_type
*subalign
;
2523 lang_output_section_statement_type
*os
;
2527 lang_output_section_statement_lookup (output_section_statement_name
);
2531 /* Add this statement to tree */
2532 /* add_statement(lang_output_section_statement_enum,
2533 output_section_statement);*/
2534 /* Make next things chain into subchain of this */
2536 if (os
->addr_tree
==
2537 (etree_type
*) NULL
)
2543 if (flags
& SEC_NEVER_LOAD
)
2547 os
->block_value
= block_value
? block_value
: 1;
2548 stat_ptr
= &os
->children
;
2550 os
->subsection_alignment
= topower(
2551 exp_get_value_int(subalign
, -1,
2552 "subsection alignment",
2554 os
->section_alignment
= topower(
2555 exp_get_value_int(align
, -1,
2556 "section alignment", 0));
2558 os
->load_base
= ebase
;
2565 lang_output_statement_type
*new =
2566 new_stat (lang_output_statement
, stat_ptr
);
2568 new->name
= output_filename
;
2571 /* Reset the current counters in the regions */
2573 reset_memory_regions ()
2575 lang_memory_region_type
*p
= lang_memory_region_list
;
2577 for (p
= lang_memory_region_list
;
2578 p
!= (lang_memory_region_type
*) NULL
;
2581 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
2582 p
->current
= p
->origin
;
2589 lang_reasonable_defaults ();
2590 current_target
= default_target
;
2592 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
2594 ldemul_create_output_section_statements ();
2596 /* Add to the hash table all undefineds on the command line */
2597 lang_place_undefineds ();
2599 /* Create a bfd for each input file */
2600 current_target
= default_target
;
2601 open_input_bfds (statement_list
.head
, false);
2603 ldemul_after_open ();
2605 /* Build all sets based on the information gathered from the input
2607 ldctor_build_sets ();
2609 /* Size up the common data */
2612 /* Run through the contours of the script and attatch input sections
2613 to the correct output sections
2615 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
2616 (lang_output_section_statement_type
*) NULL
);
2619 /* Find any sections not attatched explicitly and handle them */
2620 lang_place_orphans ();
2622 ldemul_before_allocation ();
2624 /* Now run around and relax if we can */
2625 if (command_line
.relax
)
2627 /* First time round is a trial run to get the 'worst case'
2628 addresses of the objects if there was no relaxing. */
2629 lang_size_sections (statement_list
.head
,
2631 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2634 reset_memory_regions ();
2636 /* Keep relaxing until bfd_relax_section gives up. */
2639 relax_again
= false;
2641 /* Do all the assignments with our current guesses as to
2643 lang_do_assignments (statement_list
.head
,
2645 (fill_type
) 0, (bfd_vma
) 0);
2647 /* Perform another relax pass - this time we know where the
2648 globals are, so can make better guess. */
2649 lang_size_sections (statement_list
.head
,
2651 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2653 while (relax_again
);
2657 /* Size up the sections. */
2658 lang_size_sections (statement_list
.head
,
2660 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2663 /* See if anything special should be done now we know how big
2665 ldemul_after_allocation ();
2667 /* Do all the assignments, now that we know the final restingplaces
2668 of all the symbols */
2670 lang_do_assignments (statement_list
.head
,
2672 (fill_type
) 0, (bfd_vma
) 0);
2674 /* Make sure that we're not mixing architectures */
2684 /* EXPORTED TO YACC */
2687 lang_add_wild (section_name
, filename
)
2688 CONST
char *CONST section_name
;
2689 CONST
char *CONST filename
;
2691 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
2694 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
2696 placed_commons
= true;
2698 if (filename
!= (char *) NULL
)
2700 lang_has_input_file
= true;
2702 new->section_name
= section_name
;
2703 new->filename
= filename
;
2704 lang_list_init (&new->children
);
2708 lang_section_start (name
, address
)
2710 etree_type
* address
;
2712 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
2714 ad
->section_name
= name
;
2715 ad
->address
= address
;
2718 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
2719 because of a -e argument on the command line, or zero if this is
2720 called by ENTRY in a linker script. Command line arguments take
2724 lang_add_entry (name
, cmdline
)
2728 static int from_cmdline
;
2730 if (entry_symbol
== NULL
2734 entry_symbol
= name
;
2735 from_cmdline
= cmdline
;
2740 lang_add_target (name
)
2743 lang_target_statement_type
*new = new_stat (lang_target_statement
,
2759 map_option_f
= true;
2770 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
2777 lang_add_data (type
, exp
)
2779 union etree_union
*exp
;
2782 lang_data_statement_type
*new = new_stat (lang_data_statement
,
2790 /* Create a new reloc statement. RELOC is the BFD relocation type to
2791 generate. HOWTO is the corresponding howto structure (we could
2792 look this up, but the caller has already done so). SECTION is the
2793 section to generate a reloc against, or NAME is the name of the
2794 symbol to generate a reloc against. Exactly one of SECTION and
2795 NAME must be NULL. ADDEND is an expression for the addend. */
2798 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
2799 bfd_reloc_code_real_type reloc
;
2800 reloc_howto_type
*howto
;
2803 union etree_union
*addend
;
2805 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
2809 p
->section
= section
;
2811 p
->addend_exp
= addend
;
2813 p
->addend_value
= 0;
2814 p
->output_section
= NULL
;
2819 lang_add_assignment (exp
)
2822 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
2829 lang_add_attribute (attribute
)
2830 enum statement_enum attribute
;
2832 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
2839 if (startup_file
!= (char *) NULL
)
2841 einfo ("%P%Fmultiple STARTUP files\n");
2843 first_file
->filename
= name
;
2844 first_file
->local_sym_name
= name
;
2845 first_file
->real
= true;
2847 startup_file
= name
;
2854 lang_float_flag
= maybe
;
2858 lang_leave_output_section_statement (fill
, memspec
)
2860 CONST
char *memspec
;
2862 current_section
->fill
= fill
;
2863 current_section
->region
= lang_memory_region_lookup (memspec
);
2864 stat_ptr
= &statement_list
;
2868 Create an absolute symbol with the given name with the value of the
2869 address of first byte of the section named.
2871 If the symbol already exists, then do nothing.
2874 lang_abs_symbol_at_beginning_of (secname
, name
)
2875 const char *secname
;
2878 struct bfd_link_hash_entry
*h
;
2880 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2881 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2882 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2884 if (h
->type
== bfd_link_hash_new
2885 || h
->type
== bfd_link_hash_undefined
)
2889 h
->type
= bfd_link_hash_defined
;
2891 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2892 if (sec
== (asection
*) NULL
)
2895 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
2897 h
->u
.def
.section
= bfd_abs_section_ptr
;
2902 Create an absolute symbol with the given name with the value of the
2903 address of the first byte after the end of the section named.
2905 If the symbol already exists, then do nothing.
2908 lang_abs_symbol_at_end_of (secname
, name
)
2909 const char *secname
;
2912 struct bfd_link_hash_entry
*h
;
2914 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2915 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2916 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2918 if (h
->type
== bfd_link_hash_new
2919 || h
->type
== bfd_link_hash_undefined
)
2923 h
->type
= bfd_link_hash_defined
;
2925 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2926 if (sec
== (asection
*) NULL
)
2929 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
2930 + bfd_section_size (output_bfd
, sec
));
2932 h
->u
.def
.section
= bfd_abs_section_ptr
;
2937 lang_statement_append (list
, element
, field
)
2938 lang_statement_list_type
* list
;
2939 lang_statement_union_type
* element
;
2940 lang_statement_union_type
** field
;
2942 *(list
->tail
) = element
;
2946 /* Set the output format type. -oformat overrides scripts. */
2949 lang_add_output_format (format
, big
, little
, from_script
)
2955 if (output_target
== NULL
|| !from_script
)
2957 if (command_line
.endian
== ENDIAN_BIG
2960 else if (command_line
.endian
== ENDIAN_LITTLE
2964 output_target
= format
;
2968 /* Enter a group. This creates a new lang_group_statement, and sets
2969 stat_ptr to build new statements within the group. */
2974 lang_group_statement_type
*g
;
2976 g
= new_stat (lang_group_statement
, stat_ptr
);
2977 lang_list_init (&g
->children
);
2978 stat_ptr
= &g
->children
;
2981 /* Leave a group. This just resets stat_ptr to start writing to the
2982 regular list of statements again. Note that this will not work if
2983 groups can occur inside anything else which can adjust stat_ptr,
2984 but currently they can't. */
2989 stat_ptr
= &statement_list
;