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