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