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