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