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