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
)
1285 if (sec
== hash_entry
->u
.def
.section
) {
1287 fprintf (config
.map_file
, " ");
1289 fprintf (config
.map_file
, " ");
1290 print_address (hash_entry
->u
.def
.value
+ outside_section_address (sec
));
1291 fprintf (config
.map_file
, " %s", hash_entry
->root
.string
);
1300 print_input_section (in
)
1301 lang_input_section_type
* in
;
1303 asection
*i
= in
->section
;
1304 bfd_size_type size
= i
->_cooked_size
!= 0 ? i
->_cooked_size
: i
->_raw_size
;
1309 fprintf (config
.map_file
, " ");
1310 print_section (i
->name
);
1311 fprintf (config
.map_file
, " ");
1312 if (i
->output_section
)
1314 print_address (i
->output_section
->vma
+ i
->output_offset
);
1315 fprintf (config
.map_file
, " ");
1316 print_size (i
->_raw_size
);
1317 fprintf (config
.map_file
, " ");
1318 print_size(i
->_cooked_size
);
1319 fprintf (config
.map_file
, " ");
1320 print_alignment (i
->alignment_power
);
1321 fprintf (config
.map_file
, " ");
1325 bfd
*abfd
= in
->ifile
->the_bfd
;
1327 if (in
->ifile
->just_syms_flag
== true)
1329 fprintf (config
.map_file
, "symbols only ");
1332 fprintf (config
.map_file
, " %s ", abfd
->xvec
->name
);
1333 if (abfd
->my_archive
!= (bfd
*) NULL
)
1335 fprintf (config
.map_file
, "[%s]%s", abfd
->my_archive
->filename
,
1340 fprintf (config
.map_file
, "%s", abfd
->filename
);
1342 fprintf (config
.map_file
, "(overhead %d bytes)", (int) bfd_alloc_size (abfd
));
1345 /* Print all the symbols */
1346 bfd_link_hash_traverse (link_info
.hash
, print_one_symbol
, (PTR
) i
);
1354 print_dot
= outside_section_address (i
) + size
;
1358 fprintf (config
.map_file
, "No output section allocated\n");
1364 print_fill_statement (fill
)
1365 lang_fill_statement_type
* fill
;
1367 fprintf (config
.map_file
, "FILL mask ");
1368 print_fill (fill
->fill
);
1372 print_data_statement (data
)
1373 lang_data_statement_type
* data
;
1375 /* bfd_vma value; */
1380 /* ASSERT(print_dot == data->output_vma);*/
1382 print_address (data
->output_vma
+ data
->output_section
->vma
);
1384 print_address (data
->value
);
1389 fprintf (config
.map_file
, "BYTE ");
1390 print_dot
+= BYTE_SIZE
;
1393 fprintf (config
.map_file
, "SHORT ");
1394 print_dot
+= SHORT_SIZE
;
1397 fprintf (config
.map_file
, "LONG ");
1398 print_dot
+= LONG_SIZE
;
1401 fprintf (config
.map_file
, "QUAD ");
1402 print_dot
+= QUAD_SIZE
;
1406 exp_print_tree (data
->exp
);
1408 fprintf (config
.map_file
, "\n");
1411 /* Print a reloc statement. */
1414 print_reloc_statement (reloc
)
1415 lang_reloc_statement_type
*reloc
;
1422 /* ASSERT(print_dot == data->output_vma);*/
1424 print_address (reloc
->output_vma
+ reloc
->output_section
->vma
);
1426 print_address (reloc
->addend_value
);
1429 fprintf (config
.map_file
, "RELOC %s ", reloc
->howto
->name
);
1431 print_dot
+= bfd_get_reloc_size (reloc
->howto
);
1433 exp_print_tree (reloc
->addend_exp
);
1435 fprintf (config
.map_file
, "\n");
1439 print_padding_statement (s
)
1440 lang_padding_statement_type
* s
;
1444 print_section ("*fill*");
1446 print_address (s
->output_offset
+ s
->output_section
->vma
);
1448 print_size (s
->size
);
1450 print_fill (s
->fill
);
1453 print_dot
= s
->output_offset
+ s
->output_section
->vma
+ s
->size
;
1458 print_wild_statement (w
, os
)
1459 lang_wild_statement_type
* w
;
1460 lang_output_section_statement_type
* os
;
1462 fprintf (config
.map_file
, " from ");
1463 if (w
->filename
!= (char *) NULL
)
1465 fprintf (config
.map_file
, "%s", w
->filename
);
1469 fprintf (config
.map_file
, "*");
1471 if (w
->section_name
!= (char *) NULL
)
1473 fprintf (config
.map_file
, "(%s)", w
->section_name
);
1477 fprintf (config
.map_file
, "(*)");
1480 print_statement (w
->children
.head
, os
);
1484 /* Print a group statement. */
1488 lang_group_statement_type
*s
;
1489 lang_output_section_statement_type
*os
;
1491 fprintf (config
.map_file
, "START GROUP\n");
1492 print_statement (s
->children
.head
, os
);
1493 fprintf (config
.map_file
, "END GROUP\n");
1497 print_statement (s
, os
)
1498 lang_statement_union_type
* s
;
1499 lang_output_section_statement_type
* os
;
1503 switch (s
->header
.type
)
1505 case lang_constructors_statement_enum
:
1506 fprintf (config
.map_file
, "constructors:\n");
1507 print_statement (constructor_list
.head
, os
);
1509 case lang_wild_statement_enum
:
1510 print_wild_statement (&s
->wild_statement
, os
);
1513 fprintf (config
.map_file
, "Fail with %d\n", s
->header
.type
);
1516 case lang_address_statement_enum
:
1517 fprintf (config
.map_file
, "address\n");
1519 case lang_object_symbols_statement_enum
:
1520 fprintf (config
.map_file
, "object symbols\n");
1522 case lang_fill_statement_enum
:
1523 print_fill_statement (&s
->fill_statement
);
1525 case lang_data_statement_enum
:
1526 print_data_statement (&s
->data_statement
);
1528 case lang_reloc_statement_enum
:
1529 print_reloc_statement (&s
->reloc_statement
);
1531 case lang_input_section_enum
:
1532 print_input_section (&s
->input_section
);
1534 case lang_padding_statement_enum
:
1535 print_padding_statement (&s
->padding_statement
);
1537 case lang_output_section_statement_enum
:
1538 print_output_section_statement (&s
->output_section_statement
);
1540 case lang_assignment_statement_enum
:
1541 print_assignment (&s
->assignment_statement
,
1544 case lang_target_statement_enum
:
1545 fprintf (config
.map_file
, "TARGET(%s)\n", s
->target_statement
.target
);
1547 case lang_output_statement_enum
:
1548 fprintf (config
.map_file
, "OUTPUT(%s %s)\n",
1549 s
->output_statement
.name
,
1550 output_target
? output_target
: "");
1552 case lang_input_statement_enum
:
1553 print_input_statement (&s
->input_statement
);
1555 case lang_group_statement_enum
:
1556 print_group (&s
->group_statement
, os
);
1558 case lang_afile_asection_pair_statement_enum
:
1570 print_statement (statement_list
.head
,
1571 abs_output_section
);
1576 insert_pad (this_ptr
, fill
, power
, output_section_statement
, dot
)
1577 lang_statement_union_type
** this_ptr
;
1580 asection
* output_section_statement
;
1583 /* Align this section first to the
1584 input sections requirement, then
1585 to the output section's requirement.
1586 If this alignment is > than any seen before,
1587 then record it too. Perform the alignment by
1588 inserting a magic 'padding' statement.
1591 unsigned int alignment_needed
= align_power (dot
, power
) - dot
;
1593 if (alignment_needed
!= 0)
1595 lang_statement_union_type
*new =
1596 (lang_statement_union_type
*)
1597 stat_alloc ((bfd_size_type
) (sizeof (lang_padding_statement_type
)));
1599 /* Link into existing chain */
1600 new->header
.next
= *this_ptr
;
1602 new->header
.type
= lang_padding_statement_enum
;
1603 new->padding_statement
.output_section
= output_section_statement
;
1604 new->padding_statement
.output_offset
=
1605 dot
- output_section_statement
->vma
;
1606 new->padding_statement
.fill
= fill
;
1607 new->padding_statement
.size
= alignment_needed
;
1611 /* Remember the most restrictive alignment */
1612 if (power
> output_section_statement
->alignment_power
)
1614 output_section_statement
->alignment_power
= power
;
1616 output_section_statement
->_raw_size
+= alignment_needed
;
1617 return alignment_needed
+ dot
;
1621 /* Work out how much this section will move the dot point */
1623 size_input_section (this_ptr
, output_section_statement
, fill
, dot
, relax
)
1624 lang_statement_union_type
** this_ptr
;
1625 lang_output_section_statement_type
* output_section_statement
;
1630 lang_input_section_type
*is
= &((*this_ptr
)->input_section
);
1631 asection
*i
= is
->section
;
1633 if (is
->ifile
->just_syms_flag
== false)
1635 if (output_section_statement
->subsection_alignment
!= -1)
1636 i
->alignment_power
=
1637 output_section_statement
->subsection_alignment
;
1639 dot
= insert_pad (this_ptr
, fill
, i
->alignment_power
,
1640 output_section_statement
->bfd_section
, dot
);
1642 /* Remember where in the output section this input section goes */
1644 i
->output_offset
= dot
- output_section_statement
->bfd_section
->vma
;
1646 /* Mark how big the output section must be to contain this now
1648 if (i
->_cooked_size
!= 0)
1649 dot
+= i
->_cooked_size
;
1651 dot
+= i
->_raw_size
;
1652 output_section_statement
->bfd_section
->_raw_size
= dot
- output_section_statement
->bfd_section
->vma
;
1656 i
->output_offset
= i
->vma
- output_section_statement
->bfd_section
->vma
;
1662 /* This variable indicates whether bfd_relax_section should be called
1665 static boolean relax_again
;
1667 /* Set the sizes for all the output sections. */
1670 lang_size_sections (s
, output_section_statement
, prev
, fill
, dot
, relax
)
1671 lang_statement_union_type
* s
;
1672 lang_output_section_statement_type
* output_section_statement
;
1673 lang_statement_union_type
** prev
;
1678 /* Size up the sections from their constituent parts */
1679 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1681 switch (s
->header
.type
)
1684 case lang_output_section_statement_enum
:
1687 lang_output_section_statement_type
*os
= &s
->output_section_statement
;
1689 if (os
->bfd_section
== NULL
)
1691 /* This section was never actually created. */
1695 /* If this is a COFF shared library section, use the size and
1696 address from the input section. FIXME: This is COFF
1697 specific; it would be cleaner if there were some other way
1698 to do this, but nothing simple comes to mind. */
1699 if ((os
->bfd_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
1703 if (os
->children
.head
== NULL
1704 || os
->children
.head
->next
!= NULL
1705 || os
->children
.head
->header
.type
!= lang_input_section_enum
)
1706 einfo ("%P%X: Internal error on COFF shared library section %s",
1709 input
= os
->children
.head
->input_section
.section
;
1710 bfd_set_section_vma (os
->bfd_section
->owner
,
1712 bfd_section_vma (input
->owner
, input
));
1713 os
->bfd_section
->_raw_size
= input
->_raw_size
;
1717 if (bfd_is_abs_section (os
->bfd_section
))
1719 /* No matter what happens, an abs section starts at zero */
1720 ASSERT (os
->bfd_section
->vma
== 0);
1724 if (os
->addr_tree
== (etree_type
*) NULL
)
1726 /* No address specified for this section, get one
1727 from the region specification
1729 if (os
->region
== (lang_memory_region_type
*) NULL
)
1731 os
->region
= lang_memory_region_lookup ("*default*");
1733 dot
= os
->region
->current
;
1734 if (os
->section_alignment
== -1)
1735 dot
= align_power (dot
, os
->bfd_section
->alignment_power
);
1741 r
= exp_fold_tree (os
->addr_tree
,
1743 lang_allocating_phase_enum
,
1745 if (r
.valid
== false)
1747 einfo ("%F%S: non constant address expression for section %s\n",
1752 /* The section starts here */
1753 /* First, align to what the section needs */
1755 if (os
->section_alignment
!= -1)
1756 dot
= align_power (dot
, os
->section_alignment
);
1758 bfd_set_section_vma (0, os
->bfd_section
, dot
);
1760 os
->bfd_section
->output_offset
= 0;
1763 (void) lang_size_sections (os
->children
.head
, os
, &os
->children
.head
,
1764 os
->fill
, dot
, relax
);
1765 /* Ignore the size of the input sections, use the vma and size to */
1768 after
= ALIGN_N (os
->bfd_section
->vma
+
1769 os
->bfd_section
->_raw_size
,
1770 /* The coercion here is important, see ld.h. */
1771 (bfd_vma
) os
->block_value
);
1773 if (bfd_is_abs_section (os
->bfd_section
))
1774 ASSERT (after
== os
->bfd_section
->vma
);
1776 os
->bfd_section
->_raw_size
= after
- os
->bfd_section
->vma
;
1777 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
1778 os
->processed
= true;
1780 /* Replace into region ? */
1781 if (os
->region
!= (lang_memory_region_type
*) NULL
)
1783 os
->region
->current
= dot
;
1784 /* Make sure this isn't silly. */
1785 if ((os
->region
->current
< os
->region
->origin
)
1786 || (os
->region
->current
1787 > os
->region
->origin
+ os
->region
->length
))
1789 if (os
->addr_tree
!= (etree_type
*) NULL
)
1791 einfo ("%X%P: address 0x%v of %B section %s is not within region %s\n",
1792 os
->region
->current
,
1793 os
->bfd_section
->owner
,
1794 os
->bfd_section
->name
,
1799 einfo ("%X%P: region %s is full (%B section %s)\n",
1801 os
->bfd_section
->owner
,
1802 os
->bfd_section
->name
);
1804 /* Reset the region pointer. */
1805 os
->region
->current
= os
->region
->origin
;
1811 case lang_constructors_statement_enum
:
1812 dot
= lang_size_sections (constructor_list
.head
,
1813 output_section_statement
,
1814 &s
->wild_statement
.children
.head
,
1819 case lang_data_statement_enum
:
1821 unsigned int size
= 0;
1823 s
->data_statement
.output_vma
= dot
- output_section_statement
->bfd_section
->vma
;
1824 s
->data_statement
.output_section
=
1825 output_section_statement
->bfd_section
;
1827 switch (s
->data_statement
.type
)
1844 output_section_statement
->bfd_section
->_raw_size
+= size
;
1848 case lang_reloc_statement_enum
:
1852 s
->reloc_statement
.output_vma
=
1853 dot
- output_section_statement
->bfd_section
->vma
;
1854 s
->reloc_statement
.output_section
=
1855 output_section_statement
->bfd_section
;
1856 size
= bfd_get_reloc_size (s
->reloc_statement
.howto
);
1858 output_section_statement
->bfd_section
->_raw_size
+= size
;
1862 case lang_wild_statement_enum
:
1864 dot
= lang_size_sections (s
->wild_statement
.children
.head
,
1865 output_section_statement
,
1866 &s
->wild_statement
.children
.head
,
1872 case lang_object_symbols_statement_enum
:
1873 link_info
.create_object_symbols_section
=
1874 output_section_statement
->bfd_section
;
1876 case lang_output_statement_enum
:
1877 case lang_target_statement_enum
:
1879 case lang_input_section_enum
:
1883 i
= (*prev
)->input_section
.section
;
1885 i
->_cooked_size
= i
->_raw_size
;
1890 if (! bfd_relax_section (i
->owner
, i
, &link_info
, &again
))
1891 einfo ("%P%F: can't relax section: %E\n");
1895 dot
= size_input_section (prev
,
1896 output_section_statement
,
1897 output_section_statement
->fill
,
1901 case lang_input_statement_enum
:
1903 case lang_fill_statement_enum
:
1904 s
->fill_statement
.output_section
= output_section_statement
->bfd_section
;
1906 fill
= s
->fill_statement
.fill
;
1908 case lang_assignment_statement_enum
:
1910 bfd_vma newdot
= dot
;
1912 exp_fold_tree (s
->assignment_statement
.exp
,
1913 output_section_statement
,
1914 lang_allocating_phase_enum
,
1918 if (newdot
!= dot
&& !relax
)
1920 /* The assignment changed dot. Insert a pad. */
1921 if (output_section_statement
== abs_output_section
)
1923 /* If we don't have an output section, then just adjust
1924 the default memory address. */
1925 lang_memory_region_lookup ("*default*")->current
= newdot
;
1929 lang_statement_union_type
*new =
1930 ((lang_statement_union_type
*)
1931 stat_alloc (sizeof (lang_padding_statement_type
)));
1933 /* Link into existing chain */
1934 new->header
.next
= *prev
;
1936 new->header
.type
= lang_padding_statement_enum
;
1937 new->padding_statement
.output_section
=
1938 output_section_statement
->bfd_section
;
1939 new->padding_statement
.output_offset
=
1940 dot
- output_section_statement
->bfd_section
->vma
;
1941 new->padding_statement
.fill
= fill
;
1942 new->padding_statement
.size
= newdot
- dot
;
1943 output_section_statement
->bfd_section
->_raw_size
+=
1944 new->padding_statement
.size
;
1952 case lang_padding_statement_enum
:
1953 /* If we are relaxing, and this is not the first pass, some
1954 padding statements may have been inserted during previous
1955 passes. We may have to move the padding statement to a new
1956 location if dot has a different value at this point in this
1957 pass than it did at this point in the previous pass. */
1958 s
->padding_statement
.output_offset
=
1959 dot
- output_section_statement
->bfd_section
->vma
;
1960 dot
+= s
->padding_statement
.size
;
1963 case lang_group_statement_enum
:
1964 dot
= lang_size_sections (s
->group_statement
.children
.head
,
1965 output_section_statement
,
1966 &s
->group_statement
.children
.head
,
1974 /* This can only get here when relaxing is turned on */
1976 case lang_address_statement_enum
:
1979 prev
= &s
->header
.next
;
1985 lang_do_assignments (s
, output_section_statement
, fill
, dot
)
1986 lang_statement_union_type
* s
;
1987 lang_output_section_statement_type
* output_section_statement
;
1991 for (; s
!= (lang_statement_union_type
*) NULL
; s
= s
->next
)
1993 switch (s
->header
.type
)
1995 case lang_constructors_statement_enum
:
1996 dot
= lang_do_assignments (constructor_list
.head
,
1997 output_section_statement
,
2002 case lang_output_section_statement_enum
:
2004 lang_output_section_statement_type
*os
=
2005 &(s
->output_section_statement
);
2007 if (os
->bfd_section
!= NULL
)
2009 dot
= os
->bfd_section
->vma
;
2010 (void) lang_do_assignments (os
->children
.head
, os
,
2012 dot
= os
->bfd_section
->vma
+ os
->bfd_section
->_raw_size
;
2016 /* If nothing has been placed into the output section then
2017 it won't have a bfd_section. */
2018 if (os
->bfd_section
)
2020 os
->bfd_section
->lma
2021 = exp_get_abs_int(os
->load_base
, 0,"load base", lang_final_phase_enum
);
2026 case lang_wild_statement_enum
:
2028 dot
= lang_do_assignments (s
->wild_statement
.children
.head
,
2029 output_section_statement
,
2034 case lang_object_symbols_statement_enum
:
2035 case lang_output_statement_enum
:
2036 case lang_target_statement_enum
:
2038 case lang_common_statement_enum
:
2041 case lang_data_statement_enum
:
2043 etree_value_type value
;
2045 value
= exp_fold_tree (s
->data_statement
.exp
,
2047 lang_final_phase_enum
, dot
, &dot
);
2048 s
->data_statement
.value
= value
.value
;
2049 if (value
.valid
== false)
2050 einfo ("%F%P: invalid data statement\n");
2052 switch (s
->data_statement
.type
)
2069 case lang_reloc_statement_enum
:
2071 etree_value_type value
;
2073 value
= exp_fold_tree (s
->reloc_statement
.addend_exp
,
2075 lang_final_phase_enum
, dot
, &dot
);
2076 s
->reloc_statement
.addend_value
= value
.value
;
2077 if (value
.valid
== false)
2078 einfo ("%F%P: invalid reloc statement\n");
2080 dot
+= bfd_get_reloc_size (s
->reloc_statement
.howto
);
2083 case lang_input_section_enum
:
2085 asection
*in
= s
->input_section
.section
;
2087 if (in
->_cooked_size
!= 0)
2088 dot
+= in
->_cooked_size
;
2090 dot
+= in
->_raw_size
;
2094 case lang_input_statement_enum
:
2096 case lang_fill_statement_enum
:
2097 fill
= s
->fill_statement
.fill
;
2099 case lang_assignment_statement_enum
:
2101 exp_fold_tree (s
->assignment_statement
.exp
,
2102 output_section_statement
,
2103 lang_final_phase_enum
,
2109 case lang_padding_statement_enum
:
2110 dot
+= s
->padding_statement
.size
;
2113 case lang_group_statement_enum
:
2114 dot
= lang_do_assignments (s
->group_statement
.children
.head
,
2115 output_section_statement
,
2123 case lang_address_statement_enum
:
2134 struct bfd_link_hash_entry
*h
;
2137 if (link_info
.relocateable
|| link_info
.shared
)
2142 if (entry_symbol
== (char *) NULL
)
2144 /* No entry has been specified. Look for start, but don't warn
2145 if we don't find it. */
2146 entry_symbol
= "start";
2150 h
= bfd_link_hash_lookup (link_info
.hash
, entry_symbol
, false, false, true);
2151 if (h
!= (struct bfd_link_hash_entry
*) NULL
2152 && h
->type
== bfd_link_hash_defined
)
2156 val
= (h
->u
.def
.value
2157 + bfd_get_section_vma (output_bfd
,
2158 h
->u
.def
.section
->output_section
)
2159 + h
->u
.def
.section
->output_offset
);
2160 if (! bfd_set_start_address (output_bfd
, val
))
2161 einfo ("%P%F:%s: can't set start address\n", entry_symbol
);
2167 /* Can't find the entry symbol. Use the first address in the
2169 ts
= bfd_get_section_by_name (output_bfd
, ".text");
2170 if (ts
!= (asection
*) NULL
)
2173 einfo ("%P: warning: cannot find entry symbol %s; defaulting to %V\n",
2174 entry_symbol
, bfd_get_section_vma (output_bfd
, ts
));
2175 if (! bfd_set_start_address (output_bfd
,
2176 bfd_get_section_vma (output_bfd
, ts
)))
2177 einfo ("%P%F: can't set start address\n");
2182 einfo ("%P: warning: cannot find entry symbol %s; not setting start address\n",
2188 /* Check that the architecture of all the input files is compatible
2189 with the output file. */
2194 lang_statement_union_type
*file
;
2196 CONST bfd_arch_info_type
*compatible
;
2198 for (file
= file_chain
.head
;
2199 file
!= (lang_statement_union_type
*) NULL
;
2200 file
= file
->input_statement
.next
)
2202 input_bfd
= file
->input_statement
.the_bfd
;
2203 compatible
= bfd_arch_get_compatible (input_bfd
,
2205 if (compatible
== NULL
)
2206 einfo ("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n",
2207 bfd_printable_name (input_bfd
), input_bfd
,
2208 bfd_printable_name (output_bfd
));
2212 /* Look through all the global common symbols and attach them to the
2213 correct section. The -sort-common command line switch may be used
2214 to roughly sort the entries by size. */
2219 if (link_info
.relocateable
2220 && ! command_line
.force_common_definition
)
2223 if (! config
.sort_common
)
2224 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
, (PTR
) NULL
);
2229 for (power
= 1; power
< 4; power
++)
2230 bfd_link_hash_traverse (link_info
.hash
, lang_one_common
,
2235 /* Place one common symbol in the correct section. */
2238 lang_one_common (h
, info
)
2239 struct bfd_link_hash_entry
*h
;
2242 unsigned int power_of_two
;
2246 if (h
->type
!= bfd_link_hash_common
)
2250 power_of_two
= h
->u
.c
.alignment_power
;
2252 if (config
.sort_common
2253 && power_of_two
< *(unsigned int *) info
2254 && *(unsigned int *) info
< 4)
2257 section
= h
->u
.c
.section
;
2259 /* Increase the size of the section. */
2260 section
->_raw_size
= ALIGN_N (section
->_raw_size
,
2261 (bfd_size_type
) (1 << power_of_two
));
2263 /* Adjust the alignment if necessary. */
2264 if (power_of_two
> section
->alignment_power
)
2265 section
->alignment_power
= power_of_two
;
2267 /* Change the symbol from common to defined. */
2268 h
->type
= bfd_link_hash_defined
;
2269 h
->u
.def
.section
= section
;
2270 h
->u
.def
.value
= section
->_raw_size
;
2272 /* Increase the size of the section. */
2273 section
->_raw_size
+= size
;
2275 /* Make sure the section is allocated in memory. */
2276 section
->flags
|= SEC_ALLOC
;
2278 if (config
.map_file
!= NULL
)
2279 fprintf (config
.map_file
, "Allocating common %s: %lx at %lx %s\n",
2280 h
->root
.string
, (unsigned long) size
,
2281 (unsigned long) h
->u
.def
.value
, section
->owner
->filename
);
2287 run through the input files and ensure that every input
2288 section has somewhere to go. If one is found without
2289 a destination then create an input request and place it
2290 into the statement tree.
2294 lang_place_orphans ()
2296 lang_input_statement_type
*file
;
2298 for (file
= (lang_input_statement_type
*) file_chain
.head
;
2299 file
!= (lang_input_statement_type
*) NULL
;
2300 file
= (lang_input_statement_type
*) file
->next
)
2304 for (s
= file
->the_bfd
->sections
;
2305 s
!= (asection
*) NULL
;
2308 if (s
->output_section
== (asection
*) NULL
)
2310 /* This section of the file is not attatched, root
2311 around for a sensible place for it to go */
2313 if (file
->just_syms_flag
)
2315 /* We are only retrieving symbol values from this
2316 file. We want the symbols to act as though the
2317 values in the file are absolute. */
2318 s
->output_section
= bfd_abs_section_ptr
;
2319 s
->output_offset
= s
->vma
;
2321 else if (file
->common_section
== s
)
2323 /* This is a lonely common section which must
2324 have come from an archive. We attatch to the
2325 section with the wildcard */
2326 if (! link_info
.relocateable
2327 && ! command_line
.force_common_definition
)
2329 if (default_common_section
==
2330 (lang_output_section_statement_type
*) NULL
)
2332 info_msg ("%P: no [COMMON] command, defaulting to .bss\n");
2334 default_common_section
=
2335 lang_output_section_statement_lookup (".bss");
2338 wild_doit (&default_common_section
->children
, s
,
2339 default_common_section
, file
);
2342 else if (ldemul_place_orphan (file
, s
))
2346 lang_output_section_statement_type
*os
=
2347 lang_output_section_statement_lookup (s
->name
);
2349 wild_doit (&os
->children
, s
, os
, file
);
2358 lang_set_flags (ptr
, flags
)
2362 boolean state
= false;
2377 /* ptr->flag_read = state; */
2380 /* ptr->flag_write = state; */
2383 /* ptr->flag_executable= state;*/
2387 /* ptr->flag_loadable= state;*/
2390 einfo ("%P%F: invalid syntax in flags\n");
2397 /* Call a function on each input file. This function will be called
2398 on an archive, but not on the elements. */
2401 lang_for_each_input_file (func
)
2402 void (*func
) PARAMS ((lang_input_statement_type
*));
2404 lang_input_statement_type
*f
;
2406 for (f
= (lang_input_statement_type
*) input_file_chain
.head
;
2408 f
= (lang_input_statement_type
*) f
->next_real_file
)
2412 /* Call a function on each file. The function will be called on all
2413 the elements of an archive which are included in the link, but will
2414 not be called on the archive file itself. */
2417 lang_for_each_file (func
)
2418 void (*func
) PARAMS ((lang_input_statement_type
*));
2420 lang_input_statement_type
*f
;
2422 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2423 f
!= (lang_input_statement_type
*) NULL
;
2424 f
= (lang_input_statement_type
*) f
->next
)
2435 lang_for_each_input_section (func
)
2436 void (*func
) PARAMS ((bfd
* ab
, asection
* as
));
2438 lang_input_statement_type
*f
;
2440 for (f
= (lang_input_statement_type
*) file_chain
.head
;
2441 f
!= (lang_input_statement_type
*) NULL
;
2442 f
= (lang_input_statement_type
*) f
->next
)
2446 for (s
= f
->the_bfd
->sections
;
2447 s
!= (asection
*) NULL
;
2450 func (f
->the_bfd
, s
);
2458 ldlang_add_file (entry
)
2459 lang_input_statement_type
* entry
;
2463 lang_statement_append (&file_chain
,
2464 (lang_statement_union_type
*) entry
,
2467 /* The BFD linker needs to have a list of all input BFDs involved in
2469 ASSERT (entry
->the_bfd
->link_next
== (bfd
*) NULL
);
2470 ASSERT (entry
->the_bfd
!= output_bfd
);
2471 for (pp
= &link_info
.input_bfds
;
2472 *pp
!= (bfd
*) NULL
;
2473 pp
= &(*pp
)->link_next
)
2475 *pp
= entry
->the_bfd
;
2476 entry
->the_bfd
->usrdata
= (PTR
) entry
;
2477 bfd_set_gp_size (entry
->the_bfd
, g_switch_value
);
2481 lang_add_output (name
, from_script
)
2485 /* Make -o on command line override OUTPUT in script. */
2486 if (had_output_filename
== false || !from_script
)
2488 output_filename
= name
;
2489 had_output_filename
= true;
2494 static lang_output_section_statement_type
*current_section
;
2496 static int topower(x
)
2501 if (x
< 0) return -1;
2502 for (l
= 0; l
< 32; l
++)
2504 if (i
>= x
) return l
;
2510 lang_enter_output_section_statement (output_section_statement_name
,
2511 address_exp
, flags
, block_value
,
2512 align
, subalign
, ebase
)
2513 const char *output_section_statement_name
;
2514 etree_type
* address_exp
;
2516 bfd_vma block_value
;
2518 etree_type
*subalign
;
2521 lang_output_section_statement_type
*os
;
2525 lang_output_section_statement_lookup (output_section_statement_name
);
2529 /* Add this statement to tree */
2530 /* add_statement(lang_output_section_statement_enum,
2531 output_section_statement);*/
2532 /* Make next things chain into subchain of this */
2534 if (os
->addr_tree
==
2535 (etree_type
*) NULL
)
2541 if (flags
& SEC_NEVER_LOAD
)
2545 os
->block_value
= block_value
? block_value
: 1;
2546 stat_ptr
= &os
->children
;
2548 os
->subsection_alignment
= topower(
2549 exp_get_value_int(subalign
, -1,
2550 "subsection alignment",
2552 os
->section_alignment
= topower(
2553 exp_get_value_int(align
, -1,
2554 "section alignment", 0));
2556 os
->load_base
= ebase
;
2563 lang_output_statement_type
*new =
2564 new_stat (lang_output_statement
, stat_ptr
);
2566 new->name
= output_filename
;
2569 /* Reset the current counters in the regions */
2571 reset_memory_regions ()
2573 lang_memory_region_type
*p
= lang_memory_region_list
;
2575 for (p
= lang_memory_region_list
;
2576 p
!= (lang_memory_region_type
*) NULL
;
2579 p
->old_length
= (bfd_size_type
) (p
->current
- p
->origin
);
2580 p
->current
= p
->origin
;
2587 lang_reasonable_defaults ();
2588 current_target
= default_target
;
2590 lang_for_each_statement (ldlang_open_output
); /* Open the output file */
2592 ldemul_create_output_section_statements ();
2594 /* Add to the hash table all undefineds on the command line */
2595 lang_place_undefineds ();
2597 /* Create a bfd for each input file */
2598 current_target
= default_target
;
2599 open_input_bfds (statement_list
.head
, false);
2601 ldemul_after_open ();
2603 /* Build all sets based on the information gathered from the input
2605 ldctor_build_sets ();
2607 /* Size up the common data */
2610 /* Run through the contours of the script and attatch input sections
2611 to the correct output sections
2613 map_input_to_output_sections (statement_list
.head
, (char *) NULL
,
2614 (lang_output_section_statement_type
*) NULL
);
2617 /* Find any sections not attatched explicitly and handle them */
2618 lang_place_orphans ();
2620 ldemul_before_allocation ();
2622 /* Now run around and relax if we can */
2623 if (command_line
.relax
)
2625 /* First time round is a trial run to get the 'worst case'
2626 addresses of the objects if there was no relaxing. */
2627 lang_size_sections (statement_list
.head
,
2629 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2632 reset_memory_regions ();
2634 /* Keep relaxing until bfd_relax_section gives up. */
2637 relax_again
= false;
2639 /* Do all the assignments with our current guesses as to
2641 lang_do_assignments (statement_list
.head
,
2643 (fill_type
) 0, (bfd_vma
) 0);
2645 /* Perform another relax pass - this time we know where the
2646 globals are, so can make better guess. */
2647 lang_size_sections (statement_list
.head
,
2649 &(statement_list
.head
), 0, (bfd_vma
) 0, true);
2651 while (relax_again
);
2655 /* Size up the sections. */
2656 lang_size_sections (statement_list
.head
,
2658 &(statement_list
.head
), 0, (bfd_vma
) 0, false);
2661 /* See if anything special should be done now we know how big
2663 ldemul_after_allocation ();
2665 /* Do all the assignments, now that we know the final restingplaces
2666 of all the symbols */
2668 lang_do_assignments (statement_list
.head
,
2670 (fill_type
) 0, (bfd_vma
) 0);
2672 /* Make sure that we're not mixing architectures */
2682 /* EXPORTED TO YACC */
2685 lang_add_wild (section_name
, filename
)
2686 CONST
char *CONST section_name
;
2687 CONST
char *CONST filename
;
2689 lang_wild_statement_type
*new = new_stat (lang_wild_statement
,
2692 if (section_name
!= (char *) NULL
&& strcmp (section_name
, "COMMON") == 0)
2694 placed_commons
= true;
2696 if (filename
!= (char *) NULL
)
2698 lang_has_input_file
= true;
2700 new->section_name
= section_name
;
2701 new->filename
= filename
;
2702 lang_list_init (&new->children
);
2706 lang_section_start (name
, address
)
2708 etree_type
* address
;
2710 lang_address_statement_type
*ad
= new_stat (lang_address_statement
, stat_ptr
);
2712 ad
->section_name
= name
;
2713 ad
->address
= address
;
2716 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
2717 because of a -e argument on the command line, or zero if this is
2718 called by ENTRY in a linker script. Command line arguments take
2722 lang_add_entry (name
, cmdline
)
2726 static int from_cmdline
;
2728 if (entry_symbol
== NULL
2732 entry_symbol
= name
;
2733 from_cmdline
= cmdline
;
2738 lang_add_target (name
)
2741 lang_target_statement_type
*new = new_stat (lang_target_statement
,
2757 map_option_f
= true;
2768 lang_fill_statement_type
*new = new_stat (lang_fill_statement
,
2775 lang_add_data (type
, exp
)
2777 union etree_union
*exp
;
2780 lang_data_statement_type
*new = new_stat (lang_data_statement
,
2788 /* Create a new reloc statement. RELOC is the BFD relocation type to
2789 generate. HOWTO is the corresponding howto structure (we could
2790 look this up, but the caller has already done so). SECTION is the
2791 section to generate a reloc against, or NAME is the name of the
2792 symbol to generate a reloc against. Exactly one of SECTION and
2793 NAME must be NULL. ADDEND is an expression for the addend. */
2796 lang_add_reloc (reloc
, howto
, section
, name
, addend
)
2797 bfd_reloc_code_real_type reloc
;
2798 reloc_howto_type
*howto
;
2801 union etree_union
*addend
;
2803 lang_reloc_statement_type
*p
= new_stat (lang_reloc_statement
, stat_ptr
);
2807 p
->section
= section
;
2809 p
->addend_exp
= addend
;
2811 p
->addend_value
= 0;
2812 p
->output_section
= NULL
;
2817 lang_add_assignment (exp
)
2820 lang_assignment_statement_type
*new = new_stat (lang_assignment_statement
,
2827 lang_add_attribute (attribute
)
2828 enum statement_enum attribute
;
2830 new_statement (attribute
, sizeof (lang_statement_union_type
), stat_ptr
);
2837 if (startup_file
!= (char *) NULL
)
2839 einfo ("%P%Fmultiple STARTUP files\n");
2841 first_file
->filename
= name
;
2842 first_file
->local_sym_name
= name
;
2843 first_file
->real
= true;
2845 startup_file
= name
;
2852 lang_float_flag
= maybe
;
2856 lang_leave_output_section_statement (fill
, memspec
)
2858 CONST
char *memspec
;
2860 current_section
->fill
= fill
;
2861 current_section
->region
= lang_memory_region_lookup (memspec
);
2862 stat_ptr
= &statement_list
;
2866 Create an absolute symbol with the given name with the value of the
2867 address of first byte of the section named.
2869 If the symbol already exists, then do nothing.
2872 lang_abs_symbol_at_beginning_of (secname
, name
)
2873 const char *secname
;
2876 struct bfd_link_hash_entry
*h
;
2878 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2879 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2880 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2882 if (h
->type
== bfd_link_hash_new
2883 || h
->type
== bfd_link_hash_undefined
)
2887 h
->type
= bfd_link_hash_defined
;
2889 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2890 if (sec
== (asection
*) NULL
)
2893 h
->u
.def
.value
= bfd_get_section_vma (output_bfd
, sec
);
2895 h
->u
.def
.section
= bfd_abs_section_ptr
;
2900 Create an absolute symbol with the given name with the value of the
2901 address of the first byte after the end of the section named.
2903 If the symbol already exists, then do nothing.
2906 lang_abs_symbol_at_end_of (secname
, name
)
2907 const char *secname
;
2910 struct bfd_link_hash_entry
*h
;
2912 h
= bfd_link_hash_lookup (link_info
.hash
, name
, true, true, true);
2913 if (h
== (struct bfd_link_hash_entry
*) NULL
)
2914 einfo ("%P%F: bfd_link_hash_lookup failed: %E\n");
2916 if (h
->type
== bfd_link_hash_new
2917 || h
->type
== bfd_link_hash_undefined
)
2921 h
->type
= bfd_link_hash_defined
;
2923 sec
= bfd_get_section_by_name (output_bfd
, secname
);
2924 if (sec
== (asection
*) NULL
)
2927 h
->u
.def
.value
= (bfd_get_section_vma (output_bfd
, sec
)
2928 + bfd_section_size (output_bfd
, sec
));
2930 h
->u
.def
.section
= bfd_abs_section_ptr
;
2935 lang_statement_append (list
, element
, field
)
2936 lang_statement_list_type
* list
;
2937 lang_statement_union_type
* element
;
2938 lang_statement_union_type
** field
;
2940 *(list
->tail
) = element
;
2944 /* Set the output format type. -oformat overrides scripts. */
2947 lang_add_output_format (format
, big
, little
, from_script
)
2953 if (output_target
== NULL
|| !from_script
)
2955 if (command_line
.endian
== ENDIAN_BIG
2958 else if (command_line
.endian
== ENDIAN_LITTLE
2962 output_target
= format
;
2966 /* Enter a group. This creates a new lang_group_statement, and sets
2967 stat_ptr to build new statements within the group. */
2972 lang_group_statement_type
*g
;
2974 g
= new_stat (lang_group_statement
, stat_ptr
);
2975 lang_list_init (&g
->children
);
2976 stat_ptr
= &g
->children
;
2979 /* Leave a group. This just resets stat_ptr to start writing to the
2980 regular list of statements again. Note that this will not work if
2981 groups can occur inside anything else which can adjust stat_ptr,
2982 but currently they can't. */
2987 stat_ptr
= &statement_list
;