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