projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add new field to bfd_target structure.
[deliverable/binutils-gdb.git] / ld / ldlang.c
CommitLineData
252b5132
RH		 1/* Linker command language support.
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
4
5This file is part of GLD, the Gnu Linker.
6
7GLD is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2, or (at your option)
10any later version.
11
12GLD is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GLD; see the file COPYING. If not, write to the Free
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2002111-1307, USA. */
21
22#include "bfd.h"
23#include "sysdep.h"
24#include "libiberty.h"
25#include "obstack.h"
26#include "bfdlink.h"
27
28#include "ld.h"
29#include "ldmain.h"
30#include "ldgram.h"
31#include "ldexp.h"
32#include "ldlang.h"
33#include "ldemul.h"
34#include "ldlex.h"
35#include "ldmisc.h"
36#include "ldctor.h"
37#include "ldfile.h"
38#include "fnmatch.h"
39#include "demangle.h"
40
41#include <ctype.h>
42
43/* FORWARDS */
44static lang_statement_union_type *new_statement PARAMS ((enum statement_enum,
45 size_t,
46 lang_statement_list_type*));
47
48
49/* LOCALS */
50static struct obstack stat_obstack;
51
52#define obstack_chunk_alloc xmalloc
53#define obstack_chunk_free free
54static CONST char *startup_file;
55static lang_statement_list_type input_file_chain;
56static boolean placed_commons = false;
57static lang_output_section_statement_type *default_common_section;
58static boolean map_option_f;
59static bfd_vma print_dot;
60static lang_input_statement_type *first_file;
61static lang_statement_list_type lang_output_section_statement;
62static CONST char *current_target;
63static CONST char *output_target;
64static lang_statement_list_type statement_list;
65static struct lang_phdr *lang_phdr_list;
66
67static void lang_for_each_statement_worker
68 PARAMS ((void (*func) (lang_statement_union_type *),
69 lang_statement_union_type *s));
70static 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));
73static void init_os PARAMS ((lang_output_section_statement_type *s));
74static void exp_init_os PARAMS ((etree_type *));
75static void section_already_linked PARAMS ((bfd *, asection *, PTR));
76static boolean wildcardp PARAMS ((const char *));
77static lang_statement_union_type *wild_sort
78 PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
79 asection *));
252b5132
RH		 80static lang_input_statement_type *lookup_name PARAMS ((const char *name));
81static void load_symbols PARAMS ((lang_input_statement_type *entry,
82 lang_statement_list_type *));
252b5132
RH		 83static void wild PARAMS ((lang_wild_statement_type *s,
84 const char *section, const char *file,
85 const char *target,
86 lang_output_section_statement_type *output));
87static bfd *open_output PARAMS ((const char *name));
88static void ldlang_open_output PARAMS ((lang_statement_union_type *statement));
89static void open_input_bfds
90 PARAMS ((lang_statement_union_type *statement, boolean));
91static void lang_reasonable_defaults PARAMS ((void));
92static void lang_place_undefineds PARAMS ((void));
93static void map_input_to_output_sections
94 PARAMS ((lang_statement_union_type *s,
95 const char *target,
96 lang_output_section_statement_type *output_section_statement));
97static void print_output_section_statement
98 PARAMS ((lang_output_section_statement_type *output_section_statement));
99static void print_assignment
100 PARAMS ((lang_assignment_statement_type *assignment,
101 lang_output_section_statement_type *output_section));
102static void print_input_statement PARAMS ((lang_input_statement_type *statm));
103static boolean print_one_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));
104static void print_input_section PARAMS ((lang_input_section_type *in));
105static void print_fill_statement PARAMS ((lang_fill_statement_type *fill));
106static void print_data_statement PARAMS ((lang_data_statement_type *data));
107static void print_address_statement PARAMS ((lang_address_statement_type *));
108static void print_reloc_statement PARAMS ((lang_reloc_statement_type *reloc));
109static void print_padding_statement PARAMS ((lang_padding_statement_type *s));
110static void print_wild_statement
111 PARAMS ((lang_wild_statement_type *w,
112 lang_output_section_statement_type *os));
113static void print_group
114 PARAMS ((lang_group_statement_type *, lang_output_section_statement_type *));
115static void print_statement PARAMS ((lang_statement_union_type *s,
116 lang_output_section_statement_type *os));
117static void print_statement_list PARAMS ((lang_statement_union_type *s,
118 lang_output_section_statement_type *os));
119static void print_statements PARAMS ((void));
120static bfd_vma insert_pad PARAMS ((lang_statement_union_type **this_ptr,
121 fill_type fill, unsigned int power,
122 asection *output_section_statement,
123 bfd_vma dot));
124static bfd_vma size_input_section
125 PARAMS ((lang_statement_union_type **this_ptr,
126 lang_output_section_statement_type *output_section_statement,
127 fill_type fill, bfd_vma dot, boolean relax));
128static void lang_finish PARAMS ((void));
129static void ignore_bfd_errors PARAMS ((const char *, ...));
130static void lang_check PARAMS ((void));
131static void lang_common PARAMS ((void));
132static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR));
133static void lang_place_orphans PARAMS ((void));
134static int topower PARAMS ((int));
135static void lang_set_startof PARAMS ((void));
136static void reset_memory_regions PARAMS ((void));
137static void lang_record_phdrs PARAMS ((void));
252b5132
RH		 138static void lang_gc_wild
139 PARAMS ((lang_wild_statement_type *, const char *, const char *));
140static void lang_gc_sections_1 PARAMS ((lang_statement_union_type *));
141static void lang_gc_sections PARAMS ((void));
142static void lang_do_version_exports_section PARAMS ((void));
143static void lang_check_section_addresses PARAMS ((void));
252b5132 144
4dec4d4e
RH		 145typedef void (*callback_t) PARAMS ((lang_wild_statement_type *,
146 asection *, lang_input_statement_type *,
147 void *));
148static void walk_wild_section
149 PARAMS ((lang_wild_statement_type *, const char *,
150 lang_input_statement_type *, callback_t, void *));
151static void walk_wild_file
152 PARAMS ((lang_wild_statement_type *, const char *,
153 lang_input_statement_type *, callback_t, void *));
154
252b5132
RH		 155/* EXPORTS */
156lang_output_section_statement_type *abs_output_section;
157lang_statement_list_type *stat_ptr = &statement_list;
87f2a346 158lang_statement_list_type file_chain = { NULL, NULL };
252b5132
RH		 159const char *entry_symbol = NULL;
160boolean entry_from_cmdline;
161boolean lang_has_input_file = false;
162boolean had_output_filename = false;
163boolean lang_float_flag = false;
164boolean delete_output_file_on_failure = false;
165struct lang_nocrossrefs *nocrossref_list;
166
167etree_type *base; /* Relocation base - or null */
168
169
170#if defined(__STDC__) || defined(ALMOST_STDC)
171#define cat(a,b) a##b
172#else
173#define cat(a,b) a/**/b
174#endif
175
176#define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
177
178#define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
179
180#define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
181
182#define SECTION_NAME_MAP_LENGTH (16)
183
184PTR
185stat_alloc (size)
186 size_t size;
187{
188 return obstack_alloc (&stat_obstack, size);
189}
190
4dec4d4e
RH		 191/*----------------------------------------------------------------------
192 Generic traversal routines for finding matching sections.
193*/
194
195static void
196walk_wild_section (ptr, section, file, callback, data)
197 lang_wild_statement_type *ptr;
198 const char *section;
199 lang_input_statement_type *file;
200 callback_t callback;
201 void *data;
202{
203 /* Don't process sections from files which were excluded. */
204 if (ptr->exclude_filename != NULL)
205 {
206 boolean match;
207
208 if (wildcardp (ptr->exclude_filename))
209 match = fnmatch (ptr->exclude_filename, file->filename, 0) == 0 ? true : false;
210 else
211 match = strcmp (ptr->exclude_filename, file->filename) == 0 ? true : false;
212
213 if (match)
214 return;
215 }
216
217 if (file->just_syms_flag == false)
218 {
219 register asection *s;
220 boolean wildcard;
221
222 if (section == NULL)
223 wildcard = false;
224 else
225 wildcard = wildcardp (section);
226
227 for (s = file->the_bfd->sections; s != NULL; s = s->next)
228 {
229 boolean match;
230
231 if (section == NULL)
232 match = true;
233 else
234 {
235 const char *name;
236
237 name = bfd_get_section_name (file->the_bfd, s);
238 if (wildcard)
239 match = fnmatch (section, name, 0) == 0 ? true : false;
240 else
241 match = strcmp (section, name) == 0 ? true : false;
242 }
243
244 if (match)
245 (*callback) (ptr, s, file, data);
246 }
247 }
248}
249
250/* Handle a wild statement for a single file F. */
251
252static void
253walk_wild_file (s, section, f, callback, data)
254 lang_wild_statement_type *s;
255 const char *section;
256 lang_input_statement_type *f;
257 callback_t callback;
258 void *data;
259{
260 if (f->the_bfd == NULL
261 || ! bfd_check_format (f->the_bfd, bfd_archive))
262 walk_wild_section (s, section, f, callback, data);
263 else
264 {
265 bfd *member;
266
267 /* This is an archive file. We must map each member of the
268 archive separately. */
269 member = bfd_openr_next_archived_file (f->the_bfd, (bfd *) NULL);
270 while (member != NULL)
271 {
272 /* When lookup_name is called, it will call the add_symbols
273 entry point for the archive. For each element of the
274 archive which is included, BFD will call ldlang_add_file,
275 which will set the usrdata field of the member to the
276 lang_input_statement. */
277 if (member->usrdata != NULL)
278 {
279 walk_wild_section (s, section,
280 (lang_input_statement_type *) member->usrdata,
281 callback, data);
282 }
283
284 member = bfd_openr_next_archived_file (f->the_bfd, member);
285 }
286 }
287}
288
289static void
290walk_wild (s, section, file, callback, data)
291 lang_wild_statement_type *s;
292 const char *section;
293 const char *file;
294 callback_t callback;
295 void *data;
296{
297 lang_input_statement_type *f;
298
299 if (file == (char *) NULL)
300 {
301 /* Perform the iteration over all files in the list. */
302 for (f = (lang_input_statement_type *) file_chain.head;
303 f != (lang_input_statement_type *) NULL;
304 f = (lang_input_statement_type *) f->next)
305 {
306 walk_wild_file (s, section, f, callback, data);
307 }
308 }
309 else if (wildcardp (file))
310 {
311 for (f = (lang_input_statement_type *) file_chain.head;
312 f != (lang_input_statement_type *) NULL;
313 f = (lang_input_statement_type *) f->next)
314 {
315 if (fnmatch (file, f->filename, FNM_FILE_NAME) == 0)
316 walk_wild_file (s, section, f, callback, data);
317 }
318 }
319 else
320 {
321 /* Perform the iteration over a single file. */
322 f = lookup_name (file);
323 walk_wild_file (s, section, f, callback, data);
324 }
325}
326
252b5132
RH		 327/*----------------------------------------------------------------------
328 lang_for_each_statement walks the parse tree and calls the provided
329 function for each node
330*/
331
332static void
333lang_for_each_statement_worker (func, s)
334 void (*func) PARAMS ((lang_statement_union_type *));
335 lang_statement_union_type *s;
336{
337 for (; s != (lang_statement_union_type *) NULL; s = s->next)
338 {
339 func (s);
340
341 switch (s->header.type)
342 {
343 case lang_constructors_statement_enum:
344 lang_for_each_statement_worker (func, constructor_list.head);
345 break;
346 case lang_output_section_statement_enum:
347 lang_for_each_statement_worker
348 (func,
349 s->output_section_statement.children.head);
350 break;
351 case lang_wild_statement_enum:
352 lang_for_each_statement_worker
353 (func,
354 s->wild_statement.children.head);
355 break;
356 case lang_group_statement_enum:
357 lang_for_each_statement_worker (func,
358 s->group_statement.children.head);
359 break;
360 case lang_data_statement_enum:
361 case lang_reloc_statement_enum:
362 case lang_object_symbols_statement_enum:
363 case lang_output_statement_enum:
364 case lang_target_statement_enum:
365 case lang_input_section_enum:
366 case lang_input_statement_enum:
367 case lang_assignment_statement_enum:
368 case lang_padding_statement_enum:
369 case lang_address_statement_enum:
370 case lang_fill_statement_enum:
371 break;
372 default:
373 FAIL ();
374 break;
375 }
376 }
377}
378
379void
380lang_for_each_statement (func)
381 void (*func) PARAMS ((lang_statement_union_type *));
382{
383 lang_for_each_statement_worker (func,
384 statement_list.head);
385}
386
387/*----------------------------------------------------------------------*/
388void
389lang_list_init (list)
390 lang_statement_list_type *list;
391{
392 list->head = (lang_statement_union_type *) NULL;
393 list->tail = &list->head;
394}
395
396/*----------------------------------------------------------------------
397
398 build a new statement node for the parse tree
399
400 */
401
402static
403lang_statement_union_type *
404new_statement (type, size, list)
405 enum statement_enum type;
406 size_t size;
407 lang_statement_list_type * list;
408{
409 lang_statement_union_type *new = (lang_statement_union_type *)
410 stat_alloc (size);
411
412 new->header.type = type;
413 new->header.next = (lang_statement_union_type *) NULL;
414 lang_statement_append (list, new, &new->header.next);
415 return new;
416}
417
418/*
419 Build a new input file node for the language. There are several ways
420 in which we treat an input file, eg, we only look at symbols, or
421 prefix it with a -l etc.
422
423 We can be supplied with requests for input files more than once;
424 they may, for example be split over serveral lines like foo.o(.text)
425 foo.o(.data) etc, so when asked for a file we check that we havn't
426 got it already so we don't duplicate the bfd.
427
428 */
429static lang_input_statement_type *
430new_afile (name, file_type, target, add_to_list)
431 CONST char *name;
432 lang_input_file_enum_type file_type;
433 CONST char *target;
434 boolean add_to_list;
435{
436 lang_input_statement_type *p;
437
438 if (add_to_list)
439 p = new_stat (lang_input_statement, stat_ptr);
440 else
441 {
442 p = ((lang_input_statement_type *)
443 stat_alloc (sizeof (lang_input_statement_type)));
444 p->header.next = NULL;
445 }
446
447 lang_has_input_file = true;
448 p->target = target;
449 switch (file_type)
450 {
451 case lang_input_file_is_symbols_only_enum:
452 p->filename = name;
453 p->is_archive = false;
454 p->real = true;
455 p->local_sym_name = name;
456 p->just_syms_flag = true;
457 p->search_dirs_flag = false;
458 break;
459 case lang_input_file_is_fake_enum:
460 p->filename = name;
461 p->is_archive = false;
462 p->real = false;
463 p->local_sym_name = name;
464 p->just_syms_flag = false;
465 p->search_dirs_flag = false;
466 break;
467 case lang_input_file_is_l_enum:
468 p->is_archive = true;
469 p->filename = name;
470 p->real = true;
471 p->local_sym_name = concat ("-l", name, (const char *) NULL);
472 p->just_syms_flag = false;
473 p->search_dirs_flag = true;
474 break;
475 case lang_input_file_is_marker_enum:
476 p->filename = name;
477 p->is_archive = false;
478 p->real = false;
479 p->local_sym_name = name;
480 p->just_syms_flag = false;
481 p->search_dirs_flag = true;
482 break;
483 case lang_input_file_is_search_file_enum:
484 p->filename = name;
485 p->is_archive = false;
486 p->real = true;
487 p->local_sym_name = name;
488 p->just_syms_flag = false;
489 p->search_dirs_flag = true;
490 break;
491 case lang_input_file_is_file_enum:
492 p->filename = name;
493 p->is_archive = false;
494 p->real = true;
495 p->local_sym_name = name;
496 p->just_syms_flag = false;
497 p->search_dirs_flag = false;
498 break;
499 default:
500 FAIL ();
501 }
502 p->the_bfd = (bfd *) NULL;
503 p->asymbols = (asymbol **) NULL;
504 p->next_real_file = (lang_statement_union_type *) NULL;
505 p->next = (lang_statement_union_type *) NULL;
506 p->symbol_count = 0;
507 p->dynamic = config.dynamic_link;
508 p->whole_archive = whole_archive;
509 p->loaded = false;
510 lang_statement_append (&input_file_chain,
511 (lang_statement_union_type *) p,
512 &p->next_real_file);
513 return p;
514}
515
516lang_input_statement_type *
517lang_add_input_file (name, file_type, target)
518 CONST char *name;
519 lang_input_file_enum_type file_type;
520 CONST char *target;
521{
522 lang_has_input_file = true;
523 return new_afile (name, file_type, target, true);
524}
525
526/* Build enough state so that the parser can build its tree */
527void
528lang_init ()
529{
530 obstack_begin (&stat_obstack, 1000);
531
532 stat_ptr = &statement_list;
533
534 lang_list_init (stat_ptr);
535
536 lang_list_init (&input_file_chain);
537 lang_list_init (&lang_output_section_statement);
538 lang_list_init (&file_chain);
539 first_file = lang_add_input_file ((char *) NULL,
540 lang_input_file_is_marker_enum,
541 (char *) NULL);
542 abs_output_section = lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
543
544 abs_output_section->bfd_section = bfd_abs_section_ptr;
545
546}
547
548/*----------------------------------------------------------------------
549 A region is an area of memory declared with the
550 MEMORY { name:org=exp, len=exp ... }
551 syntax.
552
553 We maintain a list of all the regions here
554
555 If no regions are specified in the script, then the default is used
556 which is created when looked up to be the entire data space
557*/
558
559static lang_memory_region_type *lang_memory_region_list;
560static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
561
562lang_memory_region_type *
563lang_memory_region_lookup (name)
564 CONST char *CONST name;
565{
566 lang_memory_region_type *p;
567
568 for (p = lang_memory_region_list;
569 p != (lang_memory_region_type *) NULL;
570 p = p->next)
571 {
572 if (strcmp (p->name, name) == 0)
573 {
574 return p;
575 }
576 }
577
578#if 0
579 /* This code used to always use the first region in the list as the
580 default region. I changed it to instead use a region
581 encompassing all of memory as the default region. This permits
582 NOLOAD sections to work reasonably without requiring a region.
583 People should specify what region they mean, if they really want
584 a region. */
585 if (strcmp (name, "*default*") == 0)
586 {
587 if (lang_memory_region_list != (lang_memory_region_type *) NULL)
588 {
589 return lang_memory_region_list;
590 }
591 }
592#endif
593
594 {
595 lang_memory_region_type *new =
596 (lang_memory_region_type *) stat_alloc (sizeof (lang_memory_region_type));
597
598 new->name = buystring (name);
599 new->next = (lang_memory_region_type *) NULL;
600
601 *lang_memory_region_list_tail = new;
602 lang_memory_region_list_tail = &new->next;
603 new->origin = 0;
604 new->flags = 0;
605 new->not_flags = 0;
606 new->length = ~(bfd_size_type)0;
607 new->current = 0;
608 new->had_full_message = false;
609
610 return new;
611 }
612}
613
614
615lang_memory_region_type *
616lang_memory_default (section)
617 asection *section;
618{
619 lang_memory_region_type *p;
620
621 flagword sec_flags = section->flags;
622
623 /* Override SEC_DATA to mean a writable section. */
624 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
625 sec_flags |= SEC_DATA;
626
627 for (p = lang_memory_region_list;
628 p != (lang_memory_region_type *) NULL;
629 p = p->next)
630 {
631 if ((p->flags & sec_flags) != 0
632 && (p->not_flags & sec_flags) == 0)
633 {
634 return p;
635 }
636 }
637 return lang_memory_region_lookup ("*default*");
638}
639
640lang_output_section_statement_type *
641lang_output_section_find (name)
642 CONST char *CONST name;
643{
644 lang_statement_union_type *u;
645 lang_output_section_statement_type *lookup;
646
647 for (u = lang_output_section_statement.head;
648 u != (lang_statement_union_type *) NULL;
649 u = lookup->next)
650 {
651 lookup = &u->output_section_statement;
652 if (strcmp (name, lookup->name) == 0)
653 {
654 return lookup;
655 }
656 }
657 return (lang_output_section_statement_type *) NULL;
658}
659
660lang_output_section_statement_type *
661lang_output_section_statement_lookup (name)
662 CONST char *CONST name;
663{
664 lang_output_section_statement_type *lookup;
665
666 lookup = lang_output_section_find (name);
667 if (lookup == (lang_output_section_statement_type *) NULL)
668 {
669
670 lookup = (lang_output_section_statement_type *)
671 new_stat (lang_output_section_statement, stat_ptr);
672 lookup->region = (lang_memory_region_type *) NULL;
673 lookup->fill = 0;
674 lookup->block_value = 1;
675 lookup->name = name;
676
677 lookup->next = (lang_statement_union_type *) NULL;
678 lookup->bfd_section = (asection *) NULL;
679 lookup->processed = false;
680 lookup->sectype = normal_section;
681 lookup->addr_tree = (etree_type *) NULL;
682 lang_list_init (&lookup->children);
683
684 lookup->memspec = (CONST char *) NULL;
685 lookup->flags = 0;
686 lookup->subsection_alignment = -1;
687 lookup->section_alignment = -1;
688 lookup->load_base = (union etree_union *) NULL;
689 lookup->phdrs = NULL;
690
691 lang_statement_append (&lang_output_section_statement,
692 (lang_statement_union_type *) lookup,
693 &lookup->next);
694 }
695 return lookup;
696}
697
698static void
699lang_map_flags (flag)
700 flagword flag;
701{
702 if (flag & SEC_ALLOC)
703 minfo ("a");
704
705 if (flag & SEC_CODE)
706 minfo ("x");
707
708 if (flag & SEC_READONLY)
709 minfo ("r");
710
711 if (flag & SEC_DATA)
712 minfo ("w");
713
714 if (flag & SEC_LOAD)
715 minfo ("l");
716}
717
718void
719lang_map ()
720{
721 lang_memory_region_type *m;
722
723 minfo (_("\nMemory Configuration\n\n"));
724 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
725 _("Name"), _("Origin"), _("Length"), _("Attributes"));
726
727 for (m = lang_memory_region_list;
728 m != (lang_memory_region_type *) NULL;
729 m = m->next)
730 {
731 char buf[100];
732 int len;
733
734 fprintf (config.map_file, "%-16s ", m->name);
735
736 sprintf_vma (buf, m->origin);
737 minfo ("0x%s ", buf);
738 len = strlen (buf);
739 while (len < 16)
740 {
741 print_space ();
742 ++len;
743 }
744
745 minfo ("0x%V", m->length);
746 if (m->flags || m->not_flags)
747 {
748#ifndef BFD64
749 minfo (" ");
750#endif
751 if (m->flags)
752 {
753 print_space ();
754 lang_map_flags (m->flags);
755 }
756
757 if (m->not_flags)
758 {
759 minfo (" !");
760 lang_map_flags (m->not_flags);
761 }
762 }
763
764 print_nl ();
765 }
766
767 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
768
769 print_statements ();
770}
771
772/* Initialize an output section. */
773
774static void
775init_os (s)
776 lang_output_section_statement_type *s;
777{
778 section_userdata_type *new;
779
780 if (s->bfd_section != NULL)
781 return;
782
783 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
784 einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME);
785
786 new = ((section_userdata_type *)
787 stat_alloc (sizeof (section_userdata_type)));
788
789 s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
790 if (s->bfd_section == (asection *) NULL)
791 s->bfd_section = bfd_make_section (output_bfd, s->name);
792 if (s->bfd_section == (asection *) NULL)
793 {
794 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
795 output_bfd->xvec->name, s->name);
796 }
797 s->bfd_section->output_section = s->bfd_section;
798
799 /* We initialize an output sections output offset to minus its own */
800 /* vma to allow us to output a section through itself */
801 s->bfd_section->output_offset = 0;
802 get_userdata (s->bfd_section) = (PTR) new;
803
804 /* If there is a base address, make sure that any sections it might
805 mention are initialized. */
806 if (s->addr_tree != NULL)
807 exp_init_os (s->addr_tree);
808}
809
810/* Make sure that all output sections mentioned in an expression are
811 initialized. */
812
813static void
814exp_init_os (exp)
815 etree_type *exp;
816{
817 switch (exp->type.node_class)
818 {
819 case etree_assign:
820 exp_init_os (exp->assign.src);
821 break;
822
823 case etree_binary:
824 exp_init_os (exp->binary.lhs);
825 exp_init_os (exp->binary.rhs);
826 break;
827
828 case etree_trinary:
829 exp_init_os (exp->trinary.cond);
830 exp_init_os (exp->trinary.lhs);
831 exp_init_os (exp->trinary.rhs);
832 break;
833
834 case etree_unary:
835 exp_init_os (exp->unary.child);
836 break;
837
838 case etree_name:
839 switch (exp->type.node_code)
840 {
841 case ADDR:
842 case LOADADDR:
843 case SIZEOF:
844 {
845 lang_output_section_statement_type *os;
846
847 os = lang_output_section_find (exp->name.name);
848 if (os != NULL && os->bfd_section == NULL)
849 init_os (os);
850 }
851 }
852 break;
853
854 default:
855 break;
856 }
857}
858
859/* Sections marked with the SEC_LINK_ONCE flag should only be linked
860 once into the output. This routine checks each sections, and
861 arranges to discard it if a section of the same name has already
862 been linked. This code assumes that all relevant sections have the
863 SEC_LINK_ONCE flag set; that is, it does not depend solely upon the
864 section name. This is called via bfd_map_over_sections. */
865
866/*ARGSUSED*/
867static void
868section_already_linked (abfd, sec, data)
869 bfd *abfd;
870 asection *sec;
871 PTR data;
872{
873 lang_input_statement_type *entry = (lang_input_statement_type *) data;
874 struct sec_link_once
875 {
876 struct sec_link_once *next;
877 asection *sec;
878 };
879 static struct sec_link_once *sec_link_once_list;
880 flagword flags;
881 const char *name;
882 struct sec_link_once *l;
883
884 /* If we are only reading symbols from this object, then we want to
885 discard all sections. */
886 if (entry->just_syms_flag)
887 {
888 sec->output_section = bfd_abs_section_ptr;
889 sec->output_offset = sec->vma;
890 return;
891 }
892
893 flags = bfd_get_section_flags (abfd, sec);
894
895 if ((flags & SEC_LINK_ONCE) == 0)
896 return;
897
e361c369
ILT		 898 /* FIXME: When doing a relocateable link, we may have trouble
899 copying relocations in other sections that refer to local symbols
900 in the section being discarded. Those relocations will have to
901 be converted somehow; as of this writing I'm not sure that any of
902 the backends handle that correctly.
903
904 It is tempting to instead not discard link once sections when
905 doing a relocateable link (technically, they should be discarded
906 whenever we are building constructors). However, that fails,
907 because the linker winds up combining all the link once sections
908 into a single large link once section, which defeats the purpose
909 of having link once sections in the first place.
910
911 Also, not merging link once sections in a relocateable link
912 causes trouble for MIPS ELF, which relies in link once semantics
913 to handle the .reginfo section correctly. */
914
252b5132
RH		 915 name = bfd_get_section_name (abfd, sec);
916
917 for (l = sec_link_once_list; l != NULL; l = l->next)
918 {
919 if (strcmp (name, bfd_get_section_name (l->sec->owner, l->sec)) == 0)
920 {
921 /* The section has already been linked. See if we should
922 issue a warning. */
923 switch (flags & SEC_LINK_DUPLICATES)
924 {
925 default:
926 abort ();
927
928 case SEC_LINK_DUPLICATES_DISCARD:
929 break;
930
931 case SEC_LINK_DUPLICATES_ONE_ONLY:
932 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
933 abfd, name);
934 break;
935
936 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
937 /* FIXME: We should really dig out the contents of both
938 sections and memcmp them. The COFF/PE spec says that
939 the Microsoft linker does not implement this
940 correctly, so I'm not going to bother doing it
941 either. */
942 /* Fall through. */
943 case SEC_LINK_DUPLICATES_SAME_SIZE:
944 if (bfd_section_size (abfd, sec)
945 != bfd_section_size (l->sec->owner, l->sec))
946 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
947 abfd, name);
948 break;
949 }
950
951 /* Set the output_section field so that wild_doit does not
952 create a lang_input_section structure for this section. */
953 sec->output_section = bfd_abs_section_ptr;
954
955 return;
956 }
957 }
958
959 /* This is the first section with this name. Record it. */
960
961 l = (struct sec_link_once *) xmalloc (sizeof *l);
962 l->sec = sec;
963 l->next = sec_link_once_list;
964 sec_link_once_list = l;
965}
966\f
967/* The wild routines.
968
969 These expand statements like *(.text) and foo.o to a list of
970 explicit actions, like foo.o(.text), bar.o(.text) and
971 foo.o(.text, .data). */
972
973/* Return true if the PATTERN argument is a wildcard pattern.
974 Although backslashes are treated specially if a pattern contains
975 wildcards, we do not consider the mere presence of a backslash to
976 be enough to cause the the pattern to be treated as a wildcard.
977 That lets us handle DOS filenames more naturally. */
978
979static boolean
980wildcardp (pattern)
981 const char *pattern;
982{
983 const char *s;
984
985 for (s = pattern; *s != '\0'; ++s)
986 if (*s == '?'
987 || *s == '*'
988 || *s == '[')
989 return true;
990 return false;
991}
992
993/* Add SECTION to the output section OUTPUT. Do this by creating a
994 lang_input_section statement which is placed at PTR. FILE is the
995 input file which holds SECTION. */
996
997void
998wild_doit (ptr, section, output, file)
999 lang_statement_list_type *ptr;
1000 asection *section;
1001 lang_output_section_statement_type *output;
1002 lang_input_statement_type *file;
1003{
1004 flagword flags;
1005 boolean discard;
1006
1007 flags = bfd_get_section_flags (section->owner, section);
1008
1009 discard = false;
1010
1011 /* If we are doing a final link, discard sections marked with
1012 SEC_EXCLUDE. */
1013 if (! link_info.relocateable
1014 && (flags & SEC_EXCLUDE) != 0)
1015 discard = true;
1016
1017 /* Discard input sections which are assigned to a section named
1018 DISCARD_SECTION_NAME. */
1019 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1020 discard = true;
1021
1022 /* Discard debugging sections if we are stripping debugging
1023 information. */
1024 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1025 && (flags & SEC_DEBUGGING) != 0)
1026 discard = true;
1027
1028 if (discard)
1029 {
1030 if (section->output_section == NULL)
1031 {
1032 /* This prevents future calls from assigning this section. */
1033 section->output_section = bfd_abs_section_ptr;
1034 }
1035 return;
1036 }
1037
1038 if (section->output_section == NULL)
1039 {
1040 boolean first;
1041 lang_input_section_type *new;
1042 flagword flags;
1043
1044 if (output->bfd_section == NULL)
1045 {
1046 init_os (output);
1047 first = true;
1048 }
1049 else
1050 first = false;
1051
1052 /* Add a section reference to the list */
1053 new = new_stat (lang_input_section, ptr);
1054
1055 new->section = section;
1056 new->ifile = file;
1057 section->output_section = output->bfd_section;
1058
1059 flags = section->flags;
1060
1061 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1062 to an output section, because we want to be able to include a
1063 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1064 section (I don't know why we want to do this, but we do).
1065 build_link_order in ldwrite.c handles this case by turning
1066 the embedded SEC_NEVER_LOAD section into a fill. */
1067
1068 flags &= ~ SEC_NEVER_LOAD;
1069
1070 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1071 already been processed. One reason to do this is that on pe
1072 format targets, .text$foo sections go into .text and it's odd
1073 to see .text with SEC_LINK_ONCE set. */
1074
1075 if (! link_info.relocateable)
1076 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1077
1078 /* If this is not the first input section, and the SEC_READONLY
1079 flag is not currently set, then don't set it just because the
1080 input section has it set. */
1081
1082 if (! first && (section->output_section->flags & SEC_READONLY) == 0)
1083 flags &= ~ SEC_READONLY;
1084
1085 section->output_section->flags |= flags;
1086
1087 /* If SEC_READONLY is not set in the input section, then clear
1088 it from the output section. */
1089 if ((section->flags & SEC_READONLY) == 0)
1090 section->output_section->flags &= ~SEC_READONLY;
1091
1092 switch (output->sectype)
1093 {
1094 case normal_section:
1095 break;
1096 case dsect_section:
1097 case copy_section:
1098 case info_section:
1099 case overlay_section:
1100 output->bfd_section->flags &= ~SEC_ALLOC;
1101 break;
1102 case noload_section:
1103 output->bfd_section->flags &= ~SEC_LOAD;
1104 output->bfd_section->flags |= SEC_NEVER_LOAD;
1105 break;
1106 }
1107
9e41f973
RH		 1108 /* Copy over SEC_SHORT. */
1109 if (section->flags & SEC_SHORT)
1110 section->output_section->flags |= SEC_SHORT;
1111
252b5132
RH		 1112 if (section->alignment_power > output->bfd_section->alignment_power)
1113 output->bfd_section->alignment_power = section->alignment_power;
1114
1115 /* If supplied an aligment, then force it. */
1116 if (output->section_alignment != -1)
1117 output->bfd_section->alignment_power = output->section_alignment;
1118 }
1119}
1120
1121/* Handle wildcard sorting. This returns the lang_input_section which
1122 should follow the one we are going to create for SECTION and FILE,
1123 based on the sorting requirements of WILD. It returns NULL if the
1124 new section should just go at the end of the current list. */
1125
1126static lang_statement_union_type *
1127wild_sort (wild, file, section)
1128 lang_wild_statement_type *wild;
1129 lang_input_statement_type *file;
1130 asection *section;
1131{
1132 const char *section_name;
1133 lang_statement_union_type *l;
1134
1135 if (! wild->filenames_sorted && ! wild->sections_sorted)
1136 return NULL;
1137
1138 section_name = bfd_get_section_name (file->the_bfd, section);
1139 for (l = wild->children.head; l != NULL; l = l->next)
1140 {
1141 lang_input_section_type *ls;
1142
1143 if (l->header.type != lang_input_section_enum)
1144 continue;
1145 ls = &l->input_section;
1146
1147 /* Sorting by filename takes precedence over sorting by section
1148 name. */
1149
1150 if (wild->filenames_sorted)
1151 {
1152 const char *fn, *ln;
1153 boolean fa, la;
1154 int i;
1155
1156 /* The PE support for the .idata section as generated by
1157 dlltool assumes that files will be sorted by the name of
1158 the archive and then the name of the file within the
1159 archive. */
1160
1161 if (file->the_bfd != NULL
1162 && bfd_my_archive (file->the_bfd) != NULL)
1163 {
1164 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1165 fa = true;
1166 }
1167 else
1168 {
1169 fn = file->filename;
1170 fa = false;
1171 }
1172
1173 if (ls->ifile->the_bfd != NULL
1174 && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1175 {
1176 ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1177 la = true;
1178 }
1179 else
1180 {
1181 ln = ls->ifile->filename;
1182 la = false;
1183 }
1184
1185 i = strcmp (fn, ln);
1186 if (i > 0)
1187 continue;
1188 else if (i < 0)
1189 break;
1190
1191 if (fa || la)
1192 {
1193 if (fa)
1194 fn = file->filename;
1195 if (la)
1196 ln = ls->ifile->filename;
1197
1198 i = strcmp (fn, ln);
1199 if (i > 0)
1200 continue;
1201 else if (i < 0)
1202 break;
1203 }
1204 }
1205
1206 /* Here either the files are not sorted by name, or we are
1207 looking at the sections for this file. */
1208
1209 if (wild->sections_sorted)
1210 {
1211 if (strcmp (section_name,
1212 bfd_get_section_name (ls->ifile->the_bfd,
1213 ls->section))
1214 < 0)
1215 break;
1216 }
1217 }
1218
1219 return l;
1220}
1221
1222/* Expand a wild statement for a particular FILE. SECTION may be
1223 NULL, in which case it is a wild card. */
1224
1225static void
4dec4d4e 1226output_section_callback (ptr, section, file, output)
252b5132 1227 lang_wild_statement_type *ptr;
4dec4d4e 1228 asection *section;
252b5132 1229 lang_input_statement_type *file;
4dec4d4e
RH		 1230 void *output;
1231{
1232 lang_statement_union_type *before;
1233
1234 /* If the wild pattern was marked KEEP, the member sections
1235 should be as well. */
1236 if (ptr->keep_sections)
1237 section->flags |= SEC_KEEP;
1238
1239 before = wild_sort (ptr, file, section);
1240
1241 /* Here BEFORE points to the lang_input_section which
1242 should follow the one we are about to add. If BEFORE
1243 is NULL, then the section should just go at the end
1244 of the current list. */
1245
1246 if (before == NULL)
1247 wild_doit (&ptr->children, section,
1248 (lang_output_section_statement_type *) output,
1249 file);
1250 else
252b5132 1251 {
4dec4d4e
RH		 1252 lang_statement_list_type list;
1253 lang_statement_union_type **pp;
1254
1255 lang_list_init (&list);
1256 wild_doit (&list, section,
1257 (lang_output_section_statement_type *) output,
1258 file);
1259
1260 /* If we are discarding the section, LIST.HEAD will
1261 be NULL. */
1262 if (list.head != NULL)
252b5132 1263 {
4dec4d4e
RH		 1264 ASSERT (list.head->next == NULL);
1265
1266 for (pp = &ptr->children.head;
1267 *pp != before;
1268 pp = &(*pp)->next)
1269 ASSERT (*pp != NULL);
1270
1271 list.head->next = *pp;
1272 *pp = list.head;
252b5132
RH		 1273 }
1274 }
1275}
1276
1277/* This is passed a file name which must have been seen already and
1278 added to the statement tree. We will see if it has been opened
1279 already and had its symbols read. If not then we'll read it. */
1280
1281static lang_input_statement_type *
1282lookup_name (name)
1283 const char *name;
1284{
1285 lang_input_statement_type *search;
1286
1287 for (search = (lang_input_statement_type *) input_file_chain.head;
1288 search != (lang_input_statement_type *) NULL;
1289 search = (lang_input_statement_type *) search->next_real_file)
1290 {
1291 if (search->filename == (char *) NULL && name == (char *) NULL)
1292 return search;
1293 if (search->filename != (char *) NULL
1294 && name != (char *) NULL
1295 && strcmp (search->filename, name) == 0)
1296 break;
1297 }
1298
1299 if (search == (lang_input_statement_type *) NULL)
1300 search = new_afile (name, lang_input_file_is_file_enum, default_target,
1301 false);
1302
1303 /* If we have already added this file, or this file is not real
1304 (FIXME: can that ever actually happen?) or the name is NULL
1305 (FIXME: can that ever actually happen?) don't add this file. */
1306 if (search->loaded
1307 || ! search->real
1308 || search->filename == (const char *) NULL)
1309 return search;
1310
1311 load_symbols (search, (lang_statement_list_type *) NULL);
1312
1313 return search;
1314}
1315
1316/* Get the symbols for an input file. */
1317
1318static void
1319load_symbols (entry, place)
1320 lang_input_statement_type *entry;
1321 lang_statement_list_type *place;
1322{
1323 char **matching;
1324
1325 if (entry->loaded)
1326 return;
1327
1328 ldfile_open_file (entry);
1329
1330 if (! bfd_check_format (entry->the_bfd, bfd_archive)
1331 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1332 {
1333 bfd_error_type err;
1334 lang_statement_list_type *hold;
1335
1336 err = bfd_get_error ();
1337 if (err == bfd_error_file_ambiguously_recognized)
1338 {
1339 char **p;
1340
1341 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1342 einfo (_("%B: matching formats:"), entry->the_bfd);
1343 for (p = matching; *p != NULL; p++)
1344 einfo (" %s", *p);
1345 einfo ("%F\n");
1346 }
1347 else if (err != bfd_error_file_not_recognized
1348 || place == NULL)
1349 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1350
1351 bfd_close (entry->the_bfd);
1352 entry->the_bfd = NULL;
1353
1354 /* See if the emulation has some special knowledge. */
1355
1356 if (ldemul_unrecognized_file (entry))
1357 return;
1358
1359 /* Try to interpret the file as a linker script. */
1360
1361 ldfile_open_command_file (entry->filename);
1362
1363 hold = stat_ptr;
1364 stat_ptr = place;
1365
1366 ldfile_assumed_script = true;
1367 parser_input = input_script;
1368 yyparse ();
1369 ldfile_assumed_script = false;
1370
1371 stat_ptr = hold;
1372
1373 return;
1374 }
1375
1376 if (ldemul_recognized_file (entry))
1377 return;
1378
1379 /* We don't call ldlang_add_file for an archive. Instead, the
1380 add_symbols entry point will call ldlang_add_file, via the
1381 add_archive_element callback, for each element of the archive
1382 which is used. */
1383 switch (bfd_get_format (entry->the_bfd))
1384 {
1385 default:
1386 break;
1387
1388 case bfd_object:
1389 ldlang_add_file (entry);
1390 if (trace_files || trace_file_tries)
1391 info_msg ("%I\n", entry);
1392 break;
1393
1394 case bfd_archive:
1395 if (entry->whole_archive)
1396 {
1397 bfd *member = bfd_openr_next_archived_file (entry->the_bfd,
1398 (bfd *) NULL);
1399 while (member != NULL)
1400 {
1401 if (! bfd_check_format (member, bfd_object))
1402 einfo (_("%F%B: object %B in archive is not object\n"),
1403 entry->the_bfd, member);
1404 if (! ((*link_info.callbacks->add_archive_element)
1405 (&link_info, member, "--whole-archive")))
1406 abort ();
1407 if (! bfd_link_add_symbols (member, &link_info))
1408 einfo (_("%F%B: could not read symbols: %E\n"), member);
1409 member = bfd_openr_next_archived_file (entry->the_bfd,
1410 member);
1411 }
1412
1413 entry->loaded = true;
1414
1415 return;
1416 }
1417 }
1418
1419 if (! bfd_link_add_symbols (entry->the_bfd, &link_info))
1420 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1421
1422 entry->loaded = true;
1423}
1424
4dec4d4e 1425
252b5132
RH		 1426
1427/* Handle a wild statement. SECTION or FILE or both may be NULL,
1428 indicating that it is a wildcard. Separate lang_input_section
1429 statements are created for each part of the expansion; they are
1430 added after the wild statement S. OUTPUT is the output section. */
1431
1432static void
1433wild (s, section, file, target, output)
1434 lang_wild_statement_type *s;
1435 const char *section;
1436 const char *file;
87f2a346 1437 const char *target ATTRIBUTE_UNUSED;
252b5132
RH		 1438 lang_output_section_statement_type *output;
1439{
4dec4d4e 1440 walk_wild (s, section, file, output_section_callback, (void *) output);
252b5132
RH		 1441
1442 if (section != (char *) NULL
1443 && strcmp (section, "COMMON") == 0
1444 && default_common_section == NULL)
1445 {
1446 /* Remember the section that common is going to in case we later
1447 get something which doesn't know where to put it. */
1448 default_common_section = output;
1449 }
1450}
1451
1452/* Open the output file. */
1453
1454static bfd *
1455open_output (name)
1456 const char *name;
1457{
1458 bfd *output;
1459
1460 if (output_target == (char *) NULL)
1461 {
1462 if (current_target != (char *) NULL)
1463 output_target = current_target;
1464 else
1465 output_target = default_target;
1466 }
1467 output = bfd_openw (name, output_target);
1468
1469 if (output == (bfd *) NULL)
1470 {
1471 if (bfd_get_error () == bfd_error_invalid_target)
1472 {
1473 einfo (_("%P%F: target %s not found\n"), output_target);
1474 }
1475 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1476 }
1477
1478 delete_output_file_on_failure = true;
1479
1480 /* output->flags |= D_PAGED;*/
1481
1482 if (! bfd_set_format (output, bfd_object))
1483 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1484 if (! bfd_set_arch_mach (output,
1485 ldfile_output_architecture,
1486 ldfile_output_machine))
1487 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1488
1489 link_info.hash = bfd_link_hash_table_create (output);
1490 if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1491 einfo (_("%P%F: can not create link hash table: %E\n"));
1492
1493 bfd_set_gp_size (output, g_switch_value);
1494 return output;
1495}
1496
1497
1498
1499
1500static void
1501ldlang_open_output (statement)
1502 lang_statement_union_type * statement;
1503{
1504 switch (statement->header.type)
1505 {
1506 case lang_output_statement_enum:
1507 ASSERT (output_bfd == (bfd *) NULL);
1508 output_bfd = open_output (statement->output_statement.name);
1509 ldemul_set_output_arch ();
1510 if (config.magic_demand_paged && !link_info.relocateable)
1511 output_bfd->flags |= D_PAGED;
1512 else
1513 output_bfd->flags &= ~D_PAGED;
1514 if (config.text_read_only)
1515 output_bfd->flags |= WP_TEXT;
1516 else
1517 output_bfd->flags &= ~WP_TEXT;
1518 if (link_info.traditional_format)
1519 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1520 else
1521 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1522 break;
1523
1524 case lang_target_statement_enum:
1525 current_target = statement->target_statement.target;
1526 break;
1527 default:
1528 break;
1529 }
1530}
1531
1532/* Open all the input files. */
1533
1534static void
1535open_input_bfds (s, force)
1536 lang_statement_union_type *s;
1537 boolean force;
1538{
1539 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1540 {
1541 switch (s->header.type)
1542 {
1543 case lang_constructors_statement_enum:
1544 open_input_bfds (constructor_list.head, force);
1545 break;
1546 case lang_output_section_statement_enum:
1547 open_input_bfds (s->output_section_statement.children.head, force);
1548 break;
1549 case lang_wild_statement_enum:
1550 /* Maybe we should load the file's symbols */
1551 if (s->wild_statement.filename
1552 && ! wildcardp (s->wild_statement.filename))
1553 (void) lookup_name (s->wild_statement.filename);
1554 open_input_bfds (s->wild_statement.children.head, force);
1555 break;
1556 case lang_group_statement_enum:
1557 {
1558 struct bfd_link_hash_entry *undefs;
1559
1560 /* We must continually search the entries in the group
1561 until no new symbols are added to the list of undefined
1562 symbols. */
1563
1564 do
1565 {
1566 undefs = link_info.hash->undefs_tail;
1567 open_input_bfds (s->group_statement.children.head, true);
1568 }
1569 while (undefs != link_info.hash->undefs_tail);
1570 }
1571 break;
1572 case lang_target_statement_enum:
1573 current_target = s->target_statement.target;
1574 break;
1575 case lang_input_statement_enum:
1576 if (s->input_statement.real == true)
1577 {
1578 lang_statement_list_type add;
1579
1580 s->input_statement.target = current_target;
1581
1582 /* If we are being called from within a group, and this
1583 is an archive which has already been searched, then
1584 force it to be researched. */
1585 if (force
1586 && s->input_statement.loaded
1587 && bfd_check_format (s->input_statement.the_bfd,
1588 bfd_archive))
1589 s->input_statement.loaded = false;
1590
1591 lang_list_init (&add);
1592
1593 load_symbols (&s->input_statement, &add);
1594
1595 if (add.head != NULL)
1596 {
1597 *add.tail = s->next;
1598 s->next = add.head;
1599 }
1600 }
1601 break;
1602 default:
1603 break;
1604 }
1605 }
1606}
1607
1608/* If there are [COMMONS] statements, put a wild one into the bss section */
1609
1610static void
1611lang_reasonable_defaults ()
1612{
1613#if 0
1614 lang_output_section_statement_lookup (".text");
1615 lang_output_section_statement_lookup (".data");
1616
1617 default_common_section =
1618 lang_output_section_statement_lookup (".bss");
1619
1620
1621 if (placed_commons == false)
1622 {
1623 lang_wild_statement_type *new =
1624 new_stat (lang_wild_statement,
1625 &default_common_section->children);
1626
1627 new->section_name = "COMMON";
1628 new->filename = (char *) NULL;
1629 lang_list_init (&new->children);
1630 }
1631#endif
1632
1633}
1634
1635/*
1636 Add the supplied name to the symbol table as an undefined reference.
1637 Remove items from the chain as we open input bfds
1638 */
1639typedef struct ldlang_undef_chain_list
1640{
1641 struct ldlang_undef_chain_list *next;
1642 char *name;
1643} ldlang_undef_chain_list_type;
1644
1645static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
1646
1647void
1648ldlang_add_undef (name)
1649 CONST char *CONST name;
1650{
1651 ldlang_undef_chain_list_type *new =
1652 ((ldlang_undef_chain_list_type *)
1653 stat_alloc (sizeof (ldlang_undef_chain_list_type)));
1654
1655 new->next = ldlang_undef_chain_list_head;
1656 ldlang_undef_chain_list_head = new;
1657
1658 new->name = buystring (name);
1659}
1660
1661/* Run through the list of undefineds created above and place them
1662 into the linker hash table as undefined symbols belonging to the
1663 script file.
1664*/
1665static void
1666lang_place_undefineds ()
1667{
1668 ldlang_undef_chain_list_type *ptr;
1669
1670 for (ptr = ldlang_undef_chain_list_head;
1671 ptr != (ldlang_undef_chain_list_type *) NULL;
1672 ptr = ptr->next)
1673 {
1674 struct bfd_link_hash_entry *h;
1675
1676 h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
1677 if (h == (struct bfd_link_hash_entry *) NULL)
1678 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1679 if (h->type == bfd_link_hash_new)
1680 {
1681 h->type = bfd_link_hash_undefined;
1682 h->u.undef.abfd = NULL;
1683 bfd_link_add_undef (link_info.hash, h);
1684 }
1685 }
1686}
1687
1688/* Open input files and attatch to output sections */
1689static void
1690map_input_to_output_sections (s, target, output_section_statement)
1691 lang_statement_union_type * s;
1692 CONST char *target;
1693 lang_output_section_statement_type * output_section_statement;
1694{
1695 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1696 {
1697 switch (s->header.type)
1698 {
1699
1700
1701 case lang_wild_statement_enum:
1702 wild (&s->wild_statement, s->wild_statement.section_name,
1703 s->wild_statement.filename, target,
1704 output_section_statement);
1705
1706 break;
1707 case lang_constructors_statement_enum:
1708 map_input_to_output_sections (constructor_list.head,
1709 target,
1710 output_section_statement);
1711 break;
1712 case lang_output_section_statement_enum:
1713 map_input_to_output_sections (s->output_section_statement.children.head,
1714 target,
1715 &s->output_section_statement);
1716 break;
1717 case lang_output_statement_enum:
1718 break;
1719 case lang_target_statement_enum:
1720 target = s->target_statement.target;
1721 break;
1722 case lang_group_statement_enum:
1723 map_input_to_output_sections (s->group_statement.children.head,
1724 target,
1725 output_section_statement);
1726 break;
1727 case lang_fill_statement_enum:
1728 case lang_input_section_enum:
1729 case lang_object_symbols_statement_enum:
1730 case lang_data_statement_enum:
1731 case lang_reloc_statement_enum:
1732 case lang_padding_statement_enum:
1733 case lang_input_statement_enum:
1734 if (output_section_statement != NULL
1735 && output_section_statement->bfd_section == NULL)
1736 init_os (output_section_statement);
1737 break;
1738 case lang_assignment_statement_enum:
1739 if (output_section_statement != NULL
1740 && output_section_statement->bfd_section == NULL)
1741 init_os (output_section_statement);
1742
1743 /* Make sure that any sections mentioned in the assignment
1744 are initialized. */
1745 exp_init_os (s->assignment_statement.exp);
1746 break;
1747 case lang_afile_asection_pair_statement_enum:
1748 FAIL ();
1749 break;
1750 case lang_address_statement_enum:
1751 /* Mark the specified section with the supplied address */
1752 {
1753 lang_output_section_statement_type *os =
1754 lang_output_section_statement_lookup
1755 (s->address_statement.section_name);
1756
1757 if (os->bfd_section == NULL)
1758 init_os (os);
1759 os->addr_tree = s->address_statement.address;
1760 }
1761 break;
1762 }
1763 }
1764}
1765
1766static void
1767print_output_section_statement (output_section_statement)
1768 lang_output_section_statement_type * output_section_statement;
1769{
1770 asection *section = output_section_statement->bfd_section;
1771 int len;
1772
1773 if (output_section_statement != abs_output_section)
1774 {
1775 minfo ("\n%s", output_section_statement->name);
1776
1777 if (section != NULL)
1778 {
1779 print_dot = section->vma;
1780
1781 len = strlen (output_section_statement->name);
1782 if (len >= SECTION_NAME_MAP_LENGTH - 1)
1783 {
1784 print_nl ();
1785 len = 0;
1786 }
1787 while (len < SECTION_NAME_MAP_LENGTH)
1788 {
1789 print_space ();
1790 ++len;
1791 }
1792
1793 minfo ("0x%V %W", section->vma, section->_raw_size);
1794
1795 if (output_section_statement->load_base != NULL)
1796 {
1797 bfd_vma addr;
1798
1799 addr = exp_get_abs_int (output_section_statement->load_base, 0,
1800 "load base", lang_final_phase_enum);
1801 minfo (_(" load address 0x%V"), addr);
1802 }
1803 }
1804
1805 print_nl ();
1806 }
1807
1808 print_statement_list (output_section_statement->children.head,
1809 output_section_statement);
1810}
1811
1812static void
1813print_assignment (assignment, output_section)
1814 lang_assignment_statement_type * assignment;
1815 lang_output_section_statement_type * output_section;
1816{
1817 int i;
1818 etree_value_type result;
1819
1820 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
1821 print_space ();
1822
1823 result = exp_fold_tree (assignment->exp->assign.src, output_section,
1824 lang_final_phase_enum, print_dot, &print_dot);
1825 if (result.valid_p)
1826 minfo ("0x%V", result.value + result.section->bfd_section->vma);
1827 else
1828 {
1829 minfo ("*undef* ");
1830#ifdef BFD64
1831 minfo (" ");
1832#endif
1833 }
1834
1835 minfo (" ");
1836
1837 exp_print_tree (assignment->exp);
1838
1839 print_nl ();
1840}
1841
1842static void
1843print_input_statement (statm)
1844 lang_input_statement_type * statm;
1845{
1846 if (statm->filename != (char *) NULL)
1847 {
1848 fprintf (config.map_file, "LOAD %s\n", statm->filename);
1849 }
1850}
1851
1852/* Print all symbols defined in a particular section. This is called
1853 via bfd_link_hash_traverse. */
1854
1855static boolean
1856print_one_symbol (hash_entry, ptr)
1857 struct bfd_link_hash_entry *hash_entry;
1858 PTR ptr;
1859{
1860 asection *sec = (asection *) ptr;
1861
1862 if ((hash_entry->type == bfd_link_hash_defined
1863 || hash_entry->type == bfd_link_hash_defweak)
1864 && sec == hash_entry->u.def.section)
1865 {
1866 int i;
1867
1868 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
1869 print_space ();
1870 minfo ("0x%V ",
1871 (hash_entry->u.def.value
1872 + hash_entry->u.def.section->output_offset
1873 + hash_entry->u.def.section->output_section->vma));
1874
1875 minfo (" %T\n", hash_entry->root.string);
1876 }
1877
1878 return true;
1879}
1880
1881/* Print information about an input section to the map file. */
1882
1883static void
1884print_input_section (in)
1885 lang_input_section_type * in;
1886{
1887 asection *i = in->section;
1888 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
1889
1890 if (size != 0)
1891 {
1892 print_space ();
1893
1894 minfo ("%s", i->name);
1895
1896 if (i->output_section != NULL)
1897 {
1898 int len;
1899
1900 len = 1 + strlen (i->name);
1901 if (len >= SECTION_NAME_MAP_LENGTH - 1)
1902 {
1903 print_nl ();
1904 len = 0;
1905 }
1906 while (len < SECTION_NAME_MAP_LENGTH)
1907 {
1908 print_space ();
1909 ++len;
1910 }
1911
1912 minfo ("0x%V %W %B\n",
1913 i->output_section->vma + i->output_offset, size,
1914 i->owner);
1915
1916 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
1917 {
1918 len = SECTION_NAME_MAP_LENGTH + 3;
1919#ifdef BFD64
1920 len += 16;
1921#else
1922 len += 8;
1923#endif
1924 while (len > 0)
1925 {
1926 print_space ();
1927 --len;
1928 }
1929
1930 minfo (_("%W (size before relaxing)\n"), i->_raw_size);
1931 }
1932
1933 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
1934
1935 print_dot = i->output_section->vma + i->output_offset + size;
1936 }
1937 }
1938}
1939
1940static void
1941print_fill_statement (fill)
1942 lang_fill_statement_type * fill;
1943{
1944 fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill);
1945}
1946
1947static void
1948print_data_statement (data)
1949 lang_data_statement_type * data;
1950{
1951 int i;
1952 bfd_vma addr;
1953 bfd_size_type size;
1954 const char *name;
1955
1956 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
1957 print_space ();
1958
1959 addr = data->output_vma;
1960 if (data->output_section != NULL)
1961 addr += data->output_section->vma;
1962
1963 switch (data->type)
1964 {
1965 default:
1966 abort ();
1967 case BYTE:
1968 size = BYTE_SIZE;
1969 name = "BYTE";
1970 break;
1971 case SHORT:
1972 size = SHORT_SIZE;
1973 name = "SHORT";
1974 break;
1975 case LONG:
1976 size = LONG_SIZE;
1977 name = "LONG";
1978 break;
1979 case QUAD:
1980 size = QUAD_SIZE;
1981 name = "QUAD";
1982 break;
1983 case SQUAD:
1984 size = QUAD_SIZE;
1985 name = "SQUAD";
1986 break;
1987 }
1988
1989 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
1990
1991 if (data->exp->type.node_class != etree_value)
1992 {
1993 print_space ();
1994 exp_print_tree (data->exp);
1995 }
1996
1997 print_nl ();
1998
1999 print_dot = addr + size;
2000}
2001
2002/* Print an address statement. These are generated by options like
2003 -Ttext. */
2004
2005static void
2006print_address_statement (address)
2007 lang_address_statement_type *address;
2008{
2009 minfo (_("Address of section %s set to "), address->section_name);
2010 exp_print_tree (address->address);
2011 print_nl ();
2012}
2013
2014/* Print a reloc statement. */
2015
2016static void
2017print_reloc_statement (reloc)
2018 lang_reloc_statement_type *reloc;
2019{
2020 int i;
2021 bfd_vma addr;
2022 bfd_size_type size;
2023
2024 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2025 print_space ();
2026
2027 addr = reloc->output_vma;
2028 if (reloc->output_section != NULL)
2029 addr += reloc->output_section->vma;
2030
2031 size = bfd_get_reloc_size (reloc->howto);
2032
2033 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2034
2035 if (reloc->name != NULL)
2036 minfo ("%s+", reloc->name);
2037 else
2038 minfo ("%s+", reloc->section->name);
2039
2040 exp_print_tree (reloc->addend_exp);
2041
2042 print_nl ();
2043
2044 print_dot = addr + size;
2045}
2046
2047static void
2048print_padding_statement (s)
2049 lang_padding_statement_type *s;
2050{
2051 int len;
2052 bfd_vma addr;
2053
2054 minfo (" *fill*");
2055
2056 len = sizeof " *fill*" - 1;
2057 while (len < SECTION_NAME_MAP_LENGTH)
2058 {
2059 print_space ();
2060 ++len;
2061 }
2062
2063 addr = s->output_offset;
2064 if (s->output_section != NULL)
2065 addr += s->output_section->vma;
2066 minfo ("0x%V %W", addr, s->size);
2067
2068 if (s->fill != 0)
2069 minfo (" %u", s->fill);
2070
2071 print_nl ();
2072
2073 print_dot = addr + s->size;
2074}
2075
2076static void
2077print_wild_statement (w, os)
2078 lang_wild_statement_type * w;
2079 lang_output_section_statement_type * os;
2080{
2081 print_space ();
2082
2083 if (w->filenames_sorted)
2084 minfo ("SORT(");
2085 if (w->exclude_filename != NULL)
2086 minfo ("EXCLUDE_FILE ( %s )", w->exclude_filename);
2087 if (w->filename != NULL)
2088 minfo ("%s", w->filename);
2089 else
2090 minfo ("*");
2091 if (w->filenames_sorted)
2092 minfo (")");
2093
2094 minfo ("(");
2095 if (w->sections_sorted)
2096 minfo ("SORT(");
2097 if (w->section_name != NULL)
2098 minfo ("%s", w->section_name);
2099 else
2100 minfo ("*");
2101 if (w->sections_sorted)
2102 minfo (")");
2103 minfo (")");
2104
2105 print_nl ();
2106
2107 print_statement_list (w->children.head, os);
2108}
2109
2110/* Print a group statement. */
2111
2112static void
2113print_group (s, os)
2114 lang_group_statement_type *s;
2115 lang_output_section_statement_type *os;
2116{
2117 fprintf (config.map_file, "START GROUP\n");
2118 print_statement_list (s->children.head, os);
2119 fprintf (config.map_file, "END GROUP\n");
2120}
2121
2122/* Print the list of statements in S.
2123 This can be called for any statement type. */
2124
2125static void
2126print_statement_list (s, os)
2127 lang_statement_union_type *s;
2128 lang_output_section_statement_type *os;
2129{
2130 while (s != NULL)
2131 {
2132 print_statement (s, os);
2133 s = s->next;
2134 }
2135}
2136
2137/* Print the first statement in statement list S.
2138 This can be called for any statement type. */
2139
2140static void
2141print_statement (s, os)
2142 lang_statement_union_type *s;
2143 lang_output_section_statement_type *os;
2144{
2145 switch (s->header.type)
2146 {
2147 default:
2148 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2149 FAIL ();
2150 break;
2151 case lang_constructors_statement_enum:
2152 if (constructor_list.head != NULL)
2153 {
2154 if (constructors_sorted)
2155 minfo (" SORT (CONSTRUCTORS)\n");
2156 else
2157 minfo (" CONSTRUCTORS\n");
2158 print_statement_list (constructor_list.head, os);
2159 }
2160 break;
2161 case lang_wild_statement_enum:
2162 print_wild_statement (&s->wild_statement, os);
2163 break;
2164 case lang_address_statement_enum:
2165 print_address_statement (&s->address_statement);
2166 break;
2167 case lang_object_symbols_statement_enum:
2168 minfo (" CREATE_OBJECT_SYMBOLS\n");
2169 break;
2170 case lang_fill_statement_enum:
2171 print_fill_statement (&s->fill_statement);
2172 break;
2173 case lang_data_statement_enum:
2174 print_data_statement (&s->data_statement);
2175 break;
2176 case lang_reloc_statement_enum:
2177 print_reloc_statement (&s->reloc_statement);
2178 break;
2179 case lang_input_section_enum:
2180 print_input_section (&s->input_section);
2181 break;
2182 case lang_padding_statement_enum:
2183 print_padding_statement (&s->padding_statement);
2184 break;
2185 case lang_output_section_statement_enum:
2186 print_output_section_statement (&s->output_section_statement);
2187 break;
2188 case lang_assignment_statement_enum:
2189 print_assignment (&s->assignment_statement, os);
2190 break;
2191 case lang_target_statement_enum:
2192 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2193 break;
2194 case lang_output_statement_enum:
2195 minfo ("OUTPUT(%s", s->output_statement.name);
2196 if (output_target != NULL)
2197 minfo (" %s", output_target);
2198 minfo (")\n");
2199 break;
2200 case lang_input_statement_enum:
2201 print_input_statement (&s->input_statement);
2202 break;
2203 case lang_group_statement_enum:
2204 print_group (&s->group_statement, os);
2205 break;
2206 case lang_afile_asection_pair_statement_enum:
2207 FAIL ();
2208 break;
2209 }
2210}
2211
2212static void
2213print_statements ()
2214{
2215 print_statement_list (statement_list.head, abs_output_section);
2216}
2217
2218/* Print the first N statements in statement list S to STDERR.
2219 If N == 0, nothing is printed.
2220 If N < 0, the entire list is printed.
2221 Intended to be called from GDB. */
2222
2223void
2224dprint_statement (s, n)
2225 lang_statement_union_type * s;
2226 int n;
2227{
2228 FILE *map_save = config.map_file;
2229
2230 config.map_file = stderr;
2231
2232 if (n < 0)
2233 print_statement_list (s, abs_output_section);
2234 else
2235 {
2236 while (s && --n >= 0)
2237 {
2238 print_statement (s, abs_output_section);
2239 s = s->next;
2240 }
2241 }
2242
2243 config.map_file = map_save;
2244}
2245
2246static bfd_vma
2247insert_pad (this_ptr, fill, power, output_section_statement, dot)
2248 lang_statement_union_type ** this_ptr;
2249 fill_type fill;
2250 unsigned int power;
2251 asection * output_section_statement;
2252 bfd_vma dot;
2253{
2254 /* Align this section first to the
2255 input sections requirement, then
2256 to the output section's requirement.
2257 If this alignment is > than any seen before,
2258 then record it too. Perform the alignment by
2259 inserting a magic 'padding' statement.
2260 */
2261
2262 unsigned int alignment_needed = align_power (dot, power) - dot;
2263
2264 if (alignment_needed != 0)
2265 {
2266 lang_statement_union_type *new =
2267 ((lang_statement_union_type *)
2268 stat_alloc (sizeof (lang_padding_statement_type)));
2269
2270 /* Link into existing chain */
2271 new->header.next = *this_ptr;
2272 *this_ptr = new;
2273 new->header.type = lang_padding_statement_enum;
2274 new->padding_statement.output_section = output_section_statement;
2275 new->padding_statement.output_offset =
2276 dot - output_section_statement->vma;
2277 new->padding_statement.fill = fill;
2278 new->padding_statement.size = alignment_needed;
2279 }
2280
2281
2282 /* Remember the most restrictive alignment */
2283 if (power > output_section_statement->alignment_power)
2284 {
2285 output_section_statement->alignment_power = power;
2286 }
2287 output_section_statement->_raw_size += alignment_needed;
2288 return alignment_needed + dot;
2289
2290}
2291
2292/* Work out how much this section will move the dot point */
2293static bfd_vma
2294size_input_section (this_ptr, output_section_statement, fill, dot, relax)
2295 lang_statement_union_type ** this_ptr;
2296 lang_output_section_statement_type * output_section_statement;
2297 fill_type fill;
2298 bfd_vma dot;
87f2a346 2299 boolean relax ATTRIBUTE_UNUSED;
252b5132
RH		 2300{
2301 lang_input_section_type *is = &((*this_ptr)->input_section);
2302 asection *i = is->section;
2303
2304 if (is->ifile->just_syms_flag == false)
2305 {
2306 if (output_section_statement->subsection_alignment != -1)
2307 i->alignment_power =
2308 output_section_statement->subsection_alignment;
2309
2310 dot = insert_pad (this_ptr, fill, i->alignment_power,
2311 output_section_statement->bfd_section, dot);
2312
2313 /* Remember where in the output section this input section goes */
2314
2315 i->output_offset = dot - output_section_statement->bfd_section->vma;
2316
2317 /* Mark how big the output section must be to contain this now
2318 */
2319 if (i->_cooked_size != 0)
2320 dot += i->_cooked_size;
2321 else
2322 dot += i->_raw_size;
2323 output_section_statement->bfd_section->_raw_size = dot - output_section_statement->bfd_section->vma;
2324 }
2325 else
2326 {
2327 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2328 }
2329
2330 return dot;
2331}
2332
2333/* Check to see if any allocated sections overlap with other allocated
2334 sections. This can happen when the linker script specifically specifies
2335 the output section addresses of the two sections. */
2336static void
2337lang_check_section_addresses ()
2338{
2339 asection * s;
2340
2341 /* Scan all sections in the output list. */
2342 for (s = output_bfd->sections; s != NULL; s = s->next)
2343 /* Ignore sections which are not loaded or which have no contents. */
2344 if ((bfd_get_section_flags (output_bfd, s) & (SEC_ALLOC | SEC_LOAD))
2345 && bfd_section_size (output_bfd, s) != 0)
2346 {
2347 asection * os;
2348
2349 /* Once we reach section 's' stop our seach. This prevents two
2350 warning messages from being produced, one for 'section A overlaps
2351 section B' and one for 'section B overlaps section A'. */
2352 for (os = output_bfd->sections; os != s; os = os->next)
2353 {
2354 bfd_vma s_start;
2355 bfd_vma s_end;
2356 bfd_vma os_start;
2357 bfd_vma os_end;
2358
2359 /* Only consider loadable sections with real contents. */
2360 if (((bfd_get_section_flags (output_bfd, os)
2361 & (SEC_ALLOC | SEC_LOAD)) == 0)
2362 || bfd_section_size (output_bfd, os) == 0)
2363 continue;
2364
2365 /* We must check the sections' LMA addresses not their
2366 VMA addresses because overlay sections can have
2367 overlapping VMAs but they must have distinct LMAs. */
2368 s_start = bfd_section_lma (output_bfd, s);
2369 os_start = bfd_section_lma (output_bfd, os);
2370 s_end = s_start + bfd_section_size (output_bfd, s) - 1;
2371 os_end = os_start + bfd_section_size (output_bfd, os) - 1;
2372
2373 /* Look for an overlap. */
2374 if ((s_end < os_start) || (s_start > os_end))
2375 continue;
2376
2377 einfo (
2378_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2379 s->name, s_start, s_end, os->name, os_start, os_end);
2380
2381 /* Once we have found one overlap for this section,
2382 stop looking for others. */
2383 break;
2384 }
2385 }
2386}
2387
2388/* This variable indicates whether bfd_relax_section should be called
2389 again. */
2390
2391static boolean relax_again;
2392
2393/* Set the sizes for all the output sections. */
2394
2395bfd_vma
2396lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
2397 lang_statement_union_type * s;
2398 lang_output_section_statement_type * output_section_statement;
2399 lang_statement_union_type ** prev;
2400 fill_type fill;
2401 bfd_vma dot;
2402 boolean relax;
2403{
2404 /* Size up the sections from their constituent parts. */
2405 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2406 {
2407 switch (s->header.type)
2408 {
2409 case lang_output_section_statement_enum:
2410 {
2411 bfd_vma after;
2412 lang_output_section_statement_type *os = &s->output_section_statement;
2413
2414 if (os->bfd_section == NULL)
2415 /* This section was never actually created. */
2416 break;
2417
2418 /* If this is a COFF shared library section, use the size and
2419 address from the input section. FIXME: This is COFF
2420 specific; it would be cleaner if there were some other way
2421 to do this, but nothing simple comes to mind. */
2422 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2423 {
2424 asection * input;
2425
2426 if (os->children.head == NULL
2427 || os->children.head->next != NULL
2428 || os->children.head->header.type != lang_input_section_enum)
2429 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2430 os->name);
2431
2432 input = os->children.head->input_section.section;
2433 bfd_set_section_vma (os->bfd_section->owner,
2434 os->bfd_section,
2435 bfd_section_vma (input->owner, input));
2436 os->bfd_section->_raw_size = input->_raw_size;
2437 break;
2438 }
2439
2440 if (bfd_is_abs_section (os->bfd_section))
2441 {
2442 /* No matter what happens, an abs section starts at zero. */
2443 ASSERT (os->bfd_section->vma == 0);
2444 }
2445 else
2446 {
2447 if (os->addr_tree == (etree_type *) NULL)
2448 {
2449 /* No address specified for this section, get one
2450 from the region specification. */
2451 if (os->region == (lang_memory_region_type *) NULL
2452 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2453 & (SEC_ALLOC | SEC_LOAD)) != 0)
2454 && os->region->name[0] == '*'
2455 && strcmp (os->region->name, "*default*") == 0))
2456 {
2457 os->region = lang_memory_default (os->bfd_section);
2458 }
2459
2460 /* If a loadable section is using the default memory
2461 region, and some non default memory regions were
2462 defined, issue a warning. */
2463 if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2464 & (SEC_ALLOC | SEC_LOAD)) != 0
2465 && ! link_info.relocateable
2466 && strcmp (os->region->name, "*default*") == 0
2467 && lang_memory_region_list != NULL
2468 && (strcmp (lang_memory_region_list->name, "*default*") != 0
2469 || lang_memory_region_list->next != NULL))
2470 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2471 bfd_get_section_name (output_bfd, os->bfd_section));
2472
2473 dot = os->region->current;
2474
2475 if (os->section_alignment == -1)
2476 {
2477 bfd_vma olddot;
2478
2479 olddot = dot;
2480 dot = align_power (dot, os->bfd_section->alignment_power);
2481
2482 if (dot != olddot && config.warn_section_align)
2483 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2484 os->name, (unsigned int) (dot - olddot));
2485 }
2486 }
2487 else
2488 {
2489 etree_value_type r;
2490
2491 r = exp_fold_tree (os->addr_tree,
2492 abs_output_section,
2493 lang_allocating_phase_enum,
2494 dot, &dot);
2495 if (r.valid_p == false)
2496 {
2497 einfo (_("%F%S: non constant address expression for section %s\n"),
2498 os->name);
2499 }
2500 dot = r.value + r.section->bfd_section->vma;
2501 }
2502
2503 /* The section starts here.
2504 First, align to what the section needs. */
2505
2506 if (os->section_alignment != -1)
2507 dot = align_power (dot, os->section_alignment);
2508
2509 bfd_set_section_vma (0, os->bfd_section, dot);
2510
2511 os->bfd_section->output_offset = 0;
2512 }
2513
2514 (void) lang_size_sections (os->children.head, os, &os->children.head,
2515 os->fill, dot, relax);
2516
2517 /* Ignore the size of the input sections, use the vma and size to
2518 align against. */
2519
2520 after = ALIGN_N (os->bfd_section->vma +
2521 os->bfd_section->_raw_size,
2522 /* The coercion here is important, see ld.h. */
2523 (bfd_vma) os->block_value);
2524
2525 if (bfd_is_abs_section (os->bfd_section))
2526 ASSERT (after == os->bfd_section->vma);
2527 else
2528 os->bfd_section->_raw_size = after - os->bfd_section->vma;
2529 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
2530 os->processed = true;
2531
2532 /* Update dot in the region ?
2533 We only do this if the section is going to be allocated,
2534 since unallocated sections do not contribute to the region's
2535 overall size in memory. */
2536 if (os->region != (lang_memory_region_type *) NULL
2537 && (bfd_get_section_flags (output_bfd, os->bfd_section)
2538 & (SEC_ALLOC | SEC_LOAD)))
2539 {
2540 os->region->current = dot;
2541
2542 /* Make sure this isn't silly. */
2543 if (os->region->current < os->region->origin
2544 || (os->region->current - os->region->origin
2545 > os->region->length))
2546 {
2547 if (os->addr_tree != (etree_type *) NULL)
2548 {
2549 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2550 os->region->current,
2551 os->bfd_section->owner,
2552 os->bfd_section->name,
2553 os->region->name);
2554 }
2555 else
2556 {
2557 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2558 os->region->name,
2559 os->bfd_section->owner,
2560 os->bfd_section->name);
2561 }
2562 /* Reset the region pointer. */
2563 os->region->current = os->region->origin;
2564 }
2565 }
2566 }
2567 break;
2568
2569 case lang_constructors_statement_enum:
2570 dot = lang_size_sections (constructor_list.head,
2571 output_section_statement,
2572 &s->wild_statement.children.head,
2573 fill,
2574 dot, relax);
2575 break;
2576
2577 case lang_data_statement_enum:
2578 {
2579 unsigned int size = 0;
2580
2581 s->data_statement.output_vma = dot - output_section_statement->bfd_section->vma;
2582 s->data_statement.output_section =
2583 output_section_statement->bfd_section;
2584
2585 switch (s->data_statement.type)
2586 {
2587 case QUAD:
2588 case SQUAD:
2589 size = QUAD_SIZE;
2590 break;
2591 case LONG:
2592 size = LONG_SIZE;
2593 break;
2594 case SHORT:
2595 size = SHORT_SIZE;
2596 break;
2597 case BYTE:
2598 size = BYTE_SIZE;
2599 break;
2600 }
2601
2602 dot += size;
2603 output_section_statement->bfd_section->_raw_size += size;
2604 /* The output section gets contents, and then we inspect for
2605 any flags set in the input script which override any ALLOC. */
2606 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
2607 if (!(output_section_statement->flags & SEC_NEVER_LOAD)) {
2608 output_section_statement->bfd_section->flags |= SEC_ALLOC | SEC_LOAD;
2609 }
2610 }
2611 break;
2612
2613 case lang_reloc_statement_enum:
2614 {
2615 int size;
2616
2617 s->reloc_statement.output_vma =
2618 dot - output_section_statement->bfd_section->vma;
2619 s->reloc_statement.output_section =
2620 output_section_statement->bfd_section;
2621 size = bfd_get_reloc_size (s->reloc_statement.howto);
2622 dot += size;
2623 output_section_statement->bfd_section->_raw_size += size;
2624 }
2625 break;
2626
2627 case lang_wild_statement_enum:
2628
2629 dot = lang_size_sections (s->wild_statement.children.head,
2630 output_section_statement,
2631 &s->wild_statement.children.head,
2632
2633 fill, dot, relax);
2634
2635 break;
2636
2637 case lang_object_symbols_statement_enum:
2638 link_info.create_object_symbols_section =
2639 output_section_statement->bfd_section;
2640 break;
2641 case lang_output_statement_enum:
2642 case lang_target_statement_enum:
2643 break;
2644 case lang_input_section_enum:
2645 {
2646 asection *i;
2647
2648 i = (*prev)->input_section.section;
2649 if (! relax)
2650 {
2651 if (i->_cooked_size == 0)
2652 i->_cooked_size = i->_raw_size;
2653 }
2654 else
2655 {
2656 boolean again;
2657
2658 if (! bfd_relax_section (i->owner, i, &link_info, &again))
2659 einfo (_("%P%F: can't relax section: %E\n"));
2660 if (again)
2661 relax_again = true;
2662 }
2663 dot = size_input_section (prev,
2664 output_section_statement,
2665 output_section_statement->fill,
2666 dot, relax);
2667 }
2668 break;
2669 case lang_input_statement_enum:
2670 break;
2671 case lang_fill_statement_enum:
2672 s->fill_statement.output_section = output_section_statement->bfd_section;
2673
2674 fill = s->fill_statement.fill;
2675 break;
2676 case lang_assignment_statement_enum:
2677 {
2678 bfd_vma newdot = dot;
2679
2680 exp_fold_tree (s->assignment_statement.exp,
2681 output_section_statement,
2682 lang_allocating_phase_enum,
2683 dot,
2684 &newdot);
2685
2686 if (newdot != dot)
2687 {
2688 /* The assignment changed dot. Insert a pad. */
2689 if (output_section_statement == abs_output_section)
2690 {
2691 /* If we don't have an output section, then just adjust
2692 the default memory address. */
2693 lang_memory_region_lookup ("*default*")->current = newdot;
2694 }
2695 else if (!relax)
2696 {
2697 lang_statement_union_type *new =
2698 ((lang_statement_union_type *)
2699 stat_alloc (sizeof (lang_padding_statement_type)));
2700
2701 /* Link into existing chain. */
2702 new->header.next = *prev;
2703 *prev = new;
2704 new->header.type = lang_padding_statement_enum;
2705 new->padding_statement.output_section =
2706 output_section_statement->bfd_section;
2707 new->padding_statement.output_offset =
2708 dot - output_section_statement->bfd_section->vma;
2709 new->padding_statement.fill = fill;
2710 new->padding_statement.size = newdot - dot;
2711 output_section_statement->bfd_section->_raw_size +=
2712 new->padding_statement.size;
2713 }
2714
2715 dot = newdot;
2716 }
2717 }
2718 break;
2719
2720 case lang_padding_statement_enum:
2721 /* If we are relaxing, and this is not the first pass, some
2722 padding statements may have been inserted during previous
2723 passes. We may have to move the padding statement to a new
2724 location if dot has a different value at this point in this
2725 pass than it did at this point in the previous pass. */
2726 s->padding_statement.output_offset =
2727 dot - output_section_statement->bfd_section->vma;
2728 dot += s->padding_statement.size;
2729 output_section_statement->bfd_section->_raw_size +=
2730 s->padding_statement.size;
2731 break;
2732
2733 case lang_group_statement_enum:
2734 dot = lang_size_sections (s->group_statement.children.head,
2735 output_section_statement,
2736 &s->group_statement.children.head,
2737 fill, dot, relax);
2738 break;
2739
2740 default:
2741 FAIL ();
2742 break;
2743
2744 /* This can only get here when relaxing is turned on. */
2745
2746 case lang_address_statement_enum:
2747 break;
2748 }
2749 prev = &s->header.next;
2750 }
2751 return dot;
2752}
2753
2754bfd_vma
2755lang_do_assignments (s, output_section_statement, fill, dot)
2756 lang_statement_union_type * s;
2757 lang_output_section_statement_type * output_section_statement;
2758 fill_type fill;
2759 bfd_vma dot;
2760{
2761 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2762 {
2763 switch (s->header.type)
2764 {
2765 case lang_constructors_statement_enum:
2766 dot = lang_do_assignments (constructor_list.head,
2767 output_section_statement,
2768 fill,
2769 dot);
2770 break;
2771
2772 case lang_output_section_statement_enum:
2773 {
2774 lang_output_section_statement_type *os =
2775 &(s->output_section_statement);
2776
2777 if (os->bfd_section != NULL)
2778 {
2779 dot = os->bfd_section->vma;
2780 (void) lang_do_assignments (os->children.head, os,
2781 os->fill, dot);
2782 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
2783 }
2784 if (os->load_base)
2785 {
2786 /* If nothing has been placed into the output section then
2787 it won't have a bfd_section. */
2788 if (os->bfd_section)
2789 {
2790 os->bfd_section->lma
2791 = exp_get_abs_int(os->load_base, 0,"load base", lang_final_phase_enum);
2792 }
2793 }
2794 }
2795 break;
2796 case lang_wild_statement_enum:
2797
2798 dot = lang_do_assignments (s->wild_statement.children.head,
2799 output_section_statement,
2800 fill, dot);
2801
2802 break;
2803
2804 case lang_object_symbols_statement_enum:
2805 case lang_output_statement_enum:
2806 case lang_target_statement_enum:
2807#if 0
2808 case lang_common_statement_enum:
2809#endif
2810 break;
2811 case lang_data_statement_enum:
2812 {
2813 etree_value_type value;
2814
2815 value = exp_fold_tree (s->data_statement.exp,
2816 abs_output_section,
2817 lang_final_phase_enum, dot, &dot);
2818 s->data_statement.value = value.value;
2819 if (value.valid_p == false)
2820 einfo (_("%F%P: invalid data statement\n"));
2821 }
2822 switch (s->data_statement.type)
2823 {
2824 case QUAD:
2825 case SQUAD:
2826 dot += QUAD_SIZE;
2827 break;
2828 case LONG:
2829 dot += LONG_SIZE;
2830 break;
2831 case SHORT:
2832 dot += SHORT_SIZE;
2833 break;
2834 case BYTE:
2835 dot += BYTE_SIZE;
2836 break;
2837 }
2838 break;
2839
2840 case lang_reloc_statement_enum:
2841 {
2842 etree_value_type value;
2843
2844 value = exp_fold_tree (s->reloc_statement.addend_exp,
2845 abs_output_section,
2846 lang_final_phase_enum, dot, &dot);
2847 s->reloc_statement.addend_value = value.value;
2848 if (value.valid_p == false)
2849 einfo (_("%F%P: invalid reloc statement\n"));
2850 }
2851 dot += bfd_get_reloc_size (s->reloc_statement.howto);
2852 break;
2853
2854 case lang_input_section_enum:
2855 {
2856 asection *in = s->input_section.section;
2857
2858 if (in->_cooked_size != 0)
2859 dot += in->_cooked_size;
2860 else
2861 dot += in->_raw_size;
2862 }
2863 break;
2864
2865 case lang_input_statement_enum:
2866 break;
2867 case lang_fill_statement_enum:
2868 fill = s->fill_statement.fill;
2869 break;
2870 case lang_assignment_statement_enum:
2871 {
2872 exp_fold_tree (s->assignment_statement.exp,
2873 output_section_statement,
2874 lang_final_phase_enum,
2875 dot,
2876 &dot);
2877 }
2878
2879 break;
2880 case lang_padding_statement_enum:
2881 dot += s->padding_statement.size;
2882 break;
2883
2884 case lang_group_statement_enum:
2885 dot = lang_do_assignments (s->group_statement.children.head,
2886 output_section_statement,
2887 fill, dot);
2888
2889 break;
2890
2891 default:
2892 FAIL ();
2893 break;
2894 case lang_address_statement_enum:
2895 break;
2896 }
2897
2898 }
2899 return dot;
2900}
2901
2902/* Fix any .startof. or .sizeof. symbols. When the assemblers see the
2903 operator .startof. (section_name), it produces an undefined symbol
2904 .startof.section_name. Similarly, when it sees
2905 .sizeof. (section_name), it produces an undefined symbol
2906 .sizeof.section_name. For all the output sections, we look for
2907 such symbols, and set them to the correct value. */
2908
2909static void
2910lang_set_startof ()
2911{
2912 asection *s;
2913
2914 if (link_info.relocateable)
2915 return;
2916
2917 for (s = output_bfd->sections; s != NULL; s = s->next)
2918 {
2919 const char *secname;
2920 char *buf;
2921 struct bfd_link_hash_entry *h;
2922
2923 secname = bfd_get_section_name (output_bfd, s);
2924 buf = xmalloc (10 + strlen (secname));
2925
2926 sprintf (buf, ".startof.%s", secname);
2927 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
2928 if (h != NULL && h->type == bfd_link_hash_undefined)
2929 {
2930 h->type = bfd_link_hash_defined;
2931 h->u.def.value = bfd_get_section_vma (output_bfd, s);
2932 h->u.def.section = bfd_abs_section_ptr;
2933 }
2934
2935 sprintf (buf, ".sizeof.%s", secname);
2936 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
2937 if (h != NULL && h->type == bfd_link_hash_undefined)
2938 {
2939 h->type = bfd_link_hash_defined;
2940 if (s->_cooked_size != 0)
2941 h->u.def.value = s->_cooked_size;
2942 else
2943 h->u.def.value = s->_raw_size;
2944 h->u.def.section = bfd_abs_section_ptr;
2945 }
2946
2947 free (buf);
2948 }
2949}
2950
2951static void
2952lang_finish ()
2953{
2954 struct bfd_link_hash_entry *h;
2955 boolean warn;
2956
2957 if (link_info.relocateable || link_info.shared)
2958 warn = false;
2959 else
2960 warn = true;
2961
2962 if (entry_symbol == (char *) NULL)
2963 {
2964 /* No entry has been specified. Look for start, but don't warn
2965 if we don't find it. */
2966 entry_symbol = "start";
2967 warn = false;
2968 }
2969
2970 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
2971 if (h != (struct bfd_link_hash_entry *) NULL
2972 && (h->type == bfd_link_hash_defined
2973 || h->type == bfd_link_hash_defweak)
2974 && h->u.def.section->output_section != NULL)
2975 {
2976 bfd_vma val;
2977
2978 val = (h->u.def.value
2979 + bfd_get_section_vma (output_bfd,
2980 h->u.def.section->output_section)
2981 + h->u.def.section->output_offset);
2982 if (! bfd_set_start_address (output_bfd, val))
2983 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
2984 }
2985 else
2986 {
2987 bfd_vma val;
2988 CONST char *send;
2989
2990 /* We couldn't find the entry symbol. Try parsing it as a
2991 number. */
2992 val = bfd_scan_vma (entry_symbol, &send, 0);
2993 if (*send == '\0')
2994 {
2995 if (! bfd_set_start_address (output_bfd, val))
2996 einfo (_("%P%F: can't set start address\n"));
2997 }
2998 else
2999 {
3000 asection *ts;
3001
3002 /* Can't find the entry symbol, and it's not a number. Use
3003 the first address in the text section. */
3004 ts = bfd_get_section_by_name (output_bfd, ".text");
3005 if (ts != (asection *) NULL)
3006 {
3007 if (warn)
3008 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3009 entry_symbol, bfd_get_section_vma (output_bfd, ts));
3010 if (! bfd_set_start_address (output_bfd,
3011 bfd_get_section_vma (output_bfd,
3012 ts)))
3013 einfo (_("%P%F: can't set start address\n"));
3014 }
3015 else
3016 {
3017 if (warn)
3018 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3019 entry_symbol);
3020 }
3021 }
3022 }
3023}
3024
3025/* This is a small function used when we want to ignore errors from
3026 BFD. */
3027
3028static void
3029#ifdef ANSI_PROTOTYPES
87f2a346 3030ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
252b5132
RH		 3031#else
3032ignore_bfd_errors (s)
87f2a346 3033 const char *s ATTRIBUTE_UNUSED;
252b5132
RH		 3034#endif
3035{
3036 /* Don't do anything. */
3037}
3038
3039/* Check that the architecture of all the input files is compatible
3040 with the output file. Also call the backend to let it do any
3041 other checking that is needed. */
3042
3043static void
3044lang_check ()
3045{
3046 lang_statement_union_type *file;
3047 bfd *input_bfd;
3048 CONST bfd_arch_info_type *compatible;
3049
3050 for (file = file_chain.head;
3051 file != (lang_statement_union_type *) NULL;
3052 file = file->input_statement.next)
3053 {
3054 input_bfd = file->input_statement.the_bfd;
3055 compatible = bfd_arch_get_compatible (input_bfd,
3056 output_bfd);
3057 if (compatible == NULL)
3058 {
3059 if (command_line.warn_mismatch)
3060 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3061 bfd_printable_name (input_bfd), input_bfd,
3062 bfd_printable_name (output_bfd));
3063 }
3064 else
3065 {
3066 bfd_error_handler_type pfn = NULL;
3067
3068 /* If we aren't supposed to warn about mismatched input
3069 files, temporarily set the BFD error handler to a
3070 function which will do nothing. We still want to call
3071 bfd_merge_private_bfd_data, since it may set up
3072 information which is needed in the output file. */
3073 if (! command_line.warn_mismatch)
3074 pfn = bfd_set_error_handler (ignore_bfd_errors);
3075 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3076 {
3077 if (command_line.warn_mismatch)
3078 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3079 input_bfd);
3080 }
3081 if (! command_line.warn_mismatch)
3082 bfd_set_error_handler (pfn);
3083 }
3084 }
3085}
3086
3087/* Look through all the global common symbols and attach them to the
3088 correct section. The -sort-common command line switch may be used
3089 to roughly sort the entries by size. */
3090
3091static void
3092lang_common ()
3093{
3094 if (link_info.relocateable
3095 && ! command_line.force_common_definition)
3096 return;
3097
3098 if (! config.sort_common)
3099 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3100 else
3101 {
3102 int power;
3103
3104 for (power = 4; power >= 0; power--)
3105 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3106 (PTR) &power);
3107 }
3108}
3109
3110/* Place one common symbol in the correct section. */
3111
3112static boolean
3113lang_one_common (h, info)
3114 struct bfd_link_hash_entry *h;
3115 PTR info;
3116{
3117 unsigned int power_of_two;
3118 bfd_vma size;
3119 asection *section;
3120
3121 if (h->type != bfd_link_hash_common)
3122 return true;
3123
3124 size = h->u.c.size;
3125 power_of_two = h->u.c.p->alignment_power;
3126
3127 if (config.sort_common
3128 && power_of_two < (unsigned int) *(int *) info)
3129 return true;
3130
3131 section = h->u.c.p->section;
3132
3133 /* Increase the size of the section. */
3134 section->_cooked_size = ALIGN_N (section->_cooked_size,
3135 (bfd_size_type) (1 << power_of_two));
3136
3137 /* Adjust the alignment if necessary. */
3138 if (power_of_two > section->alignment_power)
3139 section->alignment_power = power_of_two;
3140
3141 /* Change the symbol from common to defined. */
3142 h->type = bfd_link_hash_defined;
3143 h->u.def.section = section;
3144 h->u.def.value = section->_cooked_size;
3145
3146 /* Increase the size of the section. */
3147 section->_cooked_size += size;
3148
3149 /* Make sure the section is allocated in memory, and make sure that
3150 it is no longer a common section. */
3151 section->flags |= SEC_ALLOC;
3152 section->flags &= ~ SEC_IS_COMMON;
3153
3154 if (config.map_file != NULL)
3155 {
3156 static boolean header_printed;
3157 int len;
3158 char *name;
3159 char buf[50];
3160
3161 if (! header_printed)
3162 {
3163 minfo (_("\nAllocating common symbols\n"));
3164 minfo (_("Common symbol size file\n\n"));
3165 header_printed = true;
3166 }
3167
3168 name = demangle (h->root.string);
3169 minfo ("%s", name);
3170 len = strlen (name);
3171 free (name);
3172
3173 if (len >= 19)
3174 {
3175 print_nl ();
3176 len = 0;
3177 }
3178 while (len < 20)
3179 {
3180 print_space ();
3181 ++len;
3182 }
3183
3184 minfo ("0x");
3185 if (size <= 0xffffffff)
3186 sprintf (buf, "%lx", (unsigned long) size);
3187 else
3188 sprintf_vma (buf, size);
3189 minfo ("%s", buf);
3190 len = strlen (buf);
3191
3192 while (len < 16)
3193 {
3194 print_space ();
3195 ++len;
3196 }
3197
3198 minfo ("%B\n", section->owner);
3199 }
3200
3201 return true;
3202}
3203
3204/*
3205run through the input files and ensure that every input
3206section has somewhere to go. If one is found without
3207a destination then create an input request and place it
3208into the statement tree.
3209*/
3210
3211static void
3212lang_place_orphans ()
3213{
3214 lang_input_statement_type *file;
3215
3216 for (file = (lang_input_statement_type *) file_chain.head;
3217 file != (lang_input_statement_type *) NULL;
3218 file = (lang_input_statement_type *) file->next)
3219 {
3220 asection *s;
3221
3222 for (s = file->the_bfd->sections;
3223 s != (asection *) NULL;
3224 s = s->next)
3225 {
3226 if (s->output_section == (asection *) NULL)
3227 {
3228 /* This section of the file is not attatched, root
3229 around for a sensible place for it to go */
3230
3231 if (file->just_syms_flag)
3232 {
3233 /* We are only retrieving symbol values from this
3234 file. We want the symbols to act as though the
3235 values in the file are absolute. */
3236 s->output_section = bfd_abs_section_ptr;
3237 s->output_offset = s->vma;
3238 }
3239 else if (strcmp (s->name, "COMMON") == 0)
3240 {
3241 /* This is a lonely common section which must have
3242 come from an archive. We attach to the section
3243 with the wildcard. */
3244 if (! link_info.relocateable
3245 || command_line.force_common_definition)
3246 {
3247 if (default_common_section == NULL)
3248 {
3249#if 0
3250 /* This message happens when using the
3251 svr3.ifile linker script, so I have
3252 disabled it. */
3253 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3254#endif
3255 default_common_section =
3256 lang_output_section_statement_lookup (".bss");
3257
3258 }
3259 wild_doit (&default_common_section->children, s,
3260 default_common_section, file);
3261 }
3262 }
3263 else if (ldemul_place_orphan (file, s))
3264 ;
3265 else
3266 {
3267 lang_output_section_statement_type *os =
3268 lang_output_section_statement_lookup (s->name);
3269
3270 wild_doit (&os->children, s, os, file);
3271 }
3272 }
3273 }
3274 }
3275}
3276
3277
3278void
aa8804e4 3279lang_set_flags (ptr, flags, invert)
252b5132
RH		 3280 lang_memory_region_type *ptr;
3281 CONST char *flags;
aa8804e4 3282 int invert;
252b5132 3283{
aa8804e4 3284 flagword *ptr_flags;
252b5132 3285
aa8804e4 3286 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
252b5132
RH		 3287 while (*flags)
3288 {
3289 switch (*flags)
3290 {
252b5132
RH		 3291 case 'A': case 'a':
3292 *ptr_flags |= SEC_ALLOC;
3293 break;
3294
3295 case 'R': case 'r':
3296 *ptr_flags |= SEC_READONLY;
3297 break;
3298
3299 case 'W': case 'w':
3300 *ptr_flags |= SEC_DATA;
3301 break;
3302
3303 case 'X': case 'x':
3304 *ptr_flags |= SEC_CODE;
3305 break;
3306
3307 case 'L': case 'l':
3308 case 'I': case 'i':
3309 *ptr_flags |= SEC_LOAD;
3310 break;
3311
3312 default:
3313 einfo (_("%P%F: invalid syntax in flags\n"));
3314 break;
3315 }
3316 flags++;
3317 }
3318}
3319
3320/* Call a function on each input file. This function will be called
3321 on an archive, but not on the elements. */
3322
3323void
3324lang_for_each_input_file (func)
3325 void (*func) PARAMS ((lang_input_statement_type *));
3326{
3327 lang_input_statement_type *f;
3328
3329 for (f = (lang_input_statement_type *) input_file_chain.head;
3330 f != NULL;
3331 f = (lang_input_statement_type *) f->next_real_file)
3332 func (f);
3333}
3334
3335/* Call a function on each file. The function will be called on all
3336 the elements of an archive which are included in the link, but will
3337 not be called on the archive file itself. */
3338
3339void
3340lang_for_each_file (func)
3341 void (*func) PARAMS ((lang_input_statement_type *));
3342{
3343 lang_input_statement_type *f;
3344
3345 for (f = (lang_input_statement_type *) file_chain.head;
3346 f != (lang_input_statement_type *) NULL;
3347 f = (lang_input_statement_type *) f->next)
3348 {
3349 func (f);
3350 }
3351}
3352
3353#if 0
3354
3355/* Not used. */
3356
3357void
3358lang_for_each_input_section (func)
3359 void (*func) PARAMS ((bfd * ab, asection * as));
3360{
3361 lang_input_statement_type *f;
3362
3363 for (f = (lang_input_statement_type *) file_chain.head;
3364 f != (lang_input_statement_type *) NULL;
3365 f = (lang_input_statement_type *) f->next)
3366 {
3367 asection *s;
3368
3369 for (s = f->the_bfd->sections;
3370 s != (asection *) NULL;
3371 s = s->next)
3372 {
3373 func (f->the_bfd, s);
3374 }
3375 }
3376}
3377
3378#endif
3379
3380void
3381ldlang_add_file (entry)
3382 lang_input_statement_type * entry;
3383{
3384 bfd **pp;
3385
3386 lang_statement_append (&file_chain,
3387 (lang_statement_union_type *) entry,
3388 &entry->next);
3389
3390 /* The BFD linker needs to have a list of all input BFDs involved in
3391 a link. */
3392 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3393 ASSERT (entry->the_bfd != output_bfd);
3394 for (pp = &link_info.input_bfds;
3395 *pp != (bfd *) NULL;
3396 pp = &(*pp)->link_next)
3397 ;
3398 *pp = entry->the_bfd;
3399 entry->the_bfd->usrdata = (PTR) entry;
3400 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3401
3402 /* Look through the sections and check for any which should not be
3403 included in the link. We need to do this now, so that we can
3404 notice when the backend linker tries to report multiple
3405 definition errors for symbols which are in sections we aren't
3406 going to link. FIXME: It might be better to entirely ignore
3407 symbols which are defined in sections which are going to be
3408 discarded. This would require modifying the backend linker for
3409 each backend which might set the SEC_LINK_ONCE flag. If we do
3410 this, we should probably handle SEC_EXCLUDE in the same way. */
3411
3412 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3413}
3414
3415void
3416lang_add_output (name, from_script)
3417 CONST char *name;
3418 int from_script;
3419{
3420 /* Make -o on command line override OUTPUT in script. */
3421 if (had_output_filename == false || !from_script)
3422 {
3423 output_filename = name;
3424 had_output_filename = true;
3425 }
3426}
3427
3428
3429static lang_output_section_statement_type *current_section;
3430
3431static int
3432topower (x)
3433 int x;
3434{
3435 unsigned int i = 1;
3436 int l;
3437
3438 if (x < 0)
3439 return -1;
3440
3441 for (l = 0; l < 32; l++)
3442 {
3443 if (i >= (unsigned int) x)
3444 return l;
3445 i <<= 1;
3446 }
3447
3448 return 0;
3449}
3450
3451void
3452lang_enter_output_section_statement (output_section_statement_name,
3453 address_exp, sectype, block_value,
3454 align, subalign, ebase)
3455 const char *output_section_statement_name;
3456 etree_type * address_exp;
3457 enum section_type sectype;
3458 bfd_vma block_value;
3459 etree_type *align;
3460 etree_type *subalign;
3461 etree_type *ebase;
3462{
3463 lang_output_section_statement_type *os;
3464
3465 current_section =
3466 os =
3467 lang_output_section_statement_lookup (output_section_statement_name);
3468
3469
3470
3471 /* Add this statement to tree */
3472 /* add_statement(lang_output_section_statement_enum,
3473 output_section_statement);*/
3474 /* Make next things chain into subchain of this */
3475
3476 if (os->addr_tree ==
3477 (etree_type *) NULL)
3478 {
3479 os->addr_tree =
3480 address_exp;
3481 }
3482 os->sectype = sectype;
3483 if (sectype != noload_section)
3484 os->flags = SEC_NO_FLAGS;
3485 else
3486 os->flags = SEC_NEVER_LOAD;
3487 os->block_value = block_value ? block_value : 1;
3488 stat_ptr = &os->children;
3489
3490 os->subsection_alignment = topower(
3491 exp_get_value_int(subalign, -1,
3492 "subsection alignment",
3493 0));
3494 os->section_alignment = topower(
3495 exp_get_value_int(align, -1,
3496 "section alignment", 0));
3497
3498 os->load_base = ebase;
3499}
3500
3501
3502void
3503lang_final ()
3504{
3505 lang_output_statement_type *new =
3506 new_stat (lang_output_statement, stat_ptr);
3507
3508 new->name = output_filename;
3509}
3510
3511/* Reset the current counters in the regions */
3512static void
3513reset_memory_regions ()
3514{
3515 lang_memory_region_type *p = lang_memory_region_list;
3516
3517 for (p = lang_memory_region_list;
3518 p != (lang_memory_region_type *) NULL;
3519 p = p->next)
3520 {
3521 p->old_length = (bfd_size_type) (p->current - p->origin);
3522 p->current = p->origin;
3523 }
3524}
3525
252b5132
RH		 3526/* Expand a wild statement for a particular FILE, marking its sections KEEP
3527 as needed. SECTION may be NULL, in which case it is a wild card. */
3528
3529static void
4dec4d4e 3530gc_section_callback (ptr, section, file, data)
252b5132 3531 lang_wild_statement_type *ptr;
4dec4d4e 3532 asection *section;
87f2a346
ILT		 3533 lang_input_statement_type *file ATTRIBUTE_UNUSED;
3534 void *data ATTRIBUTE_UNUSED;
252b5132 3535{
4dec4d4e
RH		 3536 /* If the wild pattern was marked KEEP, the member sections
3537 should be as well. */
3538 if (ptr->keep_sections)
3539 section->flags |= SEC_KEEP;
252b5132
RH		 3540}
3541
3542/* Handle a wild statement, marking it against GC. SECTION or FILE or both
3543 may be NULL, indicating that it is a wildcard. */
3544
3545static void
3546lang_gc_wild (s, section, file)
3547 lang_wild_statement_type *s;
3548 const char *section;
3549 const char *file;
3550{
4dec4d4e 3551 walk_wild (s, section, file, gc_section_callback, NULL);
252b5132
RH		 3552}
3553
3554/* Iterate over sections marking them against GC. */
3555
3556static void
3557lang_gc_sections_1 (s)
3558 lang_statement_union_type * s;
3559{
3560 for (; s != (lang_statement_union_type *) NULL; s = s->next)
3561 {
3562 switch (s->header.type)
3563 {
3564 case lang_wild_statement_enum:
3565 lang_gc_wild (&s->wild_statement,
3566 s->wild_statement.section_name,
3567 s->wild_statement.filename);
3568 break;
3569 case lang_constructors_statement_enum:
3570 lang_gc_sections_1 (constructor_list.head);
3571 break;
3572 case lang_output_section_statement_enum:
3573 lang_gc_sections_1 (s->output_section_statement.children.head);
3574 break;
3575 case lang_group_statement_enum:
3576 lang_gc_sections_1 (s->group_statement.children.head);
3577 break;
3578 default:
3579 break;
3580 }
3581 }
3582}
3583
3584static void
3585lang_gc_sections ()
3586{
3587 struct bfd_link_hash_entry *h;
3588 ldlang_undef_chain_list_type *ulist, fake_list_start;
3589
3590 /* Keep all sections so marked in the link script. */
3591
3592 lang_gc_sections_1 (statement_list.head);
3593
3594 /* Keep all sections containing symbols undefined on the command-line.
3595 Handle the entry symbol at the same time. */
3596
3597 fake_list_start.next = ldlang_undef_chain_list_head;
3598 if (entry_symbol == NULL)
3599 fake_list_start.name = "start";
3600 else
3601 fake_list_start.name = (char *) entry_symbol;
3602
3603 for (ulist = &fake_list_start; ulist; ulist = ulist->next)
3604 {
3605 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
3606 false, false, false);
3607
3608 if (h != (struct bfd_link_hash_entry *) NULL
3609 && (h->type == bfd_link_hash_defined
3610 || h->type == bfd_link_hash_defweak)
3611 && ! bfd_is_abs_section (h->u.def.section))
3612 {
3613 h->u.def.section->flags |= SEC_KEEP;
3614 }
3615 }
3616
3617 bfd_gc_sections (output_bfd, &link_info);
3618}
3619
3620void
3621lang_process ()
3622{
3623 lang_reasonable_defaults ();
3624 current_target = default_target;
3625
3626 lang_for_each_statement (ldlang_open_output); /* Open the output file */
3627
3628 ldemul_create_output_section_statements ();
3629
3630 /* Add to the hash table all undefineds on the command line */
3631 lang_place_undefineds ();
3632
3633 /* Create a bfd for each input file */
3634 current_target = default_target;
3635 open_input_bfds (statement_list.head, false);
3636
3637 ldemul_after_open ();
3638
3639 /* Make sure that we're not mixing architectures. We call this
3640 after all the input files have been opened, but before we do any
3641 other processing, so that any operations merge_private_bfd_data
3642 does on the output file will be known during the rest of the
3643 link. */
3644 lang_check ();
3645
3646 /* Handle .exports instead of a version script if we're told to do so. */
3647 if (command_line.version_exports_section)
3648 lang_do_version_exports_section ();
3649
3650 /* Build all sets based on the information gathered from the input
3651 files. */
3652 ldctor_build_sets ();
3653
3654 /* Remove unreferenced sections if asked to. */
3655 if (command_line.gc_sections)
3656 lang_gc_sections ();
3657
3658 /* Size up the common data */
3659 lang_common ();
3660
3661 /* Run through the contours of the script and attach input sections
3662 to the correct output sections
3663 */
3664 map_input_to_output_sections (statement_list.head, (char *) NULL,
3665 (lang_output_section_statement_type *) NULL);
3666
3667
3668 /* Find any sections not attached explicitly and handle them */
3669 lang_place_orphans ();
3670
3671 ldemul_before_allocation ();
3672
3673 /* We must record the program headers before we try to fix the
3674 section positions, since they will affect SIZEOF_HEADERS. */
3675 lang_record_phdrs ();
3676
3677 /* Now run around and relax if we can */
3678 if (command_line.relax)
3679 {
3680 /* First time round is a trial run to get the 'worst case'
3681 addresses of the objects if there was no relaxing. */
3682 lang_size_sections (statement_list.head,
3683 abs_output_section,
3684 &(statement_list.head), 0, (bfd_vma) 0, false);
3685
3686 /* Keep relaxing until bfd_relax_section gives up. */
3687 do
3688 {
3689 reset_memory_regions ();
3690
3691 relax_again = false;
3692
3693 /* Note: pe-dll.c does something like this also. If you find
3694 you need to change this code, you probably need to change
3695 pe-dll.c also. DJ */
3696
3697 /* Do all the assignments with our current guesses as to
3698 section sizes. */
3699 lang_do_assignments (statement_list.head,
3700 abs_output_section,
3701 (fill_type) 0, (bfd_vma) 0);
3702
3703 /* Perform another relax pass - this time we know where the
3704 globals are, so can make better guess. */
3705 lang_size_sections (statement_list.head,
3706 abs_output_section,
3707 &(statement_list.head), 0, (bfd_vma) 0, true);
3708 }
3709 while (relax_again);
3710 }
3711 else
3712 {
3713 /* Size up the sections. */
3714 lang_size_sections (statement_list.head,
3715 abs_output_section,
3716 &(statement_list.head), 0, (bfd_vma) 0, false);
3717 }
3718
3719 /* See if anything special should be done now we know how big
3720 everything is. */
3721 ldemul_after_allocation ();
3722
3723 /* Fix any .startof. or .sizeof. symbols. */
3724 lang_set_startof ();
3725
3726 /* Do all the assignments, now that we know the final restingplaces
3727 of all the symbols */
3728
3729 lang_do_assignments (statement_list.head,
3730 abs_output_section,
3731 (fill_type) 0, (bfd_vma) 0);
3732
3733 /* Make sure that the section addresses make sense. */
3734 if (! link_info.relocateable
3735 && command_line.check_section_addresses)
3736 lang_check_section_addresses ();
3737
3738 /* Final stuffs */
3739
3740 ldemul_finish ();
3741 lang_finish ();
3742}
3743
3744/* EXPORTED TO YACC */
3745
3746void
3747lang_add_wild (section_name, sections_sorted, filename, filenames_sorted,
3748 keep_sections, exclude_filename)
3749 const char *const section_name;
3750 boolean sections_sorted;
3751 const char *const filename;
3752 boolean filenames_sorted;
3753 boolean keep_sections;
3754 const char *exclude_filename;
3755{
3756 lang_wild_statement_type *new = new_stat (lang_wild_statement,
3757 stat_ptr);
3758
3759 if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
3760 {
3761 placed_commons = true;
3762 }
3763 if (filename != NULL && ! wildcardp (filename))
3764 {
3765 lang_has_input_file = true;
3766 }
3767 new->section_name = section_name;
3768 new->sections_sorted = sections_sorted;
3769 new->filename = filename;
3770 new->filenames_sorted = filenames_sorted;
3771 new->keep_sections = keep_sections;
3772 new->exclude_filename = exclude_filename;
3773 lang_list_init (&new->children);
3774}
3775
3776void
3777lang_section_start (name, address)
3778 CONST char *name;
3779 etree_type * address;
3780{
3781 lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
3782
3783 ad->section_name = name;
3784 ad->address = address;
3785}
3786
3787/* Set the start symbol to NAME. CMDLINE is nonzero if this is called
3788 because of a -e argument on the command line, or zero if this is
3789 called by ENTRY in a linker script. Command line arguments take
3790 precedence. */
3791
3792void
3793lang_add_entry (name, cmdline)
3794 CONST char *name;
3795 boolean cmdline;
3796{
3797 if (entry_symbol == NULL
3798 || cmdline
3799 || ! entry_from_cmdline)
3800 {
3801 entry_symbol = name;
3802 entry_from_cmdline = cmdline;
3803 }
3804}
3805
3806void
3807lang_add_target (name)
3808 CONST char *name;
3809{
3810 lang_target_statement_type *new = new_stat (lang_target_statement,
3811 stat_ptr);
3812
3813 new->target = name;
3814
3815}
3816
3817void
3818lang_add_map (name)
3819 CONST char *name;
3820{
3821 while (*name)
3822 {
3823 switch (*name)
3824 {
3825 case 'F':
3826 map_option_f = true;
3827 break;
3828 }
3829 name++;
3830 }
3831}
3832
3833void
3834lang_add_fill (exp)
3835 int exp;
3836{
3837 lang_fill_statement_type *new = new_stat (lang_fill_statement,
3838 stat_ptr);
3839
3840 new->fill = exp;
3841}
3842
3843void
3844lang_add_data (type, exp)
3845 int type;
3846 union etree_union *exp;
3847{
3848
3849 lang_data_statement_type *new = new_stat (lang_data_statement,
3850 stat_ptr);
3851
3852 new->exp = exp;
3853 new->type = type;
3854
3855}
3856
3857/* Create a new reloc statement. RELOC is the BFD relocation type to
3858 generate. HOWTO is the corresponding howto structure (we could
3859 look this up, but the caller has already done so). SECTION is the
3860 section to generate a reloc against, or NAME is the name of the
3861 symbol to generate a reloc against. Exactly one of SECTION and
3862 NAME must be NULL. ADDEND is an expression for the addend. */
3863
3864void
3865lang_add_reloc (reloc, howto, section, name, addend)
3866 bfd_reloc_code_real_type reloc;
3867 reloc_howto_type *howto;
3868 asection *section;
3869 const char *name;
3870 union etree_union *addend;
3871{
3872 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
3873
3874 p->reloc = reloc;
3875 p->howto = howto;
3876 p->section = section;
3877 p->name = name;
3878 p->addend_exp = addend;
3879
3880 p->addend_value = 0;
3881 p->output_section = NULL;
3882 p->output_vma = 0;
3883}
3884
3885lang_assignment_statement_type *
3886lang_add_assignment (exp)
3887 etree_type * exp;
3888{
3889 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
3890 stat_ptr);
3891
3892 new->exp = exp;
3893 return new;
3894}
3895
3896void
3897lang_add_attribute (attribute)
3898 enum statement_enum attribute;
3899{
3900 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
3901}
3902
3903void
3904lang_startup (name)
3905 CONST char *name;
3906{
3907 if (startup_file != (char *) NULL)
3908 {
3909 einfo (_("%P%Fmultiple STARTUP files\n"));
3910 }
3911 first_file->filename = name;
3912 first_file->local_sym_name = name;
3913 first_file->real = true;
3914
3915 startup_file = name;
3916}
3917
3918void
3919lang_float (maybe)
3920 boolean maybe;
3921{
3922 lang_float_flag = maybe;
3923}
3924
3925void
3926lang_leave_output_section_statement (fill, memspec, phdrs)
3927 bfd_vma fill;
3928 const char *memspec;
3929 struct lang_output_section_phdr_list *phdrs;
3930{
3931 current_section->fill = fill;
3932 current_section->region = lang_memory_region_lookup (memspec);
3933 current_section->phdrs = phdrs;
3934 stat_ptr = &statement_list;
3935}
3936
3937/*
3938 Create an absolute symbol with the given name with the value of the
3939 address of first byte of the section named.
3940
3941 If the symbol already exists, then do nothing.
3942*/
3943void
3944lang_abs_symbol_at_beginning_of (secname, name)
3945 const char *secname;
3946 const char *name;
3947{
3948 struct bfd_link_hash_entry *h;
3949
3950 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
3951 if (h == (struct bfd_link_hash_entry *) NULL)
3952 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3953
3954 if (h->type == bfd_link_hash_new
3955 || h->type == bfd_link_hash_undefined)
3956 {
3957 asection *sec;
3958
3959 h->type = bfd_link_hash_defined;
3960
3961 sec = bfd_get_section_by_name (output_bfd, secname);
3962 if (sec == (asection *) NULL)
3963 h->u.def.value = 0;
3964 else
3965 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
3966
3967 h->u.def.section = bfd_abs_section_ptr;
3968 }
3969}
3970
3971/*
3972 Create an absolute symbol with the given name with the value of the
3973 address of the first byte after the end of the section named.
3974
3975 If the symbol already exists, then do nothing.
3976*/
3977void
3978lang_abs_symbol_at_end_of (secname, name)
3979 const char *secname;
3980 const char *name;
3981{
3982 struct bfd_link_hash_entry *h;
3983
3984 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
3985 if (h == (struct bfd_link_hash_entry *) NULL)
3986 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3987
3988 if (h->type == bfd_link_hash_new
3989 || h->type == bfd_link_hash_undefined)
3990 {
3991 asection *sec;
3992
3993 h->type = bfd_link_hash_defined;
3994
3995 sec = bfd_get_section_by_name (output_bfd, secname);
3996 if (sec == (asection *) NULL)
3997 h->u.def.value = 0;
3998 else
3999 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4000 + bfd_section_size (output_bfd, sec));
4001
4002 h->u.def.section = bfd_abs_section_ptr;
4003 }
4004}
4005
4006void
4007lang_statement_append (list, element, field)
4008 lang_statement_list_type * list;
4009 lang_statement_union_type * element;
4010 lang_statement_union_type ** field;
4011{
4012 *(list->tail) = element;
4013 list->tail = field;
4014}
4015
4016/* Set the output format type. -oformat overrides scripts. */
4017
4018void
4019lang_add_output_format (format, big, little, from_script)
4020 const char *format;
4021 const char *big;
4022 const char *little;
4023 int from_script;
4024{
4025 if (output_target == NULL || !from_script)
4026 {
4027 if (command_line.endian == ENDIAN_BIG
4028 && big != NULL)
4029 format = big;
4030 else if (command_line.endian == ENDIAN_LITTLE
4031 && little != NULL)
4032 format = little;
4033
4034 output_target = format;
4035 }
4036}
4037
4038/* Enter a group. This creates a new lang_group_statement, and sets
4039 stat_ptr to build new statements within the group. */
4040
4041void
4042lang_enter_group ()
4043{
4044 lang_group_statement_type *g;
4045
4046 g = new_stat (lang_group_statement, stat_ptr);
4047 lang_list_init (&g->children);
4048 stat_ptr = &g->children;
4049}
4050
4051/* Leave a group. This just resets stat_ptr to start writing to the
4052 regular list of statements again. Note that this will not work if
4053 groups can occur inside anything else which can adjust stat_ptr,
4054 but currently they can't. */
4055
4056void
4057lang_leave_group ()
4058{
4059 stat_ptr = &statement_list;
4060}
4061
4062/* Add a new program header. This is called for each entry in a PHDRS
4063 command in a linker script. */
4064
4065void
4066lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4067 const char *name;
4068 etree_type *type;
4069 boolean filehdr;
4070 boolean phdrs;
4071 etree_type *at;
4072 etree_type *flags;
4073{
4074 struct lang_phdr *n, **pp;
4075
4076 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4077 n->next = NULL;
4078 n->name = name;
4079 n->type = exp_get_value_int (type, 0, "program header type",
4080 lang_final_phase_enum);
4081 n->filehdr = filehdr;
4082 n->phdrs = phdrs;
4083 n->at = at;
4084 n->flags = flags;
4085
4086 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4087 ;
4088 *pp = n;
4089}
4090
4091/* Record the program header information in the output BFD. FIXME: We
4092 should not be calling an ELF specific function here. */
4093
4094static void
4095lang_record_phdrs ()
4096{
4097 unsigned int alc;
4098 asection **secs;
4099 struct lang_output_section_phdr_list *last;
4100 struct lang_phdr *l;
4101 lang_statement_union_type *u;
4102
4103 alc = 10;
4104 secs = (asection **) xmalloc (alc * sizeof (asection *));
4105 last = NULL;
4106 for (l = lang_phdr_list; l != NULL; l = l->next)
4107 {
4108 unsigned int c;
4109 flagword flags;
4110 bfd_vma at;
4111
4112 c = 0;
4113 for (u = lang_output_section_statement.head;
4114 u != NULL;
4115 u = u->output_section_statement.next)
4116 {
4117 lang_output_section_statement_type *os;
4118 struct lang_output_section_phdr_list *pl;
4119
4120 os = &u->output_section_statement;
4121
4122 pl = os->phdrs;
4123 if (pl != NULL)
4124 last = pl;
4125 else
4126 {
4127 if (os->sectype == noload_section
4128 || os->bfd_section == NULL
4129 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4130 continue;
4131 pl = last;
4132 }
4133
4134 if (os->bfd_section == NULL)
4135 continue;
4136
4137 for (; pl != NULL; pl = pl->next)
4138 {
4139 if (strcmp (pl->name, l->name) == 0)
4140 {
4141 if (c >= alc)
4142 {
4143 alc *= 2;
4144 secs = ((asection **)
4145 xrealloc (secs, alc * sizeof (asection *)));
4146 }
4147 secs[c] = os->bfd_section;
4148 ++c;
4149 pl->used = true;
4150 }
4151 }
4152 }
4153
4154 if (l->flags == NULL)
4155 flags = 0;
4156 else
4157 flags = exp_get_vma (l->flags, 0, "phdr flags",
4158 lang_final_phase_enum);
4159
4160 if (l->at == NULL)
4161 at = 0;
4162 else
4163 at = exp_get_vma (l->at, 0, "phdr load address",
4164 lang_final_phase_enum);
4165
4166 if (! bfd_record_phdr (output_bfd, l->type,
4167 l->flags == NULL ? false : true,
4168 flags,
4169 l->at == NULL ? false : true,
4170 at, l->filehdr, l->phdrs, c, secs))
4171 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4172 }
4173
4174 free (secs);
4175
4176 /* Make sure all the phdr assignments succeeded. */
4177 for (u = lang_output_section_statement.head;
4178 u != NULL;
4179 u = u->output_section_statement.next)
4180 {
4181 struct lang_output_section_phdr_list *pl;
4182
4183 if (u->output_section_statement.bfd_section == NULL)
4184 continue;
4185
4186 for (pl = u->output_section_statement.phdrs;
4187 pl != NULL;
4188 pl = pl->next)
4189 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4190 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4191 u->output_section_statement.name, pl->name);
4192 }
4193}
4194
4195/* Record a list of sections which may not be cross referenced. */
4196
4197void
4198lang_add_nocrossref (l)
4199 struct lang_nocrossref *l;
4200{
4201 struct lang_nocrossrefs *n;
4202
4203 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4204 n->next = nocrossref_list;
4205 n->list = l;
4206 nocrossref_list = n;
4207
4208 /* Set notice_all so that we get informed about all symbols. */
4209 link_info.notice_all = true;
4210}
4211\f
4212/* Overlay handling. We handle overlays with some static variables. */
4213
4214/* The overlay virtual address. */
4215static etree_type *overlay_vma;
4216
4217/* The overlay load address. */
4218static etree_type *overlay_lma;
4219
4220/* Whether nocrossrefs is set for this overlay. */
4221static int overlay_nocrossrefs;
4222
4223/* An expression for the maximum section size seen so far. */
4224static etree_type *overlay_max;
4225
4226/* A list of all the sections in this overlay. */
4227
4228struct overlay_list
4229{
4230 struct overlay_list *next;
4231 lang_output_section_statement_type *os;
4232};
4233
4234static struct overlay_list *overlay_list;
4235
4236/* Start handling an overlay. */
4237
4238void
4239lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
4240 etree_type *vma_expr;
4241 etree_type *lma_expr;
4242 int nocrossrefs;
4243{
4244 /* The grammar should prevent nested overlays from occurring. */
4245 ASSERT (overlay_vma == NULL
4246 && overlay_lma == NULL
4247 && overlay_list == NULL
4248 && overlay_max == NULL);
4249
4250 overlay_vma = vma_expr;
4251 overlay_lma = lma_expr;
4252 overlay_nocrossrefs = nocrossrefs;
4253}
4254
4255/* Start a section in an overlay. We handle this by calling
4256 lang_enter_output_section_statement with the correct VMA and LMA. */
4257
4258void
4259lang_enter_overlay_section (name)
4260 const char *name;
4261{
4262 struct overlay_list *n;
4263 etree_type *size;
4264
4265 lang_enter_output_section_statement (name, overlay_vma, normal_section,
4266 0, 0, 0, overlay_lma);
4267
4268 /* If this is the first section, then base the VMA and LMA of future
4269 sections on this one. This will work correctly even if `.' is
4270 used in the addresses. */
4271 if (overlay_list == NULL)
4272 {
4273 overlay_vma = exp_nameop (ADDR, name);
4274 overlay_lma = exp_nameop (LOADADDR, name);
4275 }
4276
4277 /* Remember the section. */
4278 n = (struct overlay_list *) xmalloc (sizeof *n);
4279 n->os = current_section;
4280 n->next = overlay_list;
4281 overlay_list = n;
4282
4283 size = exp_nameop (SIZEOF, name);
4284
4285 /* Adjust the LMA for the next section. */
4286 overlay_lma = exp_binop ('+', overlay_lma, size);
4287
4288 /* Arrange to work out the maximum section end address. */
4289 if (overlay_max == NULL)
4290 overlay_max = size;
4291 else
4292 overlay_max = exp_binop (MAX_K, overlay_max, size);
4293}
4294
4295/* Finish a section in an overlay. There isn't any special to do
4296 here. */
4297
4298void
4299lang_leave_overlay_section (fill, phdrs)
4300 bfd_vma fill;
4301 struct lang_output_section_phdr_list *phdrs;
4302{
4303 const char *name;
4304 char *clean, *s2;
4305 const char *s1;
4306 char *buf;
4307
4308 name = current_section->name;
4309
4310 lang_leave_output_section_statement (fill, "*default*", phdrs);
4311
4312 /* Define the magic symbols. */
4313
4314 clean = xmalloc (strlen (name) + 1);
4315 s2 = clean;
4316 for (s1 = name; *s1 != '\0'; s1++)
4317 if (isalnum ((unsigned char) *s1) || *s1 == '_')
4318 *s2++ = *s1;
4319 *s2 = '\0';
4320
4321 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4322 sprintf (buf, "__load_start_%s", clean);
4323 lang_add_assignment (exp_assop ('=', buf,
4324 exp_nameop (LOADADDR, name)));
4325
4326 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4327 sprintf (buf, "__load_stop_%s", clean);
4328 lang_add_assignment (exp_assop ('=', buf,
4329 exp_binop ('+',
4330 exp_nameop (LOADADDR, name),
4331 exp_nameop (SIZEOF, name))));
4332
4333 free (clean);
4334}
4335
4336/* Finish an overlay. If there are any overlay wide settings, this
4337 looks through all the sections in the overlay and sets them. */
4338
4339void
4340lang_leave_overlay (fill, memspec, phdrs)
4341 bfd_vma fill;
4342 const char *memspec;
4343 struct lang_output_section_phdr_list *phdrs;
4344{
4345 lang_memory_region_type *region;
4346 struct overlay_list *l;
4347 struct lang_nocrossref *nocrossref;
4348
4349 if (memspec == NULL)
4350 region = NULL;
4351 else
4352 region = lang_memory_region_lookup (memspec);
4353
4354 nocrossref = NULL;
4355
4356 l = overlay_list;
4357 while (l != NULL)
4358 {
4359 struct overlay_list *next;
4360
4361 if (fill != 0 && l->os->fill == 0)
4362 l->os->fill = fill;
4363 if (region != NULL && l->os->region == NULL)
4364 l->os->region = region;
4365 if (phdrs != NULL && l->os->phdrs == NULL)
4366 l->os->phdrs = phdrs;
4367
4368 if (overlay_nocrossrefs)
4369 {
4370 struct lang_nocrossref *nc;
4371
4372 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4373 nc->name = l->os->name;
4374 nc->next = nocrossref;
4375 nocrossref = nc;
4376 }
4377
4378 next = l->next;
4379 free (l);
4380 l = next;
4381 }
4382
4383 if (nocrossref != NULL)
4384 lang_add_nocrossref (nocrossref);
4385
4386 /* Update . for the end of the overlay. */
4387 lang_add_assignment (exp_assop ('=', ".",
4388 exp_binop ('+', overlay_vma, overlay_max)));
4389
4390 overlay_vma = NULL;
4391 overlay_lma = NULL;
4392 overlay_nocrossrefs = 0;
4393 overlay_list = NULL;
4394 overlay_max = NULL;
4395}
4396\f
4397/* Version handling. This is only useful for ELF. */
4398
4399/* This global variable holds the version tree that we build. */
4400
4401struct bfd_elf_version_tree *lang_elf_version_info;
4402
4403static int
4404lang_vers_match_lang_c (expr, sym)
4405 struct bfd_elf_version_expr *expr;
4406 const char *sym;
4407{
4408 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4409 return 1;
4410 return fnmatch (expr->pattern, sym, 0) == 0;
4411}
4412
4413static int
4414lang_vers_match_lang_cplusplus (expr, sym)
4415 struct bfd_elf_version_expr *expr;
4416 const char *sym;
4417{
4418 char *alt_sym;
4419 int result;
4420
4421 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4422 return 1;
4423
4424 alt_sym = cplus_demangle(sym, /* DMGL_NO_TPARAMS */ 0);
4425 if (!alt_sym)
4426 {
4427 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4428 Should we early out false in this case? */
4429 result = fnmatch (expr->pattern, sym, 0) == 0;
4430 }
4431 else
4432 {
4433 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4434 free (alt_sym);
4435 }
4436
4437 return result;
4438}
4439
4440static int
4441lang_vers_match_lang_java (expr, sym)
4442 struct bfd_elf_version_expr *expr;
4443 const char *sym;
4444{
4445 char *alt_sym;
4446 int result;
4447
4448 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4449 return 1;
4450
4451 alt_sym = cplus_demangle(sym, DMGL_JAVA);
4452 if (!alt_sym)
4453 {
4454 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4455 Should we early out false in this case? */
4456 result = fnmatch (expr->pattern, sym, 0) == 0;
4457 }
4458 else
4459 {
4460 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4461 free (alt_sym);
4462 }
4463
4464 return result;
4465}
4466
4467/* This is called for each variable name or match expression. */
4468
4469struct bfd_elf_version_expr *
4470lang_new_vers_regex (orig, new, lang)
4471 struct bfd_elf_version_expr *orig;
4472 const char *new;
4473 const char *lang;
4474{
4475 struct bfd_elf_version_expr *ret;
4476
4477 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
4478 ret->next = orig;
4479 ret->pattern = new;
4480
4481 if (lang == NULL || strcasecmp (lang, "C") == 0)
4482 ret->match = lang_vers_match_lang_c;
4483 else if (strcasecmp (lang, "C++") == 0)
4484 ret->match = lang_vers_match_lang_cplusplus;
4485 else if (strcasecmp (lang, "Java") == 0)
4486 ret->match = lang_vers_match_lang_java;
4487 else
4488 {
4489 einfo (_("%X%P: unknown language `%s' in version information\n"),
4490 lang);
4491 ret->match = lang_vers_match_lang_c;
4492 }
4493
4494 return ret;
4495}
4496
4497/* This is called for each set of variable names and match
4498 expressions. */
4499
4500struct bfd_elf_version_tree *
4501lang_new_vers_node (globals, locals)
4502 struct bfd_elf_version_expr *globals;
4503 struct bfd_elf_version_expr *locals;
4504{
4505 struct bfd_elf_version_tree *ret;
4506
4507 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
4508 ret->next = NULL;
4509 ret->name = NULL;
4510 ret->vernum = 0;
4511 ret->globals = globals;
4512 ret->locals = locals;
4513 ret->deps = NULL;
4514 ret->name_indx = (unsigned int) -1;
4515 ret->used = 0;
4516 return ret;
4517}
4518
4519/* This static variable keeps track of version indices. */
4520
4521static int version_index;
4522
4523/* This is called when we know the name and dependencies of the
4524 version. */
4525
4526void
4527lang_register_vers_node (name, version, deps)
4528 const char *name;
4529 struct bfd_elf_version_tree *version;
4530 struct bfd_elf_version_deps *deps;
4531{
4532 struct bfd_elf_version_tree *t, **pp;
4533 struct bfd_elf_version_expr *e1;
4534
4535 /* Make sure this node has a unique name. */
4536 for (t = lang_elf_version_info; t != NULL; t = t->next)
4537 if (strcmp (t->name, name) == 0)
4538 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
4539
4540 /* Check the global and local match names, and make sure there
4541 aren't any duplicates. */
4542
4543 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
4544 {
4545 for (t = lang_elf_version_info; t != NULL; t = t->next)
4546 {
4547 struct bfd_elf_version_expr *e2;
4548
4549 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
4550 if (strcmp (e1->pattern, e2->pattern) == 0)
4551 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4552 e1->pattern);
4553 }
4554 }
4555
4556 for (e1 = version->locals; e1 != NULL; e1 = e1->next)
4557 {
4558 for (t = lang_elf_version_info; t != NULL; t = t->next)
4559 {
4560 struct bfd_elf_version_expr *e2;
4561
4562 for (e2 = t->globals; e2 != NULL; e2 = e2->next)
4563 if (strcmp (e1->pattern, e2->pattern) == 0)
4564 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4565 e1->pattern);
4566 }
4567 }
4568
4569 version->deps = deps;
4570 version->name = name;
4571 ++version_index;
4572 version->vernum = version_index;
4573
4574 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
4575 ;
4576 *pp = version;
4577}
4578
4579/* This is called when we see a version dependency. */
4580
4581struct bfd_elf_version_deps *
4582lang_add_vers_depend (list, name)
4583 struct bfd_elf_version_deps *list;
4584 const char *name;
4585{
4586 struct bfd_elf_version_deps *ret;
4587 struct bfd_elf_version_tree *t;
4588
4589 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
4590 ret->next = list;
4591
4592 for (t = lang_elf_version_info; t != NULL; t = t->next)
4593 {
4594 if (strcmp (t->name, name) == 0)
4595 {
4596 ret->version_needed = t;
4597 return ret;
4598 }
4599 }
4600
4601 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
4602
4603 return ret;
4604}
4605
4606static void
4607lang_do_version_exports_section ()
4608{
4609 struct bfd_elf_version_expr *greg = NULL, *lreg;
4610
4611 LANG_FOR_EACH_INPUT_STATEMENT (is)
4612 {
4613 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
4614 char *contents, *p;
4615 bfd_size_type len;
4616
4617 if (sec == NULL)
4618 continue;
4619
4620 len = bfd_section_size (is->the_bfd, sec);
4621 contents = xmalloc (len);
4622 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
4623 einfo (_("%X%P: unable to read .exports section contents"), sec);
4624
4625 p = contents;
4626 while (p < contents+len)
4627 {
4628 greg = lang_new_vers_regex (greg, p, NULL);
4629 p = strchr (p, '\0') + 1;
4630 }
4631
4632 /* Do not free the contents, as we used them creating the regex. */
4633
4634 /* Do not include this section in the link. */
4635 bfd_set_section_flags (is->the_bfd, sec,
4636 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
4637 }
4638
4639 lreg = lang_new_vers_regex (NULL, "*", NULL);
4640 lang_register_vers_node (command_line.version_exports_section,
4641 lang_new_vers_node (greg, lreg), NULL);
4642}
GDB Binutils - Deliverables
This page took 0.207916 seconds and 4 git commands to generate.