binutils221: Fix missing section start/end 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));
b133d3fd 1760 lang_add_assignment (exp_assign (symname,
5e4e6ec1 1761 exp_unop (ABSOLUTE,
b133d3fd 1762 exp_nameop (NAME, "."))));
5e4e6ec1
SW
1763 }
1764 }
1765
1766 if (add_child == NULL)
1767 add_child = &os->children;
1768 lang_add_section (add_child, s, os);
1769
1770 if (after && (s->flags & (SEC_LOAD | SEC_ALLOC)) != 0)
1771 {
1772 const char *region = (after->region
1773 ? after->region->name_list.name
1774 : DEFAULT_MEMORY_REGION);
1775 const char *lma_region = (after->lma_region
1776 ? after->lma_region->name_list.name
1777 : NULL);
1778 lang_leave_output_section_statement (NULL, region, after->phdrs,
1779 lma_region);
1780 }
1781 else
1782 lang_leave_output_section_statement (NULL, DEFAULT_MEMORY_REGION, NULL,
1783 NULL);
1784
1785 if (ps != NULL && *ps == '\0')
1786 {
1787 char *symname;
1788
1789 symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
1790 symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1791 sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
b133d3fd
MD
1792 lang_add_assignment (exp_assign (symname,
1793 exp_nameop (NAME, ".")));
5e4e6ec1
SW
1794 }
1795
1796 /* Restore the global list pointer. */
1797 if (after != NULL)
1798 pop_stat_ptr ();
1799
1800 if (after != NULL && os->bfd_section != NULL)
1801 {
1802 asection *snew, *as;
1803
1804 snew = os->bfd_section;
1805
1806 /* Shuffle the bfd section list to make the output file look
1807 neater. This is really only cosmetic. */
1808 if (place->section == NULL
1809 && after != (&lang_output_section_statement.head
1810 ->output_section_statement))
1811 {
1812 asection *bfd_section = after->bfd_section;
1813
1814 /* If the output statement hasn't been used to place any input
1815 sections (and thus doesn't have an output bfd_section),
1816 look for the closest prior output statement having an
1817 output section. */
1818 if (bfd_section == NULL)
1819 bfd_section = output_prev_sec_find (after);
1820
1821 if (bfd_section != NULL && bfd_section != snew)
1822 place->section = &bfd_section->next;
1823 }
1824
1825 if (place->section == NULL)
1826 place->section = &link_info.output_bfd->sections;
1827
1828 as = *place->section;
1829
1830 if (!as)
1831 {
1832 /* Put the section at the end of the list. */
1833
1834 /* Unlink the section. */
1835 bfd_section_list_remove (link_info.output_bfd, snew);
1836
1837 /* Now tack it back on in the right place. */
1838 bfd_section_list_append (link_info.output_bfd, snew);
1839 }
1840 else if (as != snew && as->prev != snew)
1841 {
1842 /* Unlink the section. */
1843 bfd_section_list_remove (link_info.output_bfd, snew);
1844
1845 /* Now tack it back on in the right place. */
1846 bfd_section_list_insert_before (link_info.output_bfd, as, snew);
1847 }
1848
1849 /* Save the end of this list. Further ophans of this type will
1850 follow the one we've just added. */
1851 place->section = &snew->next;
1852
1853 /* The following is non-cosmetic. We try to put the output
1854 statements in some sort of reasonable order here, because they
1855 determine the final load addresses of the orphan sections.
1856 In addition, placing output statements in the wrong order may
1857 require extra segments. For instance, given a typical
1858 situation of all read-only sections placed in one segment and
1859 following that a segment containing all the read-write
1860 sections, we wouldn't want to place an orphan read/write
1861 section before or amongst the read-only ones. */
1862 if (add.head != NULL)
1863 {
1864 lang_output_section_statement_type *newly_added_os;
1865
1866 if (place->stmt == NULL)
1867 {
1868 lang_statement_union_type **where = insert_os_after (after);
1869
1870 *add.tail = *where;
1871 *where = add.head;
1872
1873 place->os_tail = &after->next;
1874 }
1875 else
1876 {
1877 /* Put it after the last orphan statement we added. */
1878 *add.tail = *place->stmt;
1879 *place->stmt = add.head;
1880 }
1881
1882 /* Fix the global list pointer if we happened to tack our
1883 new list at the tail. */
1884 if (*stat_ptr->tail == add.head)
1885 stat_ptr->tail = add.tail;
1886
1887 /* Save the end of this list. */
1888 place->stmt = add.tail;
1889
1890 /* Do the same for the list of output section statements. */
1891 newly_added_os = *os_tail;
1892 *os_tail = NULL;
1893 newly_added_os->prev = (lang_output_section_statement_type *)
1894 ((char *) place->os_tail
1895 - offsetof (lang_output_section_statement_type, next));
1896 newly_added_os->next = *place->os_tail;
1897 if (newly_added_os->next != NULL)
1898 newly_added_os->next->prev = newly_added_os;
1899 *place->os_tail = newly_added_os;
1900 place->os_tail = &newly_added_os->next;
1901
1902 /* Fixing the global list pointer here is a little different.
1903 We added to the list in lang_enter_output_section_statement,
1904 trimmed off the new output_section_statment above when
1905 assigning *os_tail = NULL, but possibly added it back in
1906 the same place when assigning *place->os_tail. */
1907 if (*os_tail == NULL)
1908 lang_output_section_statement.tail
1909 = (lang_statement_union_type **) os_tail;
1910 }
1911 }
1912 return os;
1913}
1914
1915static void
1916lang_map_flags (flagword flag)
1917{
1918 if (flag & SEC_ALLOC)
1919 minfo ("a");
1920
1921 if (flag & SEC_CODE)
1922 minfo ("x");
1923
1924 if (flag & SEC_READONLY)
1925 minfo ("r");
1926
1927 if (flag & SEC_DATA)
1928 minfo ("w");
1929
1930 if (flag & SEC_LOAD)
1931 minfo ("l");
1932}
1933
1934void
1935lang_map (void)
1936{
1937 lang_memory_region_type *m;
1938 bfd_boolean dis_header_printed = FALSE;
1939 bfd *p;
1940
1941 LANG_FOR_EACH_INPUT_STATEMENT (file)
1942 {
1943 asection *s;
1944
1945 if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
1946 || file->just_syms_flag)
1947 continue;
1948
1949 for (s = file->the_bfd->sections; s != NULL; s = s->next)
1950 if ((s->output_section == NULL
1951 || s->output_section->owner != link_info.output_bfd)
1952 && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0)
1953 {
1954 if (! dis_header_printed)
1955 {
1956 fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
1957 dis_header_printed = TRUE;
1958 }
1959
1960 print_input_section (s, TRUE);
1961 }
1962 }
1963
1964 minfo (_("\nMemory Configuration\n\n"));
1965 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
1966 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1967
1968 for (m = lang_memory_region_list; m != NULL; m = m->next)
1969 {
1970 char buf[100];
1971 int len;
1972
1973 fprintf (config.map_file, "%-16s ", m->name_list.name);
1974
1975 sprintf_vma (buf, m->origin);
1976 minfo ("0x%s ", buf);
1977 len = strlen (buf);
1978 while (len < 16)
1979 {
1980 print_space ();
1981 ++len;
1982 }
1983
1984 minfo ("0x%V", m->length);
1985 if (m->flags || m->not_flags)
1986 {
1987#ifndef BFD64
1988 minfo (" ");
1989#endif
1990 if (m->flags)
1991 {
1992 print_space ();
1993 lang_map_flags (m->flags);
1994 }
1995
1996 if (m->not_flags)
1997 {
1998 minfo (" !");
1999 lang_map_flags (m->not_flags);
2000 }
2001 }
2002
2003 print_nl ();
2004 }
2005
2006 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
2007
2008 if (! link_info.reduce_memory_overheads)
2009 {
2010 obstack_begin (&map_obstack, 1000);
2011 for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
2012 bfd_map_over_sections (p, init_map_userdata, 0);
2013 bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
2014 }
2015 lang_statement_iteration ++;
2016 print_statements ();
2017}
2018
2019static void
2020init_map_userdata (bfd *abfd ATTRIBUTE_UNUSED,
2021 asection *sec,
2022 void *data ATTRIBUTE_UNUSED)
2023{
2024 fat_section_userdata_type *new_data
2025 = ((fat_section_userdata_type *) (stat_alloc
2026 (sizeof (fat_section_userdata_type))));
2027
2028 ASSERT (get_userdata (sec) == NULL);
2029 get_userdata (sec) = new_data;
2030 new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
2031 new_data->map_symbol_def_count = 0;
2032}
2033
2034static bfd_boolean
2035sort_def_symbol (struct bfd_link_hash_entry *hash_entry,
2036 void *info ATTRIBUTE_UNUSED)
2037{
2038 if (hash_entry->type == bfd_link_hash_warning)
2039 hash_entry = (struct bfd_link_hash_entry *) hash_entry->u.i.link;
2040
2041 if (hash_entry->type == bfd_link_hash_defined
2042 || hash_entry->type == bfd_link_hash_defweak)
2043 {
2044 struct fat_user_section_struct *ud;
2045 struct map_symbol_def *def;
2046
2047 ud = (struct fat_user_section_struct *)
2048 get_userdata (hash_entry->u.def.section);
2049 if (! ud)
2050 {
2051 /* ??? What do we have to do to initialize this beforehand? */
2052 /* The first time we get here is bfd_abs_section... */
2053 init_map_userdata (0, hash_entry->u.def.section, 0);
2054 ud = (struct fat_user_section_struct *)
2055 get_userdata (hash_entry->u.def.section);
2056 }
2057 else if (!ud->map_symbol_def_tail)
2058 ud->map_symbol_def_tail = &ud->map_symbol_def_head;
2059
2060 def = (struct map_symbol_def *) obstack_alloc (&map_obstack, sizeof *def);
2061 def->entry = hash_entry;
2062 *(ud->map_symbol_def_tail) = def;
2063 ud->map_symbol_def_tail = &def->next;
2064 ud->map_symbol_def_count++;
2065 }
2066 return TRUE;
2067}
2068
2069/* Initialize an output section. */
2070
2071static void
2072init_os (lang_output_section_statement_type *s, flagword flags)
2073{
2074 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
2075 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
2076
2077 if (s->constraint != SPECIAL)
2078 s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);
2079 if (s->bfd_section == NULL)
2080 s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd,
2081 s->name, flags);
2082 if (s->bfd_section == NULL)
2083 {
2084 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2085 link_info.output_bfd->xvec->name, s->name);
2086 }
2087 s->bfd_section->output_section = s->bfd_section;
2088 s->bfd_section->output_offset = 0;
2089
2090 if (!link_info.reduce_memory_overheads)
2091 {
2092 fat_section_userdata_type *new_userdata = (fat_section_userdata_type *)
2093 stat_alloc (sizeof (fat_section_userdata_type));
2094 memset (new_userdata, 0, sizeof (fat_section_userdata_type));
2095 get_userdata (s->bfd_section) = new_userdata;
2096 }
2097
2098 /* If there is a base address, make sure that any sections it might
2099 mention are initialized. */
2100 if (s->addr_tree != NULL)
2101 exp_init_os (s->addr_tree);
2102
2103 if (s->load_base != NULL)
2104 exp_init_os (s->load_base);
2105
2106 /* If supplied an alignment, set it. */
2107 if (s->section_alignment != -1)
2108 s->bfd_section->alignment_power = s->section_alignment;
2109}
2110
2111/* Make sure that all output sections mentioned in an expression are
2112 initialized. */
2113
2114static void
2115exp_init_os (etree_type *exp)
2116{
2117 switch (exp->type.node_class)
2118 {
2119 case etree_assign:
2120 case etree_provide:
2121 exp_init_os (exp->assign.src);
2122 break;
2123
2124 case etree_binary:
2125 exp_init_os (exp->binary.lhs);
2126 exp_init_os (exp->binary.rhs);
2127 break;
2128
2129 case etree_trinary:
2130 exp_init_os (exp->trinary.cond);
2131 exp_init_os (exp->trinary.lhs);
2132 exp_init_os (exp->trinary.rhs);
2133 break;
2134
2135 case etree_assert:
2136 exp_init_os (exp->assert_s.child);
2137 break;
2138
2139 case etree_unary:
2140 exp_init_os (exp->unary.child);
2141 break;
2142
2143 case etree_name:
2144 switch (exp->type.node_code)
2145 {
2146 case ADDR:
2147 case LOADADDR:
2148 case SIZEOF:
2149 {
2150 lang_output_section_statement_type *os;
2151
2152 os = lang_output_section_find (exp->name.name);
2153 if (os != NULL && os->bfd_section == NULL)
2154 init_os (os, 0);
2155 }
2156 }
2157 break;
2158
2159 default:
2160 break;
2161 }
2162}
2163\f
2164static void
2165section_already_linked (bfd *abfd, asection *sec, void *data)
2166{
2167 lang_input_statement_type *entry = (lang_input_statement_type *) data;
2168
2169 /* If we are only reading symbols from this object, then we want to
2170 discard all sections. */
2171 if (entry->just_syms_flag)
2172 {
2173 bfd_link_just_syms (abfd, sec, &link_info);
2174 return;
2175 }
2176
2177 if (!(abfd->flags & DYNAMIC))
2178 bfd_section_already_linked (abfd, sec, &link_info);
2179}
2180\f
2181/* The wild routines.
2182
2183 These expand statements like *(.text) and foo.o to a list of
2184 explicit actions, like foo.o(.text), bar.o(.text) and
2185 foo.o(.text, .data). */
2186
2187/* Add SECTION to the output section OUTPUT. Do this by creating a
2188 lang_input_section statement which is placed at PTR. FILE is the
2189 input file which holds SECTION. */
2190
2191void
2192lang_add_section (lang_statement_list_type *ptr,
2193 asection *section,
2194 lang_output_section_statement_type *output)
2195{
2196 flagword flags = section->flags;
2197 bfd_boolean discard;
2198 lang_input_section_type *new_section;
2199
2200 /* Discard sections marked with SEC_EXCLUDE. */
2201 discard = (flags & SEC_EXCLUDE) != 0;
2202
2203 /* Discard input sections which are assigned to a section named
2204 DISCARD_SECTION_NAME. */
2205 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
2206 discard = TRUE;
2207
2208 /* Discard debugging sections if we are stripping debugging
2209 information. */
2210 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
2211 && (flags & SEC_DEBUGGING) != 0)
2212 discard = TRUE;
2213
2214 if (discard)
2215 {
2216 if (section->output_section == NULL)
2217 {
2218 /* This prevents future calls from assigning this section. */
2219 section->output_section = bfd_abs_section_ptr;
2220 }
2221 return;
2222 }
2223
2224 if (section->output_section != NULL)
2225 return;
2226
2227 /* We don't copy the SEC_NEVER_LOAD flag from an input section
2228 to an output section, because we want to be able to include a
2229 SEC_NEVER_LOAD section in the middle of an otherwise loaded
2230 section (I don't know why we want to do this, but we do).
2231 build_link_order in ldwrite.c handles this case by turning
2232 the embedded SEC_NEVER_LOAD section into a fill. */
2233 flags &= ~ SEC_NEVER_LOAD;
2234
2235 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2236 already been processed. One reason to do this is that on pe
2237 format targets, .text$foo sections go into .text and it's odd
2238 to see .text with SEC_LINK_ONCE set. */
2239
2240 if (!link_info.relocatable)
2241 flags &= ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC);
2242
2243 switch (output->sectype)
2244 {
2245 case normal_section:
2246 case overlay_section:
2247 break;
2248 case noalloc_section:
2249 flags &= ~SEC_ALLOC;
2250 break;
2251 case noload_section:
2252 flags &= ~SEC_LOAD;
2253 flags |= SEC_NEVER_LOAD;
2254 /* Unfortunately GNU ld has managed to evolve two different
2255 meanings to NOLOAD in scripts. ELF gets a .bss style noload,
2256 alloc, no contents section. All others get a noload, noalloc
2257 section. */
2258 if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
2259 flags &= ~SEC_HAS_CONTENTS;
2260 else
2261 flags &= ~SEC_ALLOC;
2262 break;
2263 }
2264
2265 if (output->bfd_section == NULL)
2266 init_os (output, flags);
2267
2268 /* If SEC_READONLY is not set in the input section, then clear
2269 it from the output section. */
2270 output->bfd_section->flags &= flags | ~SEC_READONLY;
2271
2272 if (output->bfd_section->linker_has_input)
2273 {
2274 /* Only set SEC_READONLY flag on the first input section. */
2275 flags &= ~ SEC_READONLY;
2276
2277 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
2278 if ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
2279 != (flags & (SEC_MERGE | SEC_STRINGS))
2280 || ((flags & SEC_MERGE) != 0
2281 && output->bfd_section->entsize != section->entsize))
2282 {
2283 output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
2284 flags &= ~ (SEC_MERGE | SEC_STRINGS);
2285 }
2286 }
2287 output->bfd_section->flags |= flags;
2288
2289 if (!output->bfd_section->linker_has_input)
2290 {
2291 output->bfd_section->linker_has_input = 1;
2292 /* This must happen after flags have been updated. The output
2293 section may have been created before we saw its first input
2294 section, eg. for a data statement. */
2295 bfd_init_private_section_data (section->owner, section,
2296 link_info.output_bfd,
2297 output->bfd_section,
2298 &link_info);
2299 if ((flags & SEC_MERGE) != 0)
2300 output->bfd_section->entsize = section->entsize;
2301 }
2302
2303 if ((flags & SEC_TIC54X_BLOCK) != 0
2304 && bfd_get_arch (section->owner) == bfd_arch_tic54x)
2305 {
2306 /* FIXME: This value should really be obtained from the bfd... */
2307 output->block_value = 128;
2308 }
2309
2310 if (section->alignment_power > output->bfd_section->alignment_power)
2311 output->bfd_section->alignment_power = section->alignment_power;
2312
2313 section->output_section = output->bfd_section;
2314
2315 if (!link_info.relocatable
2316 && !stripped_excluded_sections)
2317 {
2318 asection *s = output->bfd_section->map_tail.s;
2319 output->bfd_section->map_tail.s = section;
2320 section->map_head.s = NULL;
2321 section->map_tail.s = s;
2322 if (s != NULL)
2323 s->map_head.s = section;
2324 else
2325 output->bfd_section->map_head.s = section;
2326 }
2327
2328 /* Add a section reference to the list. */
2329 new_section = new_stat (lang_input_section, ptr);
2330 new_section->section = section;
2331}
2332
2333/* Handle wildcard sorting. This returns the lang_input_section which
2334 should follow the one we are going to create for SECTION and FILE,
2335 based on the sorting requirements of WILD. It returns NULL if the
2336 new section should just go at the end of the current list. */
2337
2338static lang_statement_union_type *
2339wild_sort (lang_wild_statement_type *wild,
2340 struct wildcard_list *sec,
2341 lang_input_statement_type *file,
2342 asection *section)
2343{
2344 lang_statement_union_type *l;
2345
2346 if (!wild->filenames_sorted
2347 && (sec == NULL || sec->spec.sorted == none))
2348 return NULL;
2349
2350 for (l = wild->children.head; l != NULL; l = l->header.next)
2351 {
2352 lang_input_section_type *ls;
2353
2354 if (l->header.type != lang_input_section_enum)
2355 continue;
2356 ls = &l->input_section;
2357
2358 /* Sorting by filename takes precedence over sorting by section
2359 name. */
2360
2361 if (wild->filenames_sorted)
2362 {
2363 const char *fn, *ln;
2364 bfd_boolean fa, la;
2365 int i;
2366
2367 /* The PE support for the .idata section as generated by
2368 dlltool assumes that files will be sorted by the name of
2369 the archive and then the name of the file within the
2370 archive. */
2371
2372 if (file->the_bfd != NULL
2373 && bfd_my_archive (file->the_bfd) != NULL)
2374 {
2375 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
2376 fa = TRUE;
2377 }
2378 else
2379 {
2380 fn = file->filename;
2381 fa = FALSE;
2382 }
2383
2384 if (bfd_my_archive (ls->section->owner) != NULL)
2385 {
2386 ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
2387 la = TRUE;
2388 }
2389 else
2390 {
2391 ln = ls->section->owner->filename;
2392 la = FALSE;
2393 }
2394
2395 i = strcmp (fn, ln);
2396 if (i > 0)
2397 continue;
2398 else if (i < 0)
2399 break;
2400
2401 if (fa || la)
2402 {
2403 if (fa)
2404 fn = file->filename;
2405 if (la)
2406 ln = ls->section->owner->filename;
2407
2408 i = strcmp (fn, ln);
2409 if (i > 0)
2410 continue;
2411 else if (i < 0)
2412 break;
2413 }
2414 }
2415
2416 /* Here either the files are not sorted by name, or we are
2417 looking at the sections for this file. */
2418
2419 if (sec != NULL && sec->spec.sorted != none)
2420 if (compare_section (sec->spec.sorted, section, ls->section) < 0)
2421 break;
2422 }
2423
2424 return l;
2425}
2426
2427/* Expand a wild statement for a particular FILE. SECTION may be
2428 NULL, in which case it is a wild card. */
2429
2430static void
2431output_section_callback (lang_wild_statement_type *ptr,
2432 struct wildcard_list *sec,
2433 asection *section,
2434 lang_input_statement_type *file,
2435 void *output)
2436{
2437 lang_statement_union_type *before;
2438 lang_output_section_statement_type *os;
2439
2440 os = (lang_output_section_statement_type *) output;
2441
2442 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2443 if (unique_section_p (section, os))
2444 return;
2445
2446 before = wild_sort (ptr, sec, file, section);
2447
2448 /* Here BEFORE points to the lang_input_section which
2449 should follow the one we are about to add. If BEFORE
2450 is NULL, then the section should just go at the end
2451 of the current list. */
2452
2453 if (before == NULL)
2454 lang_add_section (&ptr->children, section, os);
2455 else
2456 {
2457 lang_statement_list_type list;
2458 lang_statement_union_type **pp;
2459
2460 lang_list_init (&list);
2461 lang_add_section (&list, section, os);
2462
2463 /* If we are discarding the section, LIST.HEAD will
2464 be NULL. */
2465 if (list.head != NULL)
2466 {
2467 ASSERT (list.head->header.next == NULL);
2468
2469 for (pp = &ptr->children.head;
2470 *pp != before;
2471 pp = &(*pp)->header.next)
2472 ASSERT (*pp != NULL);
2473
2474 list.head->header.next = *pp;
2475 *pp = list.head;
2476 }
2477 }
2478}
2479
2480/* Check if all sections in a wild statement for a particular FILE
2481 are readonly. */
2482
2483static void
2484check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
2485 struct wildcard_list *sec ATTRIBUTE_UNUSED,
2486 asection *section,
2487 lang_input_statement_type *file ATTRIBUTE_UNUSED,
2488 void *output)
2489{
2490 lang_output_section_statement_type *os;
2491
2492 os = (lang_output_section_statement_type *) output;
2493
2494 /* Exclude sections that match UNIQUE_SECTION_LIST. */
2495 if (unique_section_p (section, os))
2496 return;
2497
2498 if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
2499 os->all_input_readonly = FALSE;
2500}
2501
2502/* This is passed a file name which must have been seen already and
2503 added to the statement tree. We will see if it has been opened
2504 already and had its symbols read. If not then we'll read it. */
2505
2506static lang_input_statement_type *
2507lookup_name (const char *name)
2508{
2509 lang_input_statement_type *search;
2510
2511 for (search = (lang_input_statement_type *) input_file_chain.head;
2512 search != NULL;
2513 search = (lang_input_statement_type *) search->next_real_file)
2514 {
2515 /* Use the local_sym_name as the name of the file that has
2516 already been loaded as filename might have been transformed
2517 via the search directory lookup mechanism. */
2518 const char *filename = search->local_sym_name;
2519
2520 if (filename != NULL
2521 && strcmp (filename, name) == 0)
2522 break;
2523 }
2524
2525 if (search == NULL)
2526 search = new_afile (name, lang_input_file_is_search_file_enum,
2527 default_target, FALSE);
2528
2529 /* If we have already added this file, or this file is not real
2530 don't add this file. */
2531 if (search->loaded || !search->real)
2532 return search;
2533
2534 if (! load_symbols (search, NULL))
2535 return NULL;
2536
2537 return search;
2538}
2539
2540/* Save LIST as a list of libraries whose symbols should not be exported. */
2541
2542struct excluded_lib
2543{
2544 char *name;
2545 struct excluded_lib *next;
2546};
2547static struct excluded_lib *excluded_libs;
2548
2549void
2550add_excluded_libs (const char *list)
2551{
2552 const char *p = list, *end;
2553
2554 while (*p != '\0')
2555 {
2556 struct excluded_lib *entry;
2557 end = strpbrk (p, ",:");
2558 if (end == NULL)
2559 end = p + strlen (p);
2560 entry = (struct excluded_lib *) xmalloc (sizeof (*entry));
2561 entry->next = excluded_libs;
2562 entry->name = (char *) xmalloc (end - p + 1);
2563 memcpy (entry->name, p, end - p);
2564 entry->name[end - p] = '\0';
2565 excluded_libs = entry;
2566 if (*end == '\0')
2567 break;
2568 p = end + 1;
2569 }
2570}
2571
2572static void
2573check_excluded_libs (bfd *abfd)
2574{
2575 struct excluded_lib *lib = excluded_libs;
2576
2577 while (lib)
2578 {
2579 int len = strlen (lib->name);
2580 const char *filename = lbasename (abfd->filename);
2581
2582 if (strcmp (lib->name, "ALL") == 0)
2583 {
2584 abfd->no_export = TRUE;
2585 return;
2586 }
2587
2588 if (strncmp (lib->name, filename, len) == 0
2589 && (filename[len] == '\0'
2590 || (filename[len] == '.' && filename[len + 1] == 'a'
2591 && filename[len + 2] == '\0')))
2592 {
2593 abfd->no_export = TRUE;
2594 return;
2595 }
2596
2597 lib = lib->next;
2598 }
2599}
2600
2601/* Get the symbols for an input file. */
2602
2603bfd_boolean
2604load_symbols (lang_input_statement_type *entry,
2605 lang_statement_list_type *place)
2606{
2607 char **matching;
2608
2609 if (entry->loaded)
2610 return TRUE;
2611
2612 ldfile_open_file (entry);
2613
2614 /* Do not process further if the file was missing. */
2615 if (entry->missing_file)
2616 return TRUE;
2617
2618 if (! bfd_check_format (entry->the_bfd, bfd_archive)
2619 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
2620 {
2621 bfd_error_type err;
2622 bfd_boolean save_ldlang_sysrooted_script;
2623 bfd_boolean save_add_DT_NEEDED_for_regular;
2624 bfd_boolean save_add_DT_NEEDED_for_dynamic;
2625 bfd_boolean save_whole_archive;
2626
2627 err = bfd_get_error ();
2628
2629 /* See if the emulation has some special knowledge. */
2630 if (ldemul_unrecognized_file (entry))
2631 return TRUE;
2632
2633 if (err == bfd_error_file_ambiguously_recognized)
2634 {
2635 char **p;
2636
2637 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
2638 einfo (_("%B: matching formats:"), entry->the_bfd);
2639 for (p = matching; *p != NULL; p++)
2640 einfo (" %s", *p);
2641 einfo ("%F\n");
2642 }
2643 else if (err != bfd_error_file_not_recognized
2644 || place == NULL)
2645 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
2646
2647 bfd_close (entry->the_bfd);
2648 entry->the_bfd = NULL;
2649
2650 /* Try to interpret the file as a linker script. */
2651 ldfile_open_command_file (entry->filename);
2652
2653 push_stat_ptr (place);
2654 save_ldlang_sysrooted_script = ldlang_sysrooted_script;
2655 ldlang_sysrooted_script = entry->sysrooted;
2656 save_add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;
2657 add_DT_NEEDED_for_regular = entry->add_DT_NEEDED_for_regular;
2658 save_add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;
2659 add_DT_NEEDED_for_dynamic = entry->add_DT_NEEDED_for_dynamic;
2660 save_whole_archive = whole_archive;
2661 whole_archive = entry->whole_archive;
2662
2663 ldfile_assumed_script = TRUE;
2664 parser_input = input_script;
2665 /* We want to use the same -Bdynamic/-Bstatic as the one for
2666 ENTRY. */
2667 config.dynamic_link = entry->dynamic;
2668 yyparse ();
2669 ldfile_assumed_script = FALSE;
2670
2671 ldlang_sysrooted_script = save_ldlang_sysrooted_script;
2672 add_DT_NEEDED_for_regular = save_add_DT_NEEDED_for_regular;
2673 add_DT_NEEDED_for_dynamic = save_add_DT_NEEDED_for_dynamic;
2674 whole_archive = save_whole_archive;
2675 pop_stat_ptr ();
2676
2677 return TRUE;
2678 }
2679
2680 if (ldemul_recognized_file (entry))
2681 return TRUE;
2682
2683 /* We don't call ldlang_add_file for an archive. Instead, the
2684 add_symbols entry point will call ldlang_add_file, via the
2685 add_archive_element callback, for each element of the archive
2686 which is used. */
2687 switch (bfd_get_format (entry->the_bfd))
2688 {
2689 default:
2690 break;
2691
2692 case bfd_object:
2693 ldlang_add_file (entry);
2694 if (trace_files || trace_file_tries)
2695 info_msg ("%I\n", entry);
2696 break;
2697
2698 case bfd_archive:
2699 check_excluded_libs (entry->the_bfd);
2700
2701 if (entry->whole_archive)
2702 {
2703 bfd *member = NULL;
2704 bfd_boolean loaded = TRUE;
2705
2706 for (;;)
2707 {
2708 bfd *subsbfd;
2709 member = bfd_openr_next_archived_file (entry->the_bfd, member);
2710
2711 if (member == NULL)
2712 break;
2713
2714 if (! bfd_check_format (member, bfd_object))
2715 {
2716 einfo (_("%F%B: member %B in archive is not an object\n"),
2717 entry->the_bfd, member);
2718 loaded = FALSE;
2719 }
2720
2721 subsbfd = member;
2722 if (!(*link_info.callbacks
2723 ->add_archive_element) (&link_info, member,
2724 "--whole-archive", &subsbfd))
2725 abort ();
2726
2727 /* Potentially, the add_archive_element hook may have set a
2728 substitute BFD for us. */
2729 if (!bfd_link_add_symbols (subsbfd, &link_info))
2730 {
2731 einfo (_("%F%B: could not read symbols: %E\n"), member);
2732 loaded = FALSE;
2733 }
2734 }
2735
2736 entry->loaded = loaded;
2737 return loaded;
2738 }
2739 break;
2740 }
2741
2742 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
2743 entry->loaded = TRUE;
2744 else
2745 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
2746
2747 return entry->loaded;
2748}
2749
2750/* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
2751 may be NULL, indicating that it is a wildcard. Separate
2752 lang_input_section statements are created for each part of the
2753 expansion; they are added after the wild statement S. OUTPUT is
2754 the output section. */
2755
2756static void
2757wild (lang_wild_statement_type *s,
2758 const char *target ATTRIBUTE_UNUSED,
2759 lang_output_section_statement_type *output)
2760{
2761 struct wildcard_list *sec;
2762
2763 if (s->handler_data[0]
2764 && s->handler_data[0]->spec.sorted == by_name
2765 && !s->filenames_sorted)
2766 {
2767 lang_section_bst_type *tree;
2768
2769 walk_wild (s, output_section_callback_fast, output);
2770
2771 tree = s->tree;
2772 if (tree)
2773 {
2774 output_section_callback_tree_to_list (s, tree, output);
2775 s->tree = NULL;
2776 }
2777 }
2778 else
2779 walk_wild (s, output_section_callback, output);
2780
2781 if (default_common_section == NULL)
2782 for (sec = s->section_list; sec != NULL; sec = sec->next)
2783 if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
2784 {
2785 /* Remember the section that common is going to in case we
2786 later get something which doesn't know where to put it. */
2787 default_common_section = output;
2788 break;
2789 }
2790}
2791
2792/* Return TRUE iff target is the sought target. */
2793
2794static int
2795get_target (const bfd_target *target, void *data)
2796{
2797 const char *sought = (const char *) data;
2798
2799 return strcmp (target->name, sought) == 0;
2800}
2801
2802/* Like strcpy() but convert to lower case as well. */
2803
2804static void
2805stricpy (char *dest, char *src)
2806{
2807 char c;
2808
2809 while ((c = *src++) != 0)
2810 *dest++ = TOLOWER (c);
2811
2812 *dest = 0;
2813}
2814
2815/* Remove the first occurrence of needle (if any) in haystack
2816 from haystack. */
2817
2818static void
2819strcut (char *haystack, char *needle)
2820{
2821 haystack = strstr (haystack, needle);
2822
2823 if (haystack)
2824 {
2825 char *src;
2826
2827 for (src = haystack + strlen (needle); *src;)
2828 *haystack++ = *src++;
2829
2830 *haystack = 0;
2831 }
2832}
2833
2834/* Compare two target format name strings.
2835 Return a value indicating how "similar" they are. */
2836
2837static int
2838name_compare (char *first, char *second)
2839{
2840 char *copy1;
2841 char *copy2;
2842 int result;
2843
2844 copy1 = (char *) xmalloc (strlen (first) + 1);
2845 copy2 = (char *) xmalloc (strlen (second) + 1);
2846
2847 /* Convert the names to lower case. */
2848 stricpy (copy1, first);
2849 stricpy (copy2, second);
2850
2851 /* Remove size and endian strings from the name. */
2852 strcut (copy1, "big");
2853 strcut (copy1, "little");
2854 strcut (copy2, "big");
2855 strcut (copy2, "little");
2856
2857 /* Return a value based on how many characters match,
2858 starting from the beginning. If both strings are
2859 the same then return 10 * their length. */
2860 for (result = 0; copy1[result] == copy2[result]; result++)
2861 if (copy1[result] == 0)
2862 {
2863 result *= 10;
2864 break;
2865 }
2866
2867 free (copy1);
2868 free (copy2);
2869
2870 return result;
2871}
2872
2873/* Set by closest_target_match() below. */
2874static const bfd_target *winner;
2875
2876/* Scan all the valid bfd targets looking for one that has the endianness
2877 requirement that was specified on the command line, and is the nearest
2878 match to the original output target. */
2879
2880static int
2881closest_target_match (const bfd_target *target, void *data)
2882{
2883 const bfd_target *original = (const bfd_target *) data;
2884
2885 if (command_line.endian == ENDIAN_BIG
2886 && target->byteorder != BFD_ENDIAN_BIG)
2887 return 0;
2888
2889 if (command_line.endian == ENDIAN_LITTLE
2890 && target->byteorder != BFD_ENDIAN_LITTLE)
2891 return 0;
2892
2893 /* Must be the same flavour. */
2894 if (target->flavour != original->flavour)
2895 return 0;
2896
2897 /* Ignore generic big and little endian elf vectors. */
2898 if (strcmp (target->name, "elf32-big") == 0
2899 || strcmp (target->name, "elf64-big") == 0
2900 || strcmp (target->name, "elf32-little") == 0
2901 || strcmp (target->name, "elf64-little") == 0)
2902 return 0;
2903
2904 /* If we have not found a potential winner yet, then record this one. */
2905 if (winner == NULL)
2906 {
2907 winner = target;
2908 return 0;
2909 }
2910
2911 /* Oh dear, we now have two potential candidates for a successful match.
2912 Compare their names and choose the better one. */
2913 if (name_compare (target->name, original->name)
2914 > name_compare (winner->name, original->name))
2915 winner = target;
2916
2917 /* Keep on searching until wqe have checked them all. */
2918 return 0;
2919}
2920
2921/* Return the BFD target format of the first input file. */
2922
2923static char *
2924get_first_input_target (void)
2925{
2926 char *target = NULL;
2927
2928 LANG_FOR_EACH_INPUT_STATEMENT (s)
2929 {
2930 if (s->header.type == lang_input_statement_enum
2931 && s->real)
2932 {
2933 ldfile_open_file (s);
2934
2935 if (s->the_bfd != NULL
2936 && bfd_check_format (s->the_bfd, bfd_object))
2937 {
2938 target = bfd_get_target (s->the_bfd);
2939
2940 if (target != NULL)
2941 break;
2942 }
2943 }
2944 }
2945
2946 return target;
2947}
2948
2949const char *
2950lang_get_output_target (void)
2951{
2952 const char *target;
2953
2954 /* Has the user told us which output format to use? */
2955 if (output_target != NULL)
2956 return output_target;
2957
2958 /* No - has the current target been set to something other than
2959 the default? */
2960 if (current_target != default_target)
2961 return current_target;
2962
2963 /* No - can we determine the format of the first input file? */
2964 target = get_first_input_target ();
2965 if (target != NULL)
2966 return target;
2967
2968 /* Failed - use the default output target. */
2969 return default_target;
2970}
2971
2972/* Open the output file. */
2973
2974static void
2975open_output (const char *name)
2976{
2977 output_target = lang_get_output_target ();
2978
2979 /* Has the user requested a particular endianness on the command
2980 line? */
2981 if (command_line.endian != ENDIAN_UNSET)
2982 {
2983 const bfd_target *target;
2984 enum bfd_endian desired_endian;
2985
2986 /* Get the chosen target. */
2987 target = bfd_search_for_target (get_target, (void *) output_target);
2988
2989 /* If the target is not supported, we cannot do anything. */
2990 if (target != NULL)
2991 {
2992 if (command_line.endian == ENDIAN_BIG)
2993 desired_endian = BFD_ENDIAN_BIG;
2994 else
2995 desired_endian = BFD_ENDIAN_LITTLE;
2996
2997 /* See if the target has the wrong endianness. This should
2998 not happen if the linker script has provided big and
2999 little endian alternatives, but some scrips don't do
3000 this. */
3001 if (target->byteorder != desired_endian)
3002 {
3003 /* If it does, then see if the target provides
3004 an alternative with the correct endianness. */
3005 if (target->alternative_target != NULL
3006 && (target->alternative_target->byteorder == desired_endian))
3007 output_target = target->alternative_target->name;
3008 else
3009 {
3010 /* Try to find a target as similar as possible to
3011 the default target, but which has the desired
3012 endian characteristic. */
3013 bfd_search_for_target (closest_target_match,
3014 (void *) target);
3015
3016 /* Oh dear - we could not find any targets that
3017 satisfy our requirements. */
3018 if (winner == NULL)
3019 einfo (_("%P: warning: could not find any targets"
3020 " that match endianness requirement\n"));
3021 else
3022 output_target = winner->name;
3023 }
3024 }
3025 }
3026 }
3027
3028 link_info.output_bfd = bfd_openw (name, output_target);
3029
3030 if (link_info.output_bfd == NULL)
3031 {
3032 if (bfd_get_error () == bfd_error_invalid_target)
3033 einfo (_("%P%F: target %s not found\n"), output_target);
3034
3035 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
3036 }
3037
3038 delete_output_file_on_failure = TRUE;
3039
3040 if (! bfd_set_format (link_info.output_bfd, bfd_object))
3041 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
3042 if (! bfd_set_arch_mach (link_info.output_bfd,
3043 ldfile_output_architecture,
3044 ldfile_output_machine))
3045 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
3046
3047 link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);
3048 if (link_info.hash == NULL)
3049 einfo (_("%P%F: can not create hash table: %E\n"));
3050
3051 bfd_set_gp_size (link_info.output_bfd, g_switch_value);
3052}
3053
3054static void
3055ldlang_open_output (lang_statement_union_type *statement)
3056{
3057 switch (statement->header.type)
3058 {
3059 case lang_output_statement_enum:
3060 ASSERT (link_info.output_bfd == NULL);
3061 open_output (statement->output_statement.name);
3062 ldemul_set_output_arch ();
3063 if (config.magic_demand_paged && !link_info.relocatable)
3064 link_info.output_bfd->flags |= D_PAGED;
3065 else
3066 link_info.output_bfd->flags &= ~D_PAGED;
3067 if (config.text_read_only)
3068 link_info.output_bfd->flags |= WP_TEXT;
3069 else
3070 link_info.output_bfd->flags &= ~WP_TEXT;
3071 if (link_info.traditional_format)
3072 link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
3073 else
3074 link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
3075 break;
3076
3077 case lang_target_statement_enum:
3078 current_target = statement->target_statement.target;
3079 break;
3080 default:
3081 break;
3082 }
3083}
3084
3085/* Convert between addresses in bytes and sizes in octets.
3086 For currently supported targets, octets_per_byte is always a power
3087 of two, so we can use shifts. */
3088#define TO_ADDR(X) ((X) >> opb_shift)
3089#define TO_SIZE(X) ((X) << opb_shift)
3090
3091/* Support the above. */
3092static unsigned int opb_shift = 0;
3093
3094static void
3095init_opb (void)
3096{
3097 unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3098 ldfile_output_machine);
3099 opb_shift = 0;
3100 if (x > 1)
3101 while ((x & 1) == 0)
3102 {
3103 x >>= 1;
3104 ++opb_shift;
3105 }
3106 ASSERT (x == 1);
3107}
3108
3109/* Open all the input files. */
3110
3111static void
3112open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
3113{
3114 for (; s != NULL; s = s->header.next)
3115 {
3116 switch (s->header.type)
3117 {
3118 case lang_constructors_statement_enum:
3119 open_input_bfds (constructor_list.head, force);
3120 break;
3121 case lang_output_section_statement_enum:
3122 open_input_bfds (s->output_section_statement.children.head, force);
3123 break;
3124 case lang_wild_statement_enum:
3125 /* Maybe we should load the file's symbols. */
3126 if (s->wild_statement.filename
3127 && !wildcardp (s->wild_statement.filename)
3128 && !archive_path (s->wild_statement.filename))
3129 lookup_name (s->wild_statement.filename);
3130 open_input_bfds (s->wild_statement.children.head, force);
3131 break;
3132 case lang_group_statement_enum:
3133 {
3134 struct bfd_link_hash_entry *undefs;
3135
3136 /* We must continually search the entries in the group
3137 until no new symbols are added to the list of undefined
3138 symbols. */
3139
3140 do
3141 {
3142 undefs = link_info.hash->undefs_tail;
3143 open_input_bfds (s->group_statement.children.head, TRUE);
3144 }
3145 while (undefs != link_info.hash->undefs_tail);
3146 }
3147 break;
3148 case lang_target_statement_enum:
3149 current_target = s->target_statement.target;
3150 break;
3151 case lang_input_statement_enum:
3152 if (s->input_statement.real)
3153 {
3154 lang_statement_union_type **os_tail;
3155 lang_statement_list_type add;
3156
3157 s->input_statement.target = current_target;
3158
3159 /* If we are being called from within a group, and this
3160 is an archive which has already been searched, then
3161 force it to be researched unless the whole archive
3162 has been loaded already. */
3163 if (force
3164 && !s->input_statement.whole_archive
3165 && s->input_statement.loaded
3166 && bfd_check_format (s->input_statement.the_bfd,
3167 bfd_archive))
3168 s->input_statement.loaded = FALSE;
3169
3170 os_tail = lang_output_section_statement.tail;
3171 lang_list_init (&add);
3172
3173 if (! load_symbols (&s->input_statement, &add))
3174 config.make_executable = FALSE;
3175
3176 if (add.head != NULL)
3177 {
3178 /* If this was a script with output sections then
3179 tack any added statements on to the end of the
3180 list. This avoids having to reorder the output
3181 section statement list. Very likely the user
3182 forgot -T, and whatever we do here will not meet
3183 naive user expectations. */
3184 if (os_tail != lang_output_section_statement.tail)
3185 {
3186 einfo (_("%P: warning: %s contains output sections;"
3187 " did you forget -T?\n"),
3188 s->input_statement.filename);
3189 *stat_ptr->tail = add.head;
3190 stat_ptr->tail = add.tail;
3191 }
3192 else
3193 {
3194 *add.tail = s->header.next;
3195 s->header.next = add.head;
3196 }
3197 }
3198 }
3199 break;
3200 case lang_assignment_statement_enum:
3201 if (s->assignment_statement.exp->assign.hidden)
3202 /* This is from a --defsym on the command line. */
3203 exp_fold_tree_no_dot (s->assignment_statement.exp);
3204 break;
3205 default:
3206 break;
3207 }
3208 }
3209
3210 /* Exit if any of the files were missing. */
3211 if (missing_file)
3212 einfo ("%F");
3213}
3214
3215/* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
3216
3217void
3218lang_track_definedness (const char *name)
3219{
3220 if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
3221 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
3222}
3223
3224/* New-function for the definedness hash table. */
3225
3226static struct bfd_hash_entry *
3227lang_definedness_newfunc (struct bfd_hash_entry *entry,
3228 struct bfd_hash_table *table ATTRIBUTE_UNUSED,
3229 const char *name ATTRIBUTE_UNUSED)
3230{
3231 struct lang_definedness_hash_entry *ret
3232 = (struct lang_definedness_hash_entry *) entry;
3233
3234 if (ret == NULL)
3235 ret = (struct lang_definedness_hash_entry *)
3236 bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
3237
3238 if (ret == NULL)
3239 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
3240
3241 ret->iteration = -1;
3242 return &ret->root;
3243}
3244
3245/* Return the iteration when the definition of NAME was last updated. A
3246 value of -1 means that the symbol is not defined in the linker script
3247 or the command line, but may be defined in the linker symbol table. */
3248
3249int
3250lang_symbol_definition_iteration (const char *name)
3251{
3252 struct lang_definedness_hash_entry *defentry
3253 = (struct lang_definedness_hash_entry *)
3254 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3255
3256 /* We've already created this one on the presence of DEFINED in the
3257 script, so it can't be NULL unless something is borked elsewhere in
3258 the code. */
3259 if (defentry == NULL)
3260 FAIL ();
3261
3262 return defentry->iteration;
3263}
3264
3265/* Update the definedness state of NAME. */
3266
3267void
3268lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
3269{
3270 struct lang_definedness_hash_entry *defentry
3271 = (struct lang_definedness_hash_entry *)
3272 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3273
3274 /* We don't keep track of symbols not tested with DEFINED. */
3275 if (defentry == NULL)
3276 return;
3277
3278 /* If the symbol was already defined, and not from an earlier statement
3279 iteration, don't update the definedness iteration, because that'd
3280 make the symbol seem defined in the linker script at this point, and
3281 it wasn't; it was defined in some object. If we do anyway, DEFINED
3282 would start to yield false before this point and the construct "sym =
3283 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3284 in an object. */
3285 if (h->type != bfd_link_hash_undefined
3286 && h->type != bfd_link_hash_common
3287 && h->type != bfd_link_hash_new
3288 && defentry->iteration == -1)
3289 return;
3290
3291 defentry->iteration = lang_statement_iteration;
3292}
3293
3294/* Add the supplied name to the symbol table as an undefined reference.
3295 This is a two step process as the symbol table doesn't even exist at
3296 the time the ld command line is processed. First we put the name
3297 on a list, then, once the output file has been opened, transfer the
3298 name to the symbol table. */
3299
3300typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
3301
3302#define ldlang_undef_chain_list_head entry_symbol.next
3303
3304void
3305ldlang_add_undef (const char *const name, bfd_boolean cmdline)
3306{
3307 ldlang_undef_chain_list_type *new_undef;
3308
3309 undef_from_cmdline = undef_from_cmdline || cmdline;
3310 new_undef = (ldlang_undef_chain_list_type *) stat_alloc (sizeof (*new_undef));
3311 new_undef->next = ldlang_undef_chain_list_head;
3312 ldlang_undef_chain_list_head = new_undef;
3313
3314 new_undef->name = xstrdup (name);
3315
3316 if (link_info.output_bfd != NULL)
3317 insert_undefined (new_undef->name);
3318}
3319
3320/* Insert NAME as undefined in the symbol table. */
3321
3322static void
3323insert_undefined (const char *name)
3324{
3325 struct bfd_link_hash_entry *h;
3326
3327 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
3328 if (h == NULL)
3329 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3330 if (h->type == bfd_link_hash_new)
3331 {
3332 h->type = bfd_link_hash_undefined;
3333 h->u.undef.abfd = NULL;
3334 bfd_link_add_undef (link_info.hash, h);
3335 }
3336}
3337
3338/* Run through the list of undefineds created above and place them
3339 into the linker hash table as undefined symbols belonging to the
3340 script file. */
3341
3342static void
3343lang_place_undefineds (void)
3344{
3345 ldlang_undef_chain_list_type *ptr;
3346
3347 for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
3348 insert_undefined (ptr->name);
3349}
3350
3351/* Check for all readonly or some readwrite sections. */
3352
3353static void
3354check_input_sections
3355 (lang_statement_union_type *s,
3356 lang_output_section_statement_type *output_section_statement)
3357{
3358 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3359 {
3360 switch (s->header.type)
3361 {
3362 case lang_wild_statement_enum:
3363 walk_wild (&s->wild_statement, check_section_callback,
3364 output_section_statement);
3365 if (! output_section_statement->all_input_readonly)
3366 return;
3367 break;
3368 case lang_constructors_statement_enum:
3369 check_input_sections (constructor_list.head,
3370 output_section_statement);
3371 if (! output_section_statement->all_input_readonly)
3372 return;
3373 break;
3374 case lang_group_statement_enum:
3375 check_input_sections (s->group_statement.children.head,
3376 output_section_statement);
3377 if (! output_section_statement->all_input_readonly)
3378 return;
3379 break;
3380 default:
3381 break;
3382 }
3383 }
3384}
3385
3386/* Update wildcard statements if needed. */
3387
3388static void
3389update_wild_statements (lang_statement_union_type *s)
3390{
3391 struct wildcard_list *sec;
3392
3393 switch (sort_section)
3394 {
3395 default:
3396 FAIL ();
3397
3398 case none:
3399 break;
3400
3401 case by_name:
3402 case by_alignment:
3403 for (; s != NULL; s = s->header.next)
3404 {
3405 switch (s->header.type)
3406 {
3407 default:
3408 break;
3409
3410 case lang_wild_statement_enum:
3411 sec = s->wild_statement.section_list;
3412 for (sec = s->wild_statement.section_list; sec != NULL;
3413 sec = sec->next)
3414 {
3415 switch (sec->spec.sorted)
3416 {
3417 case none:
3418 sec->spec.sorted = sort_section;
3419 break;
3420 case by_name:
3421 if (sort_section == by_alignment)
3422 sec->spec.sorted = by_name_alignment;
3423 break;
3424 case by_alignment:
3425 if (sort_section == by_name)
3426 sec->spec.sorted = by_alignment_name;
3427 break;
3428 default:
3429 break;
3430 }
3431 }
3432 break;
3433
3434 case lang_constructors_statement_enum:
3435 update_wild_statements (constructor_list.head);
3436 break;
3437
3438 case lang_output_section_statement_enum:
3439 update_wild_statements
3440 (s->output_section_statement.children.head);
3441 break;
3442
3443 case lang_group_statement_enum:
3444 update_wild_statements (s->group_statement.children.head);
3445 break;
3446 }
3447 }
3448 break;
3449 }
3450}
3451
3452/* Open input files and attach to output sections. */
3453
3454static void
3455map_input_to_output_sections
3456 (lang_statement_union_type *s, const char *target,
3457 lang_output_section_statement_type *os)
3458{
3459 for (; s != NULL; s = s->header.next)
3460 {
3461 lang_output_section_statement_type *tos;
3462 flagword flags;
3463
3464 switch (s->header.type)
3465 {
3466 case lang_wild_statement_enum:
3467 wild (&s->wild_statement, target, os);
3468 break;
3469 case lang_constructors_statement_enum:
3470 map_input_to_output_sections (constructor_list.head,
3471 target,
3472 os);
3473 break;
3474 case lang_output_section_statement_enum:
3475 tos = &s->output_section_statement;
3476 if (tos->constraint != 0)
3477 {
3478 if (tos->constraint != ONLY_IF_RW
3479 && tos->constraint != ONLY_IF_RO)
3480 break;
3481 tos->all_input_readonly = TRUE;
3482 check_input_sections (tos->children.head, tos);
3483 if (tos->all_input_readonly != (tos->constraint == ONLY_IF_RO))
3484 {
3485 tos->constraint = -1;
3486 break;
3487 }
3488 }
3489 map_input_to_output_sections (tos->children.head,
3490 target,
3491 tos);
3492 break;
3493 case lang_output_statement_enum:
3494 break;
3495 case lang_target_statement_enum:
3496 target = s->target_statement.target;
3497 break;
3498 case lang_group_statement_enum:
3499 map_input_to_output_sections (s->group_statement.children.head,
3500 target,
3501 os);
3502 break;
3503 case lang_data_statement_enum:
3504 /* Make sure that any sections mentioned in the expression
3505 are initialized. */
3506 exp_init_os (s->data_statement.exp);
3507 /* The output section gets CONTENTS, ALLOC and LOAD, but
3508 these may be overridden by the script. */
3509 flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD;
3510 switch (os->sectype)
3511 {
3512 case normal_section:
3513 case overlay_section:
3514 break;
3515 case noalloc_section:
3516 flags = SEC_HAS_CONTENTS;
3517 break;
3518 case noload_section:
3519 if (bfd_get_flavour (link_info.output_bfd)
3520 == bfd_target_elf_flavour)
3521 flags = SEC_NEVER_LOAD | SEC_ALLOC;
3522 else
3523 flags = SEC_NEVER_LOAD | SEC_HAS_CONTENTS;
3524 break;
3525 }
3526 if (os->bfd_section == NULL)
3527 init_os (os, flags);
3528 else
3529 os->bfd_section->flags |= flags;
3530 break;
3531 case lang_input_section_enum:
3532 break;
3533 case lang_fill_statement_enum:
3534 case lang_object_symbols_statement_enum:
3535 case lang_reloc_statement_enum:
3536 case lang_padding_statement_enum:
3537 case lang_input_statement_enum:
3538 if (os != NULL && os->bfd_section == NULL)
3539 init_os (os, 0);
3540 break;
3541 case lang_assignment_statement_enum:
3542 if (os != NULL && os->bfd_section == NULL)
3543 init_os (os, 0);
3544
3545 /* Make sure that any sections mentioned in the assignment
3546 are initialized. */
3547 exp_init_os (s->assignment_statement.exp);
3548 break;
3549 case lang_address_statement_enum:
3550 /* Mark the specified section with the supplied address.
3551 If this section was actually a segment marker, then the
3552 directive is ignored if the linker script explicitly
3553 processed the segment marker. Originally, the linker
3554 treated segment directives (like -Ttext on the
3555 command-line) as section directives. We honor the
3556 section directive semantics for backwards compatibilty;
3557 linker scripts that do not specifically check for
3558 SEGMENT_START automatically get the old semantics. */
3559 if (!s->address_statement.segment
3560 || !s->address_statement.segment->used)
3561 {
3562 const char *name = s->address_statement.section_name;
3563
3564 /* Create the output section statement here so that
3565 orphans with a set address will be placed after other
3566 script sections. If we let the orphan placement code
3567 place them in amongst other sections then the address
3568 will affect following script sections, which is
3569 likely to surprise naive users. */
3570 tos = lang_output_section_statement_lookup (name, 0, TRUE);
3571 tos->addr_tree = s->address_statement.address;
3572 if (tos->bfd_section == NULL)
3573 init_os (tos, 0);
3574 }
3575 break;
3576 case lang_insert_statement_enum:
3577 break;
3578 }
3579 }
3580}
3581
3582/* An insert statement snips out all the linker statements from the
3583 start of the list and places them after the output section
3584 statement specified by the insert. This operation is complicated
3585 by the fact that we keep a doubly linked list of output section
3586 statements as well as the singly linked list of all statements. */
3587
3588static void
3589process_insert_statements (void)
3590{
3591 lang_statement_union_type **s;
3592 lang_output_section_statement_type *first_os = NULL;
3593 lang_output_section_statement_type *last_os = NULL;
3594 lang_output_section_statement_type *os;
3595
3596 /* "start of list" is actually the statement immediately after
3597 the special abs_section output statement, so that it isn't
3598 reordered. */
3599 s = &lang_output_section_statement.head;
3600 while (*(s = &(*s)->header.next) != NULL)
3601 {
3602 if ((*s)->header.type == lang_output_section_statement_enum)
3603 {
3604 /* Keep pointers to the first and last output section
3605 statement in the sequence we may be about to move. */
3606 os = &(*s)->output_section_statement;
3607
3608 ASSERT (last_os == NULL || last_os->next == os);
3609 last_os = os;
3610
3611 /* Set constraint negative so that lang_output_section_find
3612 won't match this output section statement. At this
3613 stage in linking constraint has values in the range
3614 [-1, ONLY_IN_RW]. */
3615 last_os->constraint = -2 - last_os->constraint;
3616 if (first_os == NULL)
3617 first_os = last_os;
3618 }
3619 else if ((*s)->header.type == lang_insert_statement_enum)
3620 {
3621 lang_insert_statement_type *i = &(*s)->insert_statement;
3622 lang_output_section_statement_type *where;
3623 lang_statement_union_type **ptr;
3624 lang_statement_union_type *first;
3625
3626 where = lang_output_section_find (i->where);
3627 if (where != NULL && i->is_before)
3628 {
3629 do
3630 where = where->prev;
3631 while (where != NULL && where->constraint < 0);
3632 }
3633 if (where == NULL)
3634 {
3635 einfo (_("%F%P: %s not found for insert\n"), i->where);
3636 return;
3637 }
3638
3639 /* Deal with reordering the output section statement list. */
3640 if (last_os != NULL)
3641 {
3642 asection *first_sec, *last_sec;
3643 struct lang_output_section_statement_struct **next;
3644
3645 /* Snip out the output sections we are moving. */
3646 first_os->prev->next = last_os->next;
3647 if (last_os->next == NULL)
3648 {
3649 next = &first_os->prev->next;
3650 lang_output_section_statement.tail
3651 = (lang_statement_union_type **) next;
3652 }
3653 else
3654 last_os->next->prev = first_os->prev;
3655 /* Add them in at the new position. */
3656 last_os->next = where->next;
3657 if (where->next == NULL)
3658 {
3659 next = &last_os->next;
3660 lang_output_section_statement.tail
3661 = (lang_statement_union_type **) next;
3662 }
3663 else
3664 where->next->prev = last_os;
3665 first_os->prev = where;
3666 where->next = first_os;
3667
3668 /* Move the bfd sections in the same way. */
3669 first_sec = NULL;
3670 last_sec = NULL;
3671 for (os = first_os; os != NULL; os = os->next)
3672 {
3673 os->constraint = -2 - os->constraint;
3674 if (os->bfd_section != NULL
3675 && os->bfd_section->owner != NULL)
3676 {
3677 last_sec = os->bfd_section;
3678 if (first_sec == NULL)
3679 first_sec = last_sec;
3680 }
3681 if (os == last_os)
3682 break;
3683 }
3684 if (last_sec != NULL)
3685 {
3686 asection *sec = where->bfd_section;
3687 if (sec == NULL)
3688 sec = output_prev_sec_find (where);
3689
3690 /* The place we want to insert must come after the
3691 sections we are moving. So if we find no
3692 section or if the section is the same as our
3693 last section, then no move is needed. */
3694 if (sec != NULL && sec != last_sec)
3695 {
3696 /* Trim them off. */
3697 if (first_sec->prev != NULL)
3698 first_sec->prev->next = last_sec->next;
3699 else
3700 link_info.output_bfd->sections = last_sec->next;
3701 if (last_sec->next != NULL)
3702 last_sec->next->prev = first_sec->prev;
3703 else
3704 link_info.output_bfd->section_last = first_sec->prev;
3705 /* Add back. */
3706 last_sec->next = sec->next;
3707 if (sec->next != NULL)
3708 sec->next->prev = last_sec;
3709 else
3710 link_info.output_bfd->section_last = last_sec;
3711 first_sec->prev = sec;
3712 sec->next = first_sec;
3713 }
3714 }
3715
3716 first_os = NULL;
3717 last_os = NULL;
3718 }
3719
3720 ptr = insert_os_after (where);
3721 /* Snip everything after the abs_section output statement we
3722 know is at the start of the list, up to and including
3723 the insert statement we are currently processing. */
3724 first = lang_output_section_statement.head->header.next;
3725 lang_output_section_statement.head->header.next = (*s)->header.next;
3726 /* Add them back where they belong. */
3727 *s = *ptr;
3728 if (*s == NULL)
3729 statement_list.tail = s;
3730 *ptr = first;
3731 s = &lang_output_section_statement.head;
3732 }
3733 }
3734
3735 /* Undo constraint twiddling. */
3736 for (os = first_os; os != NULL; os = os->next)
3737 {
3738 os->constraint = -2 - os->constraint;
3739 if (os == last_os)
3740 break;
3741 }
3742}
3743
3744/* An output section might have been removed after its statement was
3745 added. For example, ldemul_before_allocation can remove dynamic
3746 sections if they turn out to be not needed. Clean them up here. */
3747
3748void
3749strip_excluded_output_sections (void)
3750{
3751 lang_output_section_statement_type *os;
3752
3753 /* Run lang_size_sections (if not already done). */
3754 if (expld.phase != lang_mark_phase_enum)
3755 {
3756 expld.phase = lang_mark_phase_enum;
3757 expld.dataseg.phase = exp_dataseg_none;
3758 one_lang_size_sections_pass (NULL, FALSE);
3759 lang_reset_memory_regions ();
3760 }
3761
3762 for (os = &lang_output_section_statement.head->output_section_statement;
3763 os != NULL;
3764 os = os->next)
3765 {
3766 asection *output_section;
3767 bfd_boolean exclude;
3768
3769 if (os->constraint < 0)
3770 continue;
3771
3772 output_section = os->bfd_section;
3773 if (output_section == NULL)
3774 continue;
3775
3776 exclude = (output_section->rawsize == 0
3777 && (output_section->flags & SEC_KEEP) == 0
3778 && !bfd_section_removed_from_list (link_info.output_bfd,
3779 output_section));
3780
3781 /* Some sections have not yet been sized, notably .gnu.version,
3782 .dynsym, .dynstr and .hash. These all have SEC_LINKER_CREATED
3783 input sections, so don't drop output sections that have such
3784 input sections unless they are also marked SEC_EXCLUDE. */
3785 if (exclude && output_section->map_head.s != NULL)
3786 {
3787 asection *s;
3788
3789 for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
3790 if ((s->flags & SEC_LINKER_CREATED) != 0
3791 && (s->flags & SEC_EXCLUDE) == 0)
3792 {
3793 exclude = FALSE;
3794 break;
3795 }
3796 }
3797
3798 /* TODO: Don't just junk map_head.s, turn them into link_orders. */
3799 output_section->map_head.link_order = NULL;
3800 output_section->map_tail.link_order = NULL;
3801
3802 if (exclude)
3803 {
3804 /* We don't set bfd_section to NULL since bfd_section of the
3805 removed output section statement may still be used. */
3806 if (!os->section_relative_symbol
3807 && !os->update_dot_tree)
3808 os->ignored = TRUE;
3809 output_section->flags |= SEC_EXCLUDE;
3810 bfd_section_list_remove (link_info.output_bfd, output_section);
3811 link_info.output_bfd->section_count--;
3812 }
3813 }
3814
3815 /* Stop future calls to lang_add_section from messing with map_head
3816 and map_tail link_order fields. */
3817 stripped_excluded_sections = TRUE;
3818}
3819
3820static void
3821print_output_section_statement
3822 (lang_output_section_statement_type *output_section_statement)
3823{
3824 asection *section = output_section_statement->bfd_section;
3825 int len;
3826
3827 if (output_section_statement != abs_output_section)
3828 {
3829 minfo ("\n%s", output_section_statement->name);
3830
3831 if (section != NULL)
3832 {
3833 print_dot = section->vma;
3834
3835 len = strlen (output_section_statement->name);
3836 if (len >= SECTION_NAME_MAP_LENGTH - 1)
3837 {
3838 print_nl ();
3839 len = 0;
3840 }
3841 while (len < SECTION_NAME_MAP_LENGTH)
3842 {
3843 print_space ();
3844 ++len;
3845 }
3846
3847 minfo ("0x%V %W", section->vma, section->size);
3848
3849 if (section->vma != section->lma)
3850 minfo (_(" load address 0x%V"), section->lma);
3851
3852 if (output_section_statement->update_dot_tree != NULL)
3853 exp_fold_tree (output_section_statement->update_dot_tree,
3854 bfd_abs_section_ptr, &print_dot);
3855 }
3856
3857 print_nl ();
3858 }
3859
3860 print_statement_list (output_section_statement->children.head,
3861 output_section_statement);
3862}
3863
3864/* Scan for the use of the destination in the right hand side
3865 of an expression. In such cases we will not compute the
3866 correct expression, since the value of DST that is used on
3867 the right hand side will be its final value, not its value
3868 just before this expression is evaluated. */
3869
3870static bfd_boolean
3871scan_for_self_assignment (const char * dst, etree_type * rhs)
3872{
3873 if (rhs == NULL || dst == NULL)
3874 return FALSE;
3875
3876 switch (rhs->type.node_class)
3877 {
3878 case etree_binary:
3879 return (scan_for_self_assignment (dst, rhs->binary.lhs)
3880 || scan_for_self_assignment (dst, rhs->binary.rhs));
3881
3882 case etree_trinary:
3883 return (scan_for_self_assignment (dst, rhs->trinary.lhs)
3884 || scan_for_self_assignment (dst, rhs->trinary.rhs));
3885
3886 case etree_assign:
3887 case etree_provided:
3888 case etree_provide:
3889 if (strcmp (dst, rhs->assign.dst) == 0)
3890 return TRUE;
3891 return scan_for_self_assignment (dst, rhs->assign.src);
3892
3893 case etree_unary:
3894 return scan_for_self_assignment (dst, rhs->unary.child);
3895
3896 case etree_value:
3897 if (rhs->value.str)
3898 return strcmp (dst, rhs->value.str) == 0;
3899 return FALSE;
3900
3901 case etree_name:
3902 if (rhs->name.name)
3903 return strcmp (dst, rhs->name.name) == 0;
3904 return FALSE;
3905
3906 default:
3907 break;
3908 }
3909
3910 return FALSE;
3911}
3912
3913
3914static void
3915print_assignment (lang_assignment_statement_type *assignment,
3916 lang_output_section_statement_type *output_section)
3917{
3918 unsigned int i;
3919 bfd_boolean is_dot;
3920 bfd_boolean computation_is_valid = TRUE;