projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elfxx-target.h (elfNN_bed): Add elf_backend_want_dynbss.
[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
1108 if (section->alignment_power > output->bfd_section->alignment_power)
1109 output->bfd_section->alignment_power = section->alignment_power;
1110
1111 /* If supplied an aligment, then force it. */
1112 if (output->section_alignment != -1)
1113 output->bfd_section->alignment_power = output->section_alignment;
1114 }
1115}
1116
1117/* Handle wildcard sorting. This returns the lang_input_section which
1118 should follow the one we are going to create for SECTION and FILE,
1119 based on the sorting requirements of WILD. It returns NULL if the
1120 new section should just go at the end of the current list. */
1121
1122static lang_statement_union_type *
1123wild_sort (wild, file, section)
1124 lang_wild_statement_type *wild;
1125 lang_input_statement_type *file;
1126 asection *section;
1127{
1128 const char *section_name;
1129 lang_statement_union_type *l;
1130
1131 if (! wild->filenames_sorted && ! wild->sections_sorted)
1132 return NULL;
1133
1134 section_name = bfd_get_section_name (file->the_bfd, section);
1135 for (l = wild->children.head; l != NULL; l = l->next)
1136 {
1137 lang_input_section_type *ls;
1138
1139 if (l->header.type != lang_input_section_enum)
1140 continue;
1141 ls = &l->input_section;
1142
1143 /* Sorting by filename takes precedence over sorting by section
1144 name. */
1145
1146 if (wild->filenames_sorted)
1147 {
1148 const char *fn, *ln;
1149 boolean fa, la;
1150 int i;
1151
1152 /* The PE support for the .idata section as generated by
1153 dlltool assumes that files will be sorted by the name of
1154 the archive and then the name of the file within the
1155 archive. */
1156
1157 if (file->the_bfd != NULL
1158 && bfd_my_archive (file->the_bfd) != NULL)
1159 {
1160 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1161 fa = true;
1162 }
1163 else
1164 {
1165 fn = file->filename;
1166 fa = false;
1167 }
1168
1169 if (ls->ifile->the_bfd != NULL
1170 && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1171 {
1172 ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1173 la = true;
1174 }
1175 else
1176 {
1177 ln = ls->ifile->filename;
1178 la = false;
1179 }
1180
1181 i = strcmp (fn, ln);
1182 if (i > 0)
1183 continue;
1184 else if (i < 0)
1185 break;
1186
1187 if (fa || la)
1188 {
1189 if (fa)
1190 fn = file->filename;
1191 if (la)
1192 ln = ls->ifile->filename;
1193
1194 i = strcmp (fn, ln);
1195 if (i > 0)
1196 continue;
1197 else if (i < 0)
1198 break;
1199 }
1200 }
1201
1202 /* Here either the files are not sorted by name, or we are
1203 looking at the sections for this file. */
1204
1205 if (wild->sections_sorted)
1206 {
1207 if (strcmp (section_name,
1208 bfd_get_section_name (ls->ifile->the_bfd,
1209 ls->section))
1210 < 0)
1211 break;
1212 }
1213 }
1214
1215 return l;
1216}
1217
1218/* Expand a wild statement for a particular FILE. SECTION may be
1219 NULL, in which case it is a wild card. */
1220
1221static void
4dec4d4e 1222output_section_callback (ptr, section, file, output)
252b5132 1223 lang_wild_statement_type *ptr;
4dec4d4e 1224 asection *section;
252b5132 1225 lang_input_statement_type *file;
4dec4d4e
RH		 1226 void *output;
1227{
1228 lang_statement_union_type *before;
1229
1230 /* If the wild pattern was marked KEEP, the member sections
1231 should be as well. */
1232 if (ptr->keep_sections)
1233 section->flags |= SEC_KEEP;
1234
1235 before = wild_sort (ptr, file, section);
1236
1237 /* Here BEFORE points to the lang_input_section which
1238 should follow the one we are about to add. If BEFORE
1239 is NULL, then the section should just go at the end
1240 of the current list. */
1241
1242 if (before == NULL)
1243 wild_doit (&ptr->children, section,
1244 (lang_output_section_statement_type *) output,
1245 file);
1246 else
252b5132 1247 {
4dec4d4e
RH		 1248 lang_statement_list_type list;
1249 lang_statement_union_type **pp;
1250
1251 lang_list_init (&list);
1252 wild_doit (&list, section,
1253 (lang_output_section_statement_type *) output,
1254 file);
1255
1256 /* If we are discarding the section, LIST.HEAD will
1257 be NULL. */
1258 if (list.head != NULL)
252b5132 1259 {
4dec4d4e
RH		 1260 ASSERT (list.head->next == NULL);
1261
1262 for (pp = &ptr->children.head;
1263 *pp != before;
1264 pp = &(*pp)->next)
1265 ASSERT (*pp != NULL);
1266
1267 list.head->next = *pp;
1268 *pp = list.head;
252b5132
RH		 1269 }
1270 }
1271}
1272
1273/* This is passed a file name which must have been seen already and
1274 added to the statement tree. We will see if it has been opened
1275 already and had its symbols read. If not then we'll read it. */
1276
1277static lang_input_statement_type *
1278lookup_name (name)
1279 const char *name;
1280{
1281 lang_input_statement_type *search;
1282
1283 for (search = (lang_input_statement_type *) input_file_chain.head;
1284 search != (lang_input_statement_type *) NULL;
1285 search = (lang_input_statement_type *) search->next_real_file)
1286 {
1287 if (search->filename == (char *) NULL && name == (char *) NULL)
1288 return search;
1289 if (search->filename != (char *) NULL
1290 && name != (char *) NULL
1291 && strcmp (search->filename, name) == 0)
1292 break;
1293 }
1294
1295 if (search == (lang_input_statement_type *) NULL)
1296 search = new_afile (name, lang_input_file_is_file_enum, default_target,
1297 false);
1298
1299 /* If we have already added this file, or this file is not real
1300 (FIXME: can that ever actually happen?) or the name is NULL
1301 (FIXME: can that ever actually happen?) don't add this file. */
1302 if (search->loaded
1303 || ! search->real
1304 || search->filename == (const char *) NULL)
1305 return search;
1306
1307 load_symbols (search, (lang_statement_list_type *) NULL);
1308
1309 return search;
1310}
1311
1312/* Get the symbols for an input file. */
1313
1314static void
1315load_symbols (entry, place)
1316 lang_input_statement_type *entry;
1317 lang_statement_list_type *place;
1318{
1319 char **matching;
1320
1321 if (entry->loaded)
1322 return;
1323
1324 ldfile_open_file (entry);
1325
1326 if (! bfd_check_format (entry->the_bfd, bfd_archive)
1327 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1328 {
1329 bfd_error_type err;
1330 lang_statement_list_type *hold;
1331
1332 err = bfd_get_error ();
1333 if (err == bfd_error_file_ambiguously_recognized)
1334 {
1335 char **p;
1336
1337 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1338 einfo (_("%B: matching formats:"), entry->the_bfd);
1339 for (p = matching; *p != NULL; p++)
1340 einfo (" %s", *p);
1341 einfo ("%F\n");
1342 }
1343 else if (err != bfd_error_file_not_recognized
1344 || place == NULL)
1345 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1346
1347 bfd_close (entry->the_bfd);
1348 entry->the_bfd = NULL;
1349
1350 /* See if the emulation has some special knowledge. */
1351
1352 if (ldemul_unrecognized_file (entry))
1353 return;
1354
1355 /* Try to interpret the file as a linker script. */
1356
1357 ldfile_open_command_file (entry->filename);
1358
1359 hold = stat_ptr;
1360 stat_ptr = place;
1361
1362 ldfile_assumed_script = true;
1363 parser_input = input_script;
1364 yyparse ();
1365 ldfile_assumed_script = false;
1366
1367 stat_ptr = hold;
1368
1369 return;
1370 }
1371
1372 if (ldemul_recognized_file (entry))
1373 return;
1374
1375 /* We don't call ldlang_add_file for an archive. Instead, the
1376 add_symbols entry point will call ldlang_add_file, via the
1377 add_archive_element callback, for each element of the archive
1378 which is used. */
1379 switch (bfd_get_format (entry->the_bfd))
1380 {
1381 default:
1382 break;
1383
1384 case bfd_object:
1385 ldlang_add_file (entry);
1386 if (trace_files || trace_file_tries)
1387 info_msg ("%I\n", entry);
1388 break;
1389
1390 case bfd_archive:
1391 if (entry->whole_archive)
1392 {
1393 bfd *member = bfd_openr_next_archived_file (entry->the_bfd,
1394 (bfd *) NULL);
1395 while (member != NULL)
1396 {
1397 if (! bfd_check_format (member, bfd_object))
1398 einfo (_("%F%B: object %B in archive is not object\n"),
1399 entry->the_bfd, member);
1400 if (! ((*link_info.callbacks->add_archive_element)
1401 (&link_info, member, "--whole-archive")))
1402 abort ();
1403 if (! bfd_link_add_symbols (member, &link_info))
1404 einfo (_("%F%B: could not read symbols: %E\n"), member);
1405 member = bfd_openr_next_archived_file (entry->the_bfd,
1406 member);
1407 }
1408
1409 entry->loaded = true;
1410
1411 return;
1412 }
1413 }
1414
1415 if (! bfd_link_add_symbols (entry->the_bfd, &link_info))
1416 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1417
1418 entry->loaded = true;
1419}
1420
4dec4d4e 1421
252b5132
RH		 1422
1423/* Handle a wild statement. SECTION or FILE or both may be NULL,
1424 indicating that it is a wildcard. Separate lang_input_section
1425 statements are created for each part of the expansion; they are
1426 added after the wild statement S. OUTPUT is the output section. */
1427
1428static void
1429wild (s, section, file, target, output)
1430 lang_wild_statement_type *s;
1431 const char *section;
1432 const char *file;
87f2a346 1433 const char *target ATTRIBUTE_UNUSED;
252b5132
RH		 1434 lang_output_section_statement_type *output;
1435{
4dec4d4e 1436 walk_wild (s, section, file, output_section_callback, (void *) output);
252b5132
RH		 1437
1438 if (section != (char *) NULL
1439 && strcmp (section, "COMMON") == 0
1440 && default_common_section == NULL)
1441 {
1442 /* Remember the section that common is going to in case we later
1443 get something which doesn't know where to put it. */
1444 default_common_section = output;
1445 }
1446}
1447
1448/* Open the output file. */
1449
1450static bfd *
1451open_output (name)
1452 const char *name;
1453{
1454 bfd *output;
1455
1456 if (output_target == (char *) NULL)
1457 {
1458 if (current_target != (char *) NULL)
1459 output_target = current_target;
1460 else
1461 output_target = default_target;
1462 }
1463 output = bfd_openw (name, output_target);
1464
1465 if (output == (bfd *) NULL)
1466 {
1467 if (bfd_get_error () == bfd_error_invalid_target)
1468 {
1469 einfo (_("%P%F: target %s not found\n"), output_target);
1470 }
1471 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1472 }
1473
1474 delete_output_file_on_failure = true;
1475
1476 /* output->flags |= D_PAGED;*/
1477
1478 if (! bfd_set_format (output, bfd_object))
1479 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1480 if (! bfd_set_arch_mach (output,
1481 ldfile_output_architecture,
1482 ldfile_output_machine))
1483 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1484
1485 link_info.hash = bfd_link_hash_table_create (output);
1486 if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1487 einfo (_("%P%F: can not create link hash table: %E\n"));
1488
1489 bfd_set_gp_size (output, g_switch_value);
1490 return output;
1491}
1492
1493
1494
1495
1496static void
1497ldlang_open_output (statement)
1498 lang_statement_union_type * statement;
1499{
1500 switch (statement->header.type)
1501 {
1502 case lang_output_statement_enum:
1503 ASSERT (output_bfd == (bfd *) NULL);
1504 output_bfd = open_output (statement->output_statement.name);
1505 ldemul_set_output_arch ();
1506 if (config.magic_demand_paged && !link_info.relocateable)
1507 output_bfd->flags |= D_PAGED;
1508 else
1509 output_bfd->flags &= ~D_PAGED;
1510 if (config.text_read_only)
1511 output_bfd->flags |= WP_TEXT;
1512 else
1513 output_bfd->flags &= ~WP_TEXT;
1514 if (link_info.traditional_format)
1515 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1516 else
1517 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1518 break;
1519
1520 case lang_target_statement_enum:
1521 current_target = statement->target_statement.target;
1522 break;
1523 default:
1524 break;
1525 }
1526}
1527
1528/* Open all the input files. */
1529
1530static void
1531open_input_bfds (s, force)
1532 lang_statement_union_type *s;
1533 boolean force;
1534{
1535 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1536 {
1537 switch (s->header.type)
1538 {
1539 case lang_constructors_statement_enum:
1540 open_input_bfds (constructor_list.head, force);
1541 break;
1542 case lang_output_section_statement_enum:
1543 open_input_bfds (s->output_section_statement.children.head, force);
1544 break;
1545 case lang_wild_statement_enum:
1546 /* Maybe we should load the file's symbols */
1547 if (s->wild_statement.filename
1548 && ! wildcardp (s->wild_statement.filename))
1549 (void) lookup_name (s->wild_statement.filename);
1550 open_input_bfds (s->wild_statement.children.head, force);
1551 break;
1552 case lang_group_statement_enum:
1553 {
1554 struct bfd_link_hash_entry *undefs;
1555
1556 /* We must continually search the entries in the group
1557 until no new symbols are added to the list of undefined
1558 symbols. */
1559
1560 do
1561 {
1562 undefs = link_info.hash->undefs_tail;
1563 open_input_bfds (s->group_statement.children.head, true);
1564 }
1565 while (undefs != link_info.hash->undefs_tail);
1566 }
1567 break;
1568 case lang_target_statement_enum:
1569 current_target = s->target_statement.target;
1570 break;
1571 case lang_input_statement_enum:
1572 if (s->input_statement.real == true)
1573 {
1574 lang_statement_list_type add;
1575
1576 s->input_statement.target = current_target;
1577
1578 /* If we are being called from within a group, and this
1579 is an archive which has already been searched, then
1580 force it to be researched. */
1581 if (force
1582 && s->input_statement.loaded
1583 && bfd_check_format (s->input_statement.the_bfd,
1584 bfd_archive))
1585 s->input_statement.loaded = false;
1586
1587 lang_list_init (&add);
1588
1589 load_symbols (&s->input_statement, &add);
1590
1591 if (add.head != NULL)
1592 {
1593 *add.tail = s->next;
1594 s->next = add.head;
1595 }
1596 }
1597 break;
1598 default:
1599 break;
1600 }
1601 }
1602}
1603
1604/* If there are [COMMONS] statements, put a wild one into the bss section */
1605
1606static void
1607lang_reasonable_defaults ()
1608{
1609#if 0
1610 lang_output_section_statement_lookup (".text");
1611 lang_output_section_statement_lookup (".data");
1612
1613 default_common_section =
1614 lang_output_section_statement_lookup (".bss");
1615
1616
1617 if (placed_commons == false)
1618 {
1619 lang_wild_statement_type *new =
1620 new_stat (lang_wild_statement,
1621 &default_common_section->children);
1622
1623 new->section_name = "COMMON";
1624 new->filename = (char *) NULL;
1625 lang_list_init (&new->children);
1626 }
1627#endif
1628
1629}
1630
1631/*
1632 Add the supplied name to the symbol table as an undefined reference.
1633 Remove items from the chain as we open input bfds
1634 */
1635typedef struct ldlang_undef_chain_list
1636{
1637 struct ldlang_undef_chain_list *next;
1638 char *name;
1639} ldlang_undef_chain_list_type;
1640
1641static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
1642
1643void
1644ldlang_add_undef (name)
1645 CONST char *CONST name;
1646{
1647 ldlang_undef_chain_list_type *new =
1648 ((ldlang_undef_chain_list_type *)
1649 stat_alloc (sizeof (ldlang_undef_chain_list_type)));
1650
1651 new->next = ldlang_undef_chain_list_head;
1652 ldlang_undef_chain_list_head = new;
1653
1654 new->name = buystring (name);
1655}
1656
1657/* Run through the list of undefineds created above and place them
1658 into the linker hash table as undefined symbols belonging to the
1659 script file.
1660*/
1661static void
1662lang_place_undefineds ()
1663{
1664 ldlang_undef_chain_list_type *ptr;
1665
1666 for (ptr = ldlang_undef_chain_list_head;
1667 ptr != (ldlang_undef_chain_list_type *) NULL;
1668 ptr = ptr->next)
1669 {
1670 struct bfd_link_hash_entry *h;
1671
1672 h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
1673 if (h == (struct bfd_link_hash_entry *) NULL)
1674 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1675 if (h->type == bfd_link_hash_new)
1676 {
1677 h->type = bfd_link_hash_undefined;
1678 h->u.undef.abfd = NULL;
1679 bfd_link_add_undef (link_info.hash, h);
1680 }
1681 }
1682}
1683
1684/* Open input files and attatch to output sections */
1685static void
1686map_input_to_output_sections (s, target, output_section_statement)
1687 lang_statement_union_type * s;
1688 CONST char *target;
1689 lang_output_section_statement_type * output_section_statement;
1690{
1691 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1692 {
1693 switch (s->header.type)
1694 {
1695
1696
1697 case lang_wild_statement_enum:
1698 wild (&s->wild_statement, s->wild_statement.section_name,
1699 s->wild_statement.filename, target,
1700 output_section_statement);
1701
1702 break;
1703 case lang_constructors_statement_enum:
1704 map_input_to_output_sections (constructor_list.head,
1705 target,
1706 output_section_statement);
1707 break;
1708 case lang_output_section_statement_enum:
1709 map_input_to_output_sections (s->output_section_statement.children.head,
1710 target,
1711 &s->output_section_statement);
1712 break;
1713 case lang_output_statement_enum:
1714 break;
1715 case lang_target_statement_enum:
1716 target = s->target_statement.target;
1717 break;
1718 case lang_group_statement_enum:
1719 map_input_to_output_sections (s->group_statement.children.head,
1720 target,
1721 output_section_statement);
1722 break;
1723 case lang_fill_statement_enum:
1724 case lang_input_section_enum:
1725 case lang_object_symbols_statement_enum:
1726 case lang_data_statement_enum:
1727 case lang_reloc_statement_enum:
1728 case lang_padding_statement_enum:
1729 case lang_input_statement_enum:
1730 if (output_section_statement != NULL
1731 && output_section_statement->bfd_section == NULL)
1732 init_os (output_section_statement);
1733 break;
1734 case lang_assignment_statement_enum:
1735 if (output_section_statement != NULL
1736 && output_section_statement->bfd_section == NULL)
1737 init_os (output_section_statement);
1738
1739 /* Make sure that any sections mentioned in the assignment
1740 are initialized. */
1741 exp_init_os (s->assignment_statement.exp);
1742 break;
1743 case lang_afile_asection_pair_statement_enum:
1744 FAIL ();
1745 break;
1746 case lang_address_statement_enum:
1747 /* Mark the specified section with the supplied address */
1748 {
1749 lang_output_section_statement_type *os =
1750 lang_output_section_statement_lookup
1751 (s->address_statement.section_name);
1752
1753 if (os->bfd_section == NULL)
1754 init_os (os);
1755 os->addr_tree = s->address_statement.address;
1756 }
1757 break;
1758 }
1759 }
1760}
1761
1762static void
1763print_output_section_statement (output_section_statement)
1764 lang_output_section_statement_type * output_section_statement;
1765{
1766 asection *section = output_section_statement->bfd_section;
1767 int len;
1768
1769 if (output_section_statement != abs_output_section)
1770 {
1771 minfo ("\n%s", output_section_statement->name);
1772
1773 if (section != NULL)
1774 {
1775 print_dot = section->vma;
1776
1777 len = strlen (output_section_statement->name);
1778 if (len >= SECTION_NAME_MAP_LENGTH - 1)
1779 {
1780 print_nl ();
1781 len = 0;
1782 }
1783 while (len < SECTION_NAME_MAP_LENGTH)
1784 {
1785 print_space ();
1786 ++len;
1787 }
1788
1789 minfo ("0x%V %W", section->vma, section->_raw_size);
1790
1791 if (output_section_statement->load_base != NULL)
1792 {
1793 bfd_vma addr;
1794
1795 addr = exp_get_abs_int (output_section_statement->load_base, 0,
1796 "load base", lang_final_phase_enum);
1797 minfo (_(" load address 0x%V"), addr);
1798 }
1799 }
1800
1801 print_nl ();
1802 }
1803
1804 print_statement_list (output_section_statement->children.head,
1805 output_section_statement);
1806}
1807
1808static void
1809print_assignment (assignment, output_section)
1810 lang_assignment_statement_type * assignment;
1811 lang_output_section_statement_type * output_section;
1812{
1813 int i;
1814 etree_value_type result;
1815
1816 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
1817 print_space ();
1818
1819 result = exp_fold_tree (assignment->exp->assign.src, output_section,
1820 lang_final_phase_enum, print_dot, &print_dot);
1821 if (result.valid_p)
1822 minfo ("0x%V", result.value + result.section->bfd_section->vma);
1823 else
1824 {
1825 minfo ("*undef* ");
1826#ifdef BFD64
1827 minfo (" ");
1828#endif
1829 }
1830
1831 minfo (" ");
1832
1833 exp_print_tree (assignment->exp);
1834
1835 print_nl ();
1836}
1837
1838static void
1839print_input_statement (statm)
1840 lang_input_statement_type * statm;
1841{
1842 if (statm->filename != (char *) NULL)
1843 {
1844 fprintf (config.map_file, "LOAD %s\n", statm->filename);
1845 }
1846}
1847
1848/* Print all symbols defined in a particular section. This is called
1849 via bfd_link_hash_traverse. */
1850
1851static boolean
1852print_one_symbol (hash_entry, ptr)
1853 struct bfd_link_hash_entry *hash_entry;
1854 PTR ptr;
1855{
1856 asection *sec = (asection *) ptr;
1857
1858 if ((hash_entry->type == bfd_link_hash_defined
1859 || hash_entry->type == bfd_link_hash_defweak)
1860 && sec == hash_entry->u.def.section)
1861 {
1862 int i;
1863
1864 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
1865 print_space ();
1866 minfo ("0x%V ",
1867 (hash_entry->u.def.value
1868 + hash_entry->u.def.section->output_offset
1869 + hash_entry->u.def.section->output_section->vma));
1870
1871 minfo (" %T\n", hash_entry->root.string);
1872 }
1873
1874 return true;
1875}
1876
1877/* Print information about an input section to the map file. */
1878
1879static void
1880print_input_section (in)
1881 lang_input_section_type * in;
1882{
1883 asection *i = in->section;
1884 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
1885
1886 if (size != 0)
1887 {
1888 print_space ();
1889
1890 minfo ("%s", i->name);
1891
1892 if (i->output_section != NULL)
1893 {
1894 int len;
1895
1896 len = 1 + strlen (i->name);
1897 if (len >= SECTION_NAME_MAP_LENGTH - 1)
1898 {
1899 print_nl ();
1900 len = 0;
1901 }
1902 while (len < SECTION_NAME_MAP_LENGTH)
1903 {
1904 print_space ();
1905 ++len;
1906 }
1907
1908 minfo ("0x%V %W %B\n",
1909 i->output_section->vma + i->output_offset, size,
1910 i->owner);
1911
1912 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
1913 {
1914 len = SECTION_NAME_MAP_LENGTH + 3;
1915#ifdef BFD64
1916 len += 16;
1917#else
1918 len += 8;
1919#endif
1920 while (len > 0)
1921 {
1922 print_space ();
1923 --len;
1924 }
1925
1926 minfo (_("%W (size before relaxing)\n"), i->_raw_size);
1927 }
1928
1929 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
1930
1931 print_dot = i->output_section->vma + i->output_offset + size;
1932 }
1933 }
1934}
1935
1936static void
1937print_fill_statement (fill)
1938 lang_fill_statement_type * fill;
1939{
1940 fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill);
1941}
1942
1943static void
1944print_data_statement (data)
1945 lang_data_statement_type * data;
1946{
1947 int i;
1948 bfd_vma addr;
1949 bfd_size_type size;
1950 const char *name;
1951
1952 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
1953 print_space ();
1954
1955 addr = data->output_vma;
1956 if (data->output_section != NULL)
1957 addr += data->output_section->vma;
1958
1959 switch (data->type)
1960 {
1961 default:
1962 abort ();
1963 case BYTE:
1964 size = BYTE_SIZE;
1965 name = "BYTE";
1966 break;
1967 case SHORT:
1968 size = SHORT_SIZE;
1969 name = "SHORT";
1970 break;
1971 case LONG:
1972 size = LONG_SIZE;
1973 name = "LONG";
1974 break;
1975 case QUAD:
1976 size = QUAD_SIZE;
1977 name = "QUAD";
1978 break;
1979 case SQUAD:
1980 size = QUAD_SIZE;
1981 name = "SQUAD";
1982 break;
1983 }
1984
1985 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
1986
1987 if (data->exp->type.node_class != etree_value)
1988 {
1989 print_space ();
1990 exp_print_tree (data->exp);
1991 }
1992
1993 print_nl ();
1994
1995 print_dot = addr + size;
1996}
1997
1998/* Print an address statement. These are generated by options like
1999 -Ttext. */
2000
2001static void
2002print_address_statement (address)
2003 lang_address_statement_type *address;
2004{
2005 minfo (_("Address of section %s set to "), address->section_name);
2006 exp_print_tree (address->address);
2007 print_nl ();
2008}
2009
2010/* Print a reloc statement. */
2011
2012static void
2013print_reloc_statement (reloc)
2014 lang_reloc_statement_type *reloc;
2015{
2016 int i;
2017 bfd_vma addr;
2018 bfd_size_type size;
2019
2020 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2021 print_space ();
2022
2023 addr = reloc->output_vma;
2024 if (reloc->output_section != NULL)
2025 addr += reloc->output_section->vma;
2026
2027 size = bfd_get_reloc_size (reloc->howto);
2028
2029 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2030
2031 if (reloc->name != NULL)
2032 minfo ("%s+", reloc->name);
2033 else
2034 minfo ("%s+", reloc->section->name);
2035
2036 exp_print_tree (reloc->addend_exp);
2037
2038 print_nl ();
2039
2040 print_dot = addr + size;
2041}
2042
2043static void
2044print_padding_statement (s)
2045 lang_padding_statement_type *s;
2046{
2047 int len;
2048 bfd_vma addr;
2049
2050 minfo (" *fill*");
2051
2052 len = sizeof " *fill*" - 1;
2053 while (len < SECTION_NAME_MAP_LENGTH)
2054 {
2055 print_space ();
2056 ++len;
2057 }
2058
2059 addr = s->output_offset;
2060 if (s->output_section != NULL)
2061 addr += s->output_section->vma;
2062 minfo ("0x%V %W", addr, s->size);
2063
2064 if (s->fill != 0)
2065 minfo (" %u", s->fill);
2066
2067 print_nl ();
2068
2069 print_dot = addr + s->size;
2070}
2071
2072static void
2073print_wild_statement (w, os)
2074 lang_wild_statement_type * w;
2075 lang_output_section_statement_type * os;
2076{
2077 print_space ();
2078
2079 if (w->filenames_sorted)
2080 minfo ("SORT(");
2081 if (w->exclude_filename != NULL)
2082 minfo ("EXCLUDE_FILE ( %s )", w->exclude_filename);
2083 if (w->filename != NULL)
2084 minfo ("%s", w->filename);
2085 else
2086 minfo ("*");
2087 if (w->filenames_sorted)
2088 minfo (")");
2089
2090 minfo ("(");
2091 if (w->sections_sorted)
2092 minfo ("SORT(");
2093 if (w->section_name != NULL)
2094 minfo ("%s", w->section_name);
2095 else
2096 minfo ("*");
2097 if (w->sections_sorted)
2098 minfo (")");
2099 minfo (")");
2100
2101 print_nl ();
2102
2103 print_statement_list (w->children.head, os);
2104}
2105
2106/* Print a group statement. */
2107
2108static void
2109print_group (s, os)
2110 lang_group_statement_type *s;
2111 lang_output_section_statement_type *os;
2112{
2113 fprintf (config.map_file, "START GROUP\n");
2114 print_statement_list (s->children.head, os);
2115 fprintf (config.map_file, "END GROUP\n");
2116}
2117
2118/* Print the list of statements in S.
2119 This can be called for any statement type. */
2120
2121static void
2122print_statement_list (s, os)
2123 lang_statement_union_type *s;
2124 lang_output_section_statement_type *os;
2125{
2126 while (s != NULL)
2127 {
2128 print_statement (s, os);
2129 s = s->next;
2130 }
2131}
2132
2133/* Print the first statement in statement list S.
2134 This can be called for any statement type. */
2135
2136static void
2137print_statement (s, os)
2138 lang_statement_union_type *s;
2139 lang_output_section_statement_type *os;
2140{
2141 switch (s->header.type)
2142 {
2143 default:
2144 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2145 FAIL ();
2146 break;
2147 case lang_constructors_statement_enum:
2148 if (constructor_list.head != NULL)
2149 {
2150 if (constructors_sorted)
2151 minfo (" SORT (CONSTRUCTORS)\n");
2152 else
2153 minfo (" CONSTRUCTORS\n");
2154 print_statement_list (constructor_list.head, os);
2155 }
2156 break;
2157 case lang_wild_statement_enum:
2158 print_wild_statement (&s->wild_statement, os);
2159 break;
2160 case lang_address_statement_enum:
2161 print_address_statement (&s->address_statement);
2162 break;
2163 case lang_object_symbols_statement_enum:
2164 minfo (" CREATE_OBJECT_SYMBOLS\n");
2165 break;
2166 case lang_fill_statement_enum:
2167 print_fill_statement (&s->fill_statement);
2168 break;
2169 case lang_data_statement_enum:
2170 print_data_statement (&s->data_statement);
2171 break;
2172 case lang_reloc_statement_enum:
2173 print_reloc_statement (&s->reloc_statement);
2174 break;
2175 case lang_input_section_enum:
2176 print_input_section (&s->input_section);
2177 break;
2178 case lang_padding_statement_enum:
2179 print_padding_statement (&s->padding_statement);
2180 break;
2181 case lang_output_section_statement_enum:
2182 print_output_section_statement (&s->output_section_statement);
2183 break;
2184 case lang_assignment_statement_enum:
2185 print_assignment (&s->assignment_statement, os);
2186 break;
2187 case lang_target_statement_enum:
2188 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2189 break;
2190 case lang_output_statement_enum:
2191 minfo ("OUTPUT(%s", s->output_statement.name);
2192 if (output_target != NULL)
2193 minfo (" %s", output_target);
2194 minfo (")\n");
2195 break;
2196 case lang_input_statement_enum:
2197 print_input_statement (&s->input_statement);
2198 break;
2199 case lang_group_statement_enum:
2200 print_group (&s->group_statement, os);
2201 break;
2202 case lang_afile_asection_pair_statement_enum:
2203 FAIL ();
2204 break;
2205 }
2206}
2207
2208static void
2209print_statements ()
2210{
2211 print_statement_list (statement_list.head, abs_output_section);
2212}
2213
2214/* Print the first N statements in statement list S to STDERR.
2215 If N == 0, nothing is printed.
2216 If N < 0, the entire list is printed.
2217 Intended to be called from GDB. */
2218
2219void
2220dprint_statement (s, n)
2221 lang_statement_union_type * s;
2222 int n;
2223{
2224 FILE *map_save = config.map_file;
2225
2226 config.map_file = stderr;
2227
2228 if (n < 0)
2229 print_statement_list (s, abs_output_section);
2230 else
2231 {
2232 while (s && --n >= 0)
2233 {
2234 print_statement (s, abs_output_section);
2235 s = s->next;
2236 }
2237 }
2238
2239 config.map_file = map_save;
2240}
2241
2242static bfd_vma
2243insert_pad (this_ptr, fill, power, output_section_statement, dot)
2244 lang_statement_union_type ** this_ptr;
2245 fill_type fill;
2246 unsigned int power;
2247 asection * output_section_statement;
2248 bfd_vma dot;
2249{
2250 /* Align this section first to the
2251 input sections requirement, then
2252 to the output section's requirement.
2253 If this alignment is > than any seen before,
2254 then record it too. Perform the alignment by
2255 inserting a magic 'padding' statement.
2256 */
2257
2258 unsigned int alignment_needed = align_power (dot, power) - dot;
2259
2260 if (alignment_needed != 0)
2261 {
2262 lang_statement_union_type *new =
2263 ((lang_statement_union_type *)
2264 stat_alloc (sizeof (lang_padding_statement_type)));
2265
2266 /* Link into existing chain */
2267 new->header.next = *this_ptr;
2268 *this_ptr = new;
2269 new->header.type = lang_padding_statement_enum;
2270 new->padding_statement.output_section = output_section_statement;
2271 new->padding_statement.output_offset =
2272 dot - output_section_statement->vma;
2273 new->padding_statement.fill = fill;
2274 new->padding_statement.size = alignment_needed;
2275 }
2276
2277
2278 /* Remember the most restrictive alignment */
2279 if (power > output_section_statement->alignment_power)
2280 {
2281 output_section_statement->alignment_power = power;
2282 }
2283 output_section_statement->_raw_size += alignment_needed;
2284 return alignment_needed + dot;
2285
2286}
2287
2288/* Work out how much this section will move the dot point */
2289static bfd_vma
2290size_input_section (this_ptr, output_section_statement, fill, dot, relax)
2291 lang_statement_union_type ** this_ptr;
2292 lang_output_section_statement_type * output_section_statement;
2293 fill_type fill;
2294 bfd_vma dot;
87f2a346 2295 boolean relax ATTRIBUTE_UNUSED;
252b5132
RH		 2296{
2297 lang_input_section_type *is = &((*this_ptr)->input_section);
2298 asection *i = is->section;
2299
2300 if (is->ifile->just_syms_flag == false)
2301 {
2302 if (output_section_statement->subsection_alignment != -1)
2303 i->alignment_power =
2304 output_section_statement->subsection_alignment;
2305
2306 dot = insert_pad (this_ptr, fill, i->alignment_power,
2307 output_section_statement->bfd_section, dot);
2308
2309 /* Remember where in the output section this input section goes */
2310
2311 i->output_offset = dot - output_section_statement->bfd_section->vma;
2312
2313 /* Mark how big the output section must be to contain this now
2314 */
2315 if (i->_cooked_size != 0)
2316 dot += i->_cooked_size;
2317 else
2318 dot += i->_raw_size;
2319 output_section_statement->bfd_section->_raw_size = dot - output_section_statement->bfd_section->vma;
2320 }
2321 else
2322 {
2323 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2324 }
2325
2326 return dot;
2327}
2328
2329/* Check to see if any allocated sections overlap with other allocated
2330 sections. This can happen when the linker script specifically specifies
2331 the output section addresses of the two sections. */
2332static void
2333lang_check_section_addresses ()
2334{
2335 asection * s;
2336
2337 /* Scan all sections in the output list. */
2338 for (s = output_bfd->sections; s != NULL; s = s->next)
2339 /* Ignore sections which are not loaded or which have no contents. */
2340 if ((bfd_get_section_flags (output_bfd, s) & (SEC_ALLOC | SEC_LOAD))
2341 && bfd_section_size (output_bfd, s) != 0)
2342 {
2343 asection * os;
2344
2345 /* Once we reach section 's' stop our seach. This prevents two
2346 warning messages from being produced, one for 'section A overlaps
2347 section B' and one for 'section B overlaps section A'. */
2348 for (os = output_bfd->sections; os != s; os = os->next)
2349 {
2350 bfd_vma s_start;
2351 bfd_vma s_end;
2352 bfd_vma os_start;
2353 bfd_vma os_end;
2354
2355 /* Only consider loadable sections with real contents. */
2356 if (((bfd_get_section_flags (output_bfd, os)
2357 & (SEC_ALLOC | SEC_LOAD)) == 0)
2358 || bfd_section_size (output_bfd, os) == 0)
2359 continue;
2360
2361 /* We must check the sections' LMA addresses not their
2362 VMA addresses because overlay sections can have
2363 overlapping VMAs but they must have distinct LMAs. */
2364 s_start = bfd_section_lma (output_bfd, s);
2365 os_start = bfd_section_lma (output_bfd, os);
2366 s_end = s_start + bfd_section_size (output_bfd, s) - 1;
2367 os_end = os_start + bfd_section_size (output_bfd, os) - 1;
2368
2369 /* Look for an overlap. */
2370 if ((s_end < os_start) || (s_start > os_end))
2371 continue;
2372
2373 einfo (
2374_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2375 s->name, s_start, s_end, os->name, os_start, os_end);
2376
2377 /* Once we have found one overlap for this section,
2378 stop looking for others. */
2379 break;
2380 }
2381 }
2382}
2383
2384/* This variable indicates whether bfd_relax_section should be called
2385 again. */
2386
2387static boolean relax_again;
2388
2389/* Set the sizes for all the output sections. */
2390
2391bfd_vma
2392lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
2393 lang_statement_union_type * s;
2394 lang_output_section_statement_type * output_section_statement;
2395 lang_statement_union_type ** prev;
2396 fill_type fill;
2397 bfd_vma dot;
2398 boolean relax;
2399{
2400 /* Size up the sections from their constituent parts. */
2401 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2402 {
2403 switch (s->header.type)
2404 {
2405 case lang_output_section_statement_enum:
2406 {
2407 bfd_vma after;
2408 lang_output_section_statement_type *os = &s->output_section_statement;
2409
2410 if (os->bfd_section == NULL)
2411 /* This section was never actually created. */
2412 break;
2413
2414 /* If this is a COFF shared library section, use the size and
2415 address from the input section. FIXME: This is COFF
2416 specific; it would be cleaner if there were some other way
2417 to do this, but nothing simple comes to mind. */
2418 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2419 {
2420 asection * input;
2421
2422 if (os->children.head == NULL
2423 || os->children.head->next != NULL
2424 || os->children.head->header.type != lang_input_section_enum)
2425 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2426 os->name);
2427
2428 input = os->children.head->input_section.section;
2429 bfd_set_section_vma (os->bfd_section->owner,
2430 os->bfd_section,
2431 bfd_section_vma (input->owner, input));
2432 os->bfd_section->_raw_size = input->_raw_size;
2433 break;
2434 }
2435
2436 if (bfd_is_abs_section (os->bfd_section))
2437 {
2438 /* No matter what happens, an abs section starts at zero. */
2439 ASSERT (os->bfd_section->vma == 0);
2440 }
2441 else
2442 {
2443 if (os->addr_tree == (etree_type *) NULL)
2444 {
2445 /* No address specified for this section, get one
2446 from the region specification. */
2447 if (os->region == (lang_memory_region_type *) NULL
2448 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2449 & (SEC_ALLOC | SEC_LOAD)) != 0)
2450 && os->region->name[0] == '*'
2451 && strcmp (os->region->name, "*default*") == 0))
2452 {
2453 os->region = lang_memory_default (os->bfd_section);
2454 }
2455
2456 /* If a loadable section is using the default memory
2457 region, and some non default memory regions were
2458 defined, issue a warning. */
2459 if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2460 & (SEC_ALLOC | SEC_LOAD)) != 0
2461 && ! link_info.relocateable
2462 && strcmp (os->region->name, "*default*") == 0
2463 && lang_memory_region_list != NULL
2464 && (strcmp (lang_memory_region_list->name, "*default*") != 0
2465 || lang_memory_region_list->next != NULL))
2466 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2467 bfd_get_section_name (output_bfd, os->bfd_section));
2468
2469 dot = os->region->current;
2470
2471 if (os->section_alignment == -1)
2472 {
2473 bfd_vma olddot;
2474
2475 olddot = dot;
2476 dot = align_power (dot, os->bfd_section->alignment_power);
2477
2478 if (dot != olddot && config.warn_section_align)
2479 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2480 os->name, (unsigned int) (dot - olddot));
2481 }
2482 }
2483 else
2484 {
2485 etree_value_type r;
2486
2487 r = exp_fold_tree (os->addr_tree,
2488 abs_output_section,
2489 lang_allocating_phase_enum,
2490 dot, &dot);
2491 if (r.valid_p == false)
2492 {
2493 einfo (_("%F%S: non constant address expression for section %s\n"),
2494 os->name);
2495 }
2496 dot = r.value + r.section->bfd_section->vma;
2497 }
2498
2499 /* The section starts here.
2500 First, align to what the section needs. */
2501
2502 if (os->section_alignment != -1)
2503 dot = align_power (dot, os->section_alignment);
2504
2505 bfd_set_section_vma (0, os->bfd_section, dot);
2506
2507 os->bfd_section->output_offset = 0;
2508 }
2509
2510 (void) lang_size_sections (os->children.head, os, &os->children.head,
2511 os->fill, dot, relax);
2512
2513 /* Ignore the size of the input sections, use the vma and size to
2514 align against. */
2515
2516 after = ALIGN_N (os->bfd_section->vma +
2517 os->bfd_section->_raw_size,
2518 /* The coercion here is important, see ld.h. */
2519 (bfd_vma) os->block_value);
2520
2521 if (bfd_is_abs_section (os->bfd_section))
2522 ASSERT (after == os->bfd_section->vma);
2523 else
2524 os->bfd_section->_raw_size = after - os->bfd_section->vma;
2525 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
2526 os->processed = true;
2527
2528 /* Update dot in the region ?
2529 We only do this if the section is going to be allocated,
2530 since unallocated sections do not contribute to the region's
2531 overall size in memory. */
2532 if (os->region != (lang_memory_region_type *) NULL
2533 && (bfd_get_section_flags (output_bfd, os->bfd_section)
2534 & (SEC_ALLOC | SEC_LOAD)))
2535 {
2536 os->region->current = dot;
2537
2538 /* Make sure this isn't silly. */
2539 if (os->region->current < os->region->origin
2540 || (os->region->current - os->region->origin
2541 > os->region->length))
2542 {
2543 if (os->addr_tree != (etree_type *) NULL)
2544 {
2545 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2546 os->region->current,
2547 os->bfd_section->owner,
2548 os->bfd_section->name,
2549 os->region->name);
2550 }
2551 else
2552 {
2553 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2554 os->region->name,
2555 os->bfd_section->owner,
2556 os->bfd_section->name);
2557 }
2558 /* Reset the region pointer. */
2559 os->region->current = os->region->origin;
2560 }
2561 }
2562 }
2563 break;
2564
2565 case lang_constructors_statement_enum:
2566 dot = lang_size_sections (constructor_list.head,
2567 output_section_statement,
2568 &s->wild_statement.children.head,
2569 fill,
2570 dot, relax);
2571 break;
2572
2573 case lang_data_statement_enum:
2574 {
2575 unsigned int size = 0;
2576
2577 s->data_statement.output_vma = dot - output_section_statement->bfd_section->vma;
2578 s->data_statement.output_section =
2579 output_section_statement->bfd_section;
2580
2581 switch (s->data_statement.type)
2582 {
2583 case QUAD:
2584 case SQUAD:
2585 size = QUAD_SIZE;
2586 break;
2587 case LONG:
2588 size = LONG_SIZE;
2589 break;
2590 case SHORT:
2591 size = SHORT_SIZE;
2592 break;
2593 case BYTE:
2594 size = BYTE_SIZE;
2595 break;
2596 }
2597
2598 dot += size;
2599 output_section_statement->bfd_section->_raw_size += size;
2600 /* The output section gets contents, and then we inspect for
2601 any flags set in the input script which override any ALLOC. */
2602 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
2603 if (!(output_section_statement->flags & SEC_NEVER_LOAD)) {
2604 output_section_statement->bfd_section->flags |= SEC_ALLOC | SEC_LOAD;
2605 }
2606 }
2607 break;
2608
2609 case lang_reloc_statement_enum:
2610 {
2611 int size;
2612
2613 s->reloc_statement.output_vma =
2614 dot - output_section_statement->bfd_section->vma;
2615 s->reloc_statement.output_section =
2616 output_section_statement->bfd_section;
2617 size = bfd_get_reloc_size (s->reloc_statement.howto);
2618 dot += size;
2619 output_section_statement->bfd_section->_raw_size += size;
2620 }
2621 break;
2622
2623 case lang_wild_statement_enum:
2624
2625 dot = lang_size_sections (s->wild_statement.children.head,
2626 output_section_statement,
2627 &s->wild_statement.children.head,
2628
2629 fill, dot, relax);
2630
2631 break;
2632
2633 case lang_object_symbols_statement_enum:
2634 link_info.create_object_symbols_section =
2635 output_section_statement->bfd_section;
2636 break;
2637 case lang_output_statement_enum:
2638 case lang_target_statement_enum:
2639 break;
2640 case lang_input_section_enum:
2641 {
2642 asection *i;
2643
2644 i = (*prev)->input_section.section;
2645 if (! relax)
2646 {
2647 if (i->_cooked_size == 0)
2648 i->_cooked_size = i->_raw_size;
2649 }
2650 else
2651 {
2652 boolean again;
2653
2654 if (! bfd_relax_section (i->owner, i, &link_info, &again))
2655 einfo (_("%P%F: can't relax section: %E\n"));
2656 if (again)
2657 relax_again = true;
2658 }
2659 dot = size_input_section (prev,
2660 output_section_statement,
2661 output_section_statement->fill,
2662 dot, relax);
2663 }
2664 break;
2665 case lang_input_statement_enum:
2666 break;
2667 case lang_fill_statement_enum:
2668 s->fill_statement.output_section = output_section_statement->bfd_section;
2669
2670 fill = s->fill_statement.fill;
2671 break;
2672 case lang_assignment_statement_enum:
2673 {
2674 bfd_vma newdot = dot;
2675
2676 exp_fold_tree (s->assignment_statement.exp,
2677 output_section_statement,
2678 lang_allocating_phase_enum,
2679 dot,
2680 &newdot);
2681
2682 if (newdot != dot)
2683 {
2684 /* The assignment changed dot. Insert a pad. */
2685 if (output_section_statement == abs_output_section)
2686 {
2687 /* If we don't have an output section, then just adjust
2688 the default memory address. */
2689 lang_memory_region_lookup ("*default*")->current = newdot;
2690 }
2691 else if (!relax)
2692 {
2693 lang_statement_union_type *new =
2694 ((lang_statement_union_type *)
2695 stat_alloc (sizeof (lang_padding_statement_type)));
2696
2697 /* Link into existing chain. */
2698 new->header.next = *prev;
2699 *prev = new;
2700 new->header.type = lang_padding_statement_enum;
2701 new->padding_statement.output_section =
2702 output_section_statement->bfd_section;
2703 new->padding_statement.output_offset =
2704 dot - output_section_statement->bfd_section->vma;
2705 new->padding_statement.fill = fill;
2706 new->padding_statement.size = newdot - dot;
2707 output_section_statement->bfd_section->_raw_size +=
2708 new->padding_statement.size;
2709 }
2710
2711 dot = newdot;
2712 }
2713 }
2714 break;
2715
2716 case lang_padding_statement_enum:
2717 /* If we are relaxing, and this is not the first pass, some
2718 padding statements may have been inserted during previous
2719 passes. We may have to move the padding statement to a new
2720 location if dot has a different value at this point in this
2721 pass than it did at this point in the previous pass. */
2722 s->padding_statement.output_offset =
2723 dot - output_section_statement->bfd_section->vma;
2724 dot += s->padding_statement.size;
2725 output_section_statement->bfd_section->_raw_size +=
2726 s->padding_statement.size;
2727 break;
2728
2729 case lang_group_statement_enum:
2730 dot = lang_size_sections (s->group_statement.children.head,
2731 output_section_statement,
2732 &s->group_statement.children.head,
2733 fill, dot, relax);
2734 break;
2735
2736 default:
2737 FAIL ();
2738 break;
2739
2740 /* This can only get here when relaxing is turned on. */
2741
2742 case lang_address_statement_enum:
2743 break;
2744 }
2745 prev = &s->header.next;
2746 }
2747 return dot;
2748}
2749
2750bfd_vma
2751lang_do_assignments (s, output_section_statement, fill, dot)
2752 lang_statement_union_type * s;
2753 lang_output_section_statement_type * output_section_statement;
2754 fill_type fill;
2755 bfd_vma dot;
2756{
2757 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2758 {
2759 switch (s->header.type)
2760 {
2761 case lang_constructors_statement_enum:
2762 dot = lang_do_assignments (constructor_list.head,
2763 output_section_statement,
2764 fill,
2765 dot);
2766 break;
2767
2768 case lang_output_section_statement_enum:
2769 {
2770 lang_output_section_statement_type *os =
2771 &(s->output_section_statement);
2772
2773 if (os->bfd_section != NULL)
2774 {
2775 dot = os->bfd_section->vma;
2776 (void) lang_do_assignments (os->children.head, os,
2777 os->fill, dot);
2778 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
2779 }
2780 if (os->load_base)
2781 {
2782 /* If nothing has been placed into the output section then
2783 it won't have a bfd_section. */
2784 if (os->bfd_section)
2785 {
2786 os->bfd_section->lma
2787 = exp_get_abs_int(os->load_base, 0,"load base", lang_final_phase_enum);
2788 }
2789 }
2790 }
2791 break;
2792 case lang_wild_statement_enum:
2793
2794 dot = lang_do_assignments (s->wild_statement.children.head,
2795 output_section_statement,
2796 fill, dot);
2797
2798 break;
2799
2800 case lang_object_symbols_statement_enum:
2801 case lang_output_statement_enum:
2802 case lang_target_statement_enum:
2803#if 0
2804 case lang_common_statement_enum:
2805#endif
2806 break;
2807 case lang_data_statement_enum:
2808 {
2809 etree_value_type value;
2810
2811 value = exp_fold_tree (s->data_statement.exp,
2812 abs_output_section,
2813 lang_final_phase_enum, dot, &dot);
2814 s->data_statement.value = value.value;
2815 if (value.valid_p == false)
2816 einfo (_("%F%P: invalid data statement\n"));
2817 }
2818 switch (s->data_statement.type)
2819 {
2820 case QUAD:
2821 case SQUAD:
2822 dot += QUAD_SIZE;
2823 break;
2824 case LONG:
2825 dot += LONG_SIZE;
2826 break;
2827 case SHORT:
2828 dot += SHORT_SIZE;
2829 break;
2830 case BYTE:
2831 dot += BYTE_SIZE;
2832 break;
2833 }
2834 break;
2835
2836 case lang_reloc_statement_enum:
2837 {
2838 etree_value_type value;
2839
2840 value = exp_fold_tree (s->reloc_statement.addend_exp,
2841 abs_output_section,
2842 lang_final_phase_enum, dot, &dot);
2843 s->reloc_statement.addend_value = value.value;
2844 if (value.valid_p == false)
2845 einfo (_("%F%P: invalid reloc statement\n"));
2846 }
2847 dot += bfd_get_reloc_size (s->reloc_statement.howto);
2848 break;
2849
2850 case lang_input_section_enum:
2851 {
2852 asection *in = s->input_section.section;
2853
2854 if (in->_cooked_size != 0)
2855 dot += in->_cooked_size;
2856 else
2857 dot += in->_raw_size;
2858 }
2859 break;
2860
2861 case lang_input_statement_enum:
2862 break;
2863 case lang_fill_statement_enum:
2864 fill = s->fill_statement.fill;
2865 break;
2866 case lang_assignment_statement_enum:
2867 {
2868 exp_fold_tree (s->assignment_statement.exp,
2869 output_section_statement,
2870 lang_final_phase_enum,
2871 dot,
2872 &dot);
2873 }
2874
2875 break;
2876 case lang_padding_statement_enum:
2877 dot += s->padding_statement.size;
2878 break;
2879
2880 case lang_group_statement_enum:
2881 dot = lang_do_assignments (s->group_statement.children.head,
2882 output_section_statement,
2883 fill, dot);
2884
2885 break;
2886
2887 default:
2888 FAIL ();
2889 break;
2890 case lang_address_statement_enum:
2891 break;
2892 }
2893
2894 }
2895 return dot;
2896}
2897
2898/* Fix any .startof. or .sizeof. symbols. When the assemblers see the
2899 operator .startof. (section_name), it produces an undefined symbol
2900 .startof.section_name. Similarly, when it sees
2901 .sizeof. (section_name), it produces an undefined symbol
2902 .sizeof.section_name. For all the output sections, we look for
2903 such symbols, and set them to the correct value. */
2904
2905static void
2906lang_set_startof ()
2907{
2908 asection *s;
2909
2910 if (link_info.relocateable)
2911 return;
2912
2913 for (s = output_bfd->sections; s != NULL; s = s->next)
2914 {
2915 const char *secname;
2916 char *buf;
2917 struct bfd_link_hash_entry *h;
2918
2919 secname = bfd_get_section_name (output_bfd, s);
2920 buf = xmalloc (10 + strlen (secname));
2921
2922 sprintf (buf, ".startof.%s", secname);
2923 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
2924 if (h != NULL && h->type == bfd_link_hash_undefined)
2925 {
2926 h->type = bfd_link_hash_defined;
2927 h->u.def.value = bfd_get_section_vma (output_bfd, s);
2928 h->u.def.section = bfd_abs_section_ptr;
2929 }
2930
2931 sprintf (buf, ".sizeof.%s", secname);
2932 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
2933 if (h != NULL && h->type == bfd_link_hash_undefined)
2934 {
2935 h->type = bfd_link_hash_defined;
2936 if (s->_cooked_size != 0)
2937 h->u.def.value = s->_cooked_size;
2938 else
2939 h->u.def.value = s->_raw_size;
2940 h->u.def.section = bfd_abs_section_ptr;
2941 }
2942
2943 free (buf);
2944 }
2945}
2946
2947static void
2948lang_finish ()
2949{
2950 struct bfd_link_hash_entry *h;
2951 boolean warn;
2952
2953 if (link_info.relocateable || link_info.shared)
2954 warn = false;
2955 else
2956 warn = true;
2957
2958 if (entry_symbol == (char *) NULL)
2959 {
2960 /* No entry has been specified. Look for start, but don't warn
2961 if we don't find it. */
2962 entry_symbol = "start";
2963 warn = false;
2964 }
2965
2966 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
2967 if (h != (struct bfd_link_hash_entry *) NULL
2968 && (h->type == bfd_link_hash_defined
2969 || h->type == bfd_link_hash_defweak)
2970 && h->u.def.section->output_section != NULL)
2971 {
2972 bfd_vma val;
2973
2974 val = (h->u.def.value
2975 + bfd_get_section_vma (output_bfd,
2976 h->u.def.section->output_section)
2977 + h->u.def.section->output_offset);
2978 if (! bfd_set_start_address (output_bfd, val))
2979 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
2980 }
2981 else
2982 {
2983 bfd_vma val;
2984 CONST char *send;
2985
2986 /* We couldn't find the entry symbol. Try parsing it as a
2987 number. */
2988 val = bfd_scan_vma (entry_symbol, &send, 0);
2989 if (*send == '\0')
2990 {
2991 if (! bfd_set_start_address (output_bfd, val))
2992 einfo (_("%P%F: can't set start address\n"));
2993 }
2994 else
2995 {
2996 asection *ts;
2997
2998 /* Can't find the entry symbol, and it's not a number. Use
2999 the first address in the text section. */
3000 ts = bfd_get_section_by_name (output_bfd, ".text");
3001 if (ts != (asection *) NULL)
3002 {
3003 if (warn)
3004 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3005 entry_symbol, bfd_get_section_vma (output_bfd, ts));
3006 if (! bfd_set_start_address (output_bfd,
3007 bfd_get_section_vma (output_bfd,
3008 ts)))
3009 einfo (_("%P%F: can't set start address\n"));
3010 }
3011 else
3012 {
3013 if (warn)
3014 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3015 entry_symbol);
3016 }
3017 }
3018 }
3019}
3020
3021/* This is a small function used when we want to ignore errors from
3022 BFD. */
3023
3024static void
3025#ifdef ANSI_PROTOTYPES
87f2a346 3026ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
252b5132
RH		 3027#else
3028ignore_bfd_errors (s)
87f2a346 3029 const char *s ATTRIBUTE_UNUSED;
252b5132
RH		 3030#endif
3031{
3032 /* Don't do anything. */
3033}
3034
3035/* Check that the architecture of all the input files is compatible
3036 with the output file. Also call the backend to let it do any
3037 other checking that is needed. */
3038
3039static void
3040lang_check ()
3041{
3042 lang_statement_union_type *file;
3043 bfd *input_bfd;
3044 CONST bfd_arch_info_type *compatible;
3045
3046 for (file = file_chain.head;
3047 file != (lang_statement_union_type *) NULL;
3048 file = file->input_statement.next)
3049 {
3050 input_bfd = file->input_statement.the_bfd;
3051 compatible = bfd_arch_get_compatible (input_bfd,
3052 output_bfd);
3053 if (compatible == NULL)
3054 {
3055 if (command_line.warn_mismatch)
3056 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3057 bfd_printable_name (input_bfd), input_bfd,
3058 bfd_printable_name (output_bfd));
3059 }
3060 else
3061 {
3062 bfd_error_handler_type pfn = NULL;
3063
3064 /* If we aren't supposed to warn about mismatched input
3065 files, temporarily set the BFD error handler to a
3066 function which will do nothing. We still want to call
3067 bfd_merge_private_bfd_data, since it may set up
3068 information which is needed in the output file. */
3069 if (! command_line.warn_mismatch)
3070 pfn = bfd_set_error_handler (ignore_bfd_errors);
3071 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3072 {
3073 if (command_line.warn_mismatch)
3074 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3075 input_bfd);
3076 }
3077 if (! command_line.warn_mismatch)
3078 bfd_set_error_handler (pfn);
3079 }
3080 }
3081}
3082
3083/* Look through all the global common symbols and attach them to the
3084 correct section. The -sort-common command line switch may be used
3085 to roughly sort the entries by size. */
3086
3087static void
3088lang_common ()
3089{
3090 if (link_info.relocateable
3091 && ! command_line.force_common_definition)
3092 return;
3093
3094 if (! config.sort_common)
3095 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3096 else
3097 {
3098 int power;
3099
3100 for (power = 4; power >= 0; power--)
3101 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3102 (PTR) &power);
3103 }
3104}
3105
3106/* Place one common symbol in the correct section. */
3107
3108static boolean
3109lang_one_common (h, info)
3110 struct bfd_link_hash_entry *h;
3111 PTR info;
3112{
3113 unsigned int power_of_two;
3114 bfd_vma size;
3115 asection *section;
3116
3117 if (h->type != bfd_link_hash_common)
3118 return true;
3119
3120 size = h->u.c.size;
3121 power_of_two = h->u.c.p->alignment_power;
3122
3123 if (config.sort_common
3124 && power_of_two < (unsigned int) *(int *) info)
3125 return true;
3126
3127 section = h->u.c.p->section;
3128
3129 /* Increase the size of the section. */
3130 section->_cooked_size = ALIGN_N (section->_cooked_size,
3131 (bfd_size_type) (1 << power_of_two));
3132
3133 /* Adjust the alignment if necessary. */
3134 if (power_of_two > section->alignment_power)
3135 section->alignment_power = power_of_two;
3136
3137 /* Change the symbol from common to defined. */
3138 h->type = bfd_link_hash_defined;
3139 h->u.def.section = section;
3140 h->u.def.value = section->_cooked_size;
3141
3142 /* Increase the size of the section. */
3143 section->_cooked_size += size;
3144
3145 /* Make sure the section is allocated in memory, and make sure that
3146 it is no longer a common section. */
3147 section->flags |= SEC_ALLOC;
3148 section->flags &= ~ SEC_IS_COMMON;
3149
3150 if (config.map_file != NULL)
3151 {
3152 static boolean header_printed;
3153 int len;
3154 char *name;
3155 char buf[50];
3156
3157 if (! header_printed)
3158 {
3159 minfo (_("\nAllocating common symbols\n"));
3160 minfo (_("Common symbol size file\n\n"));
3161 header_printed = true;
3162 }
3163
3164 name = demangle (h->root.string);
3165 minfo ("%s", name);
3166 len = strlen (name);
3167 free (name);
3168
3169 if (len >= 19)
3170 {
3171 print_nl ();
3172 len = 0;
3173 }
3174 while (len < 20)
3175 {
3176 print_space ();
3177 ++len;
3178 }
3179
3180 minfo ("0x");
3181 if (size <= 0xffffffff)
3182 sprintf (buf, "%lx", (unsigned long) size);
3183 else
3184 sprintf_vma (buf, size);
3185 minfo ("%s", buf);
3186 len = strlen (buf);
3187
3188 while (len < 16)
3189 {
3190 print_space ();
3191 ++len;
3192 }
3193
3194 minfo ("%B\n", section->owner);
3195 }
3196
3197 return true;
3198}
3199
3200/*
3201run through the input files and ensure that every input
3202section has somewhere to go. If one is found without
3203a destination then create an input request and place it
3204into the statement tree.
3205*/
3206
3207static void
3208lang_place_orphans ()
3209{
3210 lang_input_statement_type *file;
3211
3212 for (file = (lang_input_statement_type *) file_chain.head;
3213 file != (lang_input_statement_type *) NULL;
3214 file = (lang_input_statement_type *) file->next)
3215 {
3216 asection *s;
3217
3218 for (s = file->the_bfd->sections;
3219 s != (asection *) NULL;
3220 s = s->next)
3221 {
3222 if (s->output_section == (asection *) NULL)
3223 {
3224 /* This section of the file is not attatched, root
3225 around for a sensible place for it to go */
3226
3227 if (file->just_syms_flag)
3228 {
3229 /* We are only retrieving symbol values from this
3230 file. We want the symbols to act as though the
3231 values in the file are absolute. */
3232 s->output_section = bfd_abs_section_ptr;
3233 s->output_offset = s->vma;
3234 }
3235 else if (strcmp (s->name, "COMMON") == 0)
3236 {
3237 /* This is a lonely common section which must have
3238 come from an archive. We attach to the section
3239 with the wildcard. */
3240 if (! link_info.relocateable
3241 || command_line.force_common_definition)
3242 {
3243 if (default_common_section == NULL)
3244 {
3245#if 0
3246 /* This message happens when using the
3247 svr3.ifile linker script, so I have
3248 disabled it. */
3249 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3250#endif
3251 default_common_section =
3252 lang_output_section_statement_lookup (".bss");
3253
3254 }
3255 wild_doit (&default_common_section->children, s,
3256 default_common_section, file);
3257 }
3258 }
3259 else if (ldemul_place_orphan (file, s))
3260 ;
3261 else
3262 {
3263 lang_output_section_statement_type *os =
3264 lang_output_section_statement_lookup (s->name);
3265
3266 wild_doit (&os->children, s, os, file);
3267 }
3268 }
3269 }
3270 }
3271}
3272
3273
3274void
aa8804e4 3275lang_set_flags (ptr, flags, invert)
252b5132
RH		 3276 lang_memory_region_type *ptr;
3277 CONST char *flags;
aa8804e4 3278 int invert;
252b5132 3279{
aa8804e4 3280 flagword *ptr_flags;
252b5132 3281
aa8804e4 3282 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
252b5132
RH		 3283 while (*flags)
3284 {
3285 switch (*flags)
3286 {
252b5132
RH		 3287 case 'A': case 'a':
3288 *ptr_flags |= SEC_ALLOC;
3289 break;
3290
3291 case 'R': case 'r':
3292 *ptr_flags |= SEC_READONLY;
3293 break;
3294
3295 case 'W': case 'w':
3296 *ptr_flags |= SEC_DATA;
3297 break;
3298
3299 case 'X': case 'x':
3300 *ptr_flags |= SEC_CODE;
3301 break;
3302
3303 case 'L': case 'l':
3304 case 'I': case 'i':
3305 *ptr_flags |= SEC_LOAD;
3306 break;
3307
3308 default:
3309 einfo (_("%P%F: invalid syntax in flags\n"));
3310 break;
3311 }
3312 flags++;
3313 }
3314}
3315
3316/* Call a function on each input file. This function will be called
3317 on an archive, but not on the elements. */
3318
3319void
3320lang_for_each_input_file (func)
3321 void (*func) PARAMS ((lang_input_statement_type *));
3322{
3323 lang_input_statement_type *f;
3324
3325 for (f = (lang_input_statement_type *) input_file_chain.head;
3326 f != NULL;
3327 f = (lang_input_statement_type *) f->next_real_file)
3328 func (f);
3329}
3330
3331/* Call a function on each file. The function will be called on all
3332 the elements of an archive which are included in the link, but will
3333 not be called on the archive file itself. */
3334
3335void
3336lang_for_each_file (func)
3337 void (*func) PARAMS ((lang_input_statement_type *));
3338{
3339 lang_input_statement_type *f;
3340
3341 for (f = (lang_input_statement_type *) file_chain.head;
3342 f != (lang_input_statement_type *) NULL;
3343 f = (lang_input_statement_type *) f->next)
3344 {
3345 func (f);
3346 }
3347}
3348
3349#if 0
3350
3351/* Not used. */
3352
3353void
3354lang_for_each_input_section (func)
3355 void (*func) PARAMS ((bfd * ab, asection * as));
3356{
3357 lang_input_statement_type *f;
3358
3359 for (f = (lang_input_statement_type *) file_chain.head;
3360 f != (lang_input_statement_type *) NULL;
3361 f = (lang_input_statement_type *) f->next)
3362 {
3363 asection *s;
3364
3365 for (s = f->the_bfd->sections;
3366 s != (asection *) NULL;
3367 s = s->next)
3368 {
3369 func (f->the_bfd, s);
3370 }
3371 }
3372}
3373
3374#endif
3375
3376void
3377ldlang_add_file (entry)
3378 lang_input_statement_type * entry;
3379{
3380 bfd **pp;
3381
3382 lang_statement_append (&file_chain,
3383 (lang_statement_union_type *) entry,
3384 &entry->next);
3385
3386 /* The BFD linker needs to have a list of all input BFDs involved in
3387 a link. */
3388 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3389 ASSERT (entry->the_bfd != output_bfd);
3390 for (pp = &link_info.input_bfds;
3391 *pp != (bfd *) NULL;
3392 pp = &(*pp)->link_next)
3393 ;
3394 *pp = entry->the_bfd;
3395 entry->the_bfd->usrdata = (PTR) entry;
3396 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3397
3398 /* Look through the sections and check for any which should not be
3399 included in the link. We need to do this now, so that we can
3400 notice when the backend linker tries to report multiple
3401 definition errors for symbols which are in sections we aren't
3402 going to link. FIXME: It might be better to entirely ignore
3403 symbols which are defined in sections which are going to be
3404 discarded. This would require modifying the backend linker for
3405 each backend which might set the SEC_LINK_ONCE flag. If we do
3406 this, we should probably handle SEC_EXCLUDE in the same way. */
3407
3408 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3409}
3410
3411void
3412lang_add_output (name, from_script)
3413 CONST char *name;
3414 int from_script;
3415{
3416 /* Make -o on command line override OUTPUT in script. */
3417 if (had_output_filename == false || !from_script)
3418 {
3419 output_filename = name;
3420 had_output_filename = true;
3421 }
3422}
3423
3424
3425static lang_output_section_statement_type *current_section;
3426
3427static int
3428topower (x)
3429 int x;
3430{
3431 unsigned int i = 1;
3432 int l;
3433
3434 if (x < 0)
3435 return -1;
3436
3437 for (l = 0; l < 32; l++)
3438 {
3439 if (i >= (unsigned int) x)
3440 return l;
3441 i <<= 1;
3442 }
3443
3444 return 0;
3445}
3446
3447void
3448lang_enter_output_section_statement (output_section_statement_name,
3449 address_exp, sectype, block_value,
3450 align, subalign, ebase)
3451 const char *output_section_statement_name;
3452 etree_type * address_exp;
3453 enum section_type sectype;
3454 bfd_vma block_value;
3455 etree_type *align;
3456 etree_type *subalign;
3457 etree_type *ebase;
3458{
3459 lang_output_section_statement_type *os;
3460
3461 current_section =
3462 os =
3463 lang_output_section_statement_lookup (output_section_statement_name);
3464
3465
3466
3467 /* Add this statement to tree */
3468 /* add_statement(lang_output_section_statement_enum,
3469 output_section_statement);*/
3470 /* Make next things chain into subchain of this */
3471
3472 if (os->addr_tree ==
3473 (etree_type *) NULL)
3474 {
3475 os->addr_tree =
3476 address_exp;
3477 }
3478 os->sectype = sectype;
3479 if (sectype != noload_section)
3480 os->flags = SEC_NO_FLAGS;
3481 else
3482 os->flags = SEC_NEVER_LOAD;
3483 os->block_value = block_value ? block_value : 1;
3484 stat_ptr = &os->children;
3485
3486 os->subsection_alignment = topower(
3487 exp_get_value_int(subalign, -1,
3488 "subsection alignment",
3489 0));
3490 os->section_alignment = topower(
3491 exp_get_value_int(align, -1,
3492 "section alignment", 0));
3493
3494 os->load_base = ebase;
3495}
3496
3497
3498void
3499lang_final ()
3500{
3501 lang_output_statement_type *new =
3502 new_stat (lang_output_statement, stat_ptr);
3503
3504 new->name = output_filename;
3505}
3506
3507/* Reset the current counters in the regions */
3508static void
3509reset_memory_regions ()
3510{
3511 lang_memory_region_type *p = lang_memory_region_list;
3512
3513 for (p = lang_memory_region_list;
3514 p != (lang_memory_region_type *) NULL;
3515 p = p->next)
3516 {
3517 p->old_length = (bfd_size_type) (p->current - p->origin);
3518 p->current = p->origin;
3519 }
3520}
3521
252b5132
RH		 3522/* Expand a wild statement for a particular FILE, marking its sections KEEP
3523 as needed. SECTION may be NULL, in which case it is a wild card. */
3524
3525static void
4dec4d4e 3526gc_section_callback (ptr, section, file, data)
252b5132 3527 lang_wild_statement_type *ptr;
4dec4d4e 3528 asection *section;
87f2a346
ILT		 3529 lang_input_statement_type *file ATTRIBUTE_UNUSED;
3530 void *data ATTRIBUTE_UNUSED;
252b5132 3531{
4dec4d4e
RH		 3532 /* If the wild pattern was marked KEEP, the member sections
3533 should be as well. */
3534 if (ptr->keep_sections)
3535 section->flags |= SEC_KEEP;
252b5132
RH		 3536}
3537
3538/* Handle a wild statement, marking it against GC. SECTION or FILE or both
3539 may be NULL, indicating that it is a wildcard. */
3540
3541static void
3542lang_gc_wild (s, section, file)
3543 lang_wild_statement_type *s;
3544 const char *section;
3545 const char *file;
3546{
4dec4d4e 3547 walk_wild (s, section, file, gc_section_callback, NULL);
252b5132
RH		 3548}
3549
3550/* Iterate over sections marking them against GC. */
3551
3552static void
3553lang_gc_sections_1 (s)
3554 lang_statement_union_type * s;
3555{
3556 for (; s != (lang_statement_union_type *) NULL; s = s->next)
3557 {
3558 switch (s->header.type)
3559 {
3560 case lang_wild_statement_enum:
3561 lang_gc_wild (&s->wild_statement,
3562 s->wild_statement.section_name,
3563 s->wild_statement.filename);
3564 break;
3565 case lang_constructors_statement_enum:
3566 lang_gc_sections_1 (constructor_list.head);
3567 break;
3568 case lang_output_section_statement_enum:
3569 lang_gc_sections_1 (s->output_section_statement.children.head);
3570 break;
3571 case lang_group_statement_enum:
3572 lang_gc_sections_1 (s->group_statement.children.head);
3573 break;
3574 default:
3575 break;
3576 }
3577 }
3578}
3579
3580static void
3581lang_gc_sections ()
3582{
3583 struct bfd_link_hash_entry *h;
3584 ldlang_undef_chain_list_type *ulist, fake_list_start;
3585
3586 /* Keep all sections so marked in the link script. */
3587
3588 lang_gc_sections_1 (statement_list.head);
3589
3590 /* Keep all sections containing symbols undefined on the command-line.
3591 Handle the entry symbol at the same time. */
3592
3593 fake_list_start.next = ldlang_undef_chain_list_head;
3594 if (entry_symbol == NULL)
3595 fake_list_start.name = "start";
3596 else
3597 fake_list_start.name = (char *) entry_symbol;
3598
3599 for (ulist = &fake_list_start; ulist; ulist = ulist->next)
3600 {
3601 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
3602 false, false, false);
3603
3604 if (h != (struct bfd_link_hash_entry *) NULL
3605 && (h->type == bfd_link_hash_defined
3606 || h->type == bfd_link_hash_defweak)
3607 && ! bfd_is_abs_section (h->u.def.section))
3608 {
3609 h->u.def.section->flags |= SEC_KEEP;
3610 }
3611 }
3612
3613 bfd_gc_sections (output_bfd, &link_info);
3614}
3615
3616void
3617lang_process ()
3618{
3619 lang_reasonable_defaults ();
3620 current_target = default_target;
3621
3622 lang_for_each_statement (ldlang_open_output); /* Open the output file */
3623
3624 ldemul_create_output_section_statements ();
3625
3626 /* Add to the hash table all undefineds on the command line */
3627 lang_place_undefineds ();
3628
3629 /* Create a bfd for each input file */
3630 current_target = default_target;
3631 open_input_bfds (statement_list.head, false);
3632
3633 ldemul_after_open ();
3634
3635 /* Make sure that we're not mixing architectures. We call this
3636 after all the input files have been opened, but before we do any
3637 other processing, so that any operations merge_private_bfd_data
3638 does on the output file will be known during the rest of the
3639 link. */
3640 lang_check ();
3641
3642 /* Handle .exports instead of a version script if we're told to do so. */
3643 if (command_line.version_exports_section)
3644 lang_do_version_exports_section ();
3645
3646 /* Build all sets based on the information gathered from the input
3647 files. */
3648 ldctor_build_sets ();
3649
3650 /* Remove unreferenced sections if asked to. */
3651 if (command_line.gc_sections)
3652 lang_gc_sections ();
3653
3654 /* Size up the common data */
3655 lang_common ();
3656
3657 /* Run through the contours of the script and attach input sections
3658 to the correct output sections
3659 */
3660 map_input_to_output_sections (statement_list.head, (char *) NULL,
3661 (lang_output_section_statement_type *) NULL);
3662
3663
3664 /* Find any sections not attached explicitly and handle them */
3665 lang_place_orphans ();
3666
3667 ldemul_before_allocation ();
3668
3669 /* We must record the program headers before we try to fix the
3670 section positions, since they will affect SIZEOF_HEADERS. */
3671 lang_record_phdrs ();
3672
3673 /* Now run around and relax if we can */
3674 if (command_line.relax)
3675 {
3676 /* First time round is a trial run to get the 'worst case'
3677 addresses of the objects if there was no relaxing. */
3678 lang_size_sections (statement_list.head,
3679 abs_output_section,
3680 &(statement_list.head), 0, (bfd_vma) 0, false);
3681
3682 /* Keep relaxing until bfd_relax_section gives up. */
3683 do
3684 {
3685 reset_memory_regions ();
3686
3687 relax_again = false;
3688
3689 /* Note: pe-dll.c does something like this also. If you find
3690 you need to change this code, you probably need to change
3691 pe-dll.c also. DJ */
3692
3693 /* Do all the assignments with our current guesses as to
3694 section sizes. */
3695 lang_do_assignments (statement_list.head,
3696 abs_output_section,
3697 (fill_type) 0, (bfd_vma) 0);
3698
3699 /* Perform another relax pass - this time we know where the
3700 globals are, so can make better guess. */
3701 lang_size_sections (statement_list.head,
3702 abs_output_section,
3703 &(statement_list.head), 0, (bfd_vma) 0, true);
3704 }
3705 while (relax_again);
3706 }
3707 else
3708 {
3709 /* Size up the sections. */
3710 lang_size_sections (statement_list.head,
3711 abs_output_section,
3712 &(statement_list.head), 0, (bfd_vma) 0, false);
3713 }
3714
3715 /* See if anything special should be done now we know how big
3716 everything is. */
3717 ldemul_after_allocation ();
3718
3719 /* Fix any .startof. or .sizeof. symbols. */
3720 lang_set_startof ();
3721
3722 /* Do all the assignments, now that we know the final restingplaces
3723 of all the symbols */
3724
3725 lang_do_assignments (statement_list.head,
3726 abs_output_section,
3727 (fill_type) 0, (bfd_vma) 0);
3728
3729 /* Make sure that the section addresses make sense. */
3730 if (! link_info.relocateable
3731 && command_line.check_section_addresses)
3732 lang_check_section_addresses ();
3733
3734 /* Final stuffs */
3735
3736 ldemul_finish ();
3737 lang_finish ();
3738}
3739
3740/* EXPORTED TO YACC */
3741
3742void
3743lang_add_wild (section_name, sections_sorted, filename, filenames_sorted,
3744 keep_sections, exclude_filename)
3745 const char *const section_name;
3746 boolean sections_sorted;
3747 const char *const filename;
3748 boolean filenames_sorted;
3749 boolean keep_sections;
3750 const char *exclude_filename;
3751{
3752 lang_wild_statement_type *new = new_stat (lang_wild_statement,
3753 stat_ptr);
3754
3755 if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
3756 {
3757 placed_commons = true;
3758 }
3759 if (filename != NULL && ! wildcardp (filename))
3760 {
3761 lang_has_input_file = true;
3762 }
3763 new->section_name = section_name;
3764 new->sections_sorted = sections_sorted;
3765 new->filename = filename;
3766 new->filenames_sorted = filenames_sorted;
3767 new->keep_sections = keep_sections;
3768 new->exclude_filename = exclude_filename;
3769 lang_list_init (&new->children);
3770}
3771
3772void
3773lang_section_start (name, address)
3774 CONST char *name;
3775 etree_type * address;
3776{
3777 lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
3778
3779 ad->section_name = name;
3780 ad->address = address;
3781}
3782
3783/* Set the start symbol to NAME. CMDLINE is nonzero if this is called
3784 because of a -e argument on the command line, or zero if this is
3785 called by ENTRY in a linker script. Command line arguments take
3786 precedence. */
3787
3788void
3789lang_add_entry (name, cmdline)
3790 CONST char *name;
3791 boolean cmdline;
3792{
3793 if (entry_symbol == NULL
3794 || cmdline
3795 || ! entry_from_cmdline)
3796 {
3797 entry_symbol = name;
3798 entry_from_cmdline = cmdline;
3799 }
3800}
3801
3802void
3803lang_add_target (name)
3804 CONST char *name;
3805{
3806 lang_target_statement_type *new = new_stat (lang_target_statement,
3807 stat_ptr);
3808
3809 new->target = name;
3810
3811}
3812
3813void
3814lang_add_map (name)
3815 CONST char *name;
3816{
3817 while (*name)
3818 {
3819 switch (*name)
3820 {
3821 case 'F':
3822 map_option_f = true;
3823 break;
3824 }
3825 name++;
3826 }
3827}
3828
3829void
3830lang_add_fill (exp)
3831 int exp;
3832{
3833 lang_fill_statement_type *new = new_stat (lang_fill_statement,
3834 stat_ptr);
3835
3836 new->fill = exp;
3837}
3838
3839void
3840lang_add_data (type, exp)
3841 int type;
3842 union etree_union *exp;
3843{
3844
3845 lang_data_statement_type *new = new_stat (lang_data_statement,
3846 stat_ptr);
3847
3848 new->exp = exp;
3849 new->type = type;
3850
3851}
3852
3853/* Create a new reloc statement. RELOC is the BFD relocation type to
3854 generate. HOWTO is the corresponding howto structure (we could
3855 look this up, but the caller has already done so). SECTION is the
3856 section to generate a reloc against, or NAME is the name of the
3857 symbol to generate a reloc against. Exactly one of SECTION and
3858 NAME must be NULL. ADDEND is an expression for the addend. */
3859
3860void
3861lang_add_reloc (reloc, howto, section, name, addend)
3862 bfd_reloc_code_real_type reloc;
3863 reloc_howto_type *howto;
3864 asection *section;
3865 const char *name;
3866 union etree_union *addend;
3867{
3868 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
3869
3870 p->reloc = reloc;
3871 p->howto = howto;
3872 p->section = section;
3873 p->name = name;
3874 p->addend_exp = addend;
3875
3876 p->addend_value = 0;
3877 p->output_section = NULL;
3878 p->output_vma = 0;
3879}
3880
3881lang_assignment_statement_type *
3882lang_add_assignment (exp)
3883 etree_type * exp;
3884{
3885 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
3886 stat_ptr);
3887
3888 new->exp = exp;
3889 return new;
3890}
3891
3892void
3893lang_add_attribute (attribute)
3894 enum statement_enum attribute;
3895{
3896 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
3897}
3898
3899void
3900lang_startup (name)
3901 CONST char *name;
3902{
3903 if (startup_file != (char *) NULL)
3904 {
3905 einfo (_("%P%Fmultiple STARTUP files\n"));
3906 }
3907 first_file->filename = name;
3908 first_file->local_sym_name = name;
3909 first_file->real = true;
3910
3911 startup_file = name;
3912}
3913
3914void
3915lang_float (maybe)
3916 boolean maybe;
3917{
3918 lang_float_flag = maybe;
3919}
3920
3921void
3922lang_leave_output_section_statement (fill, memspec, phdrs)
3923 bfd_vma fill;
3924 const char *memspec;
3925 struct lang_output_section_phdr_list *phdrs;
3926{
3927 current_section->fill = fill;
3928 current_section->region = lang_memory_region_lookup (memspec);
3929 current_section->phdrs = phdrs;
3930 stat_ptr = &statement_list;
3931}
3932
3933/*
3934 Create an absolute symbol with the given name with the value of the
3935 address of first byte of the section named.
3936
3937 If the symbol already exists, then do nothing.
3938*/
3939void
3940lang_abs_symbol_at_beginning_of (secname, name)
3941 const char *secname;
3942 const char *name;
3943{
3944 struct bfd_link_hash_entry *h;
3945
3946 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
3947 if (h == (struct bfd_link_hash_entry *) NULL)
3948 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3949
3950 if (h->type == bfd_link_hash_new
3951 || h->type == bfd_link_hash_undefined)
3952 {
3953 asection *sec;
3954
3955 h->type = bfd_link_hash_defined;
3956
3957 sec = bfd_get_section_by_name (output_bfd, secname);
3958 if (sec == (asection *) NULL)
3959 h->u.def.value = 0;
3960 else
3961 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
3962
3963 h->u.def.section = bfd_abs_section_ptr;
3964 }
3965}
3966
3967/*
3968 Create an absolute symbol with the given name with the value of the
3969 address of the first byte after the end of the section named.
3970
3971 If the symbol already exists, then do nothing.
3972*/
3973void
3974lang_abs_symbol_at_end_of (secname, name)
3975 const char *secname;
3976 const char *name;
3977{
3978 struct bfd_link_hash_entry *h;
3979
3980 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
3981 if (h == (struct bfd_link_hash_entry *) NULL)
3982 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3983
3984 if (h->type == bfd_link_hash_new
3985 || h->type == bfd_link_hash_undefined)
3986 {
3987 asection *sec;
3988
3989 h->type = bfd_link_hash_defined;
3990
3991 sec = bfd_get_section_by_name (output_bfd, secname);
3992 if (sec == (asection *) NULL)
3993 h->u.def.value = 0;
3994 else
3995 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
3996 + bfd_section_size (output_bfd, sec));
3997
3998 h->u.def.section = bfd_abs_section_ptr;
3999 }
4000}
4001
4002void
4003lang_statement_append (list, element, field)
4004 lang_statement_list_type * list;
4005 lang_statement_union_type * element;
4006 lang_statement_union_type ** field;
4007{
4008 *(list->tail) = element;
4009 list->tail = field;
4010}
4011
4012/* Set the output format type. -oformat overrides scripts. */
4013
4014void
4015lang_add_output_format (format, big, little, from_script)
4016 const char *format;
4017 const char *big;
4018 const char *little;
4019 int from_script;
4020{
4021 if (output_target == NULL || !from_script)
4022 {
4023 if (command_line.endian == ENDIAN_BIG
4024 && big != NULL)
4025 format = big;
4026 else if (command_line.endian == ENDIAN_LITTLE
4027 && little != NULL)
4028 format = little;
4029
4030 output_target = format;
4031 }
4032}
4033
4034/* Enter a group. This creates a new lang_group_statement, and sets
4035 stat_ptr to build new statements within the group. */
4036
4037void
4038lang_enter_group ()
4039{
4040 lang_group_statement_type *g;
4041
4042 g = new_stat (lang_group_statement, stat_ptr);
4043 lang_list_init (&g->children);
4044 stat_ptr = &g->children;
4045}
4046
4047/* Leave a group. This just resets stat_ptr to start writing to the
4048 regular list of statements again. Note that this will not work if
4049 groups can occur inside anything else which can adjust stat_ptr,
4050 but currently they can't. */
4051
4052void
4053lang_leave_group ()
4054{
4055 stat_ptr = &statement_list;
4056}
4057
4058/* Add a new program header. This is called for each entry in a PHDRS
4059 command in a linker script. */
4060
4061void
4062lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4063 const char *name;
4064 etree_type *type;
4065 boolean filehdr;
4066 boolean phdrs;
4067 etree_type *at;
4068 etree_type *flags;
4069{
4070 struct lang_phdr *n, **pp;
4071
4072 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4073 n->next = NULL;
4074 n->name = name;
4075 n->type = exp_get_value_int (type, 0, "program header type",
4076 lang_final_phase_enum);
4077 n->filehdr = filehdr;
4078 n->phdrs = phdrs;
4079 n->at = at;
4080 n->flags = flags;
4081
4082 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4083 ;
4084 *pp = n;
4085}
4086
4087/* Record the program header information in the output BFD. FIXME: We
4088 should not be calling an ELF specific function here. */
4089
4090static void
4091lang_record_phdrs ()
4092{
4093 unsigned int alc;
4094 asection **secs;
4095 struct lang_output_section_phdr_list *last;
4096 struct lang_phdr *l;
4097 lang_statement_union_type *u;
4098
4099 alc = 10;
4100 secs = (asection **) xmalloc (alc * sizeof (asection *));
4101 last = NULL;
4102 for (l = lang_phdr_list; l != NULL; l = l->next)
4103 {
4104 unsigned int c;
4105 flagword flags;
4106 bfd_vma at;
4107
4108 c = 0;
4109 for (u = lang_output_section_statement.head;
4110 u != NULL;
4111 u = u->output_section_statement.next)
4112 {
4113 lang_output_section_statement_type *os;
4114 struct lang_output_section_phdr_list *pl;
4115
4116 os = &u->output_section_statement;
4117
4118 pl = os->phdrs;
4119 if (pl != NULL)
4120 last = pl;
4121 else
4122 {
4123 if (os->sectype == noload_section
4124 || os->bfd_section == NULL
4125 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4126 continue;
4127 pl = last;
4128 }
4129
4130 if (os->bfd_section == NULL)
4131 continue;
4132
4133 for (; pl != NULL; pl = pl->next)
4134 {
4135 if (strcmp (pl->name, l->name) == 0)
4136 {
4137 if (c >= alc)
4138 {
4139 alc *= 2;
4140 secs = ((asection **)
4141 xrealloc (secs, alc * sizeof (asection *)));
4142 }
4143 secs[c] = os->bfd_section;
4144 ++c;
4145 pl->used = true;
4146 }
4147 }
4148 }
4149
4150 if (l->flags == NULL)
4151 flags = 0;
4152 else
4153 flags = exp_get_vma (l->flags, 0, "phdr flags",
4154 lang_final_phase_enum);
4155
4156 if (l->at == NULL)
4157 at = 0;
4158 else
4159 at = exp_get_vma (l->at, 0, "phdr load address",
4160 lang_final_phase_enum);
4161
4162 if (! bfd_record_phdr (output_bfd, l->type,
4163 l->flags == NULL ? false : true,
4164 flags,
4165 l->at == NULL ? false : true,
4166 at, l->filehdr, l->phdrs, c, secs))
4167 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4168 }
4169
4170 free (secs);
4171
4172 /* Make sure all the phdr assignments succeeded. */
4173 for (u = lang_output_section_statement.head;
4174 u != NULL;
4175 u = u->output_section_statement.next)
4176 {
4177 struct lang_output_section_phdr_list *pl;
4178
4179 if (u->output_section_statement.bfd_section == NULL)
4180 continue;
4181
4182 for (pl = u->output_section_statement.phdrs;
4183 pl != NULL;
4184 pl = pl->next)
4185 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4186 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4187 u->output_section_statement.name, pl->name);
4188 }
4189}
4190
4191/* Record a list of sections which may not be cross referenced. */
4192
4193void
4194lang_add_nocrossref (l)
4195 struct lang_nocrossref *l;
4196{
4197 struct lang_nocrossrefs *n;
4198
4199 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4200 n->next = nocrossref_list;
4201 n->list = l;
4202 nocrossref_list = n;
4203
4204 /* Set notice_all so that we get informed about all symbols. */
4205 link_info.notice_all = true;
4206}
4207\f
4208/* Overlay handling. We handle overlays with some static variables. */
4209
4210/* The overlay virtual address. */
4211static etree_type *overlay_vma;
4212
4213/* The overlay load address. */
4214static etree_type *overlay_lma;
4215
4216/* Whether nocrossrefs is set for this overlay. */
4217static int overlay_nocrossrefs;
4218
4219/* An expression for the maximum section size seen so far. */
4220static etree_type *overlay_max;
4221
4222/* A list of all the sections in this overlay. */
4223
4224struct overlay_list
4225{
4226 struct overlay_list *next;
4227 lang_output_section_statement_type *os;
4228};
4229
4230static struct overlay_list *overlay_list;
4231
4232/* Start handling an overlay. */
4233
4234void
4235lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
4236 etree_type *vma_expr;
4237 etree_type *lma_expr;
4238 int nocrossrefs;
4239{
4240 /* The grammar should prevent nested overlays from occurring. */
4241 ASSERT (overlay_vma == NULL
4242 && overlay_lma == NULL
4243 && overlay_list == NULL
4244 && overlay_max == NULL);
4245
4246 overlay_vma = vma_expr;
4247 overlay_lma = lma_expr;
4248 overlay_nocrossrefs = nocrossrefs;
4249}
4250
4251/* Start a section in an overlay. We handle this by calling
4252 lang_enter_output_section_statement with the correct VMA and LMA. */
4253
4254void
4255lang_enter_overlay_section (name)
4256 const char *name;
4257{
4258 struct overlay_list *n;
4259 etree_type *size;
4260
4261 lang_enter_output_section_statement (name, overlay_vma, normal_section,
4262 0, 0, 0, overlay_lma);
4263
4264 /* If this is the first section, then base the VMA and LMA of future
4265 sections on this one. This will work correctly even if `.' is
4266 used in the addresses. */
4267 if (overlay_list == NULL)
4268 {
4269 overlay_vma = exp_nameop (ADDR, name);
4270 overlay_lma = exp_nameop (LOADADDR, name);
4271 }
4272
4273 /* Remember the section. */
4274 n = (struct overlay_list *) xmalloc (sizeof *n);
4275 n->os = current_section;
4276 n->next = overlay_list;
4277 overlay_list = n;
4278
4279 size = exp_nameop (SIZEOF, name);
4280
4281 /* Adjust the LMA for the next section. */
4282 overlay_lma = exp_binop ('+', overlay_lma, size);
4283
4284 /* Arrange to work out the maximum section end address. */
4285 if (overlay_max == NULL)
4286 overlay_max = size;
4287 else
4288 overlay_max = exp_binop (MAX_K, overlay_max, size);
4289}
4290
4291/* Finish a section in an overlay. There isn't any special to do
4292 here. */
4293
4294void
4295lang_leave_overlay_section (fill, phdrs)
4296 bfd_vma fill;
4297 struct lang_output_section_phdr_list *phdrs;
4298{
4299 const char *name;
4300 char *clean, *s2;
4301 const char *s1;
4302 char *buf;
4303
4304 name = current_section->name;
4305
4306 lang_leave_output_section_statement (fill, "*default*", phdrs);
4307
4308 /* Define the magic symbols. */
4309
4310 clean = xmalloc (strlen (name) + 1);
4311 s2 = clean;
4312 for (s1 = name; *s1 != '\0'; s1++)
4313 if (isalnum ((unsigned char) *s1) || *s1 == '_')
4314 *s2++ = *s1;
4315 *s2 = '\0';
4316
4317 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4318 sprintf (buf, "__load_start_%s", clean);
4319 lang_add_assignment (exp_assop ('=', buf,
4320 exp_nameop (LOADADDR, name)));
4321
4322 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4323 sprintf (buf, "__load_stop_%s", clean);
4324 lang_add_assignment (exp_assop ('=', buf,
4325 exp_binop ('+',
4326 exp_nameop (LOADADDR, name),
4327 exp_nameop (SIZEOF, name))));
4328
4329 free (clean);
4330}
4331
4332/* Finish an overlay. If there are any overlay wide settings, this
4333 looks through all the sections in the overlay and sets them. */
4334
4335void
4336lang_leave_overlay (fill, memspec, phdrs)
4337 bfd_vma fill;
4338 const char *memspec;
4339 struct lang_output_section_phdr_list *phdrs;
4340{
4341 lang_memory_region_type *region;
4342 struct overlay_list *l;
4343 struct lang_nocrossref *nocrossref;
4344
4345 if (memspec == NULL)
4346 region = NULL;
4347 else
4348 region = lang_memory_region_lookup (memspec);
4349
4350 nocrossref = NULL;
4351
4352 l = overlay_list;
4353 while (l != NULL)
4354 {
4355 struct overlay_list *next;
4356
4357 if (fill != 0 && l->os->fill == 0)
4358 l->os->fill = fill;
4359 if (region != NULL && l->os->region == NULL)
4360 l->os->region = region;
4361 if (phdrs != NULL && l->os->phdrs == NULL)
4362 l->os->phdrs = phdrs;
4363
4364 if (overlay_nocrossrefs)
4365 {
4366 struct lang_nocrossref *nc;
4367
4368 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4369 nc->name = l->os->name;
4370 nc->next = nocrossref;
4371 nocrossref = nc;
4372 }
4373
4374 next = l->next;
4375 free (l);
4376 l = next;
4377 }
4378
4379 if (nocrossref != NULL)
4380 lang_add_nocrossref (nocrossref);
4381
4382 /* Update . for the end of the overlay. */
4383 lang_add_assignment (exp_assop ('=', ".",
4384 exp_binop ('+', overlay_vma, overlay_max)));
4385
4386 overlay_vma = NULL;
4387 overlay_lma = NULL;
4388 overlay_nocrossrefs = 0;
4389 overlay_list = NULL;
4390 overlay_max = NULL;
4391}
4392\f
4393/* Version handling. This is only useful for ELF. */
4394
4395/* This global variable holds the version tree that we build. */
4396
4397struct bfd_elf_version_tree *lang_elf_version_info;
4398
4399static int
4400lang_vers_match_lang_c (expr, sym)
4401 struct bfd_elf_version_expr *expr;
4402 const char *sym;
4403{
4404 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4405 return 1;
4406 return fnmatch (expr->pattern, sym, 0) == 0;
4407}
4408
4409static int
4410lang_vers_match_lang_cplusplus (expr, sym)
4411 struct bfd_elf_version_expr *expr;
4412 const char *sym;
4413{
4414 char *alt_sym;
4415 int result;
4416
4417 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4418 return 1;
4419
4420 alt_sym = cplus_demangle(sym, /* DMGL_NO_TPARAMS */ 0);
4421 if (!alt_sym)
4422 {
4423 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4424 Should we early out false in this case? */
4425 result = fnmatch (expr->pattern, sym, 0) == 0;
4426 }
4427 else
4428 {
4429 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4430 free (alt_sym);
4431 }
4432
4433 return result;
4434}
4435
4436static int
4437lang_vers_match_lang_java (expr, sym)
4438 struct bfd_elf_version_expr *expr;
4439 const char *sym;
4440{
4441 char *alt_sym;
4442 int result;
4443
4444 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4445 return 1;
4446
4447 alt_sym = cplus_demangle(sym, DMGL_JAVA);
4448 if (!alt_sym)
4449 {
4450 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4451 Should we early out false in this case? */
4452 result = fnmatch (expr->pattern, sym, 0) == 0;
4453 }
4454 else
4455 {
4456 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4457 free (alt_sym);
4458 }
4459
4460 return result;
4461}
4462
4463/* This is called for each variable name or match expression. */
4464
4465struct bfd_elf_version_expr *
4466lang_new_vers_regex (orig, new, lang)
4467 struct bfd_elf_version_expr *orig;
4468 const char *new;
4469 const char *lang;
4470{
4471 struct bfd_elf_version_expr *ret;
4472
4473 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
4474 ret->next = orig;
4475 ret->pattern = new;
4476
4477 if (lang == NULL || strcasecmp (lang, "C") == 0)
4478 ret->match = lang_vers_match_lang_c;
4479 else if (strcasecmp (lang, "C++") == 0)
4480 ret->match = lang_vers_match_lang_cplusplus;
4481 else if (strcasecmp (lang, "Java") == 0)
4482 ret->match = lang_vers_match_lang_java;
4483 else
4484 {
4485 einfo (_("%X%P: unknown language `%s' in version information\n"),
4486 lang);
4487 ret->match = lang_vers_match_lang_c;
4488 }
4489
4490 return ret;
4491}
4492
4493/* This is called for each set of variable names and match
4494 expressions. */
4495
4496struct bfd_elf_version_tree *
4497lang_new_vers_node (globals, locals)
4498 struct bfd_elf_version_expr *globals;
4499 struct bfd_elf_version_expr *locals;
4500{
4501 struct bfd_elf_version_tree *ret;
4502
4503 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
4504 ret->next = NULL;
4505 ret->name = NULL;
4506 ret->vernum = 0;
4507 ret->globals = globals;
4508 ret->locals = locals;
4509 ret->deps = NULL;
4510 ret->name_indx = (unsigned int) -1;
4511 ret->used = 0;
4512 return ret;
4513}
4514
4515/* This static variable keeps track of version indices. */
4516
4517static int version_index;
4518
4519/* This is called when we know the name and dependencies of the
4520 version. */
4521
4522void
4523lang_register_vers_node (name, version, deps)
4524 const char *name;
4525 struct bfd_elf_version_tree *version;
4526 struct bfd_elf_version_deps *deps;
4527{
4528 struct bfd_elf_version_tree *t, **pp;
4529 struct bfd_elf_version_expr *e1;
4530
4531 /* Make sure this node has a unique name. */
4532 for (t = lang_elf_version_info; t != NULL; t = t->next)
4533 if (strcmp (t->name, name) == 0)
4534 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
4535
4536 /* Check the global and local match names, and make sure there
4537 aren't any duplicates. */
4538
4539 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
4540 {
4541 for (t = lang_elf_version_info; t != NULL; t = t->next)
4542 {
4543 struct bfd_elf_version_expr *e2;
4544
4545 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
4546 if (strcmp (e1->pattern, e2->pattern) == 0)
4547 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4548 e1->pattern);
4549 }
4550 }
4551
4552 for (e1 = version->locals; e1 != NULL; e1 = e1->next)
4553 {
4554 for (t = lang_elf_version_info; t != NULL; t = t->next)
4555 {
4556 struct bfd_elf_version_expr *e2;
4557
4558 for (e2 = t->globals; e2 != NULL; e2 = e2->next)
4559 if (strcmp (e1->pattern, e2->pattern) == 0)
4560 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4561 e1->pattern);
4562 }
4563 }
4564
4565 version->deps = deps;
4566 version->name = name;
4567 ++version_index;
4568 version->vernum = version_index;
4569
4570 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
4571 ;
4572 *pp = version;
4573}
4574
4575/* This is called when we see a version dependency. */
4576
4577struct bfd_elf_version_deps *
4578lang_add_vers_depend (list, name)
4579 struct bfd_elf_version_deps *list;
4580 const char *name;
4581{
4582 struct bfd_elf_version_deps *ret;
4583 struct bfd_elf_version_tree *t;
4584
4585 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
4586 ret->next = list;
4587
4588 for (t = lang_elf_version_info; t != NULL; t = t->next)
4589 {
4590 if (strcmp (t->name, name) == 0)
4591 {
4592 ret->version_needed = t;
4593 return ret;
4594 }
4595 }
4596
4597 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
4598
4599 return ret;
4600}
4601
4602static void
4603lang_do_version_exports_section ()
4604{
4605 struct bfd_elf_version_expr *greg = NULL, *lreg;
4606
4607 LANG_FOR_EACH_INPUT_STATEMENT (is)
4608 {
4609 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
4610 char *contents, *p;
4611 bfd_size_type len;
4612
4613 if (sec == NULL)
4614 continue;
4615
4616 len = bfd_section_size (is->the_bfd, sec);
4617 contents = xmalloc (len);
4618 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
4619 einfo (_("%X%P: unable to read .exports section contents"), sec);
4620
4621 p = contents;
4622 while (p < contents+len)
4623 {
4624 greg = lang_new_vers_regex (greg, p, NULL);
4625 p = strchr (p, '\0') + 1;
4626 }
4627
4628 /* Do not free the contents, as we used them creating the regex. */
4629
4630 /* Do not include this section in the link. */
4631 bfd_set_section_flags (is->the_bfd, sec,
4632 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
4633 }
4634
4635 lreg = lang_new_vers_regex (NULL, "*", NULL);
4636 lang_register_vers_node (command_line.version_exports_section,
4637 lang_new_vers_node (greg, lreg), NULL);
4638}
GDB Binutils - Deliverables
This page took 0.196417 seconds and 4 git commands to generate.