4d5d1995d33f023c9b49c33150af36865fbe9b21
[dragonfly.git] / contrib / binutils-2.21 / ld / ldlang.c
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.  */
53 static struct obstack stat_obstack;
54 static struct obstack map_obstack;
55
56 #define obstack_chunk_alloc xmalloc
57 #define obstack_chunk_free free
58 static const char *startup_file;
59 static const char *entry_symbol_default = "start";
60 static bfd_boolean placed_commons = FALSE;
61 static bfd_boolean stripped_excluded_sections = FALSE;
62 static lang_output_section_statement_type *default_common_section;
63 static bfd_boolean map_option_f;
64 static bfd_vma print_dot;
65 static lang_input_statement_type *first_file;
66 static const char *current_target;
67 static lang_statement_list_type statement_list;
68 static struct bfd_hash_table lang_definedness_table;
69 static lang_statement_list_type *stat_save[10];
70 static lang_statement_list_type **stat_save_ptr = &stat_save[0];
71 static struct unique_sections *unique_section_list;
72 static bfd_boolean ldlang_sysrooted_script = FALSE;
73
74 /* Forward declarations.  */
75 static void exp_init_os (etree_type *);
76 static void init_map_userdata (bfd *, asection *, void *);
77 static lang_input_statement_type *lookup_name (const char *);
78 static struct bfd_hash_entry *lang_definedness_newfunc
79  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
80 static void insert_undefined (const char *);
81 static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
82 static void print_statement (lang_statement_union_type *,
83                              lang_output_section_statement_type *);
84 static void print_statement_list (lang_statement_union_type *,
85                                   lang_output_section_statement_type *);
86 static void print_statements (void);
87 static void print_input_section (asection *, bfd_boolean);
88 static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
89 static void lang_record_phdrs (void);
90 static void lang_do_version_exports_section (void);
91 static void lang_finalize_version_expr_head
92   (struct bfd_elf_version_expr_head *);
93
94 /* Exported variables.  */
95 const char *output_target;
96 lang_output_section_statement_type *abs_output_section;
97 lang_statement_list_type lang_output_section_statement;
98 lang_statement_list_type *stat_ptr = &statement_list;
99 lang_statement_list_type file_chain = { NULL, NULL };
100 lang_statement_list_type input_file_chain;
101 struct bfd_sym_chain entry_symbol = { NULL, NULL };
102 const char *entry_section = ".text";
103 bfd_boolean entry_from_cmdline;
104 bfd_boolean undef_from_cmdline;
105 bfd_boolean lang_has_input_file = FALSE;
106 bfd_boolean had_output_filename = FALSE;
107 bfd_boolean lang_float_flag = FALSE;
108 bfd_boolean delete_output_file_on_failure = FALSE;
109 struct lang_phdr *lang_phdr_list;
110 struct lang_nocrossrefs *nocrossref_list;
111 bfd_boolean missing_file = FALSE;
112
113  /* Functions that traverse the linker script and might evaluate
114     DEFINED() need to increment this.  */
115 int lang_statement_iteration = 0;
116
117 etree_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
137 void *
138 stat_alloc (size_t size)
139 {
140   return obstack_alloc (&stat_obstack, size);
141 }
142
143 static int
144 name_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
154 static char *
155 archive_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
178 static bfd_boolean
179 input_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
202 static bfd_boolean
203 unique_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
230 static void
231 walk_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
272 static void
273 walk_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
309 typedef struct
310 {
311   asection *found_section;
312   bfd_boolean multiple_sections_found;
313 } section_iterator_callback_data;
314
315 static bfd_boolean
316 section_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
330 static asection *
331 find_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
349 static bfd_boolean
350 is_simple_wild (const char *name)
351 {
352   size_t len = strcspn (name, "*?[");
353   return len >= 4 && name[len] == '*' && name[len + 1] == '\0';
354 }
355
356 static bfd_boolean
357 match_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
376 static int
377 compare_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
418 static lang_section_bst_type **
419 wild_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
450 static void
451 output_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
478 static void
479 output_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
498 static void
499 walk_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
519 static void
520 walk_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
538 static void
539 walk_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
577 static void
578 walk_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
618 static void
619 walk_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
672 static void
673 walk_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
689 static bfd_boolean
690 wild_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
712 static void
713 analyze_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
802 static void
803 walk_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
837 static void
838 walk_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
882 void
883 lang_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
928 void
929 lang_for_each_statement (void (*func) (lang_statement_union_type *))
930 {
931   lang_for_each_statement_worker (func, statement_list.head);
932 }
933
934 /*----------------------------------------------------------------------*/
935
936 void
937 lang_list_init (lang_statement_list_type *list)
938 {
939   list->head = NULL;
940   list->tail = &list->head;
941 }
942
943 void
944 push_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
952 void
953 pop_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
962 static lang_statement_union_type *
963 new_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
985 static lang_input_statement_type *
986 new_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
1084 lang_input_statement_type *
1085 lang_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
1092 struct out_section_hash_entry
1093 {
1094   struct bfd_hash_entry root;
1095   lang_statement_union_type s;
1096 };
1097
1098 /* The hash table.  */
1099
1100 static 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
1105 static struct bfd_hash_entry *
1106 output_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
1153 static void
1154 output_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
1163 static void
1164 output_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
1171 void
1172 lang_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
1205 void
1206 lang_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
1233 static lang_memory_region_type *lang_memory_region_list;
1234 static lang_memory_region_type **lang_memory_region_list_tail
1235   = &lang_memory_region_list;
1236
1237 lang_memory_region_type *
1238 lang_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
1281 void
1282 lang_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
1323 static lang_memory_region_type *
1324 lang_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
1350 lang_output_section_statement_type *
1351 lang_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
1418 lang_output_section_statement_type *
1419 next_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
1449 lang_output_section_statement_type *
1450 lang_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
1617 static asection *
1618 output_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
1645 static lang_statement_union_type **
1646 insert_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
1710 lang_output_section_statement_type *
1711 lang_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));
1760           lang_add_assignment (exp_assign (symname,
1761                                             exp_unop (ABSOLUTE,
1762                                                   exp_nameop (NAME, "."))));
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);
1792       lang_add_assignment (exp_assign (symname,
1793                                         exp_nameop (NAME, ".")));
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
1915 static void
1916 lang_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
1934 void
1935 lang_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
2019 static void
2020 init_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
2034 static bfd_boolean
2035 sort_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
2071 static void
2072 init_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
2114 static void
2115 exp_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
2164 static void
2165 section_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
2191 void
2192 lang_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
2338 static lang_statement_union_type *
2339 wild_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
2430 static void
2431 output_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
2483 static void
2484 check_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
2506 static lang_input_statement_type *
2507 lookup_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
2542 struct excluded_lib
2543 {
2544   char *name;
2545   struct excluded_lib *next;
2546 };
2547 static struct excluded_lib *excluded_libs;
2548
2549 void
2550 add_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
2572 static void
2573 check_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
2603 bfd_boolean
2604 load_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
2756 static void
2757 wild (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
2794 static int
2795 get_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
2804 static void
2805 stricpy (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
2818 static void
2819 strcut (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
2837 static int
2838 name_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.  */
2874 static 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
2880 static int
2881 closest_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
2923 static char *
2924 get_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
2949 const char *
2950 lang_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
2974 static void
2975 open_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
3054 static void
3055 ldlang_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.  */
3092 static unsigned int opb_shift = 0;
3093
3094 static void
3095 init_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
3111 static void
3112 open_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
3217 void
3218 lang_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
3226 static struct bfd_hash_entry *
3227 lang_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
3249 int
3250 lang_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
3267 void
3268 lang_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
3300 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
3301
3302 #define ldlang_undef_chain_list_head entry_symbol.next
3303
3304 void
3305 ldlang_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
3322 static void
3323 insert_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
3342 static void
3343 lang_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
3353 static void
3354 check_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
3388 static void
3389 update_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
3454 static void
3455 map_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
3588 static void
3589 process_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
3748 void
3749 strip_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
3820 static void
3821 print_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
3870 static bfd_boolean
3871 scan_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
3914 static void
3915 print_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;
3921   etree_type *tree;
3922   asection *osec;
3923
3924   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
3925     print_space ();
3926
3927   if (assignment->exp->type.node_class == etree_assert)
3928     {
3929       is_dot = FALSE;
3930       tree = assignment->exp->assert_s.child;
3931       computation_is_valid = TRUE;
3932     }
3933   else
3934     {
3935       const char *dst = assignment->exp->assign.dst;
3936
3937       is_dot = (dst[0] == '.' && dst[1] == 0);
3938       tree = assignment->exp->assign.src;
3939       computation_is_valid = is_dot || !scan_for_self_assignment (dst, tree);
3940     }
3941
3942   osec = output_section->bfd_section;
3943   if (osec == NULL)
3944     osec = bfd_abs_section_ptr;
3945   exp_fold_tree (tree, osec, &print_dot);
3946   if (expld.result.valid_p)
3947     {
3948       bfd_vma value;
3949
3950       if (computation_is_valid)
3951         {
3952           value = expld.result.value;
3953
3954           if (expld.result.section != NULL)
3955             value += expld.result.section->vma;
3956
3957           minfo ("0x%V", value);
3958           if (is_dot)
3959             print_dot = value;
3960         }
3961       else
3962         {
3963           struct bfd_link_hash_entry *h;
3964
3965           h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
3966                                     FALSE, FALSE, TRUE);
3967           if (h)
3968             {
3969               value = h->u.def.value;
3970
3971               if (expld.result.section != NULL)
3972                 value += expld.result.section->vma;
3973
3974               minfo ("[0x%V]", value);
3975             }
3976           else
3977             minfo ("[unresolved]");
3978         }
3979     }
3980   else
3981     {
3982       minfo ("*undef*   ");
3983 #ifdef BFD64
3984       minfo ("        ");
3985 #endif
3986     }
3987
3988   minfo ("                ");
3989   exp_print_tree (assignment->exp);
3990   print_nl ();
3991 }
3992
3993 static void
3994 print_input_statement (lang_input_statement_type *statm)
3995 {
3996   if (statm->filename != NULL
3997       && (statm->the_bfd == NULL
3998           || (statm->the_bfd->flags & BFD_LINKER_CREATED) == 0))
3999     fprintf (config.map_file, "LOAD %s\n", statm->filename);
4000 }
4001
4002 /* Print all symbols defined in a particular section.  This is called
4003    via bfd_link_hash_traverse, or by print_all_symbols.  */
4004
4005 static bfd_boolean
4006 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
4007 {
4008   asection *sec = (asection *) ptr;
4009
4010   if ((hash_entry->type == bfd_link_hash_defined
4011        || hash_entry->type == bfd_link_hash_defweak)
4012       && sec == hash_entry->u.def.section)
4013     {
4014       int i;
4015
4016       for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4017         print_space ();
4018       minfo ("0x%V   ",
4019              (hash_entry->u.def.value
4020               + hash_entry->u.def.section->output_offset
4021               + hash_entry->u.def.section->output_section->vma));
4022
4023       minfo ("             %T\n", hash_entry->root.string);
4024     }
4025
4026   return TRUE;
4027 }
4028
4029 static int
4030 hash_entry_addr_cmp (const void *a, const void *b)
4031 {
4032   const struct bfd_link_hash_entry *l = *(const struct bfd_link_hash_entry **)a;
4033   const struct bfd_link_hash_entry *r = *(const struct bfd_link_hash_entry **)b;
4034
4035   if (l->u.def.value < r->u.def.value)
4036     return -1;
4037   else if (l->u.def.value > r->u.def.value)
4038     return 1;
4039   else
4040     return 0;
4041 }
4042
4043 static void
4044 print_all_symbols (asection *sec)
4045 {
4046   struct fat_user_section_struct *ud =
4047       (struct fat_user_section_struct *) get_userdata (sec);
4048   struct map_symbol_def *def;
4049   struct bfd_link_hash_entry **entries;
4050   unsigned int i;
4051
4052   if (!ud)
4053     return;
4054
4055   *ud->map_symbol_def_tail = 0;
4056
4057   /* Sort the symbols by address.  */
4058   entries = (struct bfd_link_hash_entry **)
4059       obstack_alloc (&map_obstack, ud->map_symbol_def_count * sizeof (*entries));
4060
4061   for (i = 0, def = ud->map_symbol_def_head; def; def = def->next, i++)
4062     entries[i] = def->entry;
4063
4064   qsort (entries, ud->map_symbol_def_count, sizeof (*entries),
4065          hash_entry_addr_cmp);
4066
4067   /* Print the symbols.  */
4068   for (i = 0; i < ud->map_symbol_def_count; i++)
4069     print_one_symbol (entries[i], sec);
4070
4071   obstack_free (&map_obstack, entries);
4072 }
4073
4074 /* Print information about an input section to the map file.  */
4075
4076 static void
4077 print_input_section (asection *i, bfd_boolean is_discarded)
4078 {
4079   bfd_size_type size = i->size;
4080   int len;
4081   bfd_vma addr;
4082
4083   init_opb ();
4084
4085   print_space ();
4086   minfo ("%s", i->name);
4087
4088   len = 1 + strlen (i->name);
4089   if (len >= SECTION_NAME_MAP_LENGTH - 1)
4090     {
4091       print_nl ();
4092       len = 0;
4093     }
4094   while (len < SECTION_NAME_MAP_LENGTH)
4095     {
4096       print_space ();
4097       ++len;
4098     }
4099
4100   if (i->output_section != NULL
4101       && i->output_section->owner == link_info.output_bfd)
4102     addr = i->output_section->vma + i->output_offset;
4103   else
4104     {
4105       addr = print_dot;
4106       if (!is_discarded)
4107         size = 0;
4108     }
4109
4110   minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
4111
4112   if (size != i->rawsize && i->rawsize != 0)
4113     {
4114       len = SECTION_NAME_MAP_LENGTH + 3;
4115 #ifdef BFD64
4116       len += 16;
4117 #else
4118       len += 8;
4119 #endif
4120       while (len > 0)
4121         {
4122           print_space ();
4123           --len;
4124         }
4125
4126       minfo (_("%W (size before relaxing)\n"), i->rawsize);
4127     }
4128
4129   if (i->output_section != NULL
4130       && i->output_section->owner == link_info.output_bfd)
4131     {
4132       if (link_info.reduce_memory_overheads)
4133         bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
4134       else
4135         print_all_symbols (i);
4136
4137       /* Update print_dot, but make sure that we do not move it
4138          backwards - this could happen if we have overlays and a
4139          later overlay is shorter than an earier one.  */
4140       if (addr + TO_ADDR (size) > print_dot)
4141         print_dot = addr + TO_ADDR (size);
4142     }
4143 }
4144
4145 static void
4146 print_fill_statement (lang_fill_statement_type *fill)
4147 {
4148   size_t size;
4149   unsigned char *p;
4150   fputs (" FILL mask 0x", config.map_file);
4151   for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
4152     fprintf (config.map_file, "%02x", *p);
4153   fputs ("\n", config.map_file);
4154 }
4155
4156 static void
4157 print_data_statement (lang_data_statement_type *data)
4158 {
4159   int i;
4160   bfd_vma addr;
4161   bfd_size_type size;
4162   const char *name;
4163
4164   init_opb ();
4165   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4166     print_space ();
4167
4168   addr = data->output_offset;
4169   if (data->output_section != NULL)
4170     addr += data->output_section->vma;
4171
4172   switch (data->type)
4173     {
4174     default:
4175       abort ();
4176     case BYTE:
4177       size = BYTE_SIZE;
4178       name = "BYTE";
4179       break;
4180     case SHORT:
4181       size = SHORT_SIZE;
4182       name = "SHORT";
4183       break;
4184     case LONG:
4185       size = LONG_SIZE;
4186       name = "LONG";
4187       break;
4188     case QUAD:
4189       size = QUAD_SIZE;
4190       name = "QUAD";
4191       break;
4192     case SQUAD:
4193       size = QUAD_SIZE;
4194       name = "SQUAD";
4195       break;
4196     }
4197
4198   minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
4199
4200   if (data->exp->type.node_class != etree_value)
4201     {
4202       print_space ();
4203       exp_print_tree (data->exp);
4204     }
4205
4206   print_nl ();
4207
4208   print_dot = addr + TO_ADDR (size);
4209 }
4210
4211 /* Print an address statement.  These are generated by options like
4212    -Ttext.  */
4213
4214 static void
4215 print_address_statement (lang_address_statement_type *address)
4216 {
4217   minfo (_("Address of section %s set to "), address->section_name);
4218   exp_print_tree (address->address);
4219   print_nl ();
4220 }
4221
4222 /* Print a reloc statement.  */
4223
4224 static void
4225 print_reloc_statement (lang_reloc_statement_type *reloc)
4226 {
4227   int i;
4228   bfd_vma addr;
4229   bfd_size_type size;
4230
4231   init_opb ();
4232   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4233     print_space ();
4234
4235   addr = reloc->output_offset;
4236   if (reloc->output_section != NULL)
4237     addr += reloc->output_section->vma;
4238
4239   size = bfd_get_reloc_size (reloc->howto);
4240
4241   minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
4242
4243   if (reloc->name != NULL)
4244     minfo ("%s+", reloc->name);
4245   else
4246     minfo ("%s+", reloc->section->name);
4247
4248   exp_print_tree (reloc->addend_exp);
4249
4250   print_nl ();
4251
4252   print_dot = addr + TO_ADDR (size);
4253 }
4254
4255 static void
4256 print_padding_statement (lang_padding_statement_type *s)
4257 {
4258   int len;
4259   bfd_vma addr;
4260
4261   init_opb ();
4262   minfo (" *fill*");
4263
4264   len = sizeof " *fill*" - 1;
4265   while (len < SECTION_NAME_MAP_LENGTH)
4266     {
4267       print_space ();
4268       ++len;
4269     }
4270
4271   addr = s->output_offset;
4272   if (s->output_section != NULL)
4273     addr += s->output_section->vma;
4274   minfo ("0x%V %W ", addr, (bfd_vma) s->size);
4275
4276   if (s->fill->size != 0)