projects / dragonfly.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | history | HEAD
binutils221: revisit start/stop label generation
[dragonfly.git] / contrib / binutils-2.21 / ld / ldlang.c
CommitLineData
5e4e6ec1
SW		 1/* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
5
6 This file is part of the GNU Binutils.
7
8 This program 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 3 of the License, or
11 (at your option) any later version.
12
13 This program 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 this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23#include "sysdep.h"
24#include "bfd.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#include "hashtab.h"
43#include "libbfd.h"
44#ifdef ENABLE_PLUGINS
45#include "plugin.h"
46#endif /* ENABLE_PLUGINS */
47
48#ifndef offsetof
49#define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
50#endif
51
52/* Locals variables. */
53static struct obstack stat_obstack;
54static struct obstack map_obstack;
55
56#define obstack_chunk_alloc xmalloc
57#define obstack_chunk_free free
58static const char *startup_file;
59static const char *entry_symbol_default = "start";
60static bfd_boolean placed_commons = FALSE;
61static bfd_boolean stripped_excluded_sections = FALSE;
62static lang_output_section_statement_type *default_common_section;
63static bfd_boolean map_option_f;
64static bfd_vma print_dot;
65static lang_input_statement_type *first_file;
66static const char *current_target;
67static lang_statement_list_type statement_list;
68static struct bfd_hash_table lang_definedness_table;
69static lang_statement_list_type *stat_save[10];
70static lang_statement_list_type **stat_save_ptr = &stat_save[0];
71static struct unique_sections *unique_section_list;
72static bfd_boolean ldlang_sysrooted_script = FALSE;
73
74/* Forward declarations. */
75static void exp_init_os (etree_type *);
76static void init_map_userdata (bfd *, asection *, void *);
77static lang_input_statement_type *lookup_name (const char *);
78static struct bfd_hash_entry *lang_definedness_newfunc
79 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
80static void insert_undefined (const char *);
81static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
82static void print_statement (lang_statement_union_type *,
83 lang_output_section_statement_type *);
84static void print_statement_list (lang_statement_union_type *,
85 lang_output_section_statement_type *);
86static void print_statements (void);
87static void print_input_section (asection *, bfd_boolean);
88static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
89static void lang_record_phdrs (void);
90static void lang_do_version_exports_section (void);
91static void lang_finalize_version_expr_head
92 (struct bfd_elf_version_expr_head *);
93
94/* Exported variables. */
95const char *output_target;
96lang_output_section_statement_type *abs_output_section;
97lang_statement_list_type lang_output_section_statement;
98lang_statement_list_type *stat_ptr = &statement_list;
99lang_statement_list_type file_chain = { NULL, NULL };
100lang_statement_list_type input_file_chain;
101struct bfd_sym_chain entry_symbol = { NULL, NULL };
102const char *entry_section = ".text";
103bfd_boolean entry_from_cmdline;
104bfd_boolean undef_from_cmdline;
105bfd_boolean lang_has_input_file = FALSE;
106bfd_boolean had_output_filename = FALSE;
107bfd_boolean lang_float_flag = FALSE;
108bfd_boolean delete_output_file_on_failure = FALSE;
109struct lang_phdr *lang_phdr_list;
110struct lang_nocrossrefs *nocrossref_list;
111bfd_boolean missing_file = FALSE;
112
113 /* Functions that traverse the linker script and might evaluate
114 DEFINED() need to increment this. */
115int lang_statement_iteration = 0;
116
117etree_type *base; /* Relocation base - or null */
118
119/* Return TRUE if the PATTERN argument is a wildcard pattern.
120 Although backslashes are treated specially if a pattern contains
121 wildcards, we do not consider the mere presence of a backslash to
122 be enough to cause the pattern to be treated as a wildcard.
123 That lets us handle DOS filenames more naturally. */
124#define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
125
126#define new_stat(x, y) \
127 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
128
129#define outside_section_address(q) \
130 ((q)->output_offset + (q)->output_section->vma)
131
132#define outside_symbol_address(q) \
133 ((q)->value + outside_section_address (q->section))
134
135#define SECTION_NAME_MAP_LENGTH (16)
136
137void *
138stat_alloc (size_t size)
139{
140 return obstack_alloc (&stat_obstack, size);
141}
142
143static int
144name_match (const char *pattern, const char *name)
145{
146 if (wildcardp (pattern))
147 return fnmatch (pattern, name, 0);
148 return strcmp (pattern, name);
149}
150
151/* If PATTERN is of the form archive:file, return a pointer to the
152 separator. If not, return NULL. */
153
154static char *
155archive_path (const char *pattern)
156{
157 char *p = NULL;
158
159 if (link_info.path_separator == 0)
160 return p;
161
162 p = strchr (pattern, link_info.path_separator);
163#ifdef HAVE_DOS_BASED_FILE_SYSTEM
164 if (p == NULL || link_info.path_separator != ':')
165 return p;
166
167 /* Assume a match on the second char is part of drive specifier,
168 as in "c:\silly.dos". */
169 if (p == pattern + 1 && ISALPHA (*pattern))
170 p = strchr (p + 1, link_info.path_separator);
171#endif
172 return p;
173}
174
175/* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
176 return whether F matches FILE_SPEC. */
177
178static bfd_boolean
179input_statement_is_archive_path (const char *file_spec, char *sep,
180 lang_input_statement_type *f)
181{
182 bfd_boolean match = FALSE;
183
184 if ((*(sep + 1) == 0
185 || name_match (sep + 1, f->filename) == 0)
186 && ((sep != file_spec)
187 == (f->the_bfd != NULL && f->the_bfd->my_archive != NULL)))
188 {
189 match = TRUE;
190
191 if (sep != file_spec)
192 {
193 const char *aname = f->the_bfd->my_archive->filename;
194 *sep = 0;
195 match = name_match (file_spec, aname) == 0;
196 *sep = link_info.path_separator;
197 }
198 }
199 return match;
200}
201
202static bfd_boolean
203unique_section_p (const asection *sec,
204 const lang_output_section_statement_type *os)
205{
206 struct unique_sections *unam;
207 const char *secnam;
208
209 if (link_info.relocatable
210 && sec->owner != NULL
211 && bfd_is_group_section (sec->owner, sec))
212 return !(os != NULL
213 && strcmp (os->name, DISCARD_SECTION_NAME) == 0);
214
215 secnam = sec->name;
216 for (unam = unique_section_list; unam; unam = unam->next)
217 if (name_match (unam->name, secnam) == 0)
218 return TRUE;
219
220 return FALSE;
221}
222
223/* Generic traversal routines for finding matching sections. */
224
225/* Try processing a section against a wildcard. This just calls
226 the callback unless the filename exclusion list is present
227 and excludes the file. It's hardly ever present so this
228 function is very fast. */
229
230static void
231walk_wild_consider_section (lang_wild_statement_type *ptr,
232 lang_input_statement_type *file,
233 asection *s,
234 struct wildcard_list *sec,
235 callback_t callback,
236 void *data)
237{
238 struct name_list *list_tmp;
239
240 /* Don't process sections from files which were excluded. */
241 for (list_tmp = sec->spec.exclude_name_list;
242 list_tmp;
243 list_tmp = list_tmp->next)
244 {
245 char *p = archive_path (list_tmp->name);
246
247 if (p != NULL)
248 {
249 if (input_statement_is_archive_path (list_tmp->name, p, file))
250 return;
251 }
252
253 else if (name_match (list_tmp->name, file->filename) == 0)
254 return;
255
256 /* FIXME: Perhaps remove the following at some stage? Matching
257 unadorned archives like this was never documented and has
258 been superceded by the archive:path syntax. */
259 else if (file->the_bfd != NULL
260 && file->the_bfd->my_archive != NULL
261 && name_match (list_tmp->name,
262 file->the_bfd->my_archive->filename) == 0)
263 return;
264 }
265
266 (*callback) (ptr, sec, s, file, data);
267}
268
269/* Lowest common denominator routine that can handle everything correctly,
270 but slowly. */
271
272static void
273walk_wild_section_general (lang_wild_statement_type *ptr,
274 lang_input_statement_type *file,
275 callback_t callback,
276 void *data)
277{
278 asection *s;
279 struct wildcard_list *sec;
280
281 for (s = file->the_bfd->sections; s != NULL; s = s->next)
282 {
283 sec = ptr->section_list;
284 if (sec == NULL)
285 (*callback) (ptr, sec, s, file, data);
286
287 while (sec != NULL)
288 {
289 bfd_boolean skip = FALSE;
290
291 if (sec->spec.name != NULL)
292 {
293 const char *sname = bfd_get_section_name (file->the_bfd, s);
294
295 skip = name_match (sec->spec.name, sname) != 0;
296 }
297
298 if (!skip)
299 walk_wild_consider_section (ptr, file, s, sec, callback, data);
300
301 sec = sec->next;
302 }
303 }
304}
305
306/* Routines to find a single section given its name. If there's more
307 than one section with that name, we report that. */
308
309typedef struct
310{
311 asection *found_section;
312 bfd_boolean multiple_sections_found;
313} section_iterator_callback_data;
314
315static bfd_boolean
316section_iterator_callback (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *data)
317{
318 section_iterator_callback_data *d = (section_iterator_callback_data *) data;
319
320 if (d->found_section != NULL)
321 {
322 d->multiple_sections_found = TRUE;
323 return TRUE;
324 }
325
326 d->found_section = s;
327 return FALSE;
328}
329
330static asection *
331find_section (lang_input_statement_type *file,
332 struct wildcard_list *sec,
333 bfd_boolean *multiple_sections_found)
334{
335 section_iterator_callback_data cb_data = { NULL, FALSE };
336
337 bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,
338 section_iterator_callback, &cb_data);
339 *multiple_sections_found = cb_data.multiple_sections_found;
340 return cb_data.found_section;
341}
342
343/* Code for handling simple wildcards without going through fnmatch,
344 which can be expensive because of charset translations etc. */
345
346/* A simple wild is a literal string followed by a single '*',
347 where the literal part is at least 4 characters long. */
348
349static bfd_boolean
350is_simple_wild (const char *name)
351{
352 size_t len = strcspn (name, "*?[");
353 return len >= 4 && name[len] == '*' && name[len + 1] == '\0';
354}
355
356static bfd_boolean
357match_simple_wild (const char *pattern, const char *name)
358{
359 /* The first four characters of the pattern are guaranteed valid
360 non-wildcard characters. So we can go faster. */
361 if (pattern[0] != name[0] || pattern[1] != name[1]
362 || pattern[2] != name[2] || pattern[3] != name[3])
363 return FALSE;
364
365 pattern += 4;
366 name += 4;
367 while (*pattern != '*')
368 if (*name++ != *pattern++)
369 return FALSE;
370
371 return TRUE;
372}
373
374/* Compare sections ASEC and BSEC according to SORT. */
375
376static int
377compare_section (sort_type sort, asection *asec, asection *bsec)
378{
379 int ret;
380
381 switch (sort)
382 {
383 default:
384 abort ();
385
386 case by_alignment_name:
387 ret = (bfd_section_alignment (bsec->owner, bsec)
388 - bfd_section_alignment (asec->owner, asec));
389 if (ret)
390 break;
391 /* Fall through. */
392
393 case by_name:
394 ret = strcmp (bfd_get_section_name (asec->owner, asec),
395 bfd_get_section_name (bsec->owner, bsec));
396 break;
397
398 case by_name_alignment:
399 ret = strcmp (bfd_get_section_name (asec->owner, asec),
400 bfd_get_section_name (bsec->owner, bsec));
401 if (ret)
402 break;
403 /* Fall through. */
404
405 case by_alignment:
406 ret = (bfd_section_alignment (bsec->owner, bsec)
407 - bfd_section_alignment (asec->owner, asec));
408 break;
409 }
410
411 return ret;
412}
413
414/* Build a Binary Search Tree to sort sections, unlike insertion sort
415 used in wild_sort(). BST is considerably faster if the number of
416 of sections are large. */
417
418static lang_section_bst_type **
419wild_sort_fast (lang_wild_statement_type *wild,
420 struct wildcard_list *sec,
421 lang_input_statement_type *file ATTRIBUTE_UNUSED,
422 asection *section)
423{
424 lang_section_bst_type **tree;
425
426 tree = &wild->tree;
427 if (!wild->filenames_sorted
428 && (sec == NULL || sec->spec.sorted == none))
429 {
430 /* Append at the right end of tree. */
431 while (*tree)
432 tree = &((*tree)->right);
433 return tree;
434 }
435
436 while (*tree)
437 {
438 /* Find the correct node to append this section. */
439 if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)
440 tree = &((*tree)->left);
441 else
442 tree = &((*tree)->right);
443 }
444
445 return tree;
446}
447
448/* Use wild_sort_fast to build a BST to sort sections. */
449
450static void
451output_section_callback_fast (lang_wild_statement_type *ptr,
452 struct wildcard_list *sec,
453 asection *section,
454 lang_input_statement_type *file,
455 void *output)
456{
457 lang_section_bst_type *node;
458 lang_section_bst_type **tree;
459 lang_output_section_statement_type *os;
460
461 os = (lang_output_section_statement_type *) output;
462
463 if (unique_section_p (section, os))
464 return;
465
466 node = (lang_section_bst_type *) xmalloc (sizeof (lang_section_bst_type));
467 node->left = 0;
468 node->right = 0;
469 node->section = section;
470
471 tree = wild_sort_fast (ptr, sec, file, section);
472 if (tree != NULL)
473 *tree = node;
474}
475
476/* Convert a sorted sections' BST back to list form. */
477
478static void
479output_section_callback_tree_to_list (lang_wild_statement_type *ptr,
480 lang_section_bst_type *tree,
481 void *output)
482{
483 if (tree->left)
484 output_section_callback_tree_to_list (ptr, tree->left, output);
485
486 lang_add_section (&ptr->children, tree->section,
487 (lang_output_section_statement_type *) output);
488
489 if (tree->right)
490 output_section_callback_tree_to_list (ptr, tree->right, output);
491
492 free (tree);
493}
494
495/* Specialized, optimized routines for handling different kinds of
496 wildcards */
497
498static void
499walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
500 lang_input_statement_type *file,
501 callback_t callback,
502 void *data)
503{
504 /* We can just do a hash lookup for the section with the right name.
505 But if that lookup discovers more than one section with the name
506 (should be rare), we fall back to the general algorithm because
507 we would otherwise have to sort the sections to make sure they
508 get processed in the bfd's order. */
509 bfd_boolean multiple_sections_found;
510 struct wildcard_list *sec0 = ptr->handler_data[0];
511 asection *s0 = find_section (file, sec0, &multiple_sections_found);
512
513 if (multiple_sections_found)
514 walk_wild_section_general (ptr, file, callback, data);
515 else if (s0)
516 walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
517}
518
519static void
520walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
521 lang_input_statement_type *file,
522 callback_t callback,
523 void *data)
524{
525 asection *s;
526 struct wildcard_list *wildsec0 = ptr->handler_data[0];
527
528 for (s = file->the_bfd->sections; s != NULL; s = s->next)
529 {
530 const char *sname = bfd_get_section_name (file->the_bfd, s);
531 bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);
532
533 if (!skip)
534 walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
535 }
536}
537
538static void
539walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
540 lang_input_statement_type *file,
541 callback_t callback,
542 void *data)
543{
544 asection *s;
545 struct wildcard_list *sec0 = ptr->handler_data[0];
546 struct wildcard_list *wildsec1 = ptr->handler_data[1];
547 bfd_boolean multiple_sections_found;
548 asection *s0 = find_section (file, sec0, &multiple_sections_found);
549
550 if (multiple_sections_found)
551 {
552 walk_wild_section_general (ptr, file, callback, data);
553 return;
554 }
555
556 /* Note that if the section was not found, s0 is NULL and
557 we'll simply never succeed the s == s0 test below. */
558 for (s = file->the_bfd->sections; s != NULL; s = s->next)
559 {
560 /* Recall that in this code path, a section cannot satisfy more
561 than one spec, so if s == s0 then it cannot match
562 wildspec1. */
563 if (s == s0)
564 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
565 else
566 {
567 const char *sname = bfd_get_section_name (file->the_bfd, s);
568 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
569
570 if (!skip)
571 walk_wild_consider_section (ptr, file, s, wildsec1, callback,
572 data);
573 }
574 }
575}
576
577static void
578walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
579 lang_input_statement_type *file,
580 callback_t callback,
581 void *data)
582{
583 asection *s;
584 struct wildcard_list *sec0 = ptr->handler_data[0];
585 struct wildcard_list *wildsec1 = ptr->handler_data[1];
586 struct wildcard_list *wildsec2 = ptr->handler_data[2];
587 bfd_boolean multiple_sections_found;
588 asection *s0 = find_section (file, sec0, &multiple_sections_found);
589
590 if (multiple_sections_found)
591 {
592 walk_wild_section_general (ptr, file, callback, data);
593 return;
594 }
595
596 for (s = file->the_bfd->sections; s != NULL; s = s->next)
597 {
598 if (s == s0)
599 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
600 else
601 {
602 const char *sname = bfd_get_section_name (file->the_bfd, s);
603 bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
604
605 if (!skip)
606 walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
607 else
608 {
609 skip = !match_simple_wild (wildsec2->spec.name, sname);
610 if (!skip)
611 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
612 data);
613 }
614 }
615 }
616}
617
618static void
619walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
620 lang_input_statement_type *file,
621 callback_t callback,
622 void *data)
623{
624 asection *s;
625 struct wildcard_list *sec0 = ptr->handler_data[0];
626 struct wildcard_list *sec1 = ptr->handler_data[1];
627 struct wildcard_list *wildsec2 = ptr->handler_data[2];
628 struct wildcard_list *wildsec3 = ptr->handler_data[3];
629 bfd_boolean multiple_sections_found;
630 asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1;
631
632 if (multiple_sections_found)
633 {
634 walk_wild_section_general (ptr, file, callback, data);
635 return;
636 }
637
638 s1 = find_section (file, sec1, &multiple_sections_found);
639 if (multiple_sections_found)
640 {
641 walk_wild_section_general (ptr, file, callback, data);
642 return;
643 }
644
645 for (s = file->the_bfd->sections; s != NULL; s = s->next)
646 {
647 if (s == s0)
648 walk_wild_consider_section (ptr, file, s, sec0, callback, data);
649 else
650 if (s == s1)
651 walk_wild_consider_section (ptr, file, s, sec1, callback, data);
652 else
653 {
654 const char *sname = bfd_get_section_name (file->the_bfd, s);
655 bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,
656 sname);
657
658 if (!skip)
659 walk_wild_consider_section (ptr, file, s, wildsec2, callback,
660 data);
661 else
662 {
663 skip = !match_simple_wild (wildsec3->spec.name, sname);
664 if (!skip)
665 walk_wild_consider_section (ptr, file, s, wildsec3,
666 callback, data);
667 }
668 }
669 }
670}
671
672static void
673walk_wild_section (lang_wild_statement_type *ptr,
674 lang_input_statement_type *file,
675 callback_t callback,
676 void *data)
677{
678 if (file->just_syms_flag)
679 return;
680
681 (*ptr->walk_wild_section_handler) (ptr, file, callback, data);
682}
683
684/* Returns TRUE when name1 is a wildcard spec that might match
685 something name2 can match. We're conservative: we return FALSE
686 only if the prefixes of name1 and name2 are different up to the
687 first wildcard character. */
688
689static bfd_boolean
690wild_spec_can_overlap (const char *name1, const char *name2)
691{
692 size_t prefix1_len = strcspn (name1, "?*[");
693 size_t prefix2_len = strcspn (name2, "?*[");
694 size_t min_prefix_len;
695
696 /* Note that if there is no wildcard character, then we treat the
697 terminating 0 as part of the prefix. Thus ".text" won't match
698 ".text." or ".text.*", for example. */
699 if (name1[prefix1_len] == '\0')
700 prefix1_len++;
701 if (name2[prefix2_len] == '\0')
702 prefix2_len++;
703
704 min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;
705
706 return memcmp (name1, name2, min_prefix_len) == 0;
707}
708
709/* Select specialized code to handle various kinds of wildcard
710 statements. */
711
712static void
713analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
714{
715 int sec_count = 0;
716 int wild_name_count = 0;
717 struct wildcard_list *sec;
718 int signature;
719 int data_counter;
720
721 ptr->walk_wild_section_handler = walk_wild_section_general;
722 ptr->handler_data[0] = NULL;
723 ptr->handler_data[1] = NULL;
724 ptr->handler_data[2] = NULL;
725 ptr->handler_data[3] = NULL;
726 ptr->tree = NULL;
727
728 /* Count how many wildcard_specs there are, and how many of those
729 actually use wildcards in the name. Also, bail out if any of the
730 wildcard names are NULL. (Can this actually happen?
731 walk_wild_section used to test for it.) And bail out if any
732 of the wildcards are more complex than a simple string
733 ending in a single '*'. */
734 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
735 {
736 ++sec_count;
737 if (sec->spec.name == NULL)
738 return;
739 if (wildcardp (sec->spec.name))
740 {
741 ++wild_name_count;
742 if (!is_simple_wild (sec->spec.name))
743 return;
744 }
745 }
746
747 /* The zero-spec case would be easy to optimize but it doesn't
748 happen in practice. Likewise, more than 4 specs doesn't
749 happen in practice. */
750 if (sec_count == 0 || sec_count > 4)
751 return;
752
753 /* Check that no two specs can match the same section. */
754 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
755 {
756 struct wildcard_list *sec2;
757 for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)
758 {
759 if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))
760 return;
761 }
762 }
763
764 signature = (sec_count << 8) + wild_name_count;
765 switch (signature)
766 {
767 case 0x0100:
768 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
769 break;
770 case 0x0101:
771 ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
772 break;
773 case 0x0201:
774 ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
775 break;
776 case 0x0302:
777 ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
778 break;
779 case 0x0402:
780 ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
781 break;
782 default:
783 return;
784 }
785
786 /* Now fill the data array with pointers to the specs, first the
787 specs with non-wildcard names, then the specs with wildcard
788 names. It's OK to process the specs in different order from the
789 given order, because we've already determined that no section
790 will match more than one spec. */
791 data_counter = 0;
792 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
793 if (!wildcardp (sec->spec.name))
794 ptr->handler_data[data_counter++] = sec;
795 for (sec = ptr->section_list; sec != NULL; sec = sec->next)
796 if (wildcardp (sec->spec.name))
797 ptr->handler_data[data_counter++] = sec;
798}
799
800/* Handle a wild statement for a single file F. */
801
802static void
803walk_wild_file (lang_wild_statement_type *s,
804 lang_input_statement_type *f,
805 callback_t callback,
806 void *data)
807{
808 if (f->the_bfd == NULL
809 || ! bfd_check_format (f->the_bfd, bfd_archive))
810 walk_wild_section (s, f, callback, data);
811 else
812 {
813 bfd *member;
814
815 /* This is an archive file. We must map each member of the
816 archive separately. */
817 member = bfd_openr_next_archived_file (f->the_bfd, NULL);
818 while (member != NULL)
819 {
820 /* When lookup_name is called, it will call the add_symbols
821 entry point for the archive. For each element of the
822 archive which is included, BFD will call ldlang_add_file,
823 which will set the usrdata field of the member to the
824 lang_input_statement. */
825 if (member->usrdata != NULL)
826 {
827 walk_wild_section (s,
828 (lang_input_statement_type *) member->usrdata,
829 callback, data);
830 }
831
832 member = bfd_openr_next_archived_file (f->the_bfd, member);
833 }
834 }
835}
836
837static void
838walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
839{
840 const char *file_spec = s->filename;
841 char *p;
842
843 if (file_spec == NULL)
844 {
845 /* Perform the iteration over all files in the list. */
846 LANG_FOR_EACH_INPUT_STATEMENT (f)
847 {
848 walk_wild_file (s, f, callback, data);
849 }
850 }
851 else if ((p = archive_path (file_spec)) != NULL)
852 {
853 LANG_FOR_EACH_INPUT_STATEMENT (f)
854 {
855 if (input_statement_is_archive_path (file_spec, p, f))
856 walk_wild_file (s, f, callback, data);
857 }
858 }
859 else if (wildcardp (file_spec))
860 {
861 LANG_FOR_EACH_INPUT_STATEMENT (f)
862 {
863 if (fnmatch (file_spec, f->filename, 0) == 0)
864 walk_wild_file (s, f, callback, data);
865 }
866 }
867 else
868 {
869 lang_input_statement_type *f;
870
871 /* Perform the iteration over a single file. */
872 f = lookup_name (file_spec);
873 if (f)
874 walk_wild_file (s, f, callback, data);
875 }
876}
877
878/* lang_for_each_statement walks the parse tree and calls the provided
879 function for each node, except those inside output section statements
880 with constraint set to -1. */
881
882void
883lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
884 lang_statement_union_type *s)
885{
886 for (; s != NULL; s = s->header.next)
887 {
888 func (s);
889
890 switch (s->header.type)
891 {
892 case lang_constructors_statement_enum:
893 lang_for_each_statement_worker (func, constructor_list.head);
894 break;
895 case lang_output_section_statement_enum:
896 if (s->output_section_statement.constraint != -1)
897 lang_for_each_statement_worker
898 (func, s->output_section_statement.children.head);
899 break;
900 case lang_wild_statement_enum:
901 lang_for_each_statement_worker (func,
902 s->wild_statement.children.head);
903 break;
904 case lang_group_statement_enum:
905 lang_for_each_statement_worker (func,
906 s->group_statement.children.head);
907 break;
908 case lang_data_statement_enum:
909 case lang_reloc_statement_enum:
910 case lang_object_symbols_statement_enum:
911 case lang_output_statement_enum:
912 case lang_target_statement_enum:
913 case lang_input_section_enum:
914 case lang_input_statement_enum:
915 case lang_assignment_statement_enum:
916 case lang_padding_statement_enum:
917 case lang_address_statement_enum:
918 case lang_fill_statement_enum:
919 case lang_insert_statement_enum:
920 break;
921 default:
922 FAIL ();
923 break;
924 }
925 }
926}
927
928void
929lang_for_each_statement (void (*func) (lang_statement_union_type *))
930{
931 lang_for_each_statement_worker (func, statement_list.head);
932}
933
934/*----------------------------------------------------------------------*/
935
936void
937lang_list_init (lang_statement_list_type *list)
938{
939 list->head = NULL;
940 list->tail = &list->head;
941}
942
943void
944push_stat_ptr (lang_statement_list_type *new_ptr)
945{
946 if (stat_save_ptr >= stat_save + sizeof (stat_save) / sizeof (stat_save[0]))
947 abort ();
948 *stat_save_ptr++ = stat_ptr;
949 stat_ptr = new_ptr;
950}
951
952void
953pop_stat_ptr (void)
954{
955 if (stat_save_ptr <= stat_save)
956 abort ();
957 stat_ptr = *--stat_save_ptr;
958}
959
960/* Build a new statement node for the parse tree. */
961
962static lang_statement_union_type *
963new_statement (enum statement_enum type,
964 size_t size,
965 lang_statement_list_type *list)
966{
967 lang_statement_union_type *new_stmt;
968
969 new_stmt = (lang_statement_union_type *) stat_alloc (size);
970 new_stmt->header.type = type;
971 new_stmt->header.next = NULL;
972 lang_statement_append (list, new_stmt, &new_stmt->header.next);
973 return new_stmt;
974}
975
976/* Build a new input file node for the language. There are several
977 ways in which we treat an input file, eg, we only look at symbols,
978 or prefix it with a -l etc.
979
980 We can be supplied with requests for input files more than once;
981 they may, for example be split over several lines like foo.o(.text)
982 foo.o(.data) etc, so when asked for a file we check that we haven't
983 got it already so we don't duplicate the bfd. */
984
985static lang_input_statement_type *
986new_afile (const char *name,
987 lang_input_file_enum_type file_type,
988 const char *target,
989 bfd_boolean add_to_list)
990{
991 lang_input_statement_type *p;
992
993 if (add_to_list)
994 p = (lang_input_statement_type *) new_stat (lang_input_statement, stat_ptr);
995 else
996 {
997 p = (lang_input_statement_type *)
998 stat_alloc (sizeof (lang_input_statement_type));
999 p->header.type = lang_input_statement_enum;
1000 p->header.next = NULL;
1001 }
1002
1003 lang_has_input_file = TRUE;
1004 p->target = target;
1005 p->sysrooted = FALSE;
1006
1007 if (file_type == lang_input_file_is_l_enum
1008 && name[0] == ':' && name[1] != '\0')
1009 {
1010 file_type = lang_input_file_is_search_file_enum;
1011 name = name + 1;
1012 }
1013
1014 switch (file_type)
1015 {
1016 case lang_input_file_is_symbols_only_enum:
1017 p->filename = name;
1018 p->maybe_archive = FALSE;
1019 p->real = TRUE;
1020 p->local_sym_name = name;
1021 p->just_syms_flag = TRUE;
1022 p->search_dirs_flag = FALSE;
1023 break;
1024 case lang_input_file_is_fake_enum:
1025 p->filename = name;
1026 p->maybe_archive = FALSE;
1027 p->real = FALSE;
1028 p->local_sym_name = name;
1029 p->just_syms_flag = FALSE;
1030 p->search_dirs_flag = FALSE;
1031 break;
1032 case lang_input_file_is_l_enum:
1033 p->maybe_archive = TRUE;
1034 p->filename = name;
1035 p->real = TRUE;
1036 p->local_sym_name = concat ("-l", name, (const char *) NULL);
1037 p->just_syms_flag = FALSE;
1038 p->search_dirs_flag = TRUE;
1039 break;
1040 case lang_input_file_is_marker_enum:
1041 p->filename = name;
1042 p->maybe_archive = FALSE;
1043 p->real = FALSE;
1044 p->local_sym_name = name;
1045 p->just_syms_flag = FALSE;
1046 p->search_dirs_flag = TRUE;
1047 break;
1048 case lang_input_file_is_search_file_enum:
1049 p->sysrooted = ldlang_sysrooted_script;
1050 p->filename = name;
1051 p->maybe_archive = FALSE;
1052 p->real = TRUE;
1053 p->local_sym_name = name;
1054 p->just_syms_flag = FALSE;
1055 p->search_dirs_flag = TRUE;
1056 break;
1057 case lang_input_file_is_file_enum:
1058 p->filename = name;
1059 p->maybe_archive = FALSE;
1060 p->real = TRUE;
1061 p->local_sym_name = name;
1062 p->just_syms_flag = FALSE;
1063 p->search_dirs_flag = FALSE;
1064 break;
1065 default:
1066 FAIL ();
1067 }
1068 p->the_bfd = NULL;
1069 p->next_real_file = NULL;
1070 p->next = NULL;
1071 p->dynamic = config.dynamic_link;
1072 p->add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;
1073 p->add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;
1074 p->whole_archive = whole_archive;
1075 p->loaded = FALSE;
1076 p->missing_file = FALSE;
1077
1078 lang_statement_append (&input_file_chain,
1079 (lang_statement_union_type *) p,
1080 &p->next_real_file);
1081 return p;
1082}
1083
1084lang_input_statement_type *
1085lang_add_input_file (const char *name,
1086 lang_input_file_enum_type file_type,
1087 const char *target)
1088{
1089 return new_afile (name, file_type, target, TRUE);
1090}
1091
1092struct out_section_hash_entry
1093{
1094 struct bfd_hash_entry root;
1095 lang_statement_union_type s;
1096};
1097
1098/* The hash table. */
1099
1100static struct bfd_hash_table output_section_statement_table;
1101
1102/* Support routines for the hash table used by lang_output_section_find,
1103 initialize the table, fill in an entry and remove the table. */
1104
1105static struct bfd_hash_entry *
1106output_section_statement_newfunc (struct bfd_hash_entry *entry,
1107 struct bfd_hash_table *table,
1108 const char *string)
1109{
1110 lang_output_section_statement_type **nextp;
1111 struct out_section_hash_entry *ret;
1112
1113 if (entry == NULL)
1114 {
1115 entry = (struct bfd_hash_entry *) bfd_hash_allocate (table,
1116 sizeof (*ret));
1117 if (entry == NULL)
1118 return entry;
1119 }
1120
1121 entry = bfd_hash_newfunc (entry, table, string);
1122 if (entry == NULL)
1123 return entry;
1124
1125 ret = (struct out_section_hash_entry *) entry;
1126 memset (&ret->s, 0, sizeof (ret->s));
1127 ret->s.header.type = lang_output_section_statement_enum;
1128 ret->s.output_section_statement.subsection_alignment = -1;
1129 ret->s.output_section_statement.section_alignment = -1;
1130 ret->s.output_section_statement.block_value = 1;
1131 lang_list_init (&ret->s.output_section_statement.children);
1132 lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);
1133
1134 /* For every output section statement added to the list, except the
1135 first one, lang_output_section_statement.tail points to the "next"
1136 field of the last element of the list. */
1137 if (lang_output_section_statement.head != NULL)
1138 ret->s.output_section_statement.prev
1139 = ((lang_output_section_statement_type *)
1140 ((char *) lang_output_section_statement.tail
1141 - offsetof (lang_output_section_statement_type, next)));
1142
1143 /* GCC's strict aliasing rules prevent us from just casting the
1144 address, so we store the pointer in a variable and cast that
1145 instead. */
1146 nextp = &ret->s.output_section_statement.next;
1147 lang_statement_append (&lang_output_section_statement,
1148 &ret->s,
1149 (lang_statement_union_type **) nextp);
1150 return &ret->root;
1151}
1152
1153static void
1154output_section_statement_table_init (void)
1155{
1156 if (!bfd_hash_table_init_n (&output_section_statement_table,
1157 output_section_statement_newfunc,
1158 sizeof (struct out_section_hash_entry),
1159 61))
1160 einfo (_("%P%F: can not create hash table: %E\n"));
1161}
1162
1163static void
1164output_section_statement_table_free (void)
1165{
1166 bfd_hash_table_free (&output_section_statement_table);
1167}
1168
1169/* Build enough state so that the parser can build its tree. */
1170
1171void
1172lang_init (void)
1173{
1174 obstack_begin (&stat_obstack, 1000);
1175
1176 stat_ptr = &statement_list;
1177
1178 output_section_statement_table_init ();
1179
1180 lang_list_init (stat_ptr);
1181
1182 lang_list_init (&input_file_chain);
1183 lang_list_init (&lang_output_section_statement);
1184 lang_list_init (&file_chain);
1185 first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
1186 NULL);
1187 abs_output_section =
1188 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME, 0, TRUE);
1189
1190 abs_output_section->bfd_section = bfd_abs_section_ptr;
1191
1192 /* The value "3" is ad-hoc, somewhat related to the expected number of
1193 DEFINED expressions in a linker script. For most default linker
1194 scripts, there are none. Why a hash table then? Well, it's somewhat
1195 simpler to re-use working machinery than using a linked list in terms
1196 of code-complexity here in ld, besides the initialization which just
1197 looks like other code here. */
1198 if (!bfd_hash_table_init_n (&lang_definedness_table,
1199 lang_definedness_newfunc,
1200 sizeof (struct lang_definedness_hash_entry),
1201 3))
1202 einfo (_("%P%F: can not create hash table: %E\n"));
1203}
1204
1205void
1206lang_finish (void)
1207{
1208 output_section_statement_table_free ();
1209}
1210
1211/*----------------------------------------------------------------------
1212 A region is an area of memory declared with the
1213 MEMORY { name:org=exp, len=exp ... }
1214 syntax.
1215
1216 We maintain a list of all the regions here.
1217
1218 If no regions are specified in the script, then the default is used
1219 which is created when looked up to be the entire data space.
1220
1221 If create is true we are creating a region inside a MEMORY block.
1222 In this case it is probably an error to create a region that has
1223 already been created. If we are not inside a MEMORY block it is
1224 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1225 and so we issue a warning.
1226
1227 Each region has at least one name. The first name is either
1228 DEFAULT_MEMORY_REGION or the name given in the MEMORY block. You can add
1229 alias names to an existing region within a script with
1230 REGION_ALIAS (alias, region_name). Each name corresponds to at most one
1231 region. */
1232
1233static lang_memory_region_type *lang_memory_region_list;
1234static lang_memory_region_type **lang_memory_region_list_tail
1235 = &lang_memory_region_list;
1236
1237lang_memory_region_type *
1238lang_memory_region_lookup (const char *const name, bfd_boolean create)
1239{
1240 lang_memory_region_name *n;
1241 lang_memory_region_type *r;
1242 lang_memory_region_type *new_region;
1243
1244 /* NAME is NULL for LMA memspecs if no region was specified. */
1245 if (name == NULL)
1246 return NULL;
1247
1248 for (r = lang_memory_region_list; r != NULL; r = r->next)
1249 for (n = &r->name_list; n != NULL; n = n->next)
1250 if (strcmp (n->name, name) == 0)
1251 {
1252 if (create)
1253 einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
1254 name);
1255 return r;
1256 }
1257
1258 if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
1259 einfo (_("%P:%S: warning: memory region `%s' not declared\n"), name);
1260
1261 new_region = (lang_memory_region_type *)
1262 stat_alloc (sizeof (lang_memory_region_type));
1263
1264 new_region->name_list.name = xstrdup (name);
1265 new_region->name_list.next = NULL;
1266 new_region->next = NULL;
1267 new_region->origin = 0;
1268 new_region->length = ~(bfd_size_type) 0;
1269 new_region->current = 0;
1270 new_region->last_os = NULL;
1271 new_region->flags = 0;
1272 new_region->not_flags = 0;
1273 new_region->had_full_message = FALSE;
1274
1275 *lang_memory_region_list_tail = new_region;
1276 lang_memory_region_list_tail = &new_region->next;
1277
1278 return new_region;
1279}
1280
1281void
1282lang_memory_region_alias (const char * alias, const char * region_name)
1283{
1284 lang_memory_region_name * n;
1285 lang_memory_region_type * r;
1286 lang_memory_region_type * region;
1287
1288 /* The default region must be unique. This ensures that it is not necessary
1289 to iterate through the name list if someone wants the check if a region is
1290 the default memory region. */
1291 if (strcmp (region_name, DEFAULT_MEMORY_REGION) == 0
1292 || strcmp (alias, DEFAULT_MEMORY_REGION) == 0)
1293 einfo (_("%F%P:%S: error: alias for default memory region\n"));
1294
1295 /* Look for the target region and check if the alias is not already
1296 in use. */
1297 region = NULL;
1298 for (r = lang_memory_region_list; r != NULL; r = r->next)
1299 for (n = &r->name_list; n != NULL; n = n->next)
1300 {
1301 if (region == NULL && strcmp (n->name, region_name) == 0)
1302 region = r;
1303 if (strcmp (n->name, alias) == 0)
1304 einfo (_("%F%P:%S: error: redefinition of memory region "
1305 "alias `%s'\n"),
1306 alias);
1307 }
1308
1309 /* Check if the target region exists. */
1310 if (region == NULL)
1311 einfo (_("%F%P:%S: error: memory region `%s' "
1312 "for alias `%s' does not exist\n"),
1313 region_name,
1314 alias);
1315
1316 /* Add alias to region name list. */
1317 n = (lang_memory_region_name *) stat_alloc (sizeof (lang_memory_region_name));
1318 n->name = xstrdup (alias);
1319 n->next = region->name_list.next;
1320 region->name_list.next = n;
1321}
1322
1323static lang_memory_region_type *
1324lang_memory_default (asection * section)
1325{
1326 lang_memory_region_type *p;
1327
1328 flagword sec_flags = section->flags;
1329
1330 /* Override SEC_DATA to mean a writable section. */
1331 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
1332 sec_flags |= SEC_DATA;
1333
1334 for (p = lang_memory_region_list; p != NULL; p = p->next)
1335 {
1336 if ((p->flags & sec_flags) != 0
1337 && (p->not_flags & sec_flags) == 0)
1338 {
1339 return p;
1340 }
1341 }
1342 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
1343}
1344
1345/* Find or create an output_section_statement with the given NAME.
1346 If CONSTRAINT is non-zero match one with that constraint, otherwise
1347 match any non-negative constraint. If CREATE, always make a
1348 new output_section_statement for SPECIAL CONSTRAINT. */
1349
1350lang_output_section_statement_type *
1351lang_output_section_statement_lookup (const char *name,
1352 int constraint,
1353 bfd_boolean create)
1354{
1355 struct out_section_hash_entry *entry;
1356
1357 entry = ((struct out_section_hash_entry *)
1358 bfd_hash_lookup (&output_section_statement_table, name,
1359 create, FALSE));
1360 if (entry == NULL)
1361 {
1362 if (create)
1363 einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1364 return NULL;
1365 }
1366
1367 if (entry->s.output_section_statement.name != NULL)
1368 {
1369 /* We have a section of this name, but it might not have the correct
1370 constraint. */
1371 struct out_section_hash_entry *last_ent;
1372
1373 name = entry->s.output_section_statement.name;
1374 if (create && constraint == SPECIAL)
1375 /* Not traversing to the end reverses the order of the second
1376 and subsequent SPECIAL sections in the hash table chain,
1377 but that shouldn't matter. */
1378 last_ent = entry;
1379 else
1380 do
1381 {
1382 if (constraint == entry->s.output_section_statement.constraint
1383 || (constraint == 0
1384 && entry->s.output_section_statement.constraint >= 0))
1385 return &entry->s.output_section_statement;
1386 last_ent = entry;
1387 entry = (struct out_section_hash_entry *) entry->root.next;
1388 }
1389 while (entry != NULL
1390 && name == entry->s.output_section_statement.name);
1391
1392 if (!create)
1393 return NULL;
1394
1395 entry
1396 = ((struct out_section_hash_entry *)
1397 output_section_statement_newfunc (NULL,
1398 &output_section_statement_table,
1399 name));
1400 if (entry == NULL)
1401 {
1402 einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1403 return NULL;
1404 }
1405 entry->root = last_ent->root;
1406 last_ent->root.next = &entry->root;
1407 }
1408
1409 entry->s.output_section_statement.name = name;
1410 entry->s.output_section_statement.constraint = constraint;
1411 return &entry->s.output_section_statement;
1412}
1413
1414/* Find the next output_section_statement with the same name as OS.
1415 If CONSTRAINT is non-zero, find one with that constraint otherwise
1416 match any non-negative constraint. */
1417
1418lang_output_section_statement_type *
1419next_matching_output_section_statement (lang_output_section_statement_type *os,
1420 int constraint)
1421{
1422 /* All output_section_statements are actually part of a
1423 struct out_section_hash_entry. */
1424 struct out_section_hash_entry *entry = (struct out_section_hash_entry *)
1425 ((char *) os
1426 - offsetof (struct out_section_hash_entry, s.output_section_statement));
1427 const char *name = os->name;
1428
1429 ASSERT (name == entry->root.string);
1430 do
1431 {
1432 entry = (struct out_section_hash_entry *) entry->root.next;
1433 if (entry == NULL
1434 || name != entry->s.output_section_statement.name)
1435 return NULL;
1436 }
1437 while (constraint != entry->s.output_section_statement.constraint
1438 && (constraint != 0
1439 || entry->s.output_section_statement.constraint < 0));
1440
1441 return &entry->s.output_section_statement;
1442}
1443
1444/* A variant of lang_output_section_find used by place_orphan.
1445 Returns the output statement that should precede a new output
1446 statement for SEC. If an exact match is found on certain flags,
1447 sets *EXACT too. */
1448
1449lang_output_section_statement_type *
1450lang_output_section_find_by_flags (const asection *sec,
1451 lang_output_section_statement_type **exact,
1452 lang_match_sec_type_func match_type)
1453{
1454 lang_output_section_statement_type *first, *look, *found;
1455 flagword flags;
1456
1457 /* We know the first statement on this list is *ABS*. May as well
1458 skip it. */
1459 first = &lang_output_section_statement.head->output_section_statement;
1460 first = first->next;
1461
1462 /* First try for an exact match. */
1463 found = NULL;
1464 for (look = first; look; look = look->next)
1465 {
1466 flags = look->flags;
1467 if (look->bfd_section != NULL)
1468 {
1469 flags = look->bfd_section->flags;
1470 if (match_type && !match_type (link_info.output_bfd,
1471 look->bfd_section,
1472 sec->owner, sec))
1473 continue;
1474 }
1475 flags ^= sec->flags;
1476 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1477 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1478 found = look;
1479 }
1480 if (found != NULL)
1481 {
1482 if (exact != NULL)
1483 *exact = found;
1484 return found;
1485 }
1486
1487 if ((sec->flags & SEC_CODE) != 0
1488 && (sec->flags & SEC_ALLOC) != 0)
1489 {
1490 /* Try for a rw code section. */
1491 for (look = first; look; look = look->next)
1492 {
1493 flags = look->flags;
1494 if (look->bfd_section != NULL)
1495 {
1496 flags = look->bfd_section->flags;
1497 if (match_type && !match_type (link_info.output_bfd,
1498 look->bfd_section,
1499 sec->owner, sec))
1500 continue;
1501 }
1502 flags ^= sec->flags;
1503 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1504 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1505 found = look;
1506 }
1507 }
1508 else if ((sec->flags & (SEC_READONLY | SEC_THREAD_LOCAL)) != 0
1509 && (sec->flags & SEC_ALLOC) != 0)
1510 {
1511 /* .rodata can go after .text, .sdata2 after .rodata. */
1512 for (look = first; look; look = look->next)
1513 {
1514 flags = look->flags;
1515 if (look->bfd_section != NULL)
1516 {
1517 flags = look->bfd_section->flags;
1518 if (match_type && !match_type (link_info.output_bfd,
1519 look->bfd_section,
1520 sec->owner, sec))
1521 continue;
1522 }
1523 flags ^= sec->flags;
1524 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1525 | SEC_READONLY))
1526 && !(look->flags & (SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1527 found = look;
1528 }
1529 }
1530 else if ((sec->flags & SEC_SMALL_DATA) != 0
1531 && (sec->flags & SEC_ALLOC) != 0)
1532 {
1533 /* .sdata goes after .data, .sbss after .sdata. */
1534 for (look = first; look; look = look->next)
1535 {
1536 flags = look->flags;
1537 if (look->bfd_section != NULL)
1538 {
1539 flags = look->bfd_section->flags;
1540 if (match_type && !match_type (link_info.output_bfd,
1541 look->bfd_section,
1542 sec->owner, sec))
1543 continue;
1544 }
1545 flags ^= sec->flags;
1546 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1547 | SEC_THREAD_LOCAL))
1548 || ((look->flags & SEC_SMALL_DATA)
1549 && !(sec->flags & SEC_HAS_CONTENTS)))
1550 found = look;
1551 }
1552 }
1553 else if ((sec->flags & SEC_HAS_CONTENTS) != 0
1554 && (sec->flags & SEC_ALLOC) != 0)
1555 {
1556 /* .data goes after .rodata. */
1557 for (look = first; look; look = look->next)
1558 {
1559 flags = look->flags;
1560 if (look->bfd_section != NULL)
1561 {
1562 flags = look->bfd_section->flags;
1563 if (match_type && !match_type (link_info.output_bfd,
1564 look->bfd_section,
1565 sec->owner, sec))
1566 continue;
1567 }
1568 flags ^= sec->flags;
1569 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1570 | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1571 found = look;
1572 }
1573 }
1574 else if ((sec->flags & SEC_ALLOC) != 0)
1575 {
1576 /* .bss goes after any other alloc section. */
1577 for (look = first; look; look = look->next)
1578 {
1579 flags = look->flags;
1580 if (look->bfd_section != NULL)
1581 {
1582 flags = look->bfd_section->flags;
1583 if (match_type && !match_type (link_info.output_bfd,
1584 look->bfd_section,
1585 sec->owner, sec))
1586 continue;
1587 }
1588 flags ^= sec->flags;
1589 if (!(flags & SEC_ALLOC))
1590 found = look;
1591 }
1592 }
1593 else
1594 {
1595 /* non-alloc go last. */
1596 for (look = first; look; look = look->next)
1597 {
1598 flags = look->flags;
1599 if (look->bfd_section != NULL)
1600 flags = look->bfd_section->flags;
1601 flags ^= sec->flags;
1602 if (!(flags & SEC_DEBUGGING))
1603 found = look;
1604 }
1605 return found;
1606 }
1607
1608 if (found || !match_type)
1609 return found;
1610
1611 return lang_output_section_find_by_flags (sec, NULL, NULL);
1612}
1613
1614/* Find the last output section before given output statement.
1615 Used by place_orphan. */
1616
1617static asection *
1618output_prev_sec_find (lang_output_section_statement_type *os)
1619{
1620 lang_output_section_statement_type *lookup;
1621
1622 for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)
1623 {
1624 if (lookup->constraint < 0)
1625 continue;
1626
1627 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1628 return lookup->bfd_section;
1629 }
1630
1631 return NULL;
1632}
1633
1634/* Look for a suitable place for a new output section statement. The
1635 idea is to skip over anything that might be inside a SECTIONS {}
1636 statement in a script, before we find another output section
1637 statement. Assignments to "dot" before an output section statement
1638 are assumed to belong to it, except in two cases; The first
1639 assignment to dot, and assignments before non-alloc sections.
1640 Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1641 similar assignments that set the initial address, or we might
1642 insert non-alloc note sections among assignments setting end of
1643 image symbols. */
1644
1645static lang_statement_union_type **
1646insert_os_after (lang_output_section_statement_type *after)
1647{
1648 lang_statement_union_type **where;
1649 lang_statement_union_type **assign = NULL;
1650 bfd_boolean ignore_first;
1651
1652 ignore_first
1653 = after == &lang_output_section_statement.head->output_section_statement;
1654
1655 for (where = &after->header.next;
1656 *where != NULL;
1657 where = &(*where)->header.next)
1658 {
1659 switch ((*where)->header.type)
1660 {
1661 case lang_assignment_statement_enum:
1662 if (assign == NULL)
1663 {
1664 lang_assignment_statement_type *ass;
1665
1666 ass = &(*where)->assignment_statement;
1667 if (ass->exp->type.node_class != etree_assert
1668 && ass->exp->assign.dst[0] == '.'
1669 && ass->exp->assign.dst[1] == 0
1670 && !ignore_first)
1671 assign = where;
1672 }
1673 ignore_first = FALSE;
1674 continue;
1675 case lang_wild_statement_enum:
1676 case lang_input_section_enum:
1677 case lang_object_symbols_statement_enum:
1678 case lang_fill_statement_enum:
1679 case lang_data_statement_enum:
1680 case lang_reloc_statement_enum:
1681 case lang_padding_statement_enum:
1682 case lang_constructors_statement_enum:
1683 assign = NULL;
1684 continue;
1685 case lang_output_section_statement_enum:
1686 if (assign != NULL)
1687 {
1688 asection *s = (*where)->output_section_statement.bfd_section;
1689
1690 if (s == NULL
1691 || s->map_head.s == NULL
1692 || (s->flags & SEC_ALLOC) != 0)
1693 where = assign;
1694 }
1695 break;
1696 case lang_input_statement_enum:
1697 case lang_address_statement_enum:
1698 case lang_target_statement_enum:
1699 case lang_output_statement_enum:
1700 case lang_group_statement_enum:
1701 case lang_insert_statement_enum:
1702 continue;
1703 }
1704 break;
1705 }
1706
1707 return where;
1708}
1709
1710lang_output_section_statement_type *
1711lang_insert_orphan (asection *s,
1712 const char *secname,
1713 int constraint,
1714 lang_output_section_statement_type *after,
1715 struct orphan_save *place,
1716 etree_type *address,
1717 lang_statement_list_type *add_child)
1718{
1719 lang_statement_list_type add;
1720 const char *ps;
1721 lang_output_section_statement_type *os;
1722 lang_output_section_statement_type **os_tail;
1723
1724 /* If we have found an appropriate place for the output section
1725 statements for this orphan, add them to our own private list,
1726 inserting them later into the global statement list. */
1727 if (after != NULL)
1728 {
1729 lang_list_init (&add);
1730 push_stat_ptr (&add);
1731 }
1732
1733 if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1734 address = exp_intop (0);
1735
1736 os_tail = ((lang_output_section_statement_type **)
1737 lang_output_section_statement.tail);
1738 os = lang_enter_output_section_statement (secname, address, normal_section,
1739 NULL, NULL, NULL, constraint);
1740
1741 ps = NULL;
1742 if (config.build_constructors && *os_tail == os)
1743 {
1744 /* If the name of the section is representable in C, then create
1745 symbols to mark the start and the end of the section. */
1746 for (ps = secname; *ps != '\0'; ps++)
1747 if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
1748 break;
1749 if (*ps == '\0')
1750 {
1751 char *symname;
1752 etree_type *e_align;
1753
1754 symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
1755 symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1756 sprintf (symname + (symname[0] != 0), "__start_%s", secname);
1757 e_align = exp_unop (ALIGN_K,
1758 exp_intop ((bfd_vma) 1 << s->alignment_power));
1759 lang_add_assignment (exp_assign (".", e_align));
f070647c
JM		 1760 if (link_info.shared)
1761 lang_add_assignment (exp_assign (symname,
1762 exp_unop (ABSOLUTE,
1763 exp_nameop (NAME, "."))));
1764 else
1765 lang_add_assignment (exp_provide (symname,
1766 exp_unop (ABSOLUTE,
1767 exp_nameop (NAME, ".")),
1768 FALSE));
5e4e6ec1
SW		 1769 }
1770 }
1771
1772 if (add_child == NULL)
1773 add_child = &os->children;
1774 lang_add_section (add_child, s, os);
1775
1776 if (after && (s->flags & (SEC_LOAD | SEC_ALLOC)) != 0)
1777 {
1778 const char *region = (after->region
1779 ? after->region->name_list.name
1780 : DEFAULT_MEMORY_REGION);
1781 const char *lma_region = (after->lma_region
1782 ? after->lma_region->name_list.name
1783 : NULL);
1784 lang_leave_output_section_statement (NULL, region, after->phdrs,
1785 lma_region);
1786 }
1787 else
1788 lang_leave_output_section_statement (NULL, DEFAULT_MEMORY_REGION, NULL,
1789 NULL);
1790
1791 if (ps != NULL && *ps == '\0')
1792 {
1793 char *symname;
1794
1795 symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
1796 symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1797 sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
f070647c
JM		 1798 if (link_info.shared)
1799 lang_add_assignment (exp_assign (symname,
1800 exp_nameop (NAME, ".")));
1801 else
1802 lang_add_assignment (exp_provide (symname,
1803 exp_nameop (NAME, "."),
1804 FALSE));
5e4e6ec1
SW		 1805 }
1806
1807 /* Restore the global list pointer. */
1808 if (after != NULL)
1809 pop_stat_ptr ();
1810
1811 if (after != NULL && os->bfd_section != NULL)
1812 {
1813 asection *snew, *as;
1814
1815 snew = os->bfd_section;
1816
1817 /* Shuffle the bfd section list to make the output file look
1818 neater. This is really only cosmetic. */
1819 if (place->section == NULL
1820 && after != (&lang_output_section_statement.head
1821 ->output_section_statement))
1822 {
1823 asection *bfd_section = after->bfd_section;
1824
1825 /* If the output statement hasn't been used to place any input
1826 sections (and thus doesn't have an output bfd_section),
1827 look for the closest prior output statement having an
1828 output section. */
1829 if (bfd_section == NULL)
1830 bfd_section = output_prev_sec_find (after);
1831
1832 if (bfd_section != NULL && bfd_section != snew)
1833 place->section = &bfd_section->next;
1834 }
1835
1836 if (place->section == NULL)
1837 place->section = &link_info.output_bfd->sections;
1838
1839 as = *place->section;
1840
1841 if (!as)
1842 {
1843 /* Put the section at the end of the list. */
1844
1845 /* Unlink the section. */
1846 bfd_section_list_remove (link_info.output_bfd, snew);
1847
1848 /* Now tack it back on in the right place. */
1849 bfd_section_list_append (link_info.output_bfd, snew);
1850 }
1851 else if (as != snew && as->prev != snew)
1852 {
1853 /* Unlink the section. */
1854 bfd_section_list_remove (link_info.output_bfd, snew);
1855
1856 /* Now tack it back on in the right place. */
1857 bfd_section_list_insert_before (link_info.output_bfd, as, snew);
1858 }
1859
1860 /* Save the end of this list. Further ophans of this type will
1861 follow the one we've just added. */
1862 place->section = &snew->next;
1863
1864 /* The following is non-cosmetic. We try to put the output
1865 statements in some sort of reasonable order here, because they
1866 determine the final load addresses of the orphan sections.
1867 In addition, placing output statements in the wrong order may
1868 require extra segments. For instance, given a typical
1869 situation of all read-only sections placed in one segment and
1870 following that a segment containing all the read-write
1871 sections, we wouldn't want to place an orphan read/write
1872 section before or amongst the read-only ones. */
1873 if (add.head != NULL)
1874 {
1875 lang_output_section_statement_type *newly_added_os;
1876
1877 if (place->stmt == NULL)
1878 {
1879 lang_statement_union_type **where = insert_os_after (after);
1880
1881 *add.tail = *where;
1882 *where = add.head;
1883
1884 place->os_tail = &after->next;
1885 }
1886 else
1887 {
1888 /* Put it after the last orphan statement we added. */
1889 *add.tail = *place->stmt;
1890 *place->stmt = add.head;
1891 }
1892
1893 /* Fix the global list pointer if we happened to tack our
1894 new list at the tail. */
1895 if (*stat_ptr->tail == add.head)
1896 stat_ptr->tail = add.tail;
1897
1898 /* Save the end of this list. */
1899 place->stmt = add.tail;
1900
1901 /* Do the same for the list of output section statements. */
1902 newly_added_os = *os_tail;
1903 *os_tail = NULL;
1904 newly_added_os->prev = (lang_output_section_statement_type *)
1905 ((char *) place->os_tail
1906 - offsetof (lang_output_section_statement_type, next));
1907 newly_added_os->next = *place->os_tail;
1908 if (newly_added_os->next != NULL)
1909 newly_added_os->next->prev = newly_added_os;
1910 *place->os_tail = newly_added_os;
1911 place->os_tail = &newly_added_os->next;
1912
1913 /* Fixing the global list pointer here is a little different.
1914 We added to the list in lang_enter_output_section_statement,
1915 trimmed off the new output_section_statment above when
1916 assigning *os_tail = NULL, but possibly added it back in
1917 the same place when assigning *place->os_tail. */
1918 if (*os_tail == NULL)
1919 lang_output_section_statement.tail
1920 = (lang_statement_union_type **) os_tail;
1921 }
1922 }
1923 return os;
1924}
1925
1926static void
1927lang_map_flags (flagword flag)
1928{
1929 if (flag & SEC_ALLOC)
1930 minfo ("a");
1931
1932 if (flag & SEC_CODE)
1933 minfo ("x");
1934
1935 if (flag & SEC_READONLY)
1936 minfo ("r");
1937
1938 if (flag & SEC_DATA)
1939 minfo ("w");
1940
1941 if (flag & SEC_LOAD)
1942 minfo ("l");
1943}
1944
1945void
1946lang_map (void)
1947{
1948 lang_memory_region_type *m;
1949 bfd_boolean dis_header_printed = FALSE;
1950 bfd *p;
1951
1952 LANG_FOR_EACH_INPUT_STATEMENT (file)
1953 {
1954 asection *s;
1955
1956 if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
1957 || file->just_syms_flag)
1958 continue;
1959
1960 for (s = file->the_bfd->sections; s != NULL; s = s->next)
1961 if ((s->output_section == NULL
1962 || s->output_section->owner != link_info.output_bfd)
1963 && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0)
1964 {
1965 if (! dis_header_printed)
1966 {
1967 fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
1968 dis_header_printed = TRUE;
1969 }
1970
1971 print_input_section (s, TRUE);
1972 }
1973 }
1974
1975 minfo (_("\nMemory Configuration\n\n"));
1976 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
1977 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1978
1979 for (m = lang_memory_region_list; m != NULL; m = m->next)
1980 {
1981 char buf[100];
1982 int len;
1983
1984 fprintf (config.map_file, "%-16s ", m->name_list.name);
1985
1986 sprintf_vma (buf, m->origin);
1987 minfo ("0x%s ", buf);
1988 len = strlen (buf);
1989 while (len < 16)
1990 {
1991 print_space ();
1992 ++len;
1993 }
1994
1995 minfo ("0x%V", m->length);
1996 if (m->flags || m->not_flags)
1997 {
1998#ifndef BFD64
1999 minfo (" ");
2000#endif
2001 if (m->flags)
2002 {
2003 print_space ();
2004 lang_map_flags (m->flags);
2005 }
2006
2007 if (m->not_flags)
2008 {
2009 minfo (" !");
2010 lang_map_flags (m->not_flags);
2011 }
2012 }
2013
2014 print_nl ();
2015 }
2016
2017 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
2018
2019 if (! link_info.reduce_memory_overheads)
2020 {
2021 obstack_begin (&map_obstack, 1000);
2022 for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
2023 bfd_map_over_sections (p, init_map_userdata, 0);
2024 bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
2025 }
2026 lang_statement_iteration ++;
2027 print_statements ();
2028}
2029
2030static void
2031init_map_userdata (bfd *abfd ATTRIBUTE_UNUSED,
2032 asection *sec,
2033 void *data ATTRIBUTE_UNUSED)
2034{
2035 fat_section_userdata_type *new_data
2036 = ((fat_section_userdata_type *) (stat_alloc
2037 (sizeof (fat_section_userdata_type))));
2038
2039 ASSERT (get_userdata (sec) == NULL);
2040 get_userdata (sec) = new_data;
2041 new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
2042 new_data->map_symbol_def_count = 0;
2043}
2044
2045static bfd_boolean
2046sort_def_symbol (struct bfd_link_hash_entry *hash_entry,
2047 void *info ATTRIBUTE_UNUSED)
2048{
2049 if (hash_entry->type == bfd_link_hash_warning)
2050 hash_entry = (struct bfd_link_hash_entry *) hash_entry->u.i.link;
2051
2052 if (hash_entry->type == bfd_link_hash_defined
2053 || hash_entry->type == bfd_link_hash_defweak)
2054 {
2055 struct fat_user_section_struct *ud;
2056 struct map_symbol_def *def;
2057
2058 ud = (struct fat_user_section_struct *)
2059 get_userdata (hash_entry->u.def.section);
2060 if (! ud)
2061 {
2062 /* ??? What do we have to do to initialize this beforehand? */
2063 /* The first time we get here is bfd_abs_section... */
2064 init_map_userdata (0, hash_entry->u.def.section, 0);
2065 ud = (struct fat_user_section_struct *)
2066 get_userdata (hash_entry->u.def.section);
2067 }
2068 else if (!ud->map_symbol_def_tail)
2069 ud->map_symbol_def_tail = &ud->map_symbol_def_head;
2070
2071 def = (struct map_symbol_def *) obstack_alloc (&map_obstack, sizeof *def);
2072 def->entry = hash_entry;
2073 *(ud->map_symbol_def_tail) = def;
2074 ud->map_symbol_def_tail = &def->next;
2075 ud->map_symbol_def_count++;
2076 }
2077 return TRUE;
2078}
2079
2080/* Initialize an output section. */
2081
2082static void
2083init_os (lang_output_section_statement_type *s, flagword flags)
2084{
2085 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
2086 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
2087
2088 if (s->constraint != SPECIAL)
2089 s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);
2090 if (s->bfd_section == NULL)
2091 s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd,
2092 s->name, flags);
2093 if (s->bfd_section == NULL)
2094 {
2095 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2096 link_info.output_bfd->xvec->name, s->name);
2097 }
2098 s->bfd_section->output_section = s->bfd_section;
2099 s->bfd_section->output_offset = 0;
2100
2101 if (!link_info.reduce_memory_overheads)
2102 {
2103 fat_section_userdata_type *new_userdata = (fat_section_userdata_type *)
2104 stat_alloc (sizeof (fat_section_userdata_type));
2105 memset (new_userdata, 0, sizeof (fat_section_userdata_type));
2106 get_userdata (s->bfd_section) = new_userdata;
2107 }
2108
2109 /* If there is a base address, make sure that any sections it might
2110 mention are initialized. */
2111 if (s->addr_tree != NULL)
2112 exp_init_os (s->addr_tree);
2113
2114 if (s->load_base != NULL)
2115 exp_init_os (s->load_base);
2116
2117 /* If supplied an alignment, set it. */
2118 if (s->section_alignment != -1)
2119 s->bfd_section->alignment_power = s->section_alignment;
2120}
2121
2122/* Make sure that all output sections mentioned in an expression are
2123 initialized. */
2124
2125static void
2126exp_init_os (etree_type *exp)
2127{
2128 switch (exp->type.node_class)
2129 {
2130 case etree_assign:
2131 case etree_provide:
2132 exp_init_os (exp->assign.src);
2133 break;
2134
2135 case etree_binary:
2136 exp_init_os (exp->binary.lhs);
2137 exp_init_os (exp->binary.rhs);
2138 break;
2139
2140 case etree_trinary:
2141 exp_init_os (exp->trinary.cond);
2142 exp_init_os (exp->trinary.lhs);
2143 exp_init_os (exp->trinary.rhs);
2144 break;
2145
2146 case etree_assert:
2147 exp_init_os (exp->assert_s.child);
2148 break;
2149
2150 case etree_unary:
2151 exp_init_os (exp->unary.child);
2152 break;
2153
2154 case etree_name:
2155 switch (exp->type.node_code)
2156 {
2157 case ADDR:
2158 case LOADADDR:
2159 case SIZEOF:
2160 {
2161 lang_output_section_statement_type *os;
2162
2163 os = lang_output_section_find (exp->name.name);
2164 if (os != NULL && os->bfd_section == NULL)
2165 init_os (os, 0);
2166 }
2167 }
2168 break;
2169
2170 default:
2171 break;
2172 }
2173}
2174\f
2175static void
2176section_already_linked (bfd *abfd, asection *sec, void *data)
2177{
2178 lang_input_statement_type *entry = (lang_input_statement_type *) data;
2179
2180 /* If we are only reading symbols from this object, then we want to
2181 discard all sections. */
2182 if (entry->just_syms_flag)
2183 {
2184 bfd_link_just_syms (abfd, sec, &link_info);
2185 return;
2186 }
2187
2188 if (!(abfd->flags & DYNAMIC))
2189 bfd_section_already_linked (abfd, sec, &link_info);
2190}
2191\f
2192/* The wild routines.
2193
2194 These expand statements like *(.text) and foo.o to a list of
2195 explicit actions, like foo.o(.text), bar.o(.text) and
2196 foo.o(.text, .data). */
2197
2198/* Add SECTION to the output section OUTPUT. Do this by creating a
2199 lang_input_section statement which is placed at PTR. FILE is the
2200 input file which holds SECTION. */
2201
2202void
2203lang_add_section (lang_statement_list_type *ptr,
2204 asection *section,
2205 lang_output_section_statement_type *output)
2206{
2207 flagword flags = section->flags;
2208 bfd_boolean discard;
2209 lang_input_section_type *new_section;
2210
2211 /* Discard sections marked with SEC_EXCLUDE. */
2212 discard = (flags & SEC_EXCLUDE) != 0;
2213
2214 /* Discard input sections which are assigned to a section named
2215 DISCARD_SECTION_NAME. */
2216 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
2217 discard = TRUE;
2218
2219 /* Discard debugging sections if we are stripping debugging
2220 information. */
2221 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
2222 && (flags & SEC_DEBUGGING) != 0)
2223 discard = TRUE;
2224
2225 if (discard)
2226 {
2227 if (section->output_section == NULL)
2228 {
2229 /* This prevents future calls from assigning this section. */
2230 section->output_section = bfd_abs_section_ptr;
2231 }
2232 return;
2233 }
2234
2235 if (section->output_section != NULL)
2236 return;
2237
2238 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2239 to an output section, because we want to be able to include a
2240 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2241 section (I don't know why we want to do this, but we do).
2242 build_link_order in ldwrite.c handles this case by turning
2243 the embedded SEC_NEVER_LOAD section into a fill. */
2244 flags &= ~ SEC_NEVER_LOAD;
2245
2246 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2247 already been processed. One reason to do this is that on pe
2248 format targets, .text$foo sections go into .text and it's odd
2249 to see .text with SEC_LINK_ONCE set. */
2250
2251 if (!link_info.relocatable)
2252 flags &= ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC);
2253
2254 switch (output->sectype)
2255 {
2256 case normal_section:
2257 case overlay_section:
2258 break;
2259 case noalloc_section:
2260 flags &= ~SEC_ALLOC;
2261 break;
2262 case noload_section:
2263 flags &= ~SEC_LOAD;
2264 flags |= SEC_NEVER_LOAD;
2265 /* Unfortunately GNU ld has managed to evolve two different
2266 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2267 alloc, no contents section. All others get a noload, noalloc
2268 section. */
2269 if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
2270 flags &= ~SEC_HAS_CONTENTS;
2271 else
2272 flags &= ~SEC_ALLOC;
2273 break;
2274 }
2275
2276 if (output->bfd_section == NULL)
2277 init_os (output, flags);
2278
2279 /* If SEC_READONLY is not set in the input section, then clear
2280 it from the output section. */
2281 output->bfd_section->flags &= flags | ~SEC_READONLY;
2282
2283 if (output->bfd_section->linker_has_input)
2284 {
2285 /* Only set SEC_READONLY flag on the first input section. */
2286 flags &= ~ SEC_READONLY;
2287
2288 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2289 if ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
2290 != (flags & (SEC_MERGE | SEC_STRINGS))
2291 || ((flags & SEC_MERGE) != 0
2292 && output->bfd_section->entsize != section->entsize))
2293 {
2294 output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
2295 flags &= ~ (SEC_MERGE | SEC_STRINGS);
2296 }
2297 }
2298 output->bfd_section->flags |= flags;
2299
2300 if (!output->bfd_section->linker_has_input)
2301 {
2302 output->bfd_section->linker_has_input = 1;
2303 /* This must happen after flags have been updated. The output
2304 section may have been created before we saw its first input
2305 section, eg. for a data statement. */
2306 bfd_init_private_section_data (section->owner, section,
2307 link_info.output_bfd,
2308 output->bfd_section,
2309 &link_info);
2310 if ((flags & SEC_MERGE) != 0)
2311 output->bfd_section->entsize = section->entsize;
2312 }
2313
2314 if ((flags & SEC_TIC54X_BLOCK) != 0
2315 && bfd_get_arch (section->owner) == bfd_arch_tic54x)
2316 {
2317 /* FIXME: This value should really be obtained from the bfd... */
2318 output->block_value = 128;
2319 }
2320
2321 if (section->alignment_power > output->bfd_section->alignment_power)
2322 output->bfd_section->alignment_power = section->alignment_power;
2323
2324 section->output_section = output->bfd_section;
2325
2326 if (!link_info.relocatable
2327 && !stripped_excluded_sections)
2328 {
2329 asection *s = output->bfd_section->map_tail.s;
2330 output->bfd_section->map_tail.s = section;
2331 section->map_head.s = NULL;
2332 section->map_tail.s = s;
2333 if (s != NULL)
2334 s->map_head.s = section;
2335 else
2336 output->bfd_section->map_head.s = section;
2337 }
2338
2339 /* Add a section reference to the list. */
2340 new_section = new_stat (lang_input_section, ptr);
2341 new_section->section = section;
2342}
2343
2344/* Handle wildcard sorting. This returns the lang_input_section which
2345 should follow the one we are going to create for SECTION and FILE,
2346 based on the sorting requirements of WILD. It returns NULL if the
2347 new section should just go at the end of the current list. */
2348
2349static lang_statement_union_type *
2350wild_sort (lang_wild_statement_type *wild,
2351 struct wildcard_list *sec,
2352 lang_input_statement_type *file,
2353 asection *section)
2354{
2355 lang_statement_union_type *l;
2356
2357 if (!wild->filenames_sorted
2358 && (sec == NULL || sec->spec.sorted == none))
2359 return NULL;
2360
2361 for (l = wild->children.head; l != NULL; l = l->header.next)
2362 {
2363 lang_input_section_type *ls;
2364
2365 if (l->header.type != lang_input_section_enum)
2366 continue;
2367 ls = &l->input_section;
2368
2369 /* Sorting by filename takes precedence over sorting by section
2370 name. */
2371
2372 if (wild->filenames_sorted)
2373 {
2374 const char *fn, *ln;
2375 bfd_boolean fa, la;
2376 int i;
2377
2378 /* The PE support for the .idata section as generated by
2379 dlltool assumes that files will be sorted by the name of
2380 the archive and then the name of the file within the
2381 archive. */
2382
2383 if (file->the_bfd != NULL
2384 && bfd_my_archive (file->the_bfd) != NULL)
2385 {
2386 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
2387 fa = TRUE;
2388 }
2389 else
2390 {
2391 fn = file->filename;
2392 fa = FALSE;
2393 }
2394
2395 if (bfd_my_archive (ls->section->owner) != NULL)
2396 {
2397 ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
2398 la = TRUE;
2399 }
2400 else
2401 {
2402 ln = ls->section->owner->filename;
2403 la = FALSE;
2404 }
2405
2406 i = strcmp (fn, ln);
2407 if (i > 0)
2408 continue;
2409 else if (i < 0)
2410 break;
2411
2412 if (fa || la)
2413 {
2414 if (fa)
2415 fn = file->filename;
2416 if (la)
2417 ln = ls->section->owner->filename;
2418
2419 i = strcmp (fn, ln);
2420 if (i > 0)
2421 continue;
2422 else if (i < 0)
2423 break;
2424 }
2425 }
2426
2427 /* Here either the files are not sorted by name, or we are
2428 looking at the sections for this file. */
2429
2430 if (sec != NULL && sec->spec.sorted != none)
2431 if (compare_section (sec->spec.sorted, section, ls->section) < 0)
2432 break;
2433 }
2434
2435 return l;
2436}
2437
2438/* Expand a wild statement for a particular FILE. SECTION may be
2439 NULL, in which case it is a wild card. */
2440
2441static void
2442output_section_callback (lang_wild_statement_type *ptr,
2443 struct wildcard_list *sec,
2444 asection *section,
2445 lang_input_statement_type *file,
2446 void *output)
2447{
2448 lang_statement_union_type *before;
2449 lang_output_section_statement_type *os;
2450
2451 os = (lang_output_section_statement_type *) output;
2452
2453 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2454 if (unique_section_p (section, os))
2455 return;
2456
2457 before = wild_sort (ptr, sec, file, section);
2458
2459 /* Here BEFORE points to the lang_input_section which
2460 should follow the one we are about to add. If BEFORE
2461 is NULL, then the section should just go at the end
2462 of the current list. */
2463
2464 if (before == NULL)
2465 lang_add_section (&ptr->children, section, os);
2466 else
2467 {
2468 lang_statement_list_type list;
2469 lang_statement_union_type **pp;
2470
2471 lang_list_init (&list);
2472 lang_add_section (&list, section, os);
2473
2474 /* If we are discarding the section, LIST.HEAD will
2475 be NULL. */
2476 if (list.head != NULL)
2477 {
2478 ASSERT (list.head->header.next == NULL);
2479
2480 for (pp = &ptr->children.head;
2481 *pp != before;
2482 pp = &(*pp)->header.next)
2483 ASSERT (*pp != NULL);
2484
2485 list.head->header.next = *pp;
2486 *pp = list.head;
2487 }
2488 }
2489}
2490
2491/* Check if all sections in a wild statement for a particular FILE
2492 are readonly. */
2493
2494static void
2495check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
2496 struct wildcard_list *sec ATTRIBUTE_UNUSED,
2497 asection *section,
2498 lang_input_statement_type *file ATTRIBUTE_UNUSED,
2499 void *output)
2500{
2501 lang_output_section_statement_type *os;
2502
2503 os = (lang_output_section_statement_type *) output;
2504
2505 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2506 if (unique_section_p (section, os))
2507 return;
2508
2509 if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
2510 os->all_input_readonly = FALSE;
2511}
2512
2513/* This is passed a file name which must have been seen already and
2514 added to the statement tree. We will see if it has been opened
2515 already and had its symbols read. If not then we'll read it. */
2516
2517static lang_input_statement_type *
2518lookup_name (const char *name)
2519{
2520 lang_input_statement_type *search;
2521
2522 for (search = (lang_input_statement_type *) input_file_chain.head;
2523 search != NULL;
2524 search = (lang_input_statement_type *) search->next_real_file)
2525 {
2526 /* Use the local_sym_name as the name of the file that has
2527 already been loaded as filename might have been transformed
2528 via the search directory lookup mechanism. */
2529 const char *filename = search->local_sym_name;
2530
2531 if (filename != NULL
2532 && strcmp (filename, name) == 0)
2533 break;
2534 }
2535
2536 if (search == NULL)
2537 search = new_afile (name, lang_input_file_is_search_file_enum,
2538 default_target, FALSE);
2539
2540 /* If we have already added this file, or this file is not real
2541 don't add this file. */
2542 if (search->loaded || !search->real)
2543 return search;
2544
2545 if (! load_symbols (search, NULL))
2546 return NULL;
2547
2548 return search;
2549}
2550
2551/* Save LIST as a list of libraries whose symbols should not be exported. */
2552
2553struct excluded_lib
2554{
2555 char *name;
2556 struct excluded_lib *next;
2557};
2558static struct excluded_lib *excluded_libs;
2559
2560void
2561add_excluded_libs (const char *list)
2562{
2563 const char *p = list, *end;
2564
2565 while (*p != '\0')
2566 {
2567 struct excluded_lib *entry;
2568 end = strpbrk (p, ",:");
2569 if (end == NULL)
2570 end = p + strlen (p);
2571 entry = (struct excluded_lib *) xmalloc (sizeof (*entry));
2572 entry->next = excluded_libs;
2573 entry->name = (char *) xmalloc (end - p + 1);
2574 memcpy (entry->name, p, end - p);
2575 entry->name[end - p] = '\0';
2576 excluded_libs = entry;
2577 if (*end == '\0')
2578 break;
2579 p = end + 1;
2580 }
2581}
2582
2583static void
2584check_excluded_libs (bfd *abfd)
2585{
2586 struct excluded_lib *lib = excluded_libs;
2587
2588 while (lib)
2589 {
2590 int len = strlen (lib->name);
2591 const char *filename = lbasename (abfd->filename);
2592
2593 if (strcmp (lib->name, "ALL") == 0)
2594 {
2595 abfd->no_export = TRUE;
2596 return;
2597 }
2598
2599 if (strncmp (lib->name, filename, len) == 0
2600 && (filename[len] == '\0'
2601 || (filename[len] == '.' && filename[len + 1] == 'a'
2602 && filename[len + 2] == '\0')))
2603 {
2604 abfd->no_export = TRUE;
2605 return;
2606 }
2607
2608 lib = lib->next;
2609 }
2610}
2611
2612/* Get the symbols for an input file. */
2613
2614bfd_boolean
2615load_symbols (lang_input_statement_type *entry,
2616 lang_statement_list_type *place)
2617{
2618 char **matching;
2619
2620 if (entry->loaded)
2621 return TRUE;
2622
2623 ldfile_open_file (entry);
2624
2625 /* Do not process further if the file was missing. */
2626 if (entry->missing_file)
2627 return TRUE;
2628
2629 if (! bfd_check_format (entry->the_bfd, bfd_archive)
2630 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
2631 {
2632 bfd_error_type err;
2633 bfd_boolean save_ldlang_sysrooted_script;
2634 bfd_boolean save_add_DT_NEEDED_for_regular;
2635 bfd_boolean save_add_DT_NEEDED_for_dynamic;
2636 bfd_boolean save_whole_archive;
2637
2638 err = bfd_get_error ();
2639
2640 /* See if the emulation has some special knowledge. */
2641 if (ldemul_unrecognized_file (entry))
2642 return TRUE;
2643
2644 if (err == bfd_error_file_ambiguously_recognized)
2645 {
2646 char **p;
2647
2648 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
2649 einfo (_("%B: matching formats:"), entry->the_bfd);
2650 for (p = matching; *p != NULL; p++)
2651 einfo (" %s", *p);
2652 einfo ("%F\n");
2653 }
2654 else if (err != bfd_error_file_not_recognized
2655 || place == NULL)
2656 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
2657
2658 bfd_close (entry->the_bfd);
2659 entry->the_bfd = NULL;
2660
2661 /* Try to interpret the file as a linker script. */
2662 ldfile_open_command_file (entry->filename);
2663
2664 push_stat_ptr (place);
2665 save_ldlang_sysrooted_script = ldlang_sysrooted_script;
2666 ldlang_sysrooted_script = entry->sysrooted;
2667 save_add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;
2668 add_DT_NEEDED_for_regular = entry->add_DT_NEEDED_for_regular;
2669 save_add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;
2670 add_DT_NEEDED_for_dynamic = entry->add_DT_NEEDED_for_dynamic;
2671 save_whole_archive = whole_archive;
2672 whole_archive = entry->whole_archive;
2673
2674 ldfile_assumed_script = TRUE;
2675 parser_input = input_script;
2676 /* We want to use the same -Bdynamic/-Bstatic as the one for
2677 ENTRY. */
2678 config.dynamic_link = entry->dynamic;
2679 yyparse ();
2680 ldfile_assumed_script = FALSE;
2681
2682 ldlang_sysrooted_script = save_ldlang_sysrooted_script;
2683 add_DT_NEEDED_for_regular = save_add_DT_NEEDED_for_regular;
2684 add_DT_NEEDED_for_dynamic = save_add_DT_NEEDED_for_dynamic;
2685 whole_archive = save_whole_archive;
2686 pop_stat_ptr ();
2687
2688 return TRUE;
2689 }
2690
2691 if (ldemul_recognized_file (entry))
2692 return TRUE;
2693
2694 /* We don't call ldlang_add_file for an archive. Instead, the
2695 add_symbols entry point will call ldlang_add_file, via the
2696 add_archive_element callback, for each element of the archive
2697 which is used. */
2698 switch (bfd_get_format (entry->the_bfd))
2699 {
2700 default:
2701 break;
2702
2703 case bfd_object:
2704 ldlang_add_file (entry);
2705 if (trace_files || trace_file_tries)
2706 info_msg ("%I\n", entry);
2707 break;
2708
2709 case bfd_archive:
2710 check_excluded_libs (entry->the_bfd);
2711
2712 if (entry->whole_archive)
2713 {
2714 bfd *member = NULL;
2715 bfd_boolean loaded = TRUE;
2716
2717 for (;;)
2718 {
2719 bfd *subsbfd;
2720 member = bfd_openr_next_archived_file (entry->the_bfd, member);
2721
2722 if (member == NULL)
2723 break;
2724
2725 if (! bfd_check_format (member, bfd_object))
2726 {
2727 einfo (_("%F%B: member %B in archive is not an object\n"),
2728 entry->the_bfd, member);
2729 loaded = FALSE;
2730 }
2731
2732 subsbfd = member;
2733 if (!(*link_info.callbacks
2734 ->add_archive_element) (&link_info, member,
2735 "--whole-archive", &subsbfd))
2736 abort ();
2737
2738 /* Potentially, the add_archive_element hook may have set a
2739 substitute BFD for us. */
2740 if (!bfd_link_add_symbols (subsbfd, &link_info))
2741 {
2742 einfo (_("%F%B: could not read symbols: %E\n"), member);
2743 loaded = FALSE;
2744 }
2745 }
2746
2747 entry->loaded = loaded;
2748 return loaded;
2749 }
2750 break;
2751 }
2752
2753 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
2754 entry->loaded = TRUE;
2755 else
2756 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
2757
2758 return entry->loaded;
2759}
2760
2761/* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2762 may be NULL, indicating that it is a wildcard. Separate
2763 lang_input_section statements are created for each part of the
2764 expansion; they are added after the wild statement S. OUTPUT is
2765 the output section. */
2766
2767static void
2768wild (lang_wild_statement_type *s,
2769 const char *target ATTRIBUTE_UNUSED,
2770 lang_output_section_statement_type *output)
2771{
2772 struct wildcard_list *sec;
2773
2774 if (s->handler_data[0]
2775 && s->handler_data[0]->spec.sorted == by_name
2776 && !s->filenames_sorted)
2777 {
2778 lang_section_bst_type *tree;
2779
2780 walk_wild (s, output_section_callback_fast, output);
2781
2782 tree = s->tree;
2783 if (tree)
2784 {
2785 output_section_callback_tree_to_list (s, tree, output);
2786 s->tree = NULL;
2787 }
2788 }
2789 else
2790 walk_wild (s, output_section_callback, output);
2791
2792 if (default_common_section == NULL)
2793 for (sec = s->section_list; sec != NULL; sec = sec->next)
2794 if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
2795 {
2796 /* Remember the section that common is going to in case we
2797 later get something which doesn't know where to put it. */
2798 default_common_section = output;
2799 break;
2800 }
2801}
2802
2803/* Return TRUE iff target is the sought target. */
2804
2805static int
2806get_target (const bfd_target *target, void *data)
2807{
2808 const char *sought = (const char *) data;
2809
2810 return strcmp (target->name, sought) == 0;
2811}
2812
2813/* Like strcpy() but convert to lower case as well. */
2814
2815static void
2816stricpy (char *dest, char *src)
2817{
2818 char c;
2819
2820 while ((c = *src++) != 0)
2821 *dest++ = TOLOWER (c);
2822
2823 *dest = 0;
2824}
2825
2826/* Remove the first occurrence of needle (if any) in haystack
2827 from haystack. */
2828
2829static void
2830strcut (char *haystack, char *needle)
2831{
2832 haystack = strstr (haystack, needle);
2833
2834 if (haystack)
2835 {
2836 char *src;
2837
2838 for (src = haystack + strlen (needle); *src;)
2839 *haystack++ = *src++;
2840
2841 *haystack = 0;
2842 }
2843}
2844
2845/* Compare two target format name strings.
2846 Return a value indicating how "similar" they are. */
2847
2848static int
2849name_compare (char *first, char *second)
2850{
2851 char *copy1;
2852 char *copy2;
2853 int result;
2854
2855 copy1 = (char *) xmalloc (strlen (first) + 1);
2856 copy2 = (char *) xmalloc (strlen (second) + 1);
2857
2858 /* Convert the names to lower case. */
2859 stricpy (copy1, first);
2860 stricpy (copy2, second);
2861
2862 /* Remove size and endian strings from the name. */
2863 strcut (copy1, "big");
2864 strcut (copy1, "little");
2865 strcut (copy2, "big");
2866 strcut (copy2, "little");
2867
2868 /* Return a value based on how many characters match,
2869 starting from the beginning. If both strings are
2870 the same then return 10 * their length. */
2871 for (result = 0; copy1[result] == copy2[result]; result++)
2872 if (copy1[result] == 0)
2873 {
2874 result *= 10;
2875 break;
2876 }
2877
2878 free (copy1);
2879 free (copy2);
2880
2881 return result;
2882}
2883
2884/* Set by closest_target_match() below. */
2885static const bfd_target *winner;
2886
2887/* Scan all the valid bfd targets looking for one that has the endianness
2888 requirement that was specified on the command line, and is the nearest
2889 match to the original output target. */
2890
2891static int
2892closest_target_match (const bfd_target *target, void *data)
2893{
2894 const bfd_target *original = (const bfd_target *) data;
2895
2896 if (command_line.endian == ENDIAN_BIG
2897 && target->byteorder != BFD_ENDIAN_BIG)
2898 return 0;
2899
2900 if (command_line.endian == ENDIAN_LITTLE
2901 && target->byteorder != BFD_ENDIAN_LITTLE)
2902 return 0;
2903
2904 /* Must be the same flavour. */
2905 if (target->flavour != original->flavour)
2906 return 0;
2907
2908 /* Ignore generic big and little endian elf vectors. */
2909 if (strcmp (target->name, "elf32-big") == 0
2910 || strcmp (target->name, "elf64-big") == 0
2911 || strcmp (target->name, "elf32-little") == 0
2912 || strcmp (target->name, "elf64-little") == 0)
2913 return 0;
2914
2915 /* If we have not found a potential winner yet, then record this one. */
2916 if (winner == NULL)
2917 {
2918 winner = target;
2919 return 0;
2920 }
2921
2922 /* Oh dear, we now have two potential candidates for a successful match.
2923 Compare their names and choose the better one. */
2924 if (name_compare (target->name, original->name)
2925 > name_compare (winner->name, original->name))
2926 winner = target;
2927
2928 /* Keep on searching until wqe have checked them all. */
2929 return 0;
2930}
2931
2932/* Return the BFD target format of the first input file. */
2933
2934static char *
2935get_first_input_target (void)
2936{
2937 char *target = NULL;
2938
2939 LANG_FOR_EACH_INPUT_STATEMENT (s)
2940 {
2941 if (s->header.type == lang_input_statement_enum
2942 && s->real)
2943 {
2944 ldfile_open_file (s);
2945
2946 if (s->the_bfd != NULL
2947 && bfd_check_format (s->the_bfd, bfd_object))
2948 {
2949 target = bfd_get_target (s->the_bfd);
2950
2951 if (target != NULL)
2952 break;
2953 }
2954 }
2955 }
2956
2957 return target;
2958}
2959
2960const char *
2961lang_get_output_target (void)
2962{
2963 const char *target;
2964
2965 /* Has the user told us which output format to use? */
2966 if (output_target != NULL)
2967 return output_target;
2968
2969 /* No - has the current target been set to something other than
2970 the default? */
2971 if (current_target != default_target)
2972 return current_target;
2973
2974 /* No - can we determine the format of the first input file? */
2975 target = get_first_input_target ();
2976 if (target != NULL)
2977 return target;
2978
2979 /* Failed - use the default output target. */
2980 return default_target;
2981}
2982
2983/* Open the output file. */
2984
2985static void
2986open_output (const char *name)
2987{
2988 output_target = lang_get_output_target ();
2989
2990 /* Has the user requested a particular endianness on the command
2991 line? */
2992 if (command_line.endian != ENDIAN_UNSET)
2993 {
2994 const bfd_target *target;
2995 enum bfd_endian desired_endian;
2996
2997 /* Get the chosen target. */
2998 target = bfd_search_for_target (get_target, (void *) output_target);
2999
3000 /* If the target is not supported, we cannot do anything. */
3001 if (target != NULL)
3002 {
3003 if (command_line.endian == ENDIAN_BIG)
3004 desired_endian = BFD_ENDIAN_BIG;
3005 else
3006 desired_endian = BFD_ENDIAN_LITTLE;
3007
3008 /* See if the target has the wrong endianness. This should
3009 not happen if the linker script has provided big and
3010 little endian alternatives, but some scrips don't do
3011 this. */
3012 if (target->byteorder != desired_endian)
3013 {
3014 /* If it does, then see if the target provides
3015 an alternative with the correct endianness. */
3016 if (target->alternative_target != NULL
3017 && (target->alternative_target->byteorder == desired_endian))
3018 output_target = target->alternative_target->name;
3019 else
3020 {
3021 /* Try to find a target as similar as possible to
3022 the default target, but which has the desired
3023 endian characteristic. */
3024 bfd_search_for_target (closest_target_match,
3025 (void *) target);
3026
3027 /* Oh dear - we could not find any targets that
3028 satisfy our requirements. */
3029 if (winner == NULL)
3030 einfo (_("%P: warning: could not find any targets"
3031 " that match endianness requirement\n"));
3032 else
3033 output_target = winner->name;
3034 }
3035 }
3036 }
3037 }
3038
3039 link_info.output_bfd = bfd_openw (name, output_target);
3040
3041 if (link_info.output_bfd == NULL)
3042 {
3043 if (bfd_get_error () == bfd_error_invalid_target)
3044 einfo (_("%P%F: target %s not found\n"), output_target);
3045
3046 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
3047 }
3048
3049 delete_output_file_on_failure = TRUE;
3050
3051 if (! bfd_set_format (link_info.output_bfd, bfd_object))
3052 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
3053 if (! bfd_set_arch_mach (link_info.output_bfd,
3054 ldfile_output_architecture,
3055 ldfile_output_machine))
3056 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
3057
3058 link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);
3059 if (link_info.hash == NULL)
3060 einfo (_("%P%F: can not create hash table: %E\n"));
3061
3062 bfd_set_gp_size (link_info.output_bfd, g_switch_value);
3063}
3064
3065static void
3066ldlang_open_output (lang_statement_union_type *statement)
3067{
3068 switch (statement->header.type)
3069 {
3070 case lang_output_statement_enum:
3071 ASSERT (link_info.output_bfd == NULL);
3072 open_output (statement->output_statement.name);
3073 ldemul_set_output_arch ();
3074 if (config.magic_demand_paged && !link_info.relocatable)
3075 link_info.output_bfd->flags |= D_PAGED;
3076 else
3077 link_info.output_bfd->flags &= ~D_PAGED;
3078 if (config.text_read_only)
3079 link_info.output_bfd->flags |= WP_TEXT;
3080 else
3081 link_info.output_bfd->flags &= ~WP_TEXT;
3082 if (link_info.traditional_format)
3083 link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
3084 else
3085 link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
3086 break;
3087
3088 case lang_target_statement_enum:
3089 current_target = statement->target_statement.target;
3090 break;
3091 default:
3092 break;
3093 }
3094}
3095
3096/* Convert between addresses in bytes and sizes in octets.
3097 For currently supported targets, octets_per_byte is always a power
3098 of two, so we can use shifts. */
3099#define TO_ADDR(X) ((X) >> opb_shift)
3100#define TO_SIZE(X) ((X) << opb_shift)
3101
3102/* Support the above. */
3103static unsigned int opb_shift = 0;
3104
3105static void
3106init_opb (void)
3107{
3108 unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3109 ldfile_output_machine);
3110 opb_shift = 0;
3111 if (x > 1)
3112 while ((x & 1) == 0)
3113 {
3114 x >>= 1;
3115 ++opb_shift;
3116 }
3117 ASSERT (x == 1);
3118}
3119
3120/* Open all the input files. */
3121
3122static void
3123open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
3124{
3125 for (; s != NULL; s = s->header.next)
3126 {
3127 switch (s->header.type)
3128 {
3129 case lang_constructors_statement_enum:
3130 open_input_bfds (constructor_list.head, force);
3131 break;
3132 case lang_output_section_statement_enum:
3133 open_input_bfds (s->output_section_statement.children.head, force);
3134 break;
3135 case lang_wild_statement_enum:
3136 /* Maybe we should load the file's symbols. */
3137 if (s->wild_statement.filename
3138 && !wildcardp (s->wild_statement.filename)
3139 && !archive_path (s->wild_statement.filename))
3140 lookup_name (s->wild_statement.filename);
3141 open_input_bfds (s->wild_statement.children.head, force);
3142 break;
3143 case lang_group_statement_enum:
3144 {
3145 struct bfd_link_hash_entry *undefs;
3146
3147 /* We must continually search the entries in the group
3148 until no new symbols are added to the list of undefined
3149 symbols. */
3150
3151 do
3152 {
3153 undefs = link_info.hash->undefs_tail;
3154 open_input_bfds (s->group_statement.children.head, TRUE);
3155 }
3156 while (undefs != link_info.hash->undefs_tail);
3157 }
3158 break;
3159 case lang_target_statement_enum:
3160 current_target = s->target_statement.target;
3161 break;
3162 case lang_input_statement_enum:
3163 if (s->input_statement.real)
3164 {
3165 lang_statement_union_type **os_tail;
3166 lang_statement_list_type add;
3167
3168 s->input_statement.target = current_target;
3169
3170 /* If we are being called from within a group, and this
3171 is an archive which has already been searched, then
3172 force it to be researched unless the whole archive
3173 has been loaded already. */
3174 if (force
3175 && !s->input_statement.whole_archive
3176 && s->input_statement.loaded
3177 && bfd_check_format (s->input_statement.the_bfd,
3178 bfd_archive))
3179 s->input_statement.loaded = FALSE;
3180
3181 os_tail = lang_output_section_statement.tail;
3182 lang_list_init (&add);
3183
3184 if (! load_symbols (&s->input_statement, &add))
3185 config.make_executable = FALSE;
3186
3187 if (add.head != NULL)
3188 {
3189 /* If this was a script with output sections then
3190 tack any added statements on to the end of the
3191 list. This avoids having to reorder the output
3192 section statement list. Very likely the user
3193 forgot -T, and whatever we do here will not meet
3194 naive user expectations. */
3195 if (os_tail != lang_output_section_statement.tail)
3196 {
3197 einfo (_("%P: warning: %s contains output sections;"
3198 " did you forget -T?\n"),
3199 s->input_statement.filename);
3200 *stat_ptr->tail = add.head;
3201 stat_ptr->tail = add.tail;
3202 }
3203 else
3204 {
3205 *add.tail = s->header.next;
3206 s->header.next = add.head;
3207 }
3208 }
3209 }
3210 break;
3211 case lang_assignment_statement_enum:
3212 if (s->assignment_statement.exp->assign.hidden)
3213 /* This is from a --defsym on the command line. */
3214 exp_fold_tree_no_dot (s->assignment_statement.exp);
3215 break;
3216 default:
3217 break;
3218 }
3219 }
3220
3221 /* Exit if any of the files were missing. */
3222 if (missing_file)
3223 einfo ("%F");
3224}
3225
3226/* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
3227
3228void
3229lang_track_definedness (const char *name)
3230{
3231 if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
3232 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
3233}
3234
3235/* New-function for the definedness hash table. */
3236
3237static struct bfd_hash_entry *
3238lang_definedness_newfunc (struct bfd_hash_entry *entry,
3239 struct bfd_hash_table *table ATTRIBUTE_UNUSED,
3240 const char *name ATTRIBUTE_UNUSED)
3241{
3242 struct lang_definedness_hash_entry *ret
3243 = (struct lang_definedness_hash_entry *) entry;
3244
3245 if (ret == NULL)
3246 ret = (struct lang_definedness_hash_entry *)
3247 bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
3248
3249 if (ret == NULL)
3250 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
3251
3252 ret->iteration = -1;
3253 return &ret->root;
3254}
3255
3256/* Return the iteration when the definition of NAME was last updated. A
3257 value of -1 means that the symbol is not defined in the linker script
3258 or the command line, but may be defined in the linker symbol table. */
3259
3260int
3261lang_symbol_definition_iteration (const char *name)
3262{
3263 struct lang_definedness_hash_entry *defentry
3264 = (struct lang_definedness_hash_entry *)
3265 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3266
3267 /* We've already created this one on the presence of DEFINED in the
3268 script, so it can't be NULL unless something is borked elsewhere in
3269 the code. */
3270 if (defentry == NULL)
3271 FAIL ();
3272
3273 return defentry->iteration;
3274}
3275
3276/* Update the definedness state of NAME. */
3277
3278void
3279lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
3280{
3281 struct lang_definedness_hash_entry *defentry
3282 = (struct lang_definedness_hash_entry *)
3283 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3284
3285 /* We don't keep track of symbols not tested with DEFINED. */
3286 if (defentry == NULL)
3287 return;
3288
3289 /* If the symbol was already defined, and not from an earlier statement
3290 iteration, don't update the definedness iteration, because that'd
3291 make the symbol seem defined in the linker script at this point, and
3292 it wasn't; it was defined in some object. If we do anyway, DEFINED
3293 would start to yield false before this point and the construct "sym =
3294 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3295 in an object. */
3296 if (h->type != bfd_link_hash_undefined
3297 && h->type != bfd_link_hash_common
3298 && h->type != bfd_link_hash_new
3299 && defentry->iteration == -1)
3300 return;
3301
3302 defentry->iteration = lang_statement_iteration;
3303}
3304
3305/* Add the supplied name to the symbol table as an undefined reference.
3306 This is a two step process as the symbol table doesn't even exist at
3307 the time the ld command line is processed. First we put the name
3308 on a list, then, once the output file has been opened, transfer the
3309 name to the symbol table. */
3310
3311typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
3312
3313#define ldlang_undef_chain_list_head entry_symbol.next
3314
3315void
3316ldlang_add_undef (const char *const name, bfd_boolean cmdline)
3317{
3318 ldlang_undef_chain_list_type *new_undef;
3319
3320 undef_from_cmdline = undef_from_cmdline || cmdline;
3321 new_undef = (ldlang_undef_chain_list_type *) stat_alloc (sizeof (*new_undef));
3322 new_undef->next = ldlang_undef_chain_list_head;
3323 ldlang_undef_chain_list_head = new_undef;
3324
3325 new_undef->name = xstrdup (name);
3326
3327 if (link_info.output_bfd != NULL)
3328 insert_undefined (new_undef->name);
3329}
3330
3331/* Insert NAME as undefined in the symbol table. */
3332
3333static void
3334insert_undefined (const char *name)
3335{
3336 struct bfd_link_hash_entry *h;
3337
3338 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
3339 if (h == NULL)
3340 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3341 if (h->type == bfd_link_hash_new)
3342 {
3343 h->type = bfd_link_hash_undefined;
3344 h->u.undef.abfd = NULL;
3345 bfd_link_add_undef (link_info.hash, h);
3346 }
3347}
3348
3349/* Run through the list of undefineds created above and place them
3350 into the linker hash table as undefined symbols belonging to the
3351 script file. */
3352
3353static void
3354lang_place_undefineds (void)
3355{
3356 ldlang_undef_chain_list_type *ptr;
3357
3358 for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
3359 insert_undefined (ptr->name);
3360}
3361
3362/* Check for all readonly or some readwrite sections. */
3363
3364static void
3365check_input_sections
3366 (lang_statement_union_type *s,
3367 lang_output_section_statement_type *output_section_statement)
3368{
3369 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3370 {
3371 switch (s->header.type)
3372 {
3373 case lang_wild_statement_enum:
3374 walk_wild (&s->wild_statement, check_section_callback,
3375 output_section_statement);
3376 if (! output_section_statement->all_input_readonly)
3377 return;
3378 break;
3379 case lang_constructors_statement_enum:
3380 check_input_sections (constructor_list.head,
3381 output_section_statement);
3382 if (! output_section_statement->all_input_readonly)
3383 return;
3384 break;
3385 case lang_group_statement_enum:
3386 check_input_sections (s->group_statement.children.head,
3387 output_section_statement);
3388 if (! output_section_statement->all_input_readonly)
3389 return;
3390 break;
3391 default:
3392 break;
3393 }
3394 }
3395}
3396
3397/* Update wildcard statements if needed. */
3398
3399static void
3400update_wild_statements (lang_statement_union_type *s)
3401{
3402 struct wildcard_list *sec;
3403
3404 switch (sort_section)
3405 {
3406 default:
3407 FAIL ();
3408
3409 case none:
3410 break;
3411
3412 case by_name:
3413 case by_alignment:
3414 for (; s != NULL; s = s->header.next)
3415 {
3416 switch (s->header.type)
3417 {
3418 default:
3419 break;
3420
3421 case lang_wild_statement_enum:
3422 sec = s->wild_statement.section_list;
3423 for (sec = s->wild_statement.section_list; sec != NULL;
3424 sec = sec->next)
3425 {
3426 switch (sec->spec.sorted)
3427 {
3428 case none:
3429 sec->spec.sorted = sort_section;
3430 break;
3431 case by_name:
3432 if (sort_section == by_alignment)
3433 sec->spec.sorted = by_name_alignment;
3434 break;
3435 case by_alignment:
3436 if (sort_section == by_name)
3437 sec->spec.sorted = by_alignment_name;
3438 break;
3439 default:
3440 break;
3441 }
3442 }
3443 break;
3444
3445 case lang_constructors_statement_enum:
3446 update_wild_statements (constructor_list.head);
3447 break;
3448
3449 case lang_output_section_statement_enum:
3450 update_wild_statements
3451 (s->output_section_statement.children.head);
3452 break;
3453
3454 case lang_group_statement_enum:
3455 update_wild_statements (s->group_statement.children.head);
3456 break;
3457 }
3458 }
3459 break;
3460 }
3461}
3462
3463/* Open input files and attach to output sections. */
3464
3465static void
3466map_input_to_output_sections
3467 (lang_statement_union_type *s, const char *target,
3468 lang_output_section_statement_type *os)
3469{
3470 for (; s != NULL; s = s->header.next)
3471 {
3472 lang_output_section_statement_type *tos;
3473 flagword flags;
3474
3475 switch (s->header.type)
3476 {
3477 case lang_wild_statement_enum:
3478 wild (&s->wild_statement, target, os);
3479 break;
3480 case lang_constructors_statement_enum:
3481 map_input_to_output_sections (constructor_list.head,
3482 target,
3483 os);
3484 break;
3485 case lang_output_section_statement_enum:
3486 tos = &s->output_section_statement;
3487 if (tos->constraint != 0)
3488 {
3489 if (tos->constraint != ONLY_IF_RW
3490 && tos->constraint != ONLY_IF_RO)
3491 break;
3492 tos->all_input_readonly = TRUE;
3493 check_input_sections (tos->children.head, tos);
3494 if (tos->all_input_readonly != (tos->constraint == ONLY_IF_RO))
3495 {
3496 tos->constraint = -1;
3497 break;
3498 }
3499 }
3500 map_input_to_output_sections (tos->children.head,
3501 target,
3502 tos);
3503 break;
3504 case lang_output_statement_enum:
3505 break;
3506 case lang_target_statement_enum:
3507 target = s->target_statement.target;
3508 break;
3509 case lang_group_statement_enum:
3510 map_input_to_output_sections (s->group_statement.children.head,
3511 target,
3512 os);
3513 break;
3514 case lang_data_statement_enum:
3515 /* Make sure that any sections mentioned in the expression
3516 are initialized. */
3517 exp_init_os (s->data_statement.exp);
3518 /* The output section gets CONTENTS, ALLOC and LOAD, but
3519 these may be overridden by the script. */
3520 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD;
3521 switch (os->sectype)
3522 {
3523 case normal_section:
3524 case overlay_section:
3525 break;
3526 case noalloc_section:
3527 flags = SEC_HAS_CONTENTS;
3528 break;
3529 case noload_section:
3530 if (bfd_get_flavour (link_info.output_bfd)
3531 == bfd_target_elf_flavour)
3532 flags = SEC_NEVER_LOAD | SEC_ALLOC;
3533 else
3534 flags = SEC_NEVER_LOAD | SEC_HAS_CONTENTS;
3535 break;
3536 }
3537 if (os->bfd_section == NULL)
3538 init_os (os, flags);
3539 else
3540 os->bfd_section->flags |= flags;
3541 break;
3542 case lang_input_section_enum:
3543 break;
3544 case lang_fill_statement_enum:
3545 case lang_object_symbols_statement_enum:
3546 case lang_reloc_statement_enum:
3547 case lang_padding_statement_enum:
3548 case lang_input_statement_enum:
3549 if (os != NULL && os->bfd_section == NULL)
3550 init_os (os, 0);
3551 break;
3552 case lang_assignment_statement_enum:
3553 if (os != NULL && os->bfd_section == NULL)
3554 init_os (os, 0);
3555
3556 /* Make sure that any sections mentioned in the assignment
3557 are initialized. */
3558 exp_init_os (s->assignment_statement.exp);
3559 break;
3560 case lang_address_statement_enum:
3561 /* Mark the specified section with the supplied address.
3562 If this section was actually a segment marker, then the
3563 directive is ignored if the linker script explicitly
3564 processed the segment marker. Originally, the linker
3565 treated segment directives (like -Ttext on the
3566 command-line) as section directives. We honor the
3567 section directive semantics for backwards compatibilty;
3568 linker scripts that do not specifically check for
3569 SEGMENT_START automatically get the old semantics. */
3570 if (!s->address_statement.segment
3571 || !s->address_statement.segment->used)
3572 {
3573 const char *name = s->address_statement.section_name;
3574
3575 /* Create the output section statement here so that
3576 orphans with a set address will be placed after other
3577 script sections. If we let the orphan placement code
3578 place them in amongst other sections then the address
3579 will affect following script sections, which is
3580 likely to surprise naive users. */
3581 tos = lang_output_section_statement_lookup (name, 0, TRUE);
3582 tos->addr_tree = s->address_statement.address;
3583 if (tos->bfd_section == NULL)
3584 init_os (tos, 0);
3585 }
3586 break;
3587 case lang_insert_statement_enum:
3588 break;
3589 }
3590 }
3591}
3592
3593/* An insert statement snips out all the linker statements from the
3594 start of the list and places them after the output section
3595 statement specified by the insert. This operation is complicated
3596 by the fact that we keep a doubly linked list of output section
3597 statements as well as the singly linked list of all statements. */
3598
3599static void
3600process_insert_statements (void)
3601{
3602 lang_statement_union_type **s;
3603 lang_output_section_statement_type *first_os = NULL;
3604 lang_output_section_statement_type *last_os = NULL;
3605 lang_output_section_statement_type *os;
3606
3607 /* "start of list" is actually the statement immediately after
3608 the special abs_section output statement, so that it isn't
3609 reordered. */
3610 s = &lang_output_section_statement.head;
3611 while (*(s = &(*s)->header.next) != NULL)
3612 {
3613 if ((*s)->header.type == lang_output_section_statement_enum)
3614 {
3615 /* Keep pointers to the first and last output section
3616 statement in the sequence we may be about to move. */
3617 os = &(*s)->output_section_statement;
3618
3619 ASSERT (last_os == NULL || last_os->next == os);
3620 last_os = os;
3621
3622 /* Set constraint negative so that lang_output_section_find
3623 won't match this output section statement. At this
3624 stage in linking constraint has values in the range
3625 [-1, ONLY_IN_RW]. */
3626 last_os->constraint = -2 - last_os->constraint;
3627 if (first_os == NULL)
3628 first_os = last_os;
3629 }
3630 else if ((*s)->header.type == lang_insert_statement_enum)
3631 {
3632 lang_insert_statement_type *i = &(*s)->insert_statement;
3633 lang_output_section_statement_type *where;
3634 lang_statement_union_type **ptr;
3635 lang_statement_union_type *first;
3636
3637 where = lang_output_section_find (i->where);
3638 if (where != NULL && i->is_before)
3639 {
3640 do
3641 where = where->prev;
3642 while (where != NULL && where->constraint < 0);
3643 }
3644 if (where == NULL)
3645 {
3646 einfo (_("%F%P: %s not found for insert\n"), i->where);
3647 return;
3648 }
3649
3650 /* Deal with reordering the output section statement list. */
3651 if (last_os != NULL)
3652 {
3653 asection *first_sec, *last_sec;
3654 struct lang_output_section_statement_struct **next;
3655
3656 /* Snip out the output sections we are moving. */
3657 first_os->prev->next = last_os->next;
3658 if (last_os->next == NULL)
3659 {
3660 next = &first_os->prev->next;
3661 lang_output_section_statement.tail
3662 = (lang_statement_union_type **) next;
3663 }
3664 else
3665 last_os->next->prev = first_os->prev;
3666 /* Add them in at the new position. */
3667 last_os->next = where->next;
3668 if (where->next == NULL)
3669 {
3670 next = &last_os->next;
3671 lang_output_section_statement.tail
3672 = (lang_statement_union_type **) next;
3673 }
3674 else
3675 where->next->prev = last_os;
3676 first_os->prev = where;
3677 where->next = first_os;
3678
3679 /* Move the bfd sections in the same way. */
3680 first_sec = NULL;
3681 last_sec = NULL;
3682 for (os = first_os; os != NULL; os = os->next)
3683 {
3684 os->constraint = -2 - os->constraint;
3685 if (os->bfd_section != NULL
3686 && os->bfd_section->owner != NULL)
3687 {
3688 last_sec = os->bfd_section;
3689 if (first_sec == NULL)
3690 first_sec = last_sec;
3691 }
3692 if (os == last_os)
3693 break;
3694 }
3695 if (last_sec != NULL)
3696 {
3697 asection *sec = where->bfd_section;
3698 if (sec == NULL)
3699 sec = output_prev_sec_find (where);
3700
3701 /* The place we want to insert must come after the
3702 sections we are moving. So if we find no
3703 section or if the section is the same as our
3704 last section, then no move is needed. */
3705 if (sec != NULL && sec != last_sec)
3706 {
3707 /* Trim them off. */
3708 if (first_sec->prev != NULL)
3709 first_sec->prev->next = last_sec->next;
3710 else
3711 link_info.output_bfd->sections = last_sec->next;
3712 if (last_sec->next != NULL)
3713 last_sec->next->prev = first_sec->prev;
3714 else
3715 link_info.output_bfd->section_last = first_sec->prev;
3716 /* Add back. */
3717 last_sec->next = sec->next;
3718 if (sec->next != NULL)
3719 sec->next->prev = last_sec;
3720 else
3721 link_info.output_bfd->section_last = last_sec;
3722 first_sec->prev = sec;
3723 sec->next = first_sec;
3724 }
3725 }
3726
3727 first_os = NULL;
3728 last_os = NULL;
3729 }
3730
3731 ptr = insert_os_after (where);
3732 /* Snip everything after the abs_section output statement we
3733 know is at the start of the list, up to and including
3734 the insert statement we are currently processing. */
3735 first = lang_output_section_statement.head->header.next;
3736 lang_output_section_statement.head->header.next = (*s)->header.next;
3737 /* Add them back where they belong. */
3738 *s = *ptr;
3739 if (*s == NULL)
3740 statement_list.tail = s;
3741 *ptr = first;
3742 s = &lang_output_section_statement.head;
3743 }
3744 }
3745
3746 /* Undo constraint twiddling. */
3747 for (os = first_os; os != NULL; os = os->next)
3748 {
3749 os->constraint = -2 - os->constraint;
3750 if (os == last_os)
3751 break;
3752 }
3753}
3754
3755/* An output section might have been removed after its statement was
3756 added. For example, ldemul_before_allocation can remove dynamic
3757 sections if they turn out to be not needed. Clean them up here. */
3758
3759void
3760strip_excluded_output_sections (void)
3761{
3762 lang_output_section_statement_type *os;
3763
3764 /* Run lang_size_sections (if not already done). */
3765 if (expld.phase != lang_mark_phase_enum)
3766 {
3767 expld.phase = lang_mark_phase_enum;
3768 expld.dataseg.phase = exp_dataseg_none;
3769 one_lang_size_sections_pass (NULL, FALSE);
3770 lang_reset_memory_regions ();
3771 }
3772
3773 for (os = &lang_output_section_statement.head->output_section_statement;
3774 os != NULL;
3775 os = os->next)
3776 {
3777 asection *output_section;
3778 bfd_boolean exclude;
3779
3780 if (os->constraint < 0)
3781 continue;
3782
3783 output_section = os->bfd_section;
3784 if (output_section == NULL)
3785 continue;
3786
3787 exclude = (output_section->rawsize == 0
3788 && (output_section->flags & SEC_KEEP) == 0
3789 && !bfd_section_removed_from_list (link_info.output_bfd,
3790 output_section));
3791
3792 /* Some sections have not yet been sized, notably .gnu.version,
3793 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3794 input sections, so don't drop output sections that have such
3795 input sections unless they are also marked SEC_EXCLUDE. */
3796 if (exclude && output_section->map_head.s != NULL)
3797 {
3798 asection *s;
3799
3800 for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
3801 if ((s->flags & SEC_LINKER_CREATED) != 0
3802 && (s->flags & SEC_EXCLUDE) == 0)
3803 {
3804 exclude = FALSE;
3805 break;
3806 }
3807 }
3808
3809 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3810 output_section->map_head.link_order = NULL;
3811 output_section->map_tail.link_order = NULL;
3812
3813 if (exclude)
3814 {
3815 /* We don't set bfd_section to NULL since bfd_section of the
3816 removed output section statement may still be used. */
3817 if (!os->section_relative_symbol
3818 && !os->update_dot_tree)
3819 os->ignored = TRUE;
3820 output_section->flags |= SEC_EXCLUDE;
3821 bfd_section_list_remove (link_info.output_bfd, output_section);
3822 link_info.output_bfd->section_count--;
3823 }
3824 }
3825
3826 /* Stop future calls to lang_add_section from messing with map_head
3827 and map_tail link_order fields. */
3828 stripped_excluded_sections = TRUE;
3829}
3830
3831static void
3832print_output_section_statement
3833 (lang_output_section_statement_type *output_section_statement)
3834{
3835 asection *section = output_section_statement->bfd_section;
3836 int len;
3837
3838 if (output_section_statement != abs_output_section)
3839 {
3840 minfo ("\n%s", output_section_statement->name);
3841
3842 if (section != NULL)
3843 {
3844 print_dot = section->vma;
3845
3846 len = strlen (output_section_statement->name);
3847 if (len >= SECTION_NAME_MAP_LENGTH - 1)
3848 {
3849 print_nl ();
3850 len = 0;
3851 }
3852 while (len < SECTION_NAME_MAP_LENGTH)
3853 {
3854 print_space ();
3855 ++len;
3856 }
3857
3858 minfo ("0x%V %W", section->vma, section->size);
3859
3860 if (section->vma != section->lma)
3861 minfo (_(" load address 0x%V"), section->lma);
3862
3863 if (output_section_statement->update_dot_tree != NULL)
3864 exp_fold_tree (output_section_statement->update_dot_tree,
3865 bfd_abs_section_ptr, &print_dot);
3866 }
3867
3868 print_nl ();
3869 }
3870
3871 print_statement_list (output_section_statement->children.head,
3872 output_section_statement);
3873}
3874
3875/* Scan for the use of the destination in the right hand side
3876 of an expression. In such cases we will not compute the
3877 correct expression, since the value of DST that is used on
3878 the right hand side will be its final value, not its value
3879 just before this expression is evaluated. */
3880
3881static bfd_boolean
3882scan_for_self_assignment (const char * dst, etree_type * rhs)
3883{
3884 if (rhs == NULL || dst == NULL)
3885 return FALSE;
3886
3887 switch (rhs->type.node_class)
3888 {
3889 case etree_binary:
3890 return (scan_for_self_assignment (dst, rhs->binary.lhs)
3891 || scan_for_self_assignment (dst, rhs->binary.rhs));
3892
3893 case etree_trinary:
3894 return (scan_for_self_assignment (dst, rhs->trinary.lhs)
3895 || scan_for_self_assignment (dst, rhs->trinary.rhs));
3896
3897 case etree_assign:
3898 case etree_provided:
3899 case etree_provide:
3900 if (strcmp (dst, rhs->assign.dst) == 0)
3901 return TRUE;
3902 return scan_for_self_assignment (dst, rhs->assign.src);
3903
3904 case etree_unary:
3905 return scan_for_self_assignment (dst, rhs->unary.child);
3906
3907 case etree_value:
3908 if (rhs->value.str)