Hardcode host-specific name for LTO plugin
[platform/upstream/binutils.git] / ld / ldlang.c
1 /* Linker command language support.
2    Copyright (C) 1991-2014 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 #include "elf-bfd.h"
44 #ifdef ENABLE_PLUGINS
45 #include "plugin.h"
46 #endif /* ENABLE_PLUGINS */
47
48 #ifndef offsetof
49 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
50 #endif
51
52 /* Locals variables.  */
53 static struct obstack stat_obstack;
54 static struct obstack map_obstack;
55
56 #define obstack_chunk_alloc xmalloc
57 #define obstack_chunk_free free
58 static const char *entry_symbol_default = "start";
59 static bfd_boolean placed_commons = FALSE;
60 static bfd_boolean map_head_is_link_order = FALSE;
61 static lang_output_section_statement_type *default_common_section;
62 static bfd_boolean map_option_f;
63 static bfd_vma print_dot;
64 static lang_input_statement_type *first_file;
65 static const char *current_target;
66 static lang_statement_list_type statement_list;
67 static struct bfd_hash_table lang_definedness_table;
68 static lang_statement_list_type *stat_save[10];
69 static lang_statement_list_type **stat_save_ptr = &stat_save[0];
70 static struct unique_sections *unique_section_list;
71 static struct asneeded_minfo *asneeded_list_head;
72
73 /* Forward declarations.  */
74 static void exp_init_os (etree_type *);
75 static lang_input_statement_type *lookup_name (const char *);
76 static struct bfd_hash_entry *lang_definedness_newfunc
77  (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
78 static void insert_undefined (const char *);
79 static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
80 static void print_statement (lang_statement_union_type *,
81                              lang_output_section_statement_type *);
82 static void print_statement_list (lang_statement_union_type *,
83                                   lang_output_section_statement_type *);
84 static void print_statements (void);
85 static void print_input_section (asection *, bfd_boolean);
86 static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
87 static void lang_record_phdrs (void);
88 static void lang_do_version_exports_section (void);
89 static void lang_finalize_version_expr_head
90   (struct bfd_elf_version_expr_head *);
91
92 /* Exported variables.  */
93 const char *output_target;
94 lang_output_section_statement_type *abs_output_section;
95 lang_statement_list_type lang_output_section_statement;
96 lang_statement_list_type *stat_ptr = &statement_list;
97 lang_statement_list_type file_chain = { NULL, NULL };
98 lang_statement_list_type input_file_chain;
99 struct bfd_sym_chain entry_symbol = { NULL, NULL };
100 const char *entry_section = ".text";
101 struct lang_input_statement_flags input_flags;
102 bfd_boolean entry_from_cmdline;
103 bfd_boolean undef_from_cmdline;
104 bfd_boolean lang_has_input_file = FALSE;
105 bfd_boolean had_output_filename = FALSE;
106 bfd_boolean lang_float_flag = FALSE;
107 bfd_boolean delete_output_file_on_failure = FALSE;
108 struct lang_phdr *lang_phdr_list;
109 struct lang_nocrossrefs *nocrossref_list;
110 struct asneeded_minfo **asneeded_list_tail;
111
112  /* Functions that traverse the linker script and might evaluate
113     DEFINED() need to increment this at the start of the traversal.  */
114 int lang_statement_iteration = 0;
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   switch (file_type)
1066     {
1067     case lang_input_file_is_symbols_only_enum:
1068       p->filename = name;
1069       p->local_sym_name = name;
1070       p->flags.real = TRUE;
1071       p->flags.just_syms = TRUE;
1072       break;
1073     case lang_input_file_is_fake_enum:
1074       p->filename = name;
1075       p->local_sym_name = name;
1076       break;
1077     case lang_input_file_is_l_enum:
1078       if (name[0] == ':' && name[1] != '\0')
1079         {
1080           p->filename = name + 1;
1081           p->flags.full_name_provided = TRUE;
1082         }
1083       else
1084         p->filename = name;
1085       p->local_sym_name = concat ("-l", name, (const char *) NULL);
1086       p->flags.maybe_archive = TRUE;
1087       p->flags.real = TRUE;
1088       p->flags.search_dirs = TRUE;
1089       break;
1090     case lang_input_file_is_marker_enum:
1091       p->filename = name;
1092       p->local_sym_name = name;
1093       p->flags.search_dirs = TRUE;
1094       break;
1095     case lang_input_file_is_search_file_enum:
1096       p->filename = name;
1097       p->local_sym_name = name;
1098       p->flags.real = TRUE;
1099       p->flags.search_dirs = TRUE;
1100       break;
1101     case lang_input_file_is_file_enum:
1102       p->filename = name;
1103       p->local_sym_name = name;
1104       p->flags.real = TRUE;
1105       break;
1106     default:
1107       FAIL ();
1108     }
1109
1110   lang_statement_append (&input_file_chain,
1111                          (lang_statement_union_type *) p,
1112                          &p->next_real_file);
1113   return p;
1114 }
1115
1116 lang_input_statement_type *
1117 lang_add_input_file (const char *name,
1118                      lang_input_file_enum_type file_type,
1119                      const char *target)
1120 {
1121   if (name != NULL && *name == '=')
1122     {
1123       lang_input_statement_type *ret;
1124       char *sysrooted_name
1125         = concat (ld_sysroot, name + 1, (const char *) NULL);
1126
1127       /* We've now forcibly prepended the sysroot, making the input
1128          file independent of the context.  Therefore, temporarily
1129          force a non-sysrooted context for this statement, so it won't
1130          get the sysroot prepended again when opened.  (N.B. if it's a
1131          script, any child nodes with input files starting with "/"
1132          will be handled as "sysrooted" as they'll be found to be
1133          within the sysroot subdirectory.)  */
1134       unsigned int outer_sysrooted = input_flags.sysrooted;
1135       input_flags.sysrooted = 0;
1136       ret = new_afile (sysrooted_name, file_type, target, TRUE);
1137       input_flags.sysrooted = outer_sysrooted;
1138       return ret;
1139     }
1140
1141   return new_afile (name, file_type, target, TRUE);
1142 }
1143
1144 struct out_section_hash_entry
1145 {
1146   struct bfd_hash_entry root;
1147   lang_statement_union_type s;
1148 };
1149
1150 /* The hash table.  */
1151
1152 static struct bfd_hash_table output_section_statement_table;
1153
1154 /* Support routines for the hash table used by lang_output_section_find,
1155    initialize the table, fill in an entry and remove the table.  */
1156
1157 static struct bfd_hash_entry *
1158 output_section_statement_newfunc (struct bfd_hash_entry *entry,
1159                                   struct bfd_hash_table *table,
1160                                   const char *string)
1161 {
1162   lang_output_section_statement_type **nextp;
1163   struct out_section_hash_entry *ret;
1164
1165   if (entry == NULL)
1166     {
1167       entry = (struct bfd_hash_entry *) bfd_hash_allocate (table,
1168                                                            sizeof (*ret));
1169       if (entry == NULL)
1170         return entry;
1171     }
1172
1173   entry = bfd_hash_newfunc (entry, table, string);
1174   if (entry == NULL)
1175     return entry;
1176
1177   ret = (struct out_section_hash_entry *) entry;
1178   memset (&ret->s, 0, sizeof (ret->s));
1179   ret->s.header.type = lang_output_section_statement_enum;
1180   ret->s.output_section_statement.subsection_alignment = -1;
1181   ret->s.output_section_statement.section_alignment = -1;
1182   ret->s.output_section_statement.block_value = 1;
1183   lang_list_init (&ret->s.output_section_statement.children);
1184   lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);
1185
1186   /* For every output section statement added to the list, except the
1187      first one, lang_output_section_statement.tail points to the "next"
1188      field of the last element of the list.  */
1189   if (lang_output_section_statement.head != NULL)
1190     ret->s.output_section_statement.prev
1191       = ((lang_output_section_statement_type *)
1192          ((char *) lang_output_section_statement.tail
1193           - offsetof (lang_output_section_statement_type, next)));
1194
1195   /* GCC's strict aliasing rules prevent us from just casting the
1196      address, so we store the pointer in a variable and cast that
1197      instead.  */
1198   nextp = &ret->s.output_section_statement.next;
1199   lang_statement_append (&lang_output_section_statement,
1200                          &ret->s,
1201                          (lang_statement_union_type **) nextp);
1202   return &ret->root;
1203 }
1204
1205 static void
1206 output_section_statement_table_init (void)
1207 {
1208   if (!bfd_hash_table_init_n (&output_section_statement_table,
1209                               output_section_statement_newfunc,
1210                               sizeof (struct out_section_hash_entry),
1211                               61))
1212     einfo (_("%P%F: can not create hash table: %E\n"));
1213 }
1214
1215 static void
1216 output_section_statement_table_free (void)
1217 {
1218   bfd_hash_table_free (&output_section_statement_table);
1219 }
1220
1221 /* Build enough state so that the parser can build its tree.  */
1222
1223 void
1224 lang_init (void)
1225 {
1226   obstack_begin (&stat_obstack, 1000);
1227
1228   stat_ptr = &statement_list;
1229
1230   output_section_statement_table_init ();
1231
1232   lang_list_init (stat_ptr);
1233
1234   lang_list_init (&input_file_chain);
1235   lang_list_init (&lang_output_section_statement);
1236   lang_list_init (&file_chain);
1237   first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
1238                                     NULL);
1239   abs_output_section =
1240     lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME, 0, TRUE);
1241
1242   abs_output_section->bfd_section = bfd_abs_section_ptr;
1243
1244   /* The value "13" is ad-hoc, somewhat related to the expected number of
1245      assignments in a linker script.  */
1246   if (!bfd_hash_table_init_n (&lang_definedness_table,
1247                               lang_definedness_newfunc,
1248                               sizeof (struct lang_definedness_hash_entry),
1249                               13))
1250     einfo (_("%P%F: can not create hash table: %E\n"));
1251
1252   asneeded_list_head = NULL;
1253   asneeded_list_tail = &asneeded_list_head;
1254 }
1255
1256 void
1257 lang_finish (void)
1258 {
1259   bfd_hash_table_free (&lang_definedness_table);
1260   output_section_statement_table_free ();
1261 }
1262
1263 /*----------------------------------------------------------------------
1264   A region is an area of memory declared with the
1265   MEMORY {  name:org=exp, len=exp ... }
1266   syntax.
1267
1268   We maintain a list of all the regions here.
1269
1270   If no regions are specified in the script, then the default is used
1271   which is created when looked up to be the entire data space.
1272
1273   If create is true we are creating a region inside a MEMORY block.
1274   In this case it is probably an error to create a region that has
1275   already been created.  If we are not inside a MEMORY block it is
1276   dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1277   and so we issue a warning.
1278
1279   Each region has at least one name.  The first name is either
1280   DEFAULT_MEMORY_REGION or the name given in the MEMORY block.  You can add
1281   alias names to an existing region within a script with
1282   REGION_ALIAS (alias, region_name).  Each name corresponds to at most one
1283   region.  */
1284
1285 static lang_memory_region_type *lang_memory_region_list;
1286 static lang_memory_region_type **lang_memory_region_list_tail
1287   = &lang_memory_region_list;
1288
1289 lang_memory_region_type *
1290 lang_memory_region_lookup (const char *const name, bfd_boolean create)
1291 {
1292   lang_memory_region_name *n;
1293   lang_memory_region_type *r;
1294   lang_memory_region_type *new_region;
1295
1296   /* NAME is NULL for LMA memspecs if no region was specified.  */
1297   if (name == NULL)
1298     return NULL;
1299
1300   for (r = lang_memory_region_list; r != NULL; r = r->next)
1301     for (n = &r->name_list; n != NULL; n = n->next)
1302       if (strcmp (n->name, name) == 0)
1303         {
1304           if (create)
1305             einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
1306                    NULL, name);
1307           return r;
1308         }
1309
1310   if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
1311     einfo (_("%P:%S: warning: memory region `%s' not declared\n"),
1312            NULL, name);
1313
1314   new_region = (lang_memory_region_type *)
1315       stat_alloc (sizeof (lang_memory_region_type));
1316
1317   new_region->name_list.name = xstrdup (name);
1318   new_region->name_list.next = NULL;
1319   new_region->next = NULL;
1320   new_region->origin = 0;
1321   new_region->length = ~(bfd_size_type) 0;
1322   new_region->current = 0;
1323   new_region->last_os = NULL;
1324   new_region->flags = 0;
1325   new_region->not_flags = 0;
1326   new_region->had_full_message = FALSE;
1327
1328   *lang_memory_region_list_tail = new_region;
1329   lang_memory_region_list_tail = &new_region->next;
1330
1331   return new_region;
1332 }
1333
1334 void
1335 lang_memory_region_alias (const char * alias, const char * region_name)
1336 {
1337   lang_memory_region_name * n;
1338   lang_memory_region_type * r;
1339   lang_memory_region_type * region;
1340
1341   /* The default region must be unique.  This ensures that it is not necessary
1342      to iterate through the name list if someone wants the check if a region is
1343      the default memory region.  */
1344   if (strcmp (region_name, DEFAULT_MEMORY_REGION) == 0
1345       || strcmp (alias, DEFAULT_MEMORY_REGION) == 0)
1346     einfo (_("%F%P:%S: error: alias for default memory region\n"), NULL);
1347
1348   /* Look for the target region and check if the alias is not already
1349      in use.  */
1350   region = NULL;
1351   for (r = lang_memory_region_list; r != NULL; r = r->next)
1352     for (n = &r->name_list; n != NULL; n = n->next)
1353       {
1354         if (region == NULL && strcmp (n->name, region_name) == 0)
1355           region = r;
1356         if (strcmp (n->name, alias) == 0)
1357           einfo (_("%F%P:%S: error: redefinition of memory region "
1358                    "alias `%s'\n"),
1359                  NULL, alias);
1360       }
1361
1362   /* Check if the target region exists.  */
1363   if (region == NULL)
1364     einfo (_("%F%P:%S: error: memory region `%s' "
1365              "for alias `%s' does not exist\n"),
1366            NULL, region_name, alias);
1367
1368   /* Add alias to region name list.  */
1369   n = (lang_memory_region_name *) stat_alloc (sizeof (lang_memory_region_name));
1370   n->name = xstrdup (alias);
1371   n->next = region->name_list.next;
1372   region->name_list.next = n;
1373 }
1374
1375 static lang_memory_region_type *
1376 lang_memory_default (asection * section)
1377 {
1378   lang_memory_region_type *p;
1379
1380   flagword sec_flags = section->flags;
1381
1382   /* Override SEC_DATA to mean a writable section.  */
1383   if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
1384     sec_flags |= SEC_DATA;
1385
1386   for (p = lang_memory_region_list; p != NULL; p = p->next)
1387     {
1388       if ((p->flags & sec_flags) != 0
1389           && (p->not_flags & sec_flags) == 0)
1390         {
1391           return p;
1392         }
1393     }
1394   return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
1395 }
1396
1397 /* Get the output section statement directly from the userdata.  */
1398
1399 lang_output_section_statement_type *
1400 lang_output_section_get (const asection *output_section)
1401 {
1402   return get_userdata (output_section);
1403 }
1404
1405 /* Find or create an output_section_statement with the given NAME.
1406    If CONSTRAINT is non-zero match one with that constraint, otherwise
1407    match any non-negative constraint.  If CREATE, always make a
1408    new output_section_statement for SPECIAL CONSTRAINT.  */
1409
1410 lang_output_section_statement_type *
1411 lang_output_section_statement_lookup (const char *name,
1412                                       int constraint,
1413                                       bfd_boolean create)
1414 {
1415   struct out_section_hash_entry *entry;
1416
1417   entry = ((struct out_section_hash_entry *)
1418            bfd_hash_lookup (&output_section_statement_table, name,
1419                             create, FALSE));
1420   if (entry == NULL)
1421     {
1422       if (create)
1423         einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1424       return NULL;
1425     }
1426
1427   if (entry->s.output_section_statement.name != NULL)
1428     {
1429       /* We have a section of this name, but it might not have the correct
1430          constraint.  */
1431       struct out_section_hash_entry *last_ent;
1432
1433       name = entry->s.output_section_statement.name;
1434       if (create && constraint == SPECIAL)
1435         /* Not traversing to the end reverses the order of the second
1436            and subsequent SPECIAL sections in the hash table chain,
1437            but that shouldn't matter.  */
1438         last_ent = entry;
1439       else
1440         do
1441           {
1442             if (constraint == entry->s.output_section_statement.constraint
1443                 || (constraint == 0
1444                     && entry->s.output_section_statement.constraint >= 0))
1445               return &entry->s.output_section_statement;
1446             last_ent = entry;
1447             entry = (struct out_section_hash_entry *) entry->root.next;
1448           }
1449         while (entry != NULL
1450                && name == entry->s.output_section_statement.name);
1451
1452       if (!create)
1453         return NULL;
1454
1455       entry
1456         = ((struct out_section_hash_entry *)
1457            output_section_statement_newfunc (NULL,
1458                                              &output_section_statement_table,
1459                                              name));
1460       if (entry == NULL)
1461         {
1462           einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1463           return NULL;
1464         }
1465       entry->root = last_ent->root;
1466       last_ent->root.next = &entry->root;
1467     }
1468
1469   entry->s.output_section_statement.name = name;
1470   entry->s.output_section_statement.constraint = constraint;
1471   return &entry->s.output_section_statement;
1472 }
1473
1474 /* Find the next output_section_statement with the same name as OS.
1475    If CONSTRAINT is non-zero, find one with that constraint otherwise
1476    match any non-negative constraint.  */
1477
1478 lang_output_section_statement_type *
1479 next_matching_output_section_statement (lang_output_section_statement_type *os,
1480                                         int constraint)
1481 {
1482   /* All output_section_statements are actually part of a
1483      struct out_section_hash_entry.  */
1484   struct out_section_hash_entry *entry = (struct out_section_hash_entry *)
1485     ((char *) os
1486      - offsetof (struct out_section_hash_entry, s.output_section_statement));
1487   const char *name = os->name;
1488
1489   ASSERT (name == entry->root.string);
1490   do
1491     {
1492       entry = (struct out_section_hash_entry *) entry->root.next;
1493       if (entry == NULL
1494           || name != entry->s.output_section_statement.name)
1495         return NULL;
1496     }
1497   while (constraint != entry->s.output_section_statement.constraint
1498          && (constraint != 0
1499              || entry->s.output_section_statement.constraint < 0));
1500
1501   return &entry->s.output_section_statement;
1502 }
1503
1504 /* A variant of lang_output_section_find used by place_orphan.
1505    Returns the output statement that should precede a new output
1506    statement for SEC.  If an exact match is found on certain flags,
1507    sets *EXACT too.  */
1508
1509 lang_output_section_statement_type *
1510 lang_output_section_find_by_flags (const asection *sec,
1511                                    lang_output_section_statement_type **exact,
1512                                    lang_match_sec_type_func match_type)
1513 {
1514   lang_output_section_statement_type *first, *look, *found;
1515   flagword look_flags, sec_flags, differ;
1516
1517   /* We know the first statement on this list is *ABS*.  May as well
1518      skip it.  */
1519   first = &lang_output_section_statement.head->output_section_statement;
1520   first = first->next;
1521
1522   /* First try for an exact match.  */
1523   sec_flags = sec->flags;
1524   found = NULL;
1525   for (look = first; look; look = look->next)
1526     {
1527       look_flags = look->flags;
1528       if (look->bfd_section != NULL)
1529         {
1530           look_flags = look->bfd_section->flags;
1531           if (match_type && !match_type (link_info.output_bfd,
1532                                          look->bfd_section,
1533                                          sec->owner, sec))
1534             continue;
1535         }
1536       differ = look_flags ^ sec_flags;
1537       if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1538                       | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1539         found = look;
1540     }
1541   if (found != NULL)
1542     {
1543       if (exact != NULL)
1544         *exact = found;
1545       return found;
1546     }
1547
1548   if ((sec_flags & SEC_CODE) != 0
1549       && (sec_flags & SEC_ALLOC) != 0)
1550     {
1551       /* Try for a rw code section.  */
1552       for (look = first; look; look = look->next)
1553         {
1554           look_flags = look->flags;
1555           if (look->bfd_section != NULL)
1556             {
1557               look_flags = look->bfd_section->flags;
1558               if (match_type && !match_type (link_info.output_bfd,
1559                                              look->bfd_section,
1560                                              sec->owner, sec))
1561                 continue;
1562             }
1563           differ = look_flags ^ sec_flags;
1564           if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1565                           | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1566             found = look;
1567         }
1568     }
1569   else if ((sec_flags & SEC_READONLY) != 0
1570            && (sec_flags & SEC_ALLOC) != 0)
1571     {
1572       /* .rodata can go after .text, .sdata2 after .rodata.  */
1573       for (look = first; look; look = look->next)
1574         {
1575           look_flags = look->flags;
1576           if (look->bfd_section != NULL)
1577             {
1578               look_flags = look->bfd_section->flags;
1579               if (match_type && !match_type (link_info.output_bfd,
1580                                              look->bfd_section,
1581                                              sec->owner, sec))
1582                 continue;
1583             }
1584           differ = look_flags ^ sec_flags;
1585           if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1586                           | SEC_READONLY | SEC_SMALL_DATA))
1587               || (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1588                               | SEC_READONLY))
1589                   && !(look_flags & SEC_SMALL_DATA)))
1590             found = look;
1591         }
1592     }
1593   else if ((sec_flags & SEC_THREAD_LOCAL) != 0
1594            && (sec_flags & SEC_ALLOC) != 0)
1595     {
1596       /* .tdata can go after .data, .tbss after .tdata.  Treat .tbss
1597          as if it were a loaded section, and don't use match_type.  */
1598       bfd_boolean seen_thread_local = FALSE;
1599
1600       match_type = NULL;
1601       for (look = first; look; look = look->next)
1602         {
1603           look_flags = look->flags;
1604           if (look->bfd_section != NULL)
1605             look_flags = look->bfd_section->flags;
1606
1607           differ = look_flags ^ (sec_flags | SEC_LOAD | SEC_HAS_CONTENTS);
1608           if (!(differ & (SEC_THREAD_LOCAL | SEC_ALLOC)))
1609             {
1610               /* .tdata and .tbss must be adjacent and in that order.  */
1611               if (!(look_flags & SEC_LOAD)
1612                   && (sec_flags & SEC_LOAD))
1613                 /* ..so if we're at a .tbss section and we're placing
1614                    a .tdata section stop looking and return the
1615                    previous section.  */
1616                 break;
1617               found = look;
1618               seen_thread_local = TRUE;
1619             }
1620           else if (seen_thread_local)
1621             break;
1622           else if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD)))
1623             found = look;
1624         }
1625     }
1626   else if ((sec_flags & SEC_SMALL_DATA) != 0
1627            && (sec_flags & SEC_ALLOC) != 0)
1628     {
1629       /* .sdata goes after .data, .sbss after .sdata.  */
1630       for (look = first; look; look = look->next)
1631         {
1632           look_flags = look->flags;
1633           if (look->bfd_section != NULL)
1634             {
1635               look_flags = look->bfd_section->flags;
1636               if (match_type && !match_type (link_info.output_bfd,
1637                                              look->bfd_section,
1638                                              sec->owner, sec))
1639                 continue;
1640             }
1641           differ = look_flags ^ sec_flags;
1642           if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1643                           | SEC_THREAD_LOCAL))
1644               || ((look_flags & SEC_SMALL_DATA)
1645                   && !(sec_flags & SEC_HAS_CONTENTS)))
1646             found = look;
1647         }
1648     }
1649   else if ((sec_flags & SEC_HAS_CONTENTS) != 0
1650            && (sec_flags & SEC_ALLOC) != 0)
1651     {
1652       /* .data goes after .rodata.  */
1653       for (look = first; look; look = look->next)
1654         {
1655           look_flags = look->flags;
1656           if (look->bfd_section != NULL)
1657             {
1658               look_flags = look->bfd_section->flags;
1659               if (match_type && !match_type (link_info.output_bfd,
1660                                              look->bfd_section,
1661                                              sec->owner, sec))
1662                 continue;
1663             }
1664           differ = look_flags ^ sec_flags;
1665           if (!(differ & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1666                           | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1667             found = look;
1668         }
1669     }
1670   else if ((sec_flags & SEC_ALLOC) != 0)
1671     {
1672       /* .bss goes after any other alloc section.  */
1673       for (look = first; look; look = look->next)
1674         {
1675           look_flags = look->flags;
1676           if (look->bfd_section != NULL)
1677             {
1678               look_flags = look->bfd_section->flags;
1679               if (match_type && !match_type (link_info.output_bfd,
1680                                              look->bfd_section,
1681                                              sec->owner, sec))
1682                 continue;
1683             }
1684           differ = look_flags ^ sec_flags;
1685           if (!(differ & SEC_ALLOC))
1686             found = look;
1687         }
1688     }
1689   else
1690     {
1691       /* non-alloc go last.  */
1692       for (look = first; look; look = look->next)
1693         {
1694           look_flags = look->flags;
1695           if (look->bfd_section != NULL)
1696             look_flags = look->bfd_section->flags;
1697           differ = look_flags ^ sec_flags;
1698           if (!(differ & SEC_DEBUGGING))
1699             found = look;
1700         }
1701       return found;
1702     }
1703
1704   if (found || !match_type)
1705     return found;
1706
1707   return lang_output_section_find_by_flags (sec, NULL, NULL);
1708 }
1709
1710 /* Find the last output section before given output statement.
1711    Used by place_orphan.  */
1712
1713 static asection *
1714 output_prev_sec_find (lang_output_section_statement_type *os)
1715 {
1716   lang_output_section_statement_type *lookup;
1717
1718   for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)
1719     {
1720       if (lookup->constraint < 0)
1721         continue;
1722
1723       if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1724         return lookup->bfd_section;
1725     }
1726
1727   return NULL;
1728 }
1729
1730 /* Look for a suitable place for a new output section statement.  The
1731    idea is to skip over anything that might be inside a SECTIONS {}
1732    statement in a script, before we find another output section
1733    statement.  Assignments to "dot" before an output section statement
1734    are assumed to belong to it, except in two cases;  The first
1735    assignment to dot, and assignments before non-alloc sections.
1736    Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1737    similar assignments that set the initial address, or we might
1738    insert non-alloc note sections among assignments setting end of
1739    image symbols.  */
1740
1741 static lang_statement_union_type **
1742 insert_os_after (lang_output_section_statement_type *after)
1743 {
1744   lang_statement_union_type **where;
1745   lang_statement_union_type **assign = NULL;
1746   bfd_boolean ignore_first;
1747
1748   ignore_first
1749     = after == &lang_output_section_statement.head->output_section_statement;
1750
1751   for (where = &after->header.next;
1752        *where != NULL;
1753        where = &(*where)->header.next)
1754     {
1755       switch ((*where)->header.type)
1756         {
1757         case lang_assignment_statement_enum:
1758           if (assign == NULL)
1759             {
1760               lang_assignment_statement_type *ass;
1761
1762               ass = &(*where)->assignment_statement;
1763               if (ass->exp->type.node_class != etree_assert
1764                   && ass->exp->assign.dst[0] == '.'
1765                   && ass->exp->assign.dst[1] == 0
1766                   && !ignore_first)
1767                 assign = where;
1768             }
1769           ignore_first = FALSE;
1770           continue;
1771         case lang_wild_statement_enum:
1772         case lang_input_section_enum:
1773         case lang_object_symbols_statement_enum:
1774         case lang_fill_statement_enum:
1775         case lang_data_statement_enum:
1776         case lang_reloc_statement_enum:
1777         case lang_padding_statement_enum:
1778         case lang_constructors_statement_enum:
1779           assign = NULL;
1780           continue;
1781         case lang_output_section_statement_enum:
1782           if (assign != NULL)
1783             {
1784               asection *s = (*where)->output_section_statement.bfd_section;
1785
1786               if (s == NULL
1787                   || s->map_head.s == NULL
1788                   || (s->flags & SEC_ALLOC) != 0)
1789                 where = assign;
1790             }
1791           break;
1792         case lang_input_statement_enum:
1793         case lang_address_statement_enum:
1794         case lang_target_statement_enum:
1795         case lang_output_statement_enum:
1796         case lang_group_statement_enum:
1797         case lang_insert_statement_enum:
1798           continue;
1799         }
1800       break;
1801     }
1802
1803   return where;
1804 }
1805
1806 lang_output_section_statement_type *
1807 lang_insert_orphan (asection *s,
1808                     const char *secname,
1809                     int constraint,
1810                     lang_output_section_statement_type *after,
1811                     struct orphan_save *place,
1812                     etree_type *address,
1813                     lang_statement_list_type *add_child)
1814 {
1815   lang_statement_list_type add;
1816   const char *ps;
1817   lang_output_section_statement_type *os;
1818   lang_output_section_statement_type **os_tail;
1819
1820   /* If we have found an appropriate place for the output section
1821      statements for this orphan, add them to our own private list,
1822      inserting them later into the global statement list.  */
1823   if (after != NULL)
1824     {
1825       lang_list_init (&add);
1826       push_stat_ptr (&add);
1827     }
1828
1829   if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1830     address = exp_intop (0);
1831
1832   os_tail = ((lang_output_section_statement_type **)
1833              lang_output_section_statement.tail);
1834   os = lang_enter_output_section_statement (secname, address, normal_section,
1835                                             NULL, NULL, NULL, constraint, 0);
1836
1837   ps = NULL;
1838   if (config.build_constructors && *os_tail == os)
1839     {
1840       /* If the name of the section is representable in C, then create
1841          symbols to mark the start and the end of the section.  */
1842       for (ps = secname; *ps != '\0'; ps++)
1843         if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
1844           break;
1845       if (*ps == '\0')
1846         {
1847           char *symname;
1848
1849           symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
1850           symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1851           sprintf (symname + (symname[0] != 0), "__start_%s", secname);
1852           lang_add_assignment (exp_provide (symname,
1853                                             exp_nameop (NAME, "."),
1854                                             FALSE));
1855         }
1856     }
1857
1858   if (add_child == NULL)
1859     add_child = &os->children;
1860   lang_add_section (add_child, s, NULL, os);
1861
1862   if (after && (s->flags & (SEC_LOAD | SEC_ALLOC)) != 0)
1863     {
1864       const char *region = (after->region
1865                             ? after->region->name_list.name
1866                             : DEFAULT_MEMORY_REGION);
1867       const char *lma_region = (after->lma_region
1868                                 ? after->lma_region->name_list.name
1869                                 : NULL);
1870       lang_leave_output_section_statement (NULL, region, after->phdrs,
1871                                            lma_region);
1872     }
1873   else
1874     lang_leave_output_section_statement (NULL, DEFAULT_MEMORY_REGION, NULL,
1875                                          NULL);
1876
1877   if (ps != NULL && *ps == '\0')
1878     {
1879       char *symname;
1880
1881       symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
1882       symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1883       sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
1884       lang_add_assignment (exp_provide (symname,
1885                                         exp_nameop (NAME, "."),
1886                                         FALSE));
1887     }
1888
1889   /* Restore the global list pointer.  */
1890   if (after != NULL)
1891     pop_stat_ptr ();
1892
1893   if (after != NULL && os->bfd_section != NULL)
1894     {
1895       asection *snew, *as;
1896
1897       snew = os->bfd_section;
1898
1899       /* Shuffle the bfd section list to make the output file look
1900          neater.  This is really only cosmetic.  */
1901       if (place->section == NULL
1902           && after != (&lang_output_section_statement.head
1903                        ->output_section_statement))
1904         {
1905           asection *bfd_section = after->bfd_section;
1906
1907           /* If the output statement hasn't been used to place any input
1908              sections (and thus doesn't have an output bfd_section),
1909              look for the closest prior output statement having an
1910              output section.  */
1911           if (bfd_section == NULL)
1912             bfd_section = output_prev_sec_find (after);
1913
1914           if (bfd_section != NULL && bfd_section != snew)
1915             place->section = &bfd_section->next;
1916         }
1917
1918       if (place->section == NULL)
1919         place->section = &link_info.output_bfd->sections;
1920
1921       as = *place->section;
1922
1923       if (!as)
1924         {
1925           /* Put the section at the end of the list.  */
1926
1927           /* Unlink the section.  */
1928           bfd_section_list_remove (link_info.output_bfd, snew);
1929
1930           /* Now tack it back on in the right place.  */
1931           bfd_section_list_append (link_info.output_bfd, snew);
1932         }
1933       else if (as != snew && as->prev != snew)
1934         {
1935           /* Unlink the section.  */
1936           bfd_section_list_remove (link_info.output_bfd, snew);
1937
1938           /* Now tack it back on in the right place.  */
1939           bfd_section_list_insert_before (link_info.output_bfd, as, snew);
1940         }
1941
1942       /* Save the end of this list.  Further ophans of this type will
1943          follow the one we've just added.  */
1944       place->section = &snew->next;
1945
1946       /* The following is non-cosmetic.  We try to put the output
1947          statements in some sort of reasonable order here, because they
1948          determine the final load addresses of the orphan sections.
1949          In addition, placing output statements in the wrong order may
1950          require extra segments.  For instance, given a typical
1951          situation of all read-only sections placed in one segment and
1952          following that a segment containing all the read-write
1953          sections, we wouldn't want to place an orphan read/write
1954          section before or amongst the read-only ones.  */
1955       if (add.head != NULL)
1956         {
1957           lang_output_section_statement_type *newly_added_os;
1958
1959           if (place->stmt == NULL)
1960             {
1961               lang_statement_union_type **where = insert_os_after (after);
1962
1963               *add.tail = *where;
1964               *where = add.head;
1965
1966               place->os_tail = &after->next;
1967             }
1968           else
1969             {
1970               /* Put it after the last orphan statement we added.  */
1971               *add.tail = *place->stmt;
1972               *place->stmt = add.head;
1973             }
1974
1975           /* Fix the global list pointer if we happened to tack our
1976              new list at the tail.  */
1977           if (*stat_ptr->tail == add.head)
1978             stat_ptr->tail = add.tail;
1979
1980           /* Save the end of this list.  */
1981           place->stmt = add.tail;
1982
1983           /* Do the same for the list of output section statements.  */
1984           newly_added_os = *os_tail;
1985           *os_tail = NULL;
1986           newly_added_os->prev = (lang_output_section_statement_type *)
1987             ((char *) place->os_tail
1988              - offsetof (lang_output_section_statement_type, next));
1989           newly_added_os->next = *place->os_tail;
1990           if (newly_added_os->next != NULL)
1991             newly_added_os->next->prev = newly_added_os;
1992           *place->os_tail = newly_added_os;
1993           place->os_tail = &newly_added_os->next;
1994
1995           /* Fixing the global list pointer here is a little different.
1996              We added to the list in lang_enter_output_section_statement,
1997              trimmed off the new output_section_statment above when
1998              assigning *os_tail = NULL, but possibly added it back in
1999              the same place when assigning *place->os_tail.  */
2000           if (*os_tail == NULL)
2001             lang_output_section_statement.tail
2002               = (lang_statement_union_type **) os_tail;
2003         }
2004     }
2005   return os;
2006 }
2007
2008 static void
2009 lang_print_asneeded (void)
2010 {
2011   struct asneeded_minfo *m;
2012   char buf[100];
2013
2014   if (asneeded_list_head == NULL)
2015     return;
2016
2017   sprintf (buf, _("\nAs-needed library included "
2018                   "to satisfy reference by file (symbol)\n\n"));
2019   minfo ("%s", buf);
2020
2021   for (m = asneeded_list_head; m != NULL; m = m->next)
2022     {
2023       size_t len;
2024
2025       minfo ("%s", m->soname);
2026       len = strlen (m->soname);
2027
2028       if (len >= 29)
2029         {
2030           print_nl ();
2031           len = 0;
2032         }
2033       while (len < 30)
2034         {
2035           print_space ();
2036           ++len;
2037         }
2038
2039       if (m->ref != NULL)
2040         minfo ("%B ", m->ref);
2041       minfo ("(%T)\n", m->name);
2042     }
2043 }
2044
2045 static void
2046 lang_map_flags (flagword flag)
2047 {
2048   if (flag & SEC_ALLOC)
2049     minfo ("a");
2050
2051   if (flag & SEC_CODE)
2052     minfo ("x");
2053
2054   if (flag & SEC_READONLY)
2055     minfo ("r");
2056
2057   if (flag & SEC_DATA)
2058     minfo ("w");
2059
2060   if (flag & SEC_LOAD)
2061     minfo ("l");
2062 }
2063
2064 void
2065 lang_map (void)
2066 {
2067   lang_memory_region_type *m;
2068   bfd_boolean dis_header_printed = FALSE;
2069
2070   LANG_FOR_EACH_INPUT_STATEMENT (file)
2071     {
2072       asection *s;
2073
2074       if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
2075           || file->flags.just_syms)
2076         continue;
2077
2078       for (s = file->the_bfd->sections; s != NULL; s = s->next)
2079         if ((s->output_section == NULL
2080              || s->output_section->owner != link_info.output_bfd)
2081             && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0)
2082           {
2083             if (! dis_header_printed)
2084               {
2085                 fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
2086                 dis_header_printed = TRUE;
2087               }
2088
2089             print_input_section (s, TRUE);
2090           }
2091     }
2092
2093   minfo (_("\nMemory Configuration\n\n"));
2094   fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
2095            _("Name"), _("Origin"), _("Length"), _("Attributes"));
2096
2097   for (m = lang_memory_region_list; m != NULL; m = m->next)
2098     {
2099       char buf[100];
2100       int len;
2101
2102       fprintf (config.map_file, "%-16s ", m->name_list.name);
2103
2104       sprintf_vma (buf, m->origin);
2105       minfo ("0x%s ", buf);
2106       len = strlen (buf);
2107       while (len < 16)
2108         {
2109           print_space ();
2110           ++len;
2111         }
2112
2113       minfo ("0x%V", m->length);
2114       if (m->flags || m->not_flags)
2115         {
2116 #ifndef BFD64
2117           minfo ("        ");
2118 #endif
2119           if (m->flags)
2120             {
2121               print_space ();
2122               lang_map_flags (m->flags);
2123             }
2124
2125           if (m->not_flags)
2126             {
2127               minfo (" !");
2128               lang_map_flags (m->not_flags);
2129             }
2130         }
2131
2132       print_nl ();
2133     }
2134
2135   fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
2136
2137   if (! link_info.reduce_memory_overheads)
2138     {
2139       obstack_begin (&map_obstack, 1000);
2140       bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
2141     }
2142   lang_statement_iteration++;
2143   print_statements ();
2144
2145   ldemul_extra_map_file_text (link_info.output_bfd, &link_info, config.map_file);
2146 }
2147
2148 static bfd_boolean
2149 sort_def_symbol (struct bfd_link_hash_entry *hash_entry,
2150                  void *info ATTRIBUTE_UNUSED)
2151 {
2152   if ((hash_entry->type == bfd_link_hash_defined
2153        || hash_entry->type == bfd_link_hash_defweak)
2154       && hash_entry->u.def.section->owner != link_info.output_bfd
2155       && hash_entry->u.def.section->owner != NULL)
2156     {
2157       input_section_userdata_type *ud;
2158       struct map_symbol_def *def;
2159
2160       ud = ((input_section_userdata_type *)
2161             get_userdata (hash_entry->u.def.section));
2162       if (!ud)
2163         {
2164           ud = (input_section_userdata_type *) stat_alloc (sizeof (*ud));
2165           get_userdata (hash_entry->u.def.section) = ud;
2166           ud->map_symbol_def_tail = &ud->map_symbol_def_head;
2167           ud->map_symbol_def_count = 0;
2168         }
2169       else if (!ud->map_symbol_def_tail)
2170         ud->map_symbol_def_tail = &ud->map_symbol_def_head;
2171
2172       def = (struct map_symbol_def *) obstack_alloc (&map_obstack, sizeof *def);
2173       def->entry = hash_entry;
2174       *(ud->map_symbol_def_tail) = def;
2175       ud->map_symbol_def_tail = &def->next;
2176       ud->map_symbol_def_count++;
2177     }
2178   return TRUE;
2179 }
2180
2181 /* Initialize an output section.  */
2182
2183 static void
2184 init_os (lang_output_section_statement_type *s, flagword flags)
2185 {
2186   if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
2187     einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
2188
2189   if (s->constraint != SPECIAL)
2190     s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);
2191   if (s->bfd_section == NULL)
2192     s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd,
2193                                                          s->name, flags);
2194   if (s->bfd_section == NULL)
2195     {
2196       einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2197              link_info.output_bfd->xvec->name, s->name);
2198     }
2199   s->bfd_section->output_section = s->bfd_section;
2200   s->bfd_section->output_offset = 0;
2201
2202   /* Set the userdata of the output section to the output section
2203      statement to avoid lookup.  */
2204   get_userdata (s->bfd_section) = s;
2205
2206   /* If there is a base address, make sure that any sections it might
2207      mention are initialized.  */
2208   if (s->addr_tree != NULL)
2209     exp_init_os (s->addr_tree);
2210
2211   if (s->load_base != NULL)
2212     exp_init_os (s->load_base);
2213
2214   /* If supplied an alignment, set it.  */
2215   if (s->section_alignment != -1)
2216     s->bfd_section->alignment_power = s->section_alignment;
2217 }
2218
2219 /* Make sure that all output sections mentioned in an expression are
2220    initialized.  */
2221
2222 static void
2223 exp_init_os (etree_type *exp)
2224 {
2225   switch (exp->type.node_class)
2226     {
2227     case etree_assign:
2228     case etree_provide:
2229       exp_init_os (exp->assign.src);
2230       break;
2231
2232     case etree_binary:
2233       exp_init_os (exp->binary.lhs);
2234       exp_init_os (exp->binary.rhs);
2235       break;
2236
2237     case etree_trinary:
2238       exp_init_os (exp->trinary.cond);
2239       exp_init_os (exp->trinary.lhs);
2240       exp_init_os (exp->trinary.rhs);
2241       break;
2242
2243     case etree_assert:
2244       exp_init_os (exp->assert_s.child);
2245       break;
2246
2247     case etree_unary:
2248       exp_init_os (exp->unary.child);
2249       break;
2250
2251     case etree_name:
2252       switch (exp->type.node_code)
2253         {
2254         case ADDR:
2255         case LOADADDR:
2256         case SIZEOF:
2257           {
2258             lang_output_section_statement_type *os;
2259
2260             os = lang_output_section_find (exp->name.name);
2261             if (os != NULL && os->bfd_section == NULL)
2262               init_os (os, 0);
2263           }
2264         }
2265       break;
2266
2267     default:
2268       break;
2269     }
2270 }
2271 \f
2272 static void
2273 section_already_linked (bfd *abfd, asection *sec, void *data)
2274 {
2275   lang_input_statement_type *entry = (lang_input_statement_type *) data;
2276
2277   /* If we are only reading symbols from this object, then we want to
2278      discard all sections.  */
2279   if (entry->flags.just_syms)
2280     {
2281       bfd_link_just_syms (abfd, sec, &link_info);
2282       return;
2283     }
2284
2285   if (!(abfd->flags & DYNAMIC))
2286     bfd_section_already_linked (abfd, sec, &link_info);
2287 }
2288 \f
2289 /* The wild routines.
2290
2291    These expand statements like *(.text) and foo.o to a list of
2292    explicit actions, like foo.o(.text), bar.o(.text) and
2293    foo.o(.text, .data).  */
2294
2295 /* Add SECTION to the output section OUTPUT.  Do this by creating a
2296    lang_input_section statement which is placed at PTR.  */
2297
2298 void
2299 lang_add_section (lang_statement_list_type *ptr,
2300                   asection *section,
2301                   struct flag_info *sflag_info,
2302                   lang_output_section_statement_type *output)
2303 {
2304   flagword flags = section->flags;
2305
2306   bfd_boolean discard;
2307   lang_input_section_type *new_section;
2308   bfd *abfd = link_info.output_bfd;
2309
2310   /* Discard sections marked with SEC_EXCLUDE.  */
2311   discard = (flags & SEC_EXCLUDE) != 0;
2312
2313   /* Discard input sections which are assigned to a section named
2314      DISCARD_SECTION_NAME.  */
2315   if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
2316     discard = TRUE;
2317
2318   /* Discard debugging sections if we are stripping debugging
2319      information.  */
2320   if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
2321       && (flags & SEC_DEBUGGING) != 0)
2322     discard = TRUE;
2323
2324   if (discard)
2325     {
2326       if (section->output_section == NULL)
2327         {
2328           /* This prevents future calls from assigning this section.  */
2329           section->output_section = bfd_abs_section_ptr;
2330         }
2331       return;
2332     }
2333
2334   if (sflag_info)
2335     {
2336       bfd_boolean keep;
2337
2338       keep = bfd_lookup_section_flags (&link_info, sflag_info, section);
2339       if (!keep)
2340         return;
2341     }
2342
2343   if (section->output_section != NULL)
2344     return;
2345
2346   /* We don't copy the SEC_NEVER_LOAD flag from an input section
2347      to an output section, because we want to be able to include a
2348      SEC_NEVER_LOAD section in the middle of an otherwise loaded
2349      section (I don't know why we want to do this, but we do).
2350      build_link_order in ldwrite.c handles this case by turning
2351      the embedded SEC_NEVER_LOAD section into a fill.  */
2352   flags &= ~ SEC_NEVER_LOAD;
2353
2354   /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2355      already been processed.  One reason to do this is that on pe
2356      format targets, .text$foo sections go into .text and it's odd
2357      to see .text with SEC_LINK_ONCE set.  */
2358
2359   if (!link_info.relocatable)
2360     flags &= ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC);
2361
2362   switch (output->sectype)
2363     {
2364     case normal_section:
2365     case overlay_section:
2366       break;
2367     case noalloc_section:
2368       flags &= ~SEC_ALLOC;
2369       break;
2370     case noload_section:
2371       flags &= ~SEC_LOAD;
2372       flags |= SEC_NEVER_LOAD;
2373       /* Unfortunately GNU ld has managed to evolve two different
2374          meanings to NOLOAD in scripts.  ELF gets a .bss style noload,
2375          alloc, no contents section.  All others get a noload, noalloc
2376          section.  */
2377       if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
2378         flags &= ~SEC_HAS_CONTENTS;
2379       else
2380         flags &= ~SEC_ALLOC;
2381       break;
2382     }
2383
2384   if (output->bfd_section == NULL)
2385     init_os (output, flags);
2386
2387   /* If SEC_READONLY is not set in the input section, then clear
2388      it from the output section.  */
2389   output->bfd_section->flags &= flags | ~SEC_READONLY;
2390
2391   if (output->bfd_section->linker_has_input)
2392     {
2393       /* Only set SEC_READONLY flag on the first input section.  */
2394       flags &= ~ SEC_READONLY;
2395
2396       /* Keep SEC_MERGE and SEC_STRINGS only if they are the same.  */
2397       if ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
2398           != (flags & (SEC_MERGE | SEC_STRINGS))
2399           || ((flags & SEC_MERGE) != 0
2400               && output->bfd_section->entsize != section->entsize))
2401         {
2402           output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
2403           flags &= ~ (SEC_MERGE | SEC_STRINGS);
2404         }
2405     }
2406   output->bfd_section->flags |= flags;
2407
2408   if (!output->bfd_section->linker_has_input)
2409     {
2410       output->bfd_section->linker_has_input = 1;
2411       /* This must happen after flags have been updated.  The output
2412          section may have been created before we saw its first input
2413          section, eg. for a data statement.  */
2414       bfd_init_private_section_data (section->owner, section,
2415                                      link_info.output_bfd,
2416                                      output->bfd_section,
2417                                      &link_info);
2418       if ((flags & SEC_MERGE) != 0)
2419         output->bfd_section->entsize = section->entsize;
2420     }
2421
2422   if ((flags & SEC_TIC54X_BLOCK) != 0
2423       && bfd_get_arch (section->owner) == bfd_arch_tic54x)
2424     {
2425       /* FIXME: This value should really be obtained from the bfd...  */
2426       output->block_value = 128;
2427     }
2428
2429   if (section->alignment_power > output->bfd_section->alignment_power)
2430     output->bfd_section->alignment_power = section->alignment_power;
2431
2432   section->output_section = output->bfd_section;
2433
2434   if (!map_head_is_link_order)
2435     {
2436       asection *s = output->bfd_section->map_tail.s;
2437       output->bfd_section->map_tail.s = section;
2438       section->map_head.s = NULL;
2439       section->map_tail.s = s;
2440       if (s != NULL)
2441         s->map_head.s = section;
2442       else
2443         output->bfd_section->map_head.s = section;
2444     }
2445
2446   /* Add a section reference to the list.  */
2447   new_section = new_stat (lang_input_section, ptr);
2448   new_section->section = section;
2449 }
2450
2451 /* Handle wildcard sorting.  This returns the lang_input_section which
2452    should follow the one we are going to create for SECTION and FILE,
2453    based on the sorting requirements of WILD.  It returns NULL if the
2454    new section should just go at the end of the current list.  */
2455
2456 static lang_statement_union_type *
2457 wild_sort (lang_wild_statement_type *wild,
2458            struct wildcard_list *sec,
2459            lang_input_statement_type *file,
2460            asection *section)
2461 {
2462   lang_statement_union_type *l;
2463
2464   if (!wild->filenames_sorted
2465       && (sec == NULL || sec->spec.sorted == none))
2466     return NULL;
2467
2468   for (l = wild->children.head; l != NULL; l = l->header.next)
2469     {
2470       lang_input_section_type *ls;
2471
2472       if (l->header.type != lang_input_section_enum)
2473         continue;
2474       ls = &l->input_section;
2475
2476       /* Sorting by filename takes precedence over sorting by section
2477          name.  */
2478
2479       if (wild->filenames_sorted)
2480         {
2481           const char *fn, *ln;
2482           bfd_boolean fa, la;
2483           int i;
2484
2485           /* The PE support for the .idata section as generated by
2486              dlltool assumes that files will be sorted by the name of
2487              the archive and then the name of the file within the
2488              archive.  */
2489
2490           if (file->the_bfd != NULL
2491               && bfd_my_archive (file->the_bfd) != NULL)
2492             {
2493               fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
2494               fa = TRUE;
2495             }
2496           else
2497             {
2498               fn = file->filename;
2499               fa = FALSE;
2500             }
2501
2502           if (bfd_my_archive (ls->section->owner) != NULL)
2503             {
2504               ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
2505               la = TRUE;
2506             }
2507           else
2508             {
2509               ln = ls->section->owner->filename;
2510               la = FALSE;
2511             }
2512
2513           i = filename_cmp (fn, ln);
2514           if (i > 0)
2515             continue;
2516           else if (i < 0)
2517             break;
2518
2519           if (fa || la)
2520             {
2521               if (fa)
2522                 fn = file->filename;
2523               if (la)
2524                 ln = ls->section->owner->filename;
2525
2526               i = filename_cmp (fn, ln);
2527               if (i > 0)
2528                 continue;
2529               else if (i < 0)
2530                 break;
2531             }
2532         }
2533
2534       /* Here either the files are not sorted by name, or we are
2535          looking at the sections for this file.  */
2536
2537       if (sec != NULL
2538           && sec->spec.sorted != none
2539           && sec->spec.sorted != by_none)
2540         if (compare_section (sec->spec.sorted, section, ls->section) < 0)
2541           break;
2542     }
2543
2544   return l;
2545 }
2546
2547 /* Expand a wild statement for a particular FILE.  SECTION may be
2548    NULL, in which case it is a wild card.  */
2549
2550 static void
2551 output_section_callback (lang_wild_statement_type *ptr,
2552                          struct wildcard_list *sec,
2553                          asection *section,
2554                          struct flag_info *sflag_info,
2555                          lang_input_statement_type *file,
2556                          void *output)
2557 {
2558   lang_statement_union_type *before;
2559   lang_output_section_statement_type *os;
2560
2561   os = (lang_output_section_statement_type *) output;
2562
2563   /* Exclude sections that match UNIQUE_SECTION_LIST.  */
2564   if (unique_section_p (section, os))
2565     return;
2566
2567   before = wild_sort (ptr, sec, file, section);
2568
2569   /* Here BEFORE points to the lang_input_section which
2570      should follow the one we are about to add.  If BEFORE
2571      is NULL, then the section should just go at the end
2572      of the current list.  */
2573
2574   if (before == NULL)
2575     lang_add_section (&ptr->children, section, sflag_info, os);
2576   else
2577     {
2578       lang_statement_list_type list;
2579       lang_statement_union_type **pp;
2580
2581       lang_list_init (&list);
2582       lang_add_section (&list, section, sflag_info, os);
2583
2584       /* If we are discarding the section, LIST.HEAD will
2585          be NULL.  */
2586       if (list.head != NULL)
2587         {
2588           ASSERT (list.head->header.next == NULL);
2589
2590           for (pp = &ptr->children.head;
2591                *pp != before;
2592                pp = &(*pp)->header.next)
2593             ASSERT (*pp != NULL);
2594
2595           list.head->header.next = *pp;
2596           *pp = list.head;
2597         }
2598     }
2599 }
2600
2601 /* Check if all sections in a wild statement for a particular FILE
2602    are readonly.  */
2603
2604 static void
2605 check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
2606                         struct wildcard_list *sec ATTRIBUTE_UNUSED,
2607                         asection *section,
2608                         struct flag_info *sflag_info ATTRIBUTE_UNUSED,
2609                         lang_input_statement_type *file ATTRIBUTE_UNUSED,
2610                         void *output)
2611 {
2612   lang_output_section_statement_type *os;
2613
2614   os = (lang_output_section_statement_type *) output;
2615
2616   /* Exclude sections that match UNIQUE_SECTION_LIST.  */
2617   if (unique_section_p (section, os))
2618     return;
2619
2620   if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
2621     os->all_input_readonly = FALSE;
2622 }
2623
2624 /* This is passed a file name which must have been seen already and
2625    added to the statement tree.  We will see if it has been opened
2626    already and had its symbols read.  If not then we'll read it.  */
2627
2628 static lang_input_statement_type *
2629 lookup_name (const char *name)
2630 {
2631   lang_input_statement_type *search;
2632
2633   for (search = (lang_input_statement_type *) input_file_chain.head;
2634        search != NULL;
2635        search = (lang_input_statement_type *) search->next_real_file)
2636     {
2637       /* Use the local_sym_name as the name of the file that has
2638          already been loaded as filename might have been transformed
2639          via the search directory lookup mechanism.  */
2640       const char *filename = search->local_sym_name;
2641
2642       if (filename != NULL
2643           && filename_cmp (filename, name) == 0)
2644         break;
2645     }
2646
2647   if (search == NULL)
2648     search = new_afile (name, lang_input_file_is_search_file_enum,
2649                         default_target, FALSE);
2650
2651   /* If we have already added this file, or this file is not real
2652      don't add this file.  */
2653   if (search->flags.loaded || !search->flags.real)
2654     return search;
2655
2656   if (! load_symbols (search, NULL))
2657     return NULL;
2658
2659   return search;
2660 }
2661
2662 /* Save LIST as a list of libraries whose symbols should not be exported.  */
2663
2664 struct excluded_lib
2665 {
2666   char *name;
2667   struct excluded_lib *next;
2668 };
2669 static struct excluded_lib *excluded_libs;
2670
2671 void
2672 add_excluded_libs (const char *list)
2673 {
2674   const char *p = list, *end;
2675
2676   while (*p != '\0')
2677     {
2678       struct excluded_lib *entry;
2679       end = strpbrk (p, ",:");
2680       if (end == NULL)
2681         end = p + strlen (p);
2682       entry = (struct excluded_lib *) xmalloc (sizeof (*entry));
2683       entry->next = excluded_libs;
2684       entry->name = (char *) xmalloc (end - p + 1);
2685       memcpy (entry->name, p, end - p);
2686       entry->name[end - p] = '\0';
2687       excluded_libs = entry;
2688       if (*end == '\0')
2689         break;
2690       p = end + 1;
2691     }
2692 }
2693
2694 static void
2695 check_excluded_libs (bfd *abfd)
2696 {
2697   struct excluded_lib *lib = excluded_libs;
2698
2699   while (lib)
2700     {
2701       int len = strlen (lib->name);
2702       const char *filename = lbasename (abfd->filename);
2703
2704       if (strcmp (lib->name, "ALL") == 0)
2705         {
2706           abfd->no_export = TRUE;
2707           return;
2708         }
2709
2710       if (filename_ncmp (lib->name, filename, len) == 0
2711           && (filename[len] == '\0'
2712               || (filename[len] == '.' && filename[len + 1] == 'a'
2713                   && filename[len + 2] == '\0')))
2714         {
2715           abfd->no_export = TRUE;
2716           return;
2717         }
2718
2719       lib = lib->next;
2720     }
2721 }
2722
2723 /* Get the symbols for an input file.  */
2724
2725 bfd_boolean
2726 load_symbols (lang_input_statement_type *entry,
2727               lang_statement_list_type *place)
2728 {
2729   char **matching;
2730
2731   if (entry->flags.loaded)
2732     return TRUE;
2733
2734   ldfile_open_file (entry);
2735
2736   /* Do not process further if the file was missing.  */
2737   if (entry->flags.missing_file)
2738     return TRUE;
2739
2740   if (! bfd_check_format (entry->the_bfd, bfd_archive)
2741       && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
2742     {
2743       bfd_error_type err;
2744       struct lang_input_statement_flags save_flags;
2745       extern FILE *yyin;
2746
2747       err = bfd_get_error ();
2748
2749       /* See if the emulation has some special knowledge.  */
2750       if (ldemul_unrecognized_file (entry))
2751         return TRUE;
2752
2753       if (err == bfd_error_file_ambiguously_recognized)
2754         {
2755           char **p;
2756
2757           einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
2758           einfo (_("%B: matching formats:"), entry->the_bfd);
2759           for (p = matching; *p != NULL; p++)
2760             einfo (" %s", *p);
2761           einfo ("%F\n");
2762         }
2763       else if (err != bfd_error_file_not_recognized
2764                || place == NULL)
2765         einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
2766
2767       bfd_close (entry->the_bfd);
2768       entry->the_bfd = NULL;
2769
2770       /* Try to interpret the file as a linker script.  */
2771       save_flags = input_flags;
2772       ldfile_open_command_file (entry->filename);
2773
2774       push_stat_ptr (place);
2775       input_flags.add_DT_NEEDED_for_regular
2776         = entry->flags.add_DT_NEEDED_for_regular;
2777       input_flags.add_DT_NEEDED_for_dynamic
2778         = entry->flags.add_DT_NEEDED_for_dynamic;
2779       input_flags.whole_archive = entry->flags.whole_archive;
2780       input_flags.dynamic = entry->flags.dynamic;
2781
2782       ldfile_assumed_script = TRUE;
2783       parser_input = input_script;
2784       yyparse ();
2785       ldfile_assumed_script = FALSE;
2786
2787       /* missing_file is sticky.  sysrooted will already have been
2788          restored when seeing EOF in yyparse, but no harm to restore
2789          again.  */
2790       save_flags.missing_file |= input_flags.missing_file;
2791       input_flags = save_flags;
2792       pop_stat_ptr ();
2793       fclose (yyin);
2794       yyin = NULL;
2795       entry->flags.loaded = TRUE;
2796
2797       return TRUE;
2798     }
2799
2800   if (ldemul_recognized_file (entry))
2801     return TRUE;
2802
2803   /* We don't call ldlang_add_file for an archive.  Instead, the
2804      add_symbols entry point will call ldlang_add_file, via the
2805      add_archive_element callback, for each element of the archive
2806      which is used.  */
2807   switch (bfd_get_format (entry->the_bfd))
2808     {
2809     default:
2810       break;
2811
2812     case bfd_object:
2813       if (!entry->flags.reload)
2814         ldlang_add_file (entry);
2815       if (trace_files || verbose)
2816         info_msg ("%I\n", entry);
2817       break;
2818
2819     case bfd_archive:
2820       check_excluded_libs (entry->the_bfd);
2821
2822       if (entry->flags.whole_archive)
2823         {
2824           bfd *member = NULL;
2825           bfd_boolean loaded = TRUE;
2826
2827           for (;;)
2828             {
2829               bfd *subsbfd;
2830               member = bfd_openr_next_archived_file (entry->the_bfd, member);
2831
2832               if (member == NULL)
2833                 break;
2834
2835               if (! bfd_check_format (member, bfd_object))
2836                 {
2837                   einfo (_("%F%B: member %B in archive is not an object\n"),
2838                          entry->the_bfd, member);
2839                   loaded = FALSE;
2840                 }
2841
2842               subsbfd = member;
2843               if (!(*link_info.callbacks
2844                     ->add_archive_element) (&link_info, member,
2845                                             "--whole-archive", &subsbfd))
2846                 abort ();
2847
2848               /* Potentially, the add_archive_element hook may have set a
2849                  substitute BFD for us.  */
2850               if (!bfd_link_add_symbols (subsbfd, &link_info))
2851                 {
2852                   einfo (_("%F%B: error adding symbols: %E\n"), member);
2853                   loaded = FALSE;
2854                 }
2855             }
2856
2857           entry->flags.loaded = loaded;
2858           return loaded;
2859         }
2860       break;
2861     }
2862
2863   if (bfd_link_add_symbols (entry->the_bfd, &link_info))
2864     entry->flags.loaded = TRUE;
2865   else
2866     einfo (_("%F%B: error adding symbols: %E\n"), entry->the_bfd);
2867
2868   return entry->flags.loaded;
2869 }
2870
2871 /* Handle a wild statement.  S->FILENAME or S->SECTION_LIST or both
2872    may be NULL, indicating that it is a wildcard.  Separate
2873    lang_input_section statements are created for each part of the
2874    expansion; they are added after the wild statement S.  OUTPUT is
2875    the output section.  */
2876
2877 static void
2878 wild (lang_wild_statement_type *s,
2879       const char *target ATTRIBUTE_UNUSED,
2880       lang_output_section_statement_type *output)
2881 {
2882   struct wildcard_list *sec;
2883
2884   if (s->handler_data[0]
2885       && s->handler_data[0]->spec.sorted == by_name
2886       && !s->filenames_sorted)
2887     {
2888       lang_section_bst_type *tree;
2889
2890       walk_wild (s, output_section_callback_fast, output);
2891
2892       tree = s->tree;
2893       if (tree)
2894         {
2895           output_section_callback_tree_to_list (s, tree, output);
2896           s->tree = NULL;
2897         }
2898     }
2899   else
2900     walk_wild (s, output_section_callback, output);
2901
2902   if (default_common_section == NULL)
2903     for (sec = s->section_list; sec != NULL; sec = sec->next)
2904       if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
2905         {
2906           /* Remember the section that common is going to in case we
2907              later get something which doesn't know where to put it.  */
2908           default_common_section = output;
2909           break;
2910         }
2911 }
2912
2913 /* Return TRUE iff target is the sought target.  */
2914
2915 static int
2916 get_target (const bfd_target *target, void *data)
2917 {
2918   const char *sought = (const char *) data;
2919
2920   return strcmp (target->name, sought) == 0;
2921 }
2922
2923 /* Like strcpy() but convert to lower case as well.  */
2924
2925 static void
2926 stricpy (char *dest, char *src)
2927 {
2928   char c;
2929
2930   while ((c = *src++) != 0)
2931     *dest++ = TOLOWER (c);
2932
2933   *dest = 0;
2934 }
2935
2936 /* Remove the first occurrence of needle (if any) in haystack
2937    from haystack.  */
2938
2939 static void
2940 strcut (char *haystack, char *needle)
2941 {
2942   haystack = strstr (haystack, needle);
2943
2944   if (haystack)
2945     {
2946       char *src;
2947
2948       for (src = haystack + strlen (needle); *src;)
2949         *haystack++ = *src++;
2950
2951       *haystack = 0;
2952     }
2953 }
2954
2955 /* Compare two target format name strings.
2956    Return a value indicating how "similar" they are.  */
2957
2958 static int
2959 name_compare (char *first, char *second)
2960 {
2961   char *copy1;
2962   char *copy2;
2963   int result;
2964
2965   copy1 = (char *) xmalloc (strlen (first) + 1);
2966   copy2 = (char *) xmalloc (strlen (second) + 1);
2967
2968   /* Convert the names to lower case.  */
2969   stricpy (copy1, first);
2970   stricpy (copy2, second);
2971
2972   /* Remove size and endian strings from the name.  */
2973   strcut (copy1, "big");
2974   strcut (copy1, "little");
2975   strcut (copy2, "big");
2976   strcut (copy2, "little");
2977
2978   /* Return a value based on how many characters match,
2979      starting from the beginning.   If both strings are
2980      the same then return 10 * their length.  */
2981   for (result = 0; copy1[result] == copy2[result]; result++)
2982     if (copy1[result] == 0)
2983       {
2984         result *= 10;
2985         break;
2986       }
2987
2988   free (copy1);
2989   free (copy2);
2990
2991   return result;
2992 }
2993
2994 /* Set by closest_target_match() below.  */
2995 static const bfd_target *winner;
2996
2997 /* Scan all the valid bfd targets looking for one that has the endianness
2998    requirement that was specified on the command line, and is the nearest
2999    match to the original output target.  */
3000
3001 static int
3002 closest_target_match (const bfd_target *target, void *data)
3003 {
3004   const bfd_target *original = (const bfd_target *) data;
3005
3006   if (command_line.endian == ENDIAN_BIG
3007       && target->byteorder != BFD_ENDIAN_BIG)
3008     return 0;
3009
3010   if (command_line.endian == ENDIAN_LITTLE
3011       && target->byteorder != BFD_ENDIAN_LITTLE)
3012     return 0;
3013
3014   /* Must be the same flavour.  */
3015   if (target->flavour != original->flavour)
3016     return 0;
3017
3018   /* Ignore generic big and little endian elf vectors.  */
3019   if (strcmp (target->name, "elf32-big") == 0
3020       || strcmp (target->name, "elf64-big") == 0
3021       || strcmp (target->name, "elf32-little") == 0
3022       || strcmp (target->name, "elf64-little") == 0)
3023     return 0;
3024
3025   /* If we have not found a potential winner yet, then record this one.  */
3026   if (winner == NULL)
3027     {
3028       winner = target;
3029       return 0;
3030     }
3031
3032   /* Oh dear, we now have two potential candidates for a successful match.
3033      Compare their names and choose the better one.  */
3034   if (name_compare (target->name, original->name)
3035       > name_compare (winner->name, original->name))
3036     winner = target;
3037
3038   /* Keep on searching until wqe have checked them all.  */
3039   return 0;
3040 }
3041
3042 /* Return the BFD target format of the first input file.  */
3043
3044 static char *
3045 get_first_input_target (void)
3046 {
3047   char *target = NULL;
3048
3049   LANG_FOR_EACH_INPUT_STATEMENT (s)
3050     {
3051       if (s->header.type == lang_input_statement_enum
3052           && s->flags.real)
3053         {
3054           ldfile_open_file (s);
3055
3056           if (s->the_bfd != NULL
3057               && bfd_check_format (s->the_bfd, bfd_object))
3058             {
3059               target = bfd_get_target (s->the_bfd);
3060
3061               if (target != NULL)
3062                 break;
3063             }
3064         }
3065     }
3066
3067   return target;
3068 }
3069
3070 const char *
3071 lang_get_output_target (void)
3072 {
3073   const char *target;
3074
3075   /* Has the user told us which output format to use?  */
3076   if (output_target != NULL)
3077     return output_target;
3078
3079   /* No - has the current target been set to something other than
3080      the default?  */
3081   if (current_target != default_target && current_target != NULL)
3082     return current_target;
3083
3084   /* No - can we determine the format of the first input file?  */
3085   target = get_first_input_target ();
3086   if (target != NULL)
3087     return target;
3088
3089   /* Failed - use the default output target.  */
3090   return default_target;
3091 }
3092
3093 /* Open the output file.  */
3094
3095 static void
3096 open_output (const char *name)
3097 {
3098   output_target = lang_get_output_target ();
3099
3100   /* Has the user requested a particular endianness on the command
3101      line?  */
3102   if (command_line.endian != ENDIAN_UNSET)
3103     {
3104       const bfd_target *target;
3105       enum bfd_endian desired_endian;
3106
3107       /* Get the chosen target.  */
3108       target = bfd_search_for_target (get_target, (void *) output_target);
3109
3110       /* If the target is not supported, we cannot do anything.  */
3111       if (target != NULL)
3112         {
3113           if (command_line.endian == ENDIAN_BIG)
3114             desired_endian = BFD_ENDIAN_BIG;
3115           else
3116             desired_endian = BFD_ENDIAN_LITTLE;
3117
3118           /* See if the target has the wrong endianness.  This should
3119              not happen if the linker script has provided big and
3120              little endian alternatives, but some scrips don't do
3121              this.  */
3122           if (target->byteorder != desired_endian)
3123             {
3124               /* If it does, then see if the target provides
3125                  an alternative with the correct endianness.  */
3126               if (target->alternative_target != NULL
3127                   && (target->alternative_target->byteorder == desired_endian))
3128                 output_target = target->alternative_target->name;
3129               else
3130                 {
3131                   /* Try to find a target as similar as possible to
3132                      the default target, but which has the desired
3133                      endian characteristic.  */
3134                   bfd_search_for_target (closest_target_match,
3135                                          (void *) target);
3136
3137                   /* Oh dear - we could not find any targets that
3138                      satisfy our requirements.  */
3139                   if (winner == NULL)
3140                     einfo (_("%P: warning: could not find any targets"
3141                              " that match endianness requirement\n"));
3142                   else
3143                     output_target = winner->name;
3144                 }
3145             }
3146         }
3147     }
3148
3149   link_info.output_bfd = bfd_openw (name, output_target);
3150
3151   if (link_info.output_bfd == NULL)
3152     {
3153       if (bfd_get_error () == bfd_error_invalid_target)
3154         einfo (_("%P%F: target %s not found\n"), output_target);
3155
3156       einfo (_("%P%F: cannot open output file %s: %E\n"), name);
3157     }
3158
3159   delete_output_file_on_failure = TRUE;
3160
3161   if (! bfd_set_format (link_info.output_bfd, bfd_object))
3162     einfo (_("%P%F:%s: can not make object file: %E\n"), name);
3163   if (! bfd_set_arch_mach (link_info.output_bfd,
3164                            ldfile_output_architecture,
3165                            ldfile_output_machine))
3166     einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
3167
3168   link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);
3169   if (link_info.hash == NULL)
3170     einfo (_("%P%F: can not create hash table: %E\n"));
3171
3172   bfd_set_gp_size (link_info.output_bfd, g_switch_value);
3173 }
3174
3175 static void
3176 ldlang_open_output (lang_statement_union_type *statement)
3177 {
3178   switch (statement->header.type)
3179     {
3180     case lang_output_statement_enum:
3181       ASSERT (link_info.output_bfd == NULL);
3182       open_output (statement->output_statement.name);
3183       ldemul_set_output_arch ();
3184       if (config.magic_demand_paged && !link_info.relocatable)
3185         link_info.output_bfd->flags |= D_PAGED;
3186       else
3187         link_info.output_bfd->flags &= ~D_PAGED;
3188       if (config.text_read_only)
3189         link_info.output_bfd->flags |= WP_TEXT;
3190       else
3191         link_info.output_bfd->flags &= ~WP_TEXT;
3192       if (link_info.traditional_format)
3193         link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
3194       else
3195         link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
3196       break;
3197
3198     case lang_target_statement_enum:
3199       current_target = statement->target_statement.target;
3200       break;
3201     default:
3202       break;
3203     }
3204 }
3205
3206 /* Convert between addresses in bytes and sizes in octets.
3207    For currently supported targets, octets_per_byte is always a power
3208    of two, so we can use shifts.  */
3209 #define TO_ADDR(X) ((X) >> opb_shift)
3210 #define TO_SIZE(X) ((X) << opb_shift)
3211
3212 /* Support the above.  */
3213 static unsigned int opb_shift = 0;
3214
3215 static void
3216 init_opb (void)
3217 {
3218   unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3219                                               ldfile_output_machine);
3220   opb_shift = 0;
3221   if (x > 1)
3222     while ((x & 1) == 0)
3223       {
3224         x >>= 1;
3225         ++opb_shift;
3226       }
3227   ASSERT (x == 1);
3228 }
3229
3230 /* Open all the input files.  */
3231
3232 enum open_bfd_mode
3233   {
3234     OPEN_BFD_NORMAL = 0,
3235     OPEN_BFD_FORCE = 1,
3236     OPEN_BFD_RESCAN = 2
3237   };
3238 #ifdef ENABLE_PLUGINS
3239 static lang_input_statement_type *plugin_insert = NULL;
3240 #endif
3241
3242 static void
3243 open_input_bfds (lang_statement_union_type *s, enum open_bfd_mode mode)
3244 {
3245   for (; s != NULL; s = s->header.next)
3246     {
3247       switch (s->header.type)
3248         {
3249         case lang_constructors_statement_enum:
3250           open_input_bfds (constructor_list.head, mode);
3251           break;
3252         case lang_output_section_statement_enum:
3253           open_input_bfds (s->output_section_statement.children.head, mode);
3254           break;
3255         case lang_wild_statement_enum:
3256           /* Maybe we should load the file's symbols.  */
3257           if ((mode & OPEN_BFD_RESCAN) == 0
3258               && s->wild_statement.filename
3259               && !wildcardp (s->wild_statement.filename)
3260               && !archive_path (s->wild_statement.filename))
3261             lookup_name (s->wild_statement.filename);
3262           open_input_bfds (s->wild_statement.children.head, mode);
3263           break;
3264         case lang_group_statement_enum:
3265           {
3266             struct bfd_link_hash_entry *undefs;
3267
3268             /* We must continually search the entries in the group
3269                until no new symbols are added to the list of undefined
3270                symbols.  */
3271
3272             do
3273               {
3274                 undefs = link_info.hash->undefs_tail;
3275                 open_input_bfds (s->group_statement.children.head,
3276                                  mode | OPEN_BFD_FORCE);
3277               }
3278             while (undefs != link_info.hash->undefs_tail);
3279           }
3280           break;
3281         case lang_target_statement_enum:
3282           current_target = s->target_statement.target;
3283           break;
3284         case lang_input_statement_enum:
3285           if (s->input_statement.flags.real)
3286             {
3287               lang_statement_union_type **os_tail;
3288               lang_statement_list_type add;
3289               bfd *abfd;
3290
3291               s->input_statement.target = current_target;
3292
3293               /* If we are being called from within a group, and this
3294                  is an archive which has already been searched, then
3295                  force it to be researched unless the whole archive
3296                  has been loaded already.  Do the same for a rescan.
3297                  Likewise reload --as-needed shared libs.  */
3298               if (mode != OPEN_BFD_NORMAL
3299 #ifdef ENABLE_PLUGINS
3300                   && ((mode & OPEN_BFD_RESCAN) == 0
3301                       || plugin_insert == NULL)
3302 #endif
3303                   && s->input_statement.flags.loaded
3304                   && (abfd = s->input_statement.the_bfd) != NULL
3305                   && ((bfd_get_format (abfd) == bfd_archive
3306                        && !s->input_statement.flags.whole_archive)
3307                       || (bfd_get_format (abfd) == bfd_object
3308                           && ((abfd->flags) & DYNAMIC) != 0
3309                           && s->input_statement.flags.add_DT_NEEDED_for_regular
3310                           && bfd_get_flavour (abfd) == bfd_target_elf_flavour
3311                           && (elf_dyn_lib_class (abfd) & DYN_AS_NEEDED) != 0)))
3312                 {
3313                   s->input_statement.flags.loaded = FALSE;
3314                   s->input_statement.flags.reload = TRUE;
3315                 }
3316
3317               os_tail = lang_output_section_statement.tail;
3318               lang_list_init (&add);
3319
3320               if (! load_symbols (&s->input_statement, &add))
3321                 config.make_executable = FALSE;
3322
3323               if (add.head != NULL)
3324                 {
3325                   /* If this was a script with output sections then
3326                      tack any added statements on to the end of the
3327                      list.  This avoids having to reorder the output
3328                      section statement list.  Very likely the user
3329                      forgot -T, and whatever we do here will not meet
3330                      naive user expectations.  */
3331                   if (os_tail != lang_output_section_statement.tail)
3332                     {
3333                       einfo (_("%P: warning: %s contains output sections;"
3334                                " did you forget -T?\n"),
3335                              s->input_statement.filename);
3336                       *stat_ptr->tail = add.head;
3337                       stat_ptr->tail = add.tail;
3338                     }
3339                   else
3340                     {
3341                       *add.tail = s->header.next;
3342                       s->header.next = add.head;
3343                     }
3344                 }
3345             }
3346 #ifdef ENABLE_PLUGINS
3347           /* If we have found the point at which a plugin added new
3348              files, clear plugin_insert to enable archive rescan.  */
3349           if (&s->input_statement == plugin_insert)
3350             plugin_insert = NULL;
3351 #endif
3352           break;
3353         case lang_assignment_statement_enum:
3354           if (s->assignment_statement.exp->assign.defsym)
3355             /* This is from a --defsym on the command line.  */
3356             exp_fold_tree_no_dot (s->assignment_statement.exp);
3357           break;
3358         default:
3359           break;
3360         }
3361     }
3362
3363   /* Exit if any of the files were missing.  */
3364   if (input_flags.missing_file)
3365     einfo ("%F");
3366 }
3367
3368 /* New-function for the definedness hash table.  */
3369
3370 static struct bfd_hash_entry *
3371 lang_definedness_newfunc (struct bfd_hash_entry *entry,
3372                           struct bfd_hash_table *table ATTRIBUTE_UNUSED,
3373                           const char *name ATTRIBUTE_UNUSED)
3374 {
3375   struct lang_definedness_hash_entry *ret
3376     = (struct lang_definedness_hash_entry *) entry;
3377
3378   if (ret == NULL)
3379     ret = (struct lang_definedness_hash_entry *)
3380       bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
3381
3382   if (ret == NULL)
3383     einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
3384
3385   ret->by_object = 0;
3386   ret->by_script = 0;
3387   ret->iteration = 0;
3388   return &ret->root;
3389 }
3390
3391 /* Called during processing of linker script script expressions.
3392    For symbols assigned in a linker script, return a struct describing
3393    where the symbol is defined relative to the current expression,
3394    otherwise return NULL.  */
3395
3396 struct lang_definedness_hash_entry *
3397 lang_symbol_defined (const char *name)
3398 {
3399   return ((struct lang_definedness_hash_entry *)
3400           bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE));
3401 }
3402
3403 /* Update the definedness state of NAME.  */
3404
3405 void
3406 lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
3407 {
3408   struct lang_definedness_hash_entry *defentry
3409     = (struct lang_definedness_hash_entry *)
3410     bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE);
3411
3412   if (defentry == NULL)
3413     einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
3414
3415   /* If the symbol was already defined, and not by a script, then it
3416      must be defined by an object file.  */
3417   if (!defentry->by_script
3418       && h->type != bfd_link_hash_undefined
3419       && h->type != bfd_link_hash_common
3420       && h->type != bfd_link_hash_new)
3421     defentry->by_object = 1;
3422
3423   defentry->by_script = 1;
3424   defentry->iteration = lang_statement_iteration;
3425 }
3426
3427 /* Add the supplied name to the symbol table as an undefined reference.
3428    This is a two step process as the symbol table doesn't even exist at
3429    the time the ld command line is processed.  First we put the name
3430    on a list, then, once the output file has been opened, transfer the
3431    name to the symbol table.  */
3432
3433 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
3434
3435 #define ldlang_undef_chain_list_head entry_symbol.next
3436
3437 void
3438 ldlang_add_undef (const char *const name, bfd_boolean cmdline)
3439 {
3440   ldlang_undef_chain_list_type *new_undef;
3441
3442   undef_from_cmdline = undef_from_cmdline || cmdline;
3443   new_undef = (ldlang_undef_chain_list_type *) stat_alloc (sizeof (*new_undef));
3444   new_undef->next = ldlang_undef_chain_list_head;
3445   ldlang_undef_chain_list_head = new_undef;
3446
3447   new_undef->name = xstrdup (name);
3448
3449   if (link_info.output_bfd != NULL)
3450     insert_undefined (new_undef->name);
3451 }
3452
3453 /* Insert NAME as undefined in the symbol table.  */
3454
3455 static void
3456 insert_undefined (const char *name)
3457 {
3458   struct bfd_link_hash_entry *h;
3459
3460   h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
3461   if (h == NULL)
3462     einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3463   if (h->type == bfd_link_hash_new)
3464     {
3465       h->type = bfd_link_hash_undefined;
3466       h->u.undef.abfd = NULL;
3467       bfd_link_add_undef (link_info.hash, h);
3468     }
3469 }
3470
3471 /* Run through the list of undefineds created above and place them
3472    into the linker hash table as undefined symbols belonging to the
3473    script file.  */
3474
3475 static void
3476 lang_place_undefineds (void)
3477 {
3478   ldlang_undef_chain_list_type *ptr;
3479
3480   for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
3481     insert_undefined (ptr->name);
3482 }
3483
3484 /* Check for all readonly or some readwrite sections.  */
3485
3486 static void
3487 check_input_sections
3488   (lang_statement_union_type *s,
3489    lang_output_section_statement_type *output_section_statement)
3490 {
3491   for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3492     {
3493       switch (s->header.type)
3494         {
3495         case lang_wild_statement_enum:
3496           walk_wild (&s->wild_statement, check_section_callback,
3497                      output_section_statement);
3498           if (! output_section_statement->all_input_readonly)
3499             return;
3500           break;
3501         case lang_constructors_statement_enum:
3502           check_input_sections (constructor_list.head,
3503                                 output_section_statement);
3504           if (! output_section_statement->all_input_readonly)
3505             return;
3506           break;
3507         case lang_group_statement_enum:
3508           check_input_sections (s->group_statement.children.head,
3509                                 output_section_statement);
3510           if (! output_section_statement->all_input_readonly)
3511             return;
3512           break;
3513         default:
3514           break;
3515         }
3516     }
3517 }
3518
3519 /* Update wildcard statements if needed.  */
3520
3521 static void
3522 update_wild_statements (lang_statement_union_type *s)
3523 {
3524   struct wildcard_list *sec;
3525
3526   switch (sort_section)
3527     {
3528     default:
3529       FAIL ();
3530
3531     case none:
3532       break;
3533
3534     case by_name:
3535     case by_alignment:
3536       for (; s != NULL; s = s->header.next)
3537         {
3538           switch (s->header.type)
3539             {
3540             default:
3541               break;
3542
3543             case lang_wild_statement_enum:
3544               for (sec = s->wild_statement.section_list; sec != NULL;
3545                    sec = sec->next)
3546                 {
3547                   switch (sec->spec.sorted)
3548                     {
3549                     case none:
3550                       sec->spec.sorted = sort_section;
3551                       break;
3552                     case by_name:
3553                       if (sort_section == by_alignment)
3554                         sec->spec.sorted = by_name_alignment;
3555                       break;
3556                     case by_alignment:
3557                       if (sort_section == by_name)
3558                         sec->spec.sorted = by_alignment_name;
3559                       break;
3560                     default:
3561                       break;
3562                     }
3563                 }
3564               break;
3565
3566             case lang_constructors_statement_enum:
3567               update_wild_statements (constructor_list.head);
3568               break;
3569
3570             case lang_output_section_statement_enum:
3571               /* Don't sort .init/.fini sections.  */
3572               if (strcmp (s->output_section_statement.name, ".init") != 0
3573                   && strcmp (s->output_section_statement.name, ".fini") != 0)
3574                 update_wild_statements
3575                   (s->output_section_statement.children.head);
3576               break;
3577
3578             case lang_group_statement_enum:
3579               update_wild_statements (s->group_statement.children.head);
3580               break;
3581             }
3582         }
3583       break;
3584     }
3585 }
3586
3587 /* Open input files and attach to output sections.  */
3588
3589 static void
3590 map_input_to_output_sections
3591   (lang_statement_union_type *s, const char *target,
3592    lang_output_section_statement_type *os)
3593 {
3594   for (; s != NULL; s = s->header.next)
3595     {
3596       lang_output_section_statement_type *tos;
3597       flagword flags;
3598
3599       switch (s->header.type)
3600         {
3601         case lang_wild_statement_enum:
3602           wild (&s->wild_statement, target, os);
3603           break;
3604         case lang_constructors_statement_enum:
3605           map_input_to_output_sections (constructor_list.head,
3606                                         target,
3607                                         os);
3608           break;
3609         case lang_output_section_statement_enum:
3610           tos = &s->output_section_statement;
3611           if (tos->constraint != 0)
3612             {
3613               if (tos->constraint != ONLY_IF_RW
3614                   && tos->constraint != ONLY_IF_RO)
3615                 break;
3616               tos->all_input_readonly = TRUE;
3617               check_input_sections (tos->children.head, tos);
3618               if (tos->all_input_readonly != (tos->constraint == ONLY_IF_RO))
3619                 {
3620                   tos->constraint = -1;
3621                   break;
3622                 }
3623             }
3624           map_input_to_output_sections (tos->children.head,
3625                                         target,
3626                                         tos);
3627           break;
3628         case lang_output_statement_enum:
3629           break;
3630         case lang_target_statement_enum:
3631           target = s->target_statement.target;
3632           break;
3633         case lang_group_statement_enum:
3634           map_input_to_output_sections (s->group_statement.children.head,
3635                                         target,
3636                                         os);
3637           break;
3638         case lang_data_statement_enum:
3639           /* Make sure that any sections mentioned in the expression
3640              are initialized.  */
3641           exp_init_os (s->data_statement.exp);
3642           /* The output section gets CONTENTS, ALLOC and LOAD, but
3643              these may be overridden by the script.  */
3644           flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD;
3645           switch (os->sectype)
3646             {
3647             case normal_section:
3648             case overlay_section:
3649               break;
3650             case noalloc_section:
3651               flags = SEC_HAS_CONTENTS;
3652               break;
3653             case noload_section:
3654               if (bfd_get_flavour (link_info.output_bfd)
3655                   == bfd_target_elf_flavour)
3656                 flags = SEC_NEVER_LOAD | SEC_ALLOC;
3657               else
3658                 flags = SEC_NEVER_LOAD | SEC_HAS_CONTENTS;
3659               break;
3660             }
3661           if (os->bfd_section == NULL)
3662             init_os (os, flags);
3663           else
3664             os->bfd_section->flags |= flags;
3665           break;
3666         case lang_input_section_enum:
3667           break;
3668         case lang_fill_statement_enum:
3669         case lang_object_symbols_statement_enum:
3670         case lang_reloc_statement_enum:
3671         case lang_padding_statement_enum:
3672         case lang_input_statement_enum:
3673           if (os != NULL && os->bfd_section == NULL)
3674             init_os (os, 0);
3675           break;
3676         case lang_assignment_statement_enum:
3677           if (os != NULL && os->bfd_section == NULL)
3678             init_os (os, 0);
3679
3680           /* Make sure that any sections mentioned in the assignment
3681              are initialized.  */
3682           exp_init_os (s->assignment_statement.exp);
3683           break;
3684         case lang_address_statement_enum:
3685           /* Mark the specified section with the supplied address.
3686              If this section was actually a segment marker, then the
3687              directive is ignored if the linker script explicitly
3688              processed the segment marker.  Originally, the linker
3689              treated segment directives (like -Ttext on the
3690              command-line) as section directives.  We honor the
3691              section directive semantics for backwards compatibilty;
3692              linker scripts that do not specifically check for
3693              SEGMENT_START automatically get the old semantics.  */
3694           if (!s->address_statement.segment
3695               || !s->address_statement.segment->used)
3696             {
3697               const char *name = s->address_statement.section_name;
3698
3699               /* Create the output section statement here so that
3700                  orphans with a set address will be placed after other
3701                  script sections.  If we let the orphan placement code
3702                  place them in amongst other sections then the address
3703                  will affect following script sections, which is
3704                  likely to surprise naive users.  */
3705               tos = lang_output_section_statement_lookup (name, 0, TRUE);
3706               tos->addr_tree = s->address_statement.address;
3707               if (tos->bfd_section == NULL)
3708                 init_os (tos, 0);
3709             }
3710           break;
3711         case lang_insert_statement_enum:
3712           break;
3713         }
3714     }
3715 }
3716
3717 /* An insert statement snips out all the linker statements from the
3718    start of the list and places them after the output section
3719    statement specified by the insert.  This operation is complicated
3720    by the fact that we keep a doubly linked list of output section
3721    statements as well as the singly linked list of all statements.  */
3722
3723 static void
3724 process_insert_statements (void)
3725 {
3726   lang_statement_union_type **s;
3727   lang_output_section_statement_type *first_os = NULL;
3728   lang_output_section_statement_type *last_os = NULL;
3729   lang_output_section_statement_type *os;
3730
3731   /* "start of list" is actually the statement immediately after
3732      the special abs_section output statement, so that it isn't
3733      reordered.  */
3734   s = &lang_output_section_statement.head;
3735   while (*(s = &(*s)->header.next) != NULL)
3736     {
3737       if ((*s)->header.type == lang_output_section_statement_enum)
3738         {
3739           /* Keep pointers to the first and last output section
3740              statement in the sequence we may be about to move.  */
3741           os = &(*s)->output_section_statement;
3742
3743           ASSERT (last_os == NULL || last_os->next == os);
3744           last_os = os;
3745
3746           /* Set constraint negative so that lang_output_section_find
3747              won't match this output section statement.  At this
3748              stage in linking constraint has values in the range
3749              [-1, ONLY_IN_RW].  */
3750           last_os->constraint = -2 - last_os->constraint;
3751           if (first_os == NULL)
3752             first_os = last_os;
3753         }
3754       else if ((*s)->header.type == lang_insert_statement_enum)
3755         {
3756           lang_insert_statement_type *i = &(*s)->insert_statement;
3757           lang_output_section_statement_type *where;
3758           lang_statement_union_type **ptr;
3759           lang_statement_union_type *first;
3760
3761           where = lang_output_section_find (i->where);
3762           if (where != NULL && i->is_before)
3763             {
3764               do
3765                 where = where->prev;
3766               while (where != NULL && where->constraint < 0);
3767             }
3768           if (where == NULL)
3769             {
3770               einfo (_("%F%P: %s not found for insert\n"), i->where);
3771               return;
3772             }
3773
3774           /* Deal with reordering the output section statement list.  */
3775           if (last_os != NULL)
3776             {
3777               asection *first_sec, *last_sec;
3778               struct lang_output_section_statement_struct **next;
3779
3780               /* Snip out the output sections we are moving.  */
3781               first_os->prev->next = last_os->next;
3782               if (last_os->next == NULL)
3783                 {
3784                   next = &first_os->prev->next;
3785                   lang_output_section_statement.tail
3786                     = (lang_statement_union_type **) next;
3787                 }
3788               else
3789                 last_os->next->prev = first_os->prev;
3790               /* Add them in at the new position.  */
3791               last_os->next = where->next;
3792               if (where->next == NULL)
3793                 {
3794                   next = &last_os->next;
3795                   lang_output_section_statement.tail
3796                     = (lang_statement_union_type **) next;
3797                 }
3798               else
3799                 where->next->prev = last_os;
3800               first_os->prev = where;
3801               where->next = first_os;
3802
3803               /* Move the bfd sections in the same way.  */
3804               first_sec = NULL;
3805               last_sec = NULL;
3806               for (os = first_os; os != NULL; os = os->next)
3807                 {
3808                   os->constraint = -2 - os->constraint;
3809                   if (os->bfd_section != NULL
3810                       && os->bfd_section->owner != NULL)
3811                     {
3812                       last_sec = os->bfd_section;
3813                       if (first_sec == NULL)
3814                         first_sec = last_sec;
3815                     }
3816                   if (os == last_os)
3817                     break;
3818                 }
3819               if (last_sec != NULL)
3820                 {
3821                   asection *sec = where->bfd_section;
3822                   if (sec == NULL)
3823                     sec = output_prev_sec_find (where);
3824
3825                   /* The place we want to insert must come after the
3826                      sections we are moving.  So if we find no
3827                      section or if the section is the same as our
3828                      last section, then no move is needed.  */
3829                   if (sec != NULL && sec != last_sec)
3830                     {
3831                       /* Trim them off.  */
3832                       if (first_sec->prev != NULL)
3833                         first_sec->prev->next = last_sec->next;
3834                       else
3835                         link_info.output_bfd->sections = last_sec->next;
3836                       if (last_sec->next != NULL)
3837                         last_sec->next->prev = first_sec->prev;
3838                       else
3839                         link_info.output_bfd->section_last = first_sec->prev;
3840                       /* Add back.  */
3841                       last_sec->next = sec->next;
3842                       if (sec->next != NULL)
3843                         sec->next->prev = last_sec;
3844                       else
3845                         link_info.output_bfd->section_last = last_sec;
3846                       first_sec->prev = sec;
3847                       sec->next = first_sec;
3848                     }
3849                 }
3850
3851               first_os = NULL;
3852               last_os = NULL;
3853             }
3854
3855           ptr = insert_os_after (where);
3856           /* Snip everything after the abs_section output statement we
3857              know is at the start of the list, up to and including
3858              the insert statement we are currently processing.  */
3859           first = lang_output_section_statement.head->header.next;
3860           lang_output_section_statement.head->header.next = (*s)->header.next;
3861           /* Add them back where they belong.  */
3862           *s = *ptr;
3863           if (*s == NULL)
3864             statement_list.tail = s;
3865           *ptr = first;
3866           s = &lang_output_section_statement.head;
3867         }
3868     }
3869
3870   /* Undo constraint twiddling.  */
3871   for (os = first_os; os != NULL; os = os->next)
3872     {
3873       os->constraint = -2 - os->constraint;
3874       if (os == last_os)
3875         break;
3876     }
3877 }
3878
3879 /* An output section might have been removed after its statement was
3880    added.  For example, ldemul_before_allocation can remove dynamic
3881    sections if they turn out to be not needed.  Clean them up here.  */
3882
3883 void
3884 strip_excluded_output_sections (void)
3885 {
3886   lang_output_section_statement_type *os;
3887
3888   /* Run lang_size_sections (if not already done).  */
3889   if (expld.phase != lang_mark_phase_enum)
3890     {
3891       expld.phase = lang_mark_phase_enum;
3892       expld.dataseg.phase = exp_dataseg_none;
3893       one_lang_size_sections_pass (NULL, FALSE);
3894       lang_reset_memory_regions ();
3895     }
3896
3897   for (os = &lang_output_section_statement.head->output_section_statement;
3898        os != NULL;
3899        os = os->next)
3900     {
3901       asection *output_section;
3902       bfd_boolean exclude;
3903
3904       if (os->constraint < 0)
3905         continue;
3906
3907       output_section = os->bfd_section;
3908       if (output_section == NULL)
3909         continue;
3910
3911       exclude = (output_section->rawsize == 0
3912                  && (output_section->flags & SEC_KEEP) == 0
3913                  && !bfd_section_removed_from_list (link_info.output_bfd,
3914                                                     output_section));
3915
3916       /* Some sections have not yet been sized, notably .gnu.version,
3917          .dynsym, .dynstr and .hash.  These all have SEC_LINKER_CREATED
3918          input sections, so don't drop output sections that have such
3919          input sections unless they are also marked SEC_EXCLUDE.  */
3920       if (exclude && output_section->map_head.s != NULL)
3921         {
3922           asection *s;
3923
3924           for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
3925             if ((s->flags & SEC_EXCLUDE) == 0
3926                 && ((s->flags & SEC_LINKER_CREATED) != 0
3927                     || link_info.emitrelocations))
3928               {
3929                 exclude = FALSE;
3930                 break;
3931               }
3932         }
3933
3934       if (exclude)
3935         {
3936           /* We don't set bfd_section to NULL since bfd_section of the
3937              removed output section statement may still be used.  */
3938           if (!os->update_dot)
3939             os->ignored = TRUE;
3940           output_section->flags |= SEC_EXCLUDE;
3941           bfd_section_list_remove (link_info.output_bfd, output_section);
3942           link_info.output_bfd->section_count--;
3943         }
3944     }
3945 }
3946
3947 /* Called from ldwrite to clear out asection.map_head and
3948    asection.map_tail for use as link_orders in ldwrite.
3949    FIXME: Except for sh64elf.em which starts creating link_orders in
3950    its after_allocation routine so needs to call it early.  */
3951
3952 void
3953 lang_clear_os_map (void)
3954 {
3955   lang_output_section_statement_type *os;
3956
3957   if (map_head_is_link_order)
3958     return;
3959
3960   for (os = &lang_output_section_statement.head->output_section_statement;
3961        os != NULL;
3962        os = os->next)
3963     {
3964       asection *output_section;
3965
3966       if (os->constraint < 0)
3967         continue;
3968
3969       output_section = os->bfd_section;
3970       if (output_section == NULL)
3971         continue;
3972
3973       /* TODO: Don't just junk map_head.s, turn them into link_orders.  */
3974       output_section->map_head.link_order = NULL;
3975       output_section->map_tail.link_order = NULL;
3976     }
3977
3978   /* Stop future calls to lang_add_section from messing with map_head
3979      and map_tail link_order fields.  */
3980   map_head_is_link_order = TRUE;
3981 }
3982
3983 static void
3984 print_output_section_statement
3985   (lang_output_section_statement_type *output_section_statement)
3986 {
3987   asection *section = output_section_statement->bfd_section;
3988   int len;
3989
3990   if (output_section_statement != abs_output_section)
3991     {
3992       minfo ("\n%s", output_section_statement->name);
3993
3994       if (section != NULL)
3995         {
3996           print_dot = section->vma;
3997
3998           len = strlen (output_section_statement->name);
3999           if (len >= SECTION_NAME_MAP_LENGTH - 1)
4000             {
4001               print_nl ();
4002               len = 0;
4003             }
4004           while (len < SECTION_NAME_MAP_LENGTH)
4005             {
4006               print_space ();
4007               ++len;
4008             }
4009
4010           minfo ("0x%V %W", section->vma, section->size);
4011
4012           if (section->vma != section->lma)
4013             minfo (_(" load address 0x%V"), section->lma);
4014
4015           if (output_section_statement->update_dot_tree != NULL)
4016             exp_fold_tree (output_section_statement->update_dot_tree,
4017                            bfd_abs_section_ptr, &print_dot);
4018         }
4019
4020       print_nl ();
4021     }
4022
4023   print_statement_list (output_section_statement->children.head,
4024                         output_section_statement);
4025 }
4026
4027 static void
4028 print_assignment (lang_assignment_statement_type *assignment,
4029                   lang_output_section_statement_type *output_section)
4030 {
4031   unsigned int i;
4032   bfd_boolean is_dot;
4033   etree_type *tree;
4034   asection *osec;
4035
4036   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4037     print_space ();
4038
4039   if (assignment->exp->type.node_class == etree_assert)
4040     {
4041       is_dot = FALSE;
4042       tree = assignment->exp->assert_s.child;
4043     }
4044   else
4045     {
4046       const char *dst = assignment->exp->assign.dst;
4047
4048       is_dot = (dst[0] == '.' && dst[1] == 0);
4049       if (!is_dot)
4050         expld.assign_name = dst;
4051       tree = assignment->exp->assign.src;
4052     }
4053
4054   osec = output_section->bfd_section;
4055   if (osec == NULL)
4056     osec = bfd_abs_section_ptr;
4057   exp_fold_tree (tree, osec, &print_dot);
4058   if (expld.result.valid_p)
4059     {
4060       bfd_vma value;
4061
4062       if (assignment->exp->type.node_class == etree_assert
4063           || is_dot
4064           || expld.assign_name != NULL)
4065         {
4066           value = expld.result.value;
4067
4068           if (expld.result.section != NULL)
4069             value += expld.result.section->vma;
4070
4071           minfo ("0x%V", value);
4072           if (is_dot)
4073             print_dot = value;
4074         }
4075       else
4076         {
4077           struct bfd_link_hash_entry *h;
4078
4079           h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
4080                                     FALSE, FALSE, TRUE);
4081           if (h)
4082             {
4083               value = h->u.def.value;
4084               value += h->u.def.section->output_section->vma;
4085               value += h->u.def.section->output_offset;
4086
4087               minfo ("[0x%V]", value);
4088             }
4089           else
4090             minfo ("[unresolved]");
4091         }
4092     }
4093   else
4094     {
4095       minfo ("*undef*   ");
4096 #ifdef BFD64
4097       minfo ("        ");
4098 #endif
4099     }
4100   expld.assign_name = NULL;
4101
4102   minfo ("                ");
4103   exp_print_tree (assignment->exp);
4104   print_nl ();
4105 }
4106
4107 static void
4108 print_input_statement (lang_input_statement_type *statm)
4109 {
4110   if (statm->filename != NULL
4111       && (statm->the_bfd == NULL
4112           || (statm->the_bfd->flags & BFD_LINKER_CREATED) == 0))
4113     fprintf (config.map_file, "LOAD %s\n", statm->filename);
4114 }
4115
4116 /* Print all symbols defined in a particular section.  This is called
4117    via bfd_link_hash_traverse, or by print_all_symbols.  */
4118
4119 static bfd_boolean
4120 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
4121 {
4122   asection *sec = (asection *) ptr;
4123
4124   if ((hash_entry->type == bfd_link_hash_defined
4125        || hash_entry->type == bfd_link_hash_defweak)
4126       && sec == hash_entry->u.def.section)
4127     {
4128       int i;
4129
4130       for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4131         print_space ();
4132       minfo ("0x%V   ",
4133              (hash_entry->u.def.value
4134               + hash_entry->u.def.section->output_offset
4135               + hash_entry->u.def.section->output_section->vma));
4136
4137       minfo ("             %T\n", hash_entry->root.string);
4138     }
4139
4140   return TRUE;
4141 }
4142
4143 static int
4144 hash_entry_addr_cmp (const void *a, const void *b)
4145 {
4146   const struct bfd_link_hash_entry *l = *(const struct bfd_link_hash_entry **)a;
4147   const struct bfd_link_hash_entry *r = *(const struct bfd_link_hash_entry **)b;
4148
4149   if (l->u.def.value < r->u.def.value)
4150     return -1;
4151   else if (l->u.def.value > r->u.def.value)
4152     return 1;
4153   else
4154     return 0;
4155 }
4156
4157 static void
4158 print_all_symbols (asection *sec)
4159 {
4160   input_section_userdata_type *ud
4161     = (input_section_userdata_type *) get_userdata (sec);
4162   struct map_symbol_def *def;
4163   struct bfd_link_hash_entry **entries;
4164   unsigned int i;
4165
4166   if (!ud)
4167     return;
4168
4169   *ud->map_symbol_def_tail = 0;
4170
4171   /* Sort the symbols by address.  */
4172   entries = (struct bfd_link_hash_entry **)
4173       obstack_alloc (&map_obstack, ud->map_symbol_def_count * sizeof (*entries));
4174
4175   for (i = 0, def = ud->map_symbol_def_head; def; def = def->next, i++)
4176     entries[i] = def->entry;
4177
4178   qsort (entries, ud->map_symbol_def_count, sizeof (*entries),
4179          hash_entry_addr_cmp);
4180
4181   /* Print the symbols.  */
4182   for (i = 0; i < ud->map_symbol_def_count; i++)
4183     print_one_symbol (entries[i], sec);
4184
4185   obstack_free (&map_obstack, entries);
4186 }
4187
4188 /* Print information about an input section to the map file.  */
4189
4190 static void
4191 print_input_section (asection *i, bfd_boolean is_discarded)
4192 {
4193   bfd_size_type size = i->size;
4194   int len;
4195   bfd_vma addr;
4196
4197   init_opb ();
4198
4199   print_space ();
4200   minfo ("%s", i->name);
4201
4202   len = 1 + strlen (i->name);
4203   if (len >= SECTION_NAME_MAP_LENGTH - 1)
4204     {
4205       print_nl ();
4206       len = 0;
4207     }
4208   while (len < SECTION_NAME_MAP_LENGTH)
4209     {
4210       print_space ();
4211       ++len;
4212     }
4213
4214   if (i->output_section != NULL
4215       && i->output_section->owner == link_info.output_bfd)
4216     addr = i->output_section->vma + i->output_offset;
4217   else
4218     {
4219       addr = print_dot;
4220       if (!is_discarded)
4221         size = 0;
4222     }
4223
4224   minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
4225
4226   if (size != i->rawsize && i->rawsize != 0)
4227     {
4228       len = SECTION_NAME_MAP_LENGTH + 3;
4229 #ifdef BFD64
4230       len += 16;
4231 #else
4232       len += 8;
4233 #endif
4234       while (len > 0)
4235         {
4236           print_space ();
4237           --len;
4238         }
4239
4240       minfo (_("%W (size before relaxing)\n"), i->rawsize);
4241     }
4242
4243   if (i->output_section != NULL
4244       && i->output_section->owner == link_info.output_bfd)
4245     {
4246       if (link_info.reduce_memory_overheads)
4247         bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
4248       else
4249         print_all_symbols (i);
4250
4251       /* Update print_dot, but make sure that we do not move it
4252          backwards - this could happen if we have overlays and a
4253          later overlay is shorter than an earier one.  */
4254       if (addr + TO_ADDR (size) > print_dot)
4255         print_dot = addr + TO_ADDR (size);
4256     }
4257 }
4258
4259 static void
4260 print_fill_statement (lang_fill_statement_type *fill)
4261 {
4262   size_t size;
4263   unsigned char *p;
4264   fputs (" FILL mask 0x", config.map_file);
4265   for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
4266     fprintf (config.map_file, "%02x", *p);
4267   fputs ("\n", config.map_file);
4268 }
4269
4270 static void
4271 print_data_statement (lang_data_statement_type *data)
4272 {
4273   int i;
4274   bfd_vma addr;
4275   bfd_size_type size;
4276   const char *name;
4277
4278   init_opb ();
4279   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4280     print_space ();
4281
4282   addr = data->output_offset;
4283   if (data->output_section != NULL)
4284     addr += data->output_section->vma;
4285
4286   switch (data->type)
4287     {
4288     default:
4289       abort ();
4290     case BYTE:
4291       size = BYTE_SIZE;
4292       name = "BYTE";
4293       break;
4294     case SHORT:
4295       size = SHORT_SIZE;
4296       name = "SHORT";
4297       break;
4298     case LONG:
4299       size = LONG_SIZE;
4300       name = "LONG";
4301       break;
4302     case QUAD:
4303       size = QUAD_SIZE;
4304       name = "QUAD";
4305       break;
4306     case SQUAD:
4307       size = QUAD_SIZE;
4308       name = "SQUAD";
4309       break;
4310     }
4311
4312   minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
4313
4314   if (data->exp->type.node_class != etree_value)
4315     {
4316       print_space ();
4317       exp_print_tree (data->exp);
4318     }
4319
4320   print_nl ();
4321
4322   print_dot = addr + TO_ADDR (size);
4323 }
4324
4325 /* Print an address statement.  These are generated by options like
4326    -Ttext.  */
4327
4328 static void
4329 print_address_statement (lang_address_statement_type *address)
4330 {
4331   minfo (_("Address of section %s set to "), address->section_name);
4332   exp_print_tree (address->address);
4333   print_nl ();
4334 }
4335
4336 /* Print a reloc statement.  */
4337
4338 static void
4339 print_reloc_statement (lang_reloc_statement_type *reloc)
4340 {
4341   int i;
4342   bfd_vma addr;
4343   bfd_size_type size;
4344
4345   init_opb ();
4346   for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4347     print_space ();
4348
4349   addr = reloc->output_offset;
4350   if (reloc->output_section != NULL)
4351     addr += reloc->output_section->vma;
4352
4353   size = bfd_get_reloc_size (reloc->howto);
4354
4355   minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
4356
4357   if (reloc->name != NULL)
4358     minfo ("%s+", reloc->name);
4359   else
4360     minfo ("%s+", reloc->section->name);
4361
4362   exp_print_tree (reloc->addend_exp);
4363
4364   print_nl ();
4365
4366   print_dot = addr + TO_ADDR (size);
4367 }
4368
4369 static void
4370 print_padding_statement (lang_padding_statement_type *s)
4371 {
4372   int len;
4373   bfd_vma addr;
4374
4375   init_opb ();
4376   minfo (" *fill*");
4377
4378   len = sizeof " *fill*" - 1;
4379   while (len < SECTION_NAME_MAP_LENGTH)
4380     {
4381       print_space ();
4382       ++len;
4383     }
4384
4385   addr = s->output_offset;
4386   if (s->output_section != NULL)
4387     addr += s->output_section->vma;
4388   minfo ("0x%V %W ", addr, (bfd_vma) s->size);
4389
4390   if (s->fill->size != 0)
4391     {
4392       size_t size;
4393       unsigned char *p;
4394       for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
4395         fprintf (config.map_file, "%02x", *p);
4396     }
4397
4398   print_nl ();
4399
4400   print_dot = addr + TO_ADDR (s->size);
4401 }
4402
4403 static void
4404 print_wild_statement (lang_wild_statement_type *w,
4405                       lang_output_section_statement_type *os)
4406 {
4407   struct wildcard_list *sec;
4408
4409   print_space ();
4410
4411   if (w->filenames_sorted)
4412     minfo ("SORT(");
4413   if (w->filename != NULL)
4414     minfo ("%s", w->filename);
4415   else
4416     minfo ("*");
4417   if (w->filenames_sorted)
4418     minfo (")");
4419
4420   minfo ("(");
4421   for (sec = w->section_list; sec; sec = sec->next)
4422     {
4423       if (sec->spec.sorted)
4424         minfo ("SORT(");
4425       if (sec->spec.exclude_name_list != NULL)
4426         {
4427           name_list *tmp;
4428           minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
4429           for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
4430             minfo (" %s", tmp->name);
4431           minfo (") ");
4432         }
4433       if (sec->spec.name != NULL)
4434         minfo ("%s", sec->spec.name);
4435       else
4436         minfo ("*");
4437       if (sec->spec.sorted)
4438         minfo (")");
4439       if (sec->next)
4440         minfo (" ");
4441     }
4442   minfo (")");
4443
4444   print_nl ();
4445
4446   print_statement_list (w->children.head, os);
4447 }
4448
4449 /* Print a group statement.  */
4450
4451 static void
4452 print_group (lang_group_statement_type *s,
4453              lang_output_section_statement_type *os)
4454 {
4455   fprintf (config.map_file, "START GROUP\n");
4456   print_statement_list (s->children.head, os);
4457   fprintf (config.map_file, "END GROUP\n");
4458 }
4459
4460 /* Print the list of statements in S.
4461    This can be called for any statement type.  */
4462
4463 static void
4464 print_statement_list (lang_statement_union_type *s,
4465                       lang_output_section_statement_type *os)
4466 {
4467   while (s != NULL)
4468     {
4469       print_statement (s, os);
4470       s = s->header.next;
4471     }
4472 }
4473
4474 /* Print the first statement in statement list S.
4475    This can be called for any statement type.  */
4476
4477 static void
4478 print_statement (lang_statement_union_type *s,
4479                  lang_output_section_statement_type *os)
4480 {
4481   switch (s->header.type)
4482     {
4483     default:
4484       fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
4485       FAIL ();
4486       break;
4487     case lang_constructors_statement_enum:
4488       if (constructor_list.head != NULL)
4489         {
4490           if (constructors_sorted)
4491             minfo (" SORT (CONSTRUCTORS)\n");
4492           else
4493             minfo (" CONSTRUCTORS\n");
4494           print_statement_list (constructor_list.head, os);
4495         }
4496       break;
4497     case lang_wild_statement_enum:
4498       print_wild_statement (&s->wild_statement, os);
4499       break;
4500     case lang_address_statement_enum:
4501       print_address_statement (&s->address_statement);
4502       break;
4503     case lang_object_symbols_statement_enum:
4504       minfo (" CREATE_OBJECT_SYMBOLS\n");
4505       break;
4506     case lang_fill_statement_enum:
4507       print_fill_statement (&s->fill_statement);
4508       break;
4509     case lang_data_statement_enum:
4510       print_data_statement (&s->data_statement);
4511       break;
4512     case lang_reloc_statement_enum:
4513       print_reloc_statement (&s->reloc_statement);
4514       break;
4515     case lang_input_section_enum:
4516       print_input_section (s->input_section.section, FALSE);
4517       break;
4518     case lang_padding_statement_enum:
4519       print_padding_statement (&s->padding_statement);
4520       break;
4521     case lang_output_section_statement_enum:
4522       print_output_section_statement (&s->output_section_statement);
4523       break;
4524     case lang_assignment_statement_enum:
4525       print_assignment (&s->assignment_statement, os);
4526       break;
4527     case lang_target_statement_enum:
4528       fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
4529       break;
4530     case lang_output_statement_enum:
4531       minfo ("OUTPUT(%s", s->output_statement.name);
4532       if (output_target != NULL)
4533         minfo (" %s", output_target);
4534       minfo (")\n");
4535       break;
4536     case lang_input_statement_enum:
4537       print_input_statement (&s->input_statement);
4538       break;
4539     case lang_group_statement_enum:
4540       print_group (&s->group_statement, os);
4541       break;
4542     case lang_insert_statement_enum:
4543       minfo ("INSERT %s %s\n",
4544              s->insert_statement.is_before ? "BEFORE" : "AFTER",
4545              s->insert_statement.where);
4546       break;
4547     }
4548 }
4549
4550 static void
4551 print_statements (void)
4552 {
4553   print_statement_list (statement_list.head, abs_output_section);
4554 }
4555
4556 /* Print the first N statements in statement list S to STDERR.
4557    If N == 0, nothing is printed.
4558    If N < 0, the entire list is printed.
4559    Intended to be called from GDB.  */
4560
4561 void
4562 dprint_statement (lang_statement_union_type *s, int n)
4563 {
4564   FILE *map_save = config.map_file;
4565
4566   config.map_file = stderr;
4567
4568   if (n < 0)
4569     print_statement_list (s, abs_output_section);
4570   else
4571     {
4572       while (s && --n >= 0)
4573         {
4574           print_statement (s, abs_output_section);
4575           s = s->header.next;
4576         }
4577     }
4578
4579   config.map_file = map_save;
4580 }
4581
4582 static void
4583 insert_pad (lang_statement_union_type **ptr,
4584             fill_type *fill,
4585             bfd_size_type alignment_needed,
4586             asection *output_section,
4587             bfd_vma dot)
4588 {
4589   static fill_type zero_fill;
4590   lang_statement_union_type *pad = NULL;
4591
4592   if (ptr != &statement_list.head)
4593     pad = ((lang_statement_union_type *)
4594            ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
4595   if (pad != NULL
4596       && pad->header.type == lang_padding_statement_enum
4597       && pad->padding_statement.output_section == output_section)
4598     {
4599       /* Use the existing pad statement.  */
4600     }
4601   else if ((pad = *ptr) != NULL
4602            && pad->header.type == lang_padding_statement_enum
4603            && pad->padding_statement.output_section == output_section)
4604     {
4605       /* Use the existing pad statement.  */
4606     }
4607   else
4608     {
4609       /* Make a new padding statement, linked into existing chain.  */
4610       pad = (lang_statement_union_type *)
4611           stat_alloc (sizeof (lang_padding_statement_type));
4612       pad->header.next = *ptr;
4613       *ptr = pad;
4614       pad->header.type = lang_padding_statement_enum;
4615       pad->padding_statement.output_section = output_section;
4616       if (fill == NULL)
4617         fill = &zero_fill;
4618       pad->padding_statement.fill = fill;
4619     }
4620   pad->padding_statement.output_offset = dot - output_section->vma;
4621   pad->padding_statement.size = alignment_needed;
4622   output_section->size = TO_SIZE (dot + TO_ADDR (alignment_needed)
4623                                   - output_section->vma);
4624 }
4625
4626 /* Work out how much this section will move the dot point.  */
4627
4628 static bfd_vma
4629 size_input_section
4630   (lang_statement_union_type **this_ptr,
4631    lang_output_section_statement_type *output_section_statement,
4632    fill_type *fill,
4633    bfd_vma dot)
4634 {
4635   lang_input_section_type *is = &((*this_ptr)->input_section);
4636   asection *i = is->section;
4637   asection *o = output_section_statement->bfd_section;
4638
4639   if (i->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
4640     i->output_offset = i->vma - o->vma;
4641   else if ((i->flags & SEC_EXCLUDE) != 0)
4642     i->output_offset = dot - o->vma;
4643   else
4644     {
4645       bfd_size_type alignment_needed;
4646
4647       /* Align this section first to the input sections requirement,
4648          then to the output section's requirement.  If this alignment
4649          is greater than any seen before, then record it too.  Perform
4650          the alignment by inserting a magic 'padding' statement.  */
4651
4652       if (output_section_statement->subsection_alignment != -1)
4653         i->alignment_power = output_section_statement->subsection_alignment;
4654
4655       if (o->alignment_power < i->alignment_power)
4656         o->alignment_power = i->alignment_power;
4657
4658       alignment_needed = align_power (dot, i->alignment_power) - dot;
4659
4660       if (alignment_needed != 0)
4661         {
4662           insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
4663           dot += alignment_needed;
4664         }
4665
4666       /* Remember where in the output section this input section goes.  */
4667       i->output_offset = dot - o->vma;
4668
4669       /* Mark how big the output section must be to contain this now.  */
4670       dot += TO_ADDR (i->size);
4671       o->size = TO_SIZE (dot - o->vma);
4672     }
4673
4674   return dot;
4675 }
4676
4677 static int
4678 sort_sections_by_lma (const void *arg1, const void *arg2)
4679 {
4680   const asection *sec1 = *(const asection **) arg1;
4681   const asection *sec2 = *(const asection **) arg2;
4682
4683   if (bfd_section_lma (sec1->owner, sec1)
4684       < bfd_section_lma (sec2->owner, sec2))
4685     return -1;
4686   else if (bfd_section_lma (sec1->owner, sec1)
4687            > bfd_section_lma (sec2->owner, sec2))
4688     return 1;
4689   else if (sec1->id < sec2->id)
4690     return -1;
4691   else if (sec1->id > sec2->id)
4692     return 1;
4693
4694   return 0;
4695 }
4696
4697 #define IGNORE_SECTION(s) \
4698   ((s->flags & SEC_ALLOC) == 0                          \
4699    || ((s->flags & SEC_THREAD_LOCAL) != 0               \
4700         && (s->flags & SEC_LOAD) == 0))
4701
4702 /* Check to see if any allocated sections overlap with other allocated
4703    sections.  This can happen if a linker script specifies the output
4704    section addresses of the two sections.  Also check whether any memory
4705    region has overflowed.  */
4706
4707 static void
4708 lang_check_section_addresses (void)
4709 {
4710   asection *s, *p;
4711   asection **sections, **spp;
4712   unsigned int count;
4713   bfd_vma s_start;
4714   bfd_vma s_end;
4715   bfd_vma p_start;
4716   bfd_vma p_end;
4717   bfd_size_type amt;
4718   lang_memory_region_type *m;
4719
4720   if (bfd_count_sections (link_info.output_bfd) <= 1)
4721     return;
4722
4723   amt = bfd_count_sections (link_info.output_bfd) * sizeof (asection *);
4724   sections = (asection **) xmalloc (amt);
4725
4726   /* Scan all sections in the output list.  */
4727   count = 0;
4728   for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
4729     {
4730       /* Only consider loadable sections with real contents.  */
4731       if (!(s->flags & SEC_LOAD)
4732           || !(s->flags & SEC_ALLOC)
4733           || s->size == 0)
4734         continue;
4735
4736       sections[count] = s;
4737       count++;
4738     }
4739
4740   if (count <= 1)
4741     return;
4742
4743   qsort (sections, (size_t) count, sizeof (asection *),
4744          sort_sections_by_lma);
4745
4746   spp = sections;
4747   s = *spp++;
4748   s_start = s->lma;
4749   s_end = s_start + TO_ADDR (s->size) - 1;
4750   for (count--; count; count--)
4751     {
4752       /* We must check the sections' LMA addresses not their VMA
4753          addresses because overlay sections can have overlapping VMAs
4754          but they must have distinct LMAs.  */
4755       p = s;
4756       p_start = s_start;
4757       p_end = s_end;
4758       s = *spp++;
4759       s_start = s->lma;
4760       s_end = s_start + TO_ADDR (s->size) - 1;
4761
4762       /* Look for an overlap.  We have sorted sections by lma, so we
4763          know that s_start >= p_start.  Besides the obvious case of
4764          overlap when the current section starts before the previous
4765          one ends, we also must have overlap if the previous section
4766          wraps around the address space.  */
4767       if (s_start <= p_end
4768           || p_end < p_start)
4769         einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),
4770                s->name, s_start, s_end, p->name, p_start, p_end);
4771     }
4772
4773   free (sections);
4774
4775   /* If any memory region has overflowed, report by how much.
4776      We do not issue this diagnostic for regions that had sections
4777      explicitly placed outside their bounds; os_region_check's
4778      diagnostics are adequate for that case.
4779
4780      FIXME: It is conceivable that m->current - (m->origin + m->length)
4781      might overflow a 32-bit integer.  There is, alas, no way to print
4782      a bfd_vma quantity in decimal.  */
4783   for (m = lang_memory_region_list; m; m = m->next)
4784     if (m->had_full_message)
4785       einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4786              m->name_list.name, (long)(m->current - (m->origin + m->length)));
4787
4788 }
4789
4790 /* Make sure the new address is within the region.  We explicitly permit the
4791    current address to be at the exact end of the region when the address is
4792    non-zero, in case the region is at the end of addressable memory and the
4793    calculation wraps around.  */
4794
4795 static void
4796 os_region_check (lang_output_section_statement_type *os,
4797                  lang_memory_region_type *region,
4798                  etree_type *tree,
4799                  bfd_vma rbase)
4800 {
4801   if ((region->current < region->origin
4802        || (region->current - region->origin > region->length))
4803       && ((region->current != region->origin + region->length)
4804           || rbase == 0))
4805     {
4806       if (tree != NULL)
4807         {
4808           einfo (_("%X%P: address 0x%v of %B section `%s'"
4809                    " is not within region `%s'\n"),
4810                  region->current,
4811                  os->bfd_section->owner,
4812                  os->bfd_section->name,
4813                  region->name_list.name);
4814         }
4815       else if (!region->had_full_message)
4816         {
4817           region->had_full_message = TRUE;
4818
4819           einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4820                  os->bfd_section->owner,
4821                  os->bfd_section->name,
4822                  region->name_list.name);
4823         }
4824     }
4825 }
4826
4827 /* Set the sizes for all the output sections.  */
4828
4829 static bfd_vma
4830 lang_size_sections_1
4831   (lang_statement_union_type **prev,
4832    lang_output_section_statement_type *output_section_statement,
4833    fill_type *fill,
4834    bfd_vma dot,
4835    bfd_boolean *relax,
4836    bfd_boolean check_regions)
4837 {
4838   lang_statement_union_type *s;
4839
4840   /* Size up the sections from their constituent parts.  */
4841   for (s = *prev; s != NULL; s = s->header.next)
4842     {
4843       switch (s->header.type)
4844         {
4845         case lang_output_section_statement_enum:
4846           {
4847             bfd_vma newdot, after, dotdelta;
4848             lang_output_section_statement_type *os;
4849             lang_memory_region_type *r;
4850             int section_alignment = 0;
4851
4852             os = &s->output_section_statement;
4853             if (os->constraint == -1)
4854               break;
4855
4856             /* FIXME: We shouldn't need to zero section vmas for ld -r
4857                here, in lang_insert_orphan, or in the default linker scripts.
4858                This is covering for coff backend linker bugs.  See PR6945.  */
4859             if (os->addr_tree == NULL
4860                 && link_info.relocatable
4861                 && (bfd_get_flavour (link_info.output_bfd)
4862                     == bfd_target_coff_flavour))
4863               os->addr_tree = exp_intop (0);
4864             if (os->addr_tree != NULL)
4865               {
4866                 os->processed_vma = FALSE;
4867                 exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
4868
4869                 if (expld.result.valid_p)
4870                   {
4871                     dot = expld.result.value;
4872                     if (expld.result.section != NULL)
4873                       dot += expld.result.section->vma;
4874                   }
4875                 else if (expld.phase != lang_mark_phase_enum)
4876                   einfo (_("%F%S: non constant or forward reference"
4877                            " address expression for section %s\n"),
4878                          os->addr_tree, os->name);
4879               }
4880
4881             if (os->bfd_section == NULL)
4882               /* This section was removed or never actually created.  */
4883               break;
4884
4885             /* If this is a COFF shared library section, use the size and
4886                address from the input section.  FIXME: This is COFF
4887                specific; it would be cleaner if there were some other way
4888                to do this, but nothing simple comes to mind.  */
4889             if (((bfd_get_flavour (link_info.output_bfd)
4890                   == bfd_target_ecoff_flavour)
4891                  || (bfd_get_flavour (link_info.output_bfd)
4892                      == bfd_target_coff_flavour))
4893                 && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
4894               {
4895                 asection *input;
4896
4897                 if (os->children.head == NULL
4898                     || os->children.head->header.next != NULL
4899                     || (os->children.head->header.type
4900                         != lang_input_section_enum))
4901                   einfo (_("%P%X: Internal error on COFF shared library"
4902                            " section %s\n"), os->name);
4903
4904                 input = os->children.head->input_section.section;
4905                 bfd_set_section_vma (os->bfd_section->owner,
4906                                      os->bfd_section,
4907                                      bfd_section_vma (input->owner, input));
4908                 os->bfd_section->size = input->size;
4909                 break;
4910               }
4911
4912             newdot = dot;
4913             dotdelta = 0;
4914             if (bfd_is_abs_section (os->bfd_section))
4915               {
4916                 /* No matter what happens, an abs section starts at zero.  */
4917                 ASSERT (os->bfd_section->vma == 0);
4918               }
4919             else
4920               {
4921                 if (os->addr_tree == NULL)
4922                   {
4923                     /* No address specified for this section, get one
4924                        from the region specification.  */
4925                     if (os->region == NULL
4926                         || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
4927                             && os->region->name_list.name[0] == '*'
4928                             && strcmp (os->region->name_list.name,
4929                                        DEFAULT_MEMORY_REGION) == 0))
4930                       {
4931                         os->region = lang_memory_default (os->bfd_section);
4932                       }
4933
4934                     /* If a loadable section is using the default memory
4935                        region, and some non default memory regions were
4936                        defined, issue an error message.  */
4937                     if (!os->ignored
4938                         && !IGNORE_SECTION (os->bfd_section)
4939                         && ! link_info.relocatable
4940                         && check_regions
4941                         && strcmp (os->region->name_list.name,
4942                                    DEFAULT_MEMORY_REGION) == 0
4943                         && lang_memory_region_list != NULL
4944                         && (strcmp (lang_memory_region_list->name_list.name,
4945                                     DEFAULT_MEMORY_REGION) != 0
4946                             || lang_memory_region_list->next != NULL)
4947                         && expld.phase != lang_mark_phase_enum)
4948                       {
4949                         /* By default this is an error rather than just a
4950                            warning because if we allocate the section to the
4951                            default memory region we can end up creating an
4952                            excessively large binary, or even seg faulting when
4953                            attempting to perform a negative seek.  See
4954                            sources.redhat.com/ml/binutils/2003-04/msg00423.html
4955                            for an example of this.  This behaviour can be
4956                            overridden by the using the --no-check-sections
4957                            switch.  */
4958                         if (command_line.check_section_addresses)
4959                           einfo (_("%P%F: error: no memory region specified"
4960                                    " for loadable section `%s'\n"),
4961                                  bfd_get_section_name (link_info.output_bfd,
4962                                                        os->bfd_section));
4963                         else
4964                           einfo (_("%P: warning: no memory region specified"
4965                                    " for loadable section `%s'\n"),
4966                                  bfd_get_section_name (link_info.output_bfd,
4967                                                        os->bfd_section));
4968                       }
4969
4970                     newdot = os->region->current;
4971                     section_alignment = os->bfd_section->alignment_power;
4972                   }
4973                 else
4974                   section_alignment = os->section_alignment;
4975
4976                 /* Align to what the section needs.  */
4977                 if (section_alignment > 0)
4978                   {
4979                     bfd_vma savedot = newdot;
4980                     newdot = align_power (newdot, section_alignment);
4981
4982                     dotdelta = newdot - savedot;
4983                     if (dotdelta != 0
4984                         && (config.warn_section_align
4985                             || os->addr_tree != NULL)
4986                         && expld.phase != lang_mark_phase_enum)
4987                       einfo (_("%P: warning: changing start of section"
4988                                " %s by %lu bytes\n"),
4989                              os->name, (unsigned long) dotdelta);
4990                   }
4991
4992                 bfd_set_section_vma (0, os->bfd_section, newdot);
4993
4994                 os->bfd_section->output_offset = 0;
4995               }
4996
4997             lang_size_sections_1 (&os->children.head, os,
4998                                   os->fill, newdot, relax, check_regions);
4999
5000             os->processed_vma = TRUE;
5001
5002             if (bfd_is_abs_section (os->bfd_section) || os->ignored)
5003               /* Except for some special linker created sections,
5004                  no output section should change from zero size
5005                  after strip_excluded_output_sections.  A non-zero
5006                  size on an ignored section indicates that some
5007                  input section was not sized early enough.  */
5008               ASSERT (os->bfd_section->size == 0);
5009             else
5010               {
5011                 dot = os->bfd_section->vma;
5012
5013                 /* Put the section within the requested block size, or
5014                    align at the block boundary.  */
5015                 after = ((dot
5016                           + TO_ADDR (os->bfd_section->size)
5017                           + os->block_value - 1)
5018                          & - (bfd_vma) os->block_value);
5019
5020                 os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
5021               }
5022
5023             /* Set section lma.  */
5024             r = os->region;
5025             if (r == NULL)
5026               r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
5027
5028             if (os->load_base)
5029               {
5030                 bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
5031                 os->bfd_section->lma = lma;
5032               }
5033             else if (os->lma_region != NULL)
5034               {
5035                 bfd_vma lma = os->lma_region->current;
5036
5037                 if (os->align_lma_with_input)
5038                   lma += dotdelta;
5039                 else
5040                   {
5041                     /* When LMA_REGION is the same as REGION, align the LMA
5042                        as we did for the VMA, possibly including alignment
5043                        from the bfd section.  If a different region, then
5044                        only align according to the value in the output
5045                        statement.  */
5046                     if (os->lma_region != os->region)
5047                       section_alignment = os->section_alignment;
5048                     if (section_alignment > 0)
5049                       lma = align_power (lma, section_alignment);
5050                   }
5051                 os->bfd_section->lma = lma;
5052               }
5053             else if (r->last_os != NULL
5054                      && (os->bfd_section->flags & SEC_ALLOC) != 0)
5055               {
5056                 bfd_vma lma;
5057                 asection *last;
5058
5059                 last = r->last_os->output_section_statement.bfd_section;
5060
5061                 /* A backwards move of dot should be accompanied by
5062                    an explicit assignment to the section LMA (ie.
5063                    os->load_base set) because backwards moves can
5064                    create overlapping LMAs.  */
5065                 if (dot < last->vma
5066                     && os->bfd_section->size != 0
5067                     && dot + os->bfd_section->size <= last->vma)
5068                   {
5069                     /* If dot moved backwards then leave lma equal to
5070                        vma.  This is the old default lma, which might
5071                        just happen to work when the backwards move is
5072                        sufficiently large.  Nag if this changes anything,
5073                        so people can fix their linker scripts.  */
5074
5075                     if (last->vma != last->lma)
5076                       einfo (_("%P: warning: dot moved backwards before `%s'\n"),
5077                              os->name);
5078                   }
5079                 else
5080                   {
5081                     /* If this is an overlay, set the current lma to that
5082                        at the end of the previous section.  */
5083                     if (os->sectype == overlay_section)
5084                       lma = last->lma + last->size;
5085
5086                     /* Otherwise, keep the same lma to vma relationship
5087                        as the previous section.  */
5088                     else
5089                       lma = dot + last->lma - last->vma;
5090
5091                     if (section_alignment > 0)
5092                       lma = align_power (lma, section_alignment);
5093                     os->bfd_section->lma = lma;
5094                   }
5095               }
5096             os->processed_lma = TRUE;
5097
5098             if (bfd_is_abs_section (os->bfd_section) || os->ignored)
5099               break;
5100
5101             /* Keep track of normal sections using the default
5102                lma region.  We use this to set the lma for
5103                following sections.  Overlays or other linker
5104                script assignment to lma might mean that the
5105                default lma == vma is incorrect.
5106                To avoid warnings about dot moving backwards when using
5107                -Ttext, don't start tracking sections until we find one
5108                of non-zero size or with lma set differently to vma.  */
5109             if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5110                  || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)
5111                 && (os->bfd_section->flags & SEC_ALLOC) != 0
5112                 && (os->bfd_section->size != 0
5113                     || (r->last_os == NULL
5114                         && os->bfd_section->vma != os->bfd_section->lma)
5115                     || (r->last_os != NULL
5116                         && dot >= (r->last_os->output_section_statement
5117                                    .bfd_section->vma)))
5118                 && os->lma_region == NULL
5119                 && !link_info.relocatable)
5120               r->last_os = s;
5121
5122             /* .tbss sections effectively have zero size.  */
5123             if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5124                 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
5125                 || link_info.relocatable)
5126               dotdelta = TO_ADDR (os->bfd_section->size);
5127             else
5128               dotdelta = 0;
5129             dot += dotdelta;
5130
5131             if (os->update_dot_tree != 0)
5132               exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
5133
5134             /* Update dot in the region ?
5135                We only do this if the section is going to be allocated,
5136                since unallocated sections do not contribute to the region's
5137                overall size in memory.  */
5138             if (os->region != NULL
5139                 && (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD)))
5140               {
5141                 os->region->current = dot;
5142
5143                 if (check_regions)
5144                   /* Make sure the new address is within the region.  */
5145                   os_region_check (os, os->region, os->addr_tree,
5146                                    os->bfd_section->vma);
5147
5148                 if (os->lma_region != NULL && os->lma_region != os->region
5149                     && ((os->bfd_section->flags & SEC_LOAD)
5150                         || os->align_lma_with_input))
5151                   {
5152                     os->lma_region->current = os->bfd_section->lma + dotdelta;
5153
5154                     if (check_regions)
5155                       os_region_check (os, os->lma_region, NULL,
5156                                        os->bfd_section->lma);
5157                   }
5158               }
5159           }
5160           break;
5161
5162         case lang_constructors_statement_enum:
5163           dot = lang_size_sections_1 (&constructor_list.head,
5164                                       output_section_statement,
5165                                       fill, dot, relax, check_regions);
5166           break;
5167
5168         case lang_data_statement_enum:
5169           {
5170             unsigned int size = 0;
5171
5172             s->data_statement.output_offset =
5173               dot - output_section_statement->bfd_section->vma;
5174             s->data_statement.output_section =
5175               output_section_statement->bfd_section;
5176
5177             /* We might refer to provided symbols in the expression, and
5178                need to mark them as needed.  */
5179             exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
5180
5181             switch (s->data_statement.type)
5182               {
5183               default:
5184                 abort ();
5185               case QUAD:
5186               case SQUAD:
5187                 size = QUAD_SIZE;
5188                 break;
5189               case LONG:
5190                 size = LONG_SIZE;
5191                 break;
5192               case SHORT:
5193                 size = SHORT_SIZE;
5194                 break;
5195               case BYTE:
5196                 size = BYTE_SIZE;
5197                 break;
5198               }
5199             if (size < TO_SIZE ((unsigned) 1))
5200               size = TO_SIZE ((unsigned) 1);
5201             dot += TO_ADDR (size);
5202             output_section_statement->bfd_section->size
5203               = TO_SIZE (dot - output_section_statement->bfd_section->vma);
5204
5205           }
5206           break;
5207
5208         case lang_reloc_statement_enum:
5209           {
5210             int size;
5211
5212             s->reloc_statement.output_offset =
5213               dot - output_section_statement->bfd_section->vma;
5214             s->reloc_statement.output_section =
5215               output_section_statement->bfd_section;
5216             size = bfd_get_reloc_size (s->reloc_statement.howto);
5217             dot += TO_ADDR (size);
5218             output_section_statement->bfd_section->size
5219               = TO_SIZE (dot - output_section_statement->bfd_section->vma);
5220           }
5221           break;
5222
5223         case lang_wild_statement_enum:
5224           dot = lang_size_sections_1 (&s->wild_statement.children.head,
5225                                       output_section_statement,
5226                                       fill, dot, relax, check_regions);
5227           break;
5228
5229         case lang_object_symbols_statement_enum:
5230           link_info.create_object_symbols_section =
5231             output_section_statement->bfd_section;
5232           break;
5233
5234         case lang_output_statement_enum:
5235         case lang_target_statement_enum:
5236           break;
5237
5238         case lang_input_section_enum:
5239           {
5240             asection *i;
5241
5242             i = s->input_section.section;
5243             if (relax)
5244               {
5245                 bfd_boolean again;
5246
5247                 if (! bfd_relax_section (i->owner, i, &link_info, &again))
5248                   einfo (_("%P%F: can't relax section: %E\n"));
5249                 if (again)
5250                   *relax = TRUE;
5251               }
5252             dot = size_input_section (prev, output_section_statement,
5253                                       fill, dot);
5254           }
5255           break;
5256
5257         case lang_input_statement_enum:
5258           break;
5259
5260         case lang_fill_statement_enum:
5261           s->fill_statement.output_section =
5262             output_section_statement->bfd_section;
5263
5264           fill = s->fill_statement.fill;
5265           break;
5266
5267         case lang_assignment_statement_enum:
5268           {
5269             bfd_vma newdot = dot;
5270             etree_type *tree = s->assignment_statement.exp;
5271
5272             expld.dataseg.relro = exp_dataseg_relro_none;
5273
5274             exp_fold_tree (tree,
5275                            output_section_statement->bfd_section,
5276                            &newdot);
5277
5278             if (expld.dataseg.relro == exp_dataseg_relro_start)
5279               {
5280                 if (!expld.dataseg.relro_start_stat)
5281                   expld.dataseg.relro_start_stat = s;
5282                 else
5283                   {
5284                     ASSERT (expld.dataseg.relro_start_stat == s);
5285                   }
5286               }
5287             else if (expld.dataseg.relro == exp_dataseg_relro_end)
5288               {
5289                 if (!expld.dataseg.relro_end_stat)
5290                   expld.dataseg.relro_end_stat = s;
5291                 else
5292                   {
5293                     ASSERT (expld.dataseg.relro_end_stat == s);
5294                   }
5295               }
5296             expld.dataseg.relro = exp_dataseg_relro_none;
5297
5298             /* This symbol may be relative to this section.  */
5299             if ((tree->type.node_class == etree_provided
5300                  || tree->type.node_class == etree_assign)
5301                 && (tree->assign.dst [0] != '.'
5302                     || tree->assign.dst [1] != '\0'))
5303               output_section_statement->update_dot = 1;
5304
5305             if (!output_section_statement->ignored)
5306               {
5307                 if (output_section_statement == abs_output_section)
5308                   {
5309                     /* If we don't have an output section, then just adjust
5310                        the default memory address.  */
5311                     lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
5312                                                FALSE)->current = newdot;
5313                   }
5314                 else if (newdot != dot)
5315                   {
5316                     /* Insert a pad after this statement.  We can't
5317                        put the pad before when relaxing, in case the
5318                        assignment references dot.  */
5319                     insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
5320                                 output_section_statement->bfd_section, dot);
5321
5322                     /* Don't neuter the pad below when relaxing.  */
5323                     s = s->header.next;
5324
5325                     /* If dot is advanced, this implies that the section
5326                        should have space allocated to it, unless the
5327                        user has explicitly stated that the section
5328                        should not be allocated.  */
5329                     if (output_section_statement->sectype != noalloc_section
5330                         && (output_section_statement->sectype != noload_section
5331                             || (bfd_get_flavour (link_info.output_bfd)
5332                                 == bfd_target_elf_flavour)))
5333                       output_section_statement->bfd_section->flags |= SEC_ALLOC;
5334                   }
5335                 dot = newdot;
5336               }
5337           }
5338           break;
5339
5340         case lang_padding_statement_enum:
5341           /* If this is the first time lang_size_sections is called,
5342              we won't have any padding statements.  If this is the
5343              second or later passes when relaxing, we should allow
5344              padding to shrink.  If padding is needed on this pass, it
5345              will be added back in.  */
5346           s->padding_statement.size = 0;
5347
5348           /* Make sure output_offset is valid.  If relaxation shrinks
5349              the section and this pad isn't needed, it's possible to
5350              have output_offset larger than the final size of the
5351              section.  bfd_set_section_contents will complain even for
5352              a pad size of zero.  */
5353           s->padding_statement.output_offset
5354             = dot - output_section_statement->bfd_section->vma;
5355           break;
5356
5357         case lang_group_statement_enum:
5358           dot = lang_size_sections_1 (&s->group_statement.children.head,
5359                                       output_section_statement,
5360                                       fill, dot, relax, check_regions);
5361           break;
5362
5363         case lang_insert_statement_enum:
5364           break;
5365
5366           /* We can only get here when relaxing is turned on.  */
5367         case lang_address_statement_enum:
5368           break;
5369
5370         default:
5371           FAIL ();
5372           break;
5373         }
5374       prev = &s->header.next;
5375     }
5376   return dot;
5377 }
5378
5379 /* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5380    The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5381    CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5382    segments.  We are allowed an opportunity to override this decision.  */
5383
5384 bfd_boolean
5385 ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,
5386                                     bfd * abfd ATTRIBUTE_UNUSED,
5387                                     asection * current_section,
5388                                     asection * previous_section,
5389                                     bfd_boolean new_segment)
5390 {
5391   lang_output_section_statement_type * cur;
5392   lang_output_section_statement_type * prev;
5393
5394   /* The checks below are only necessary when the BFD library has decided
5395      that the two sections ought to be placed into the same segment.  */
5396   if (new_segment)
5397     return TRUE;
5398
5399   /* Paranoia checks.  */
5400   if (current_section == NULL || previous_section == NULL)
5401     return new_segment;
5402
5403   /* If this flag is set, the target never wants code and non-code
5404      sections comingled in the same segment.  */
5405   if (config.separate_code
5406       && ((current_section->flags ^ previous_section->flags) & SEC_CODE))
5407     return TRUE;
5408
5409   /* Find the memory regions associated with the two sections.
5410      We call lang_output_section_find() here rather than scanning the list
5411      of output sections looking for a matching section pointer because if
5412      we have a large number of sections then a hash lookup is faster.  */
5413   cur  = lang_output_section_find (current_section->name);
5414   prev = lang_output_section_find (previous_section->name);
5415
5416   /* More paranoia.  */
5417   if (cur == NULL || prev == NULL)
5418     return new_segment;
5419
5420   /* If the regions are different then force the sections to live in
5421      different segments.  See the email thread starting at the following
5422      URL for the reasons why this is necessary:
5423      http://sourceware.org/ml/binutils/2007-02/msg00216.html  */
5424   return cur->region != prev->region;
5425 }
5426
5427 void
5428 one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
5429 {
5430   lang_statement_iteration++;
5431   lang_size_sections_1 (&statement_list.head, abs_output_section,
5432                         0, 0, relax, check_regions);
5433 }
5434
5435 void
5436 lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
5437 {
5438   expld.phase = lang_allocating_phase_enum;
5439   expld.dataseg.phase = exp_dataseg_none;
5440
5441   one_lang_size_sections_pass (relax, check_regions);
5442   if (expld.dataseg.phase == exp_dataseg_end_seen
5443       && link_info.relro && expld.dataseg.relro_end)
5444     {
5445       /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
5446          to put expld.dataseg.relro_end on a (common) page boundary.  */
5447       bfd_vma min_base, relro_end, maxpage;
5448
5449       expld.dataseg.phase = exp_dataseg_relro_adjust;
5450       maxpage = expld.dataseg.maxpagesize;
5451       /* MIN_BASE is the absolute minimum address we are allowed to start the
5452          read-write segment (byte before will be mapped read-only).  */
5453       min_base = (expld.dataseg.min_base + maxpage - 1) & ~(maxpage - 1);
5454       expld.dataseg.base += (-expld.dataseg.relro_end
5455                              & (expld.dataseg.pagesize - 1));
5456       /* Compute the expected PT_GNU_RELRO segment end.  */
5457       relro_end = ((expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
5458                    & ~(expld.dataseg.pagesize - 1));
5459       if (min_base + maxpage < expld.dataseg.base)
5460         {
5461           expld.dataseg.base -= maxpage;
5462           relro_end -= maxpage;
5463         }
5464       lang_reset_memory_regions ();
5465       one_lang_size_sections_pass (relax, check_regions);
5466       if (expld.dataseg.relro_end > relro_end)
5467         {
5468           /* The alignment of sections between DATA_SEGMENT_ALIGN
5469              and DATA_SEGMENT_RELRO_END can cause excessive padding to
5470              be inserted at DATA_SEGMENT_RELRO_END.  Try to start a
5471              bit lower so that the section alignments will fit in.  */
5472           asection *sec;
5473           unsigned int max_alignment_power = 0;
5474
5475           /* Find maximum alignment power of sections between
5476              DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END.  */
5477           for (sec = link_info.output_bfd->sections; sec; sec = sec->next)
5478             if (sec->vma >= expld.dataseg.base
5479                 && sec->vma < expld.dataseg.relro_end
5480                 && sec->alignment_power > max_alignment_power)
5481               max_alignment_power = sec->alignment_power;
5482
5483           if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)
5484             {
5485               /* Aligning the adjusted base guarantees the padding
5486                  between sections won't change.  This is better than
5487                  simply subtracting 1 << max_alignment_power which is
5488                  what we used to do here.  */
5489               expld.dataseg.base &= ~((1 << max_alignment_power) - 1);
5490               lang_reset_memory_regions ();
5491               one_lang_size_sections_pass (relax, check_regions);
5492             }
5493         }
5494       link_info.relro_start = expld.dataseg.base;
5495       link_info.relro_end = expld.dataseg.relro_end;
5496     }
5497   else if (expld.dataseg.phase == exp_dataseg_end_seen)
5498     {
5499       /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5500          a page could be saved in the data segment.  */
5501       bfd_vma first, last;
5502
5503       first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
5504       last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
5505       if (first && last
5506           && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
5507               != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
5508           && first + last <= expld.dataseg.pagesize)
5509         {
5510           expld.dataseg.phase = exp_dataseg_adjust;
5511           lang_reset_memory_regions ();
5512           one_lang_size_sections_pass (relax, check_regions);
5513         }
5514       else
5515         expld.dataseg.phase = exp_dataseg_done;
5516     }
5517   else
5518     expld.dataseg.phase = exp_dataseg_done;
5519 }
5520
5521 static lang_output_section_statement_type *current_section;
5522 static lang_assignment_statement_type *current_assign;
5523 static bfd_boolean prefer_next_section;
5524
5525 /* Worker function for lang_do_assignments.  Recursiveness goes here.  */
5526
5527 static bfd_vma
5528 lang_do_assignments_1 (lang_statement_union_type *s,
5529                        lang_output_section_statement_type *current_os,
5530                        fill_type *fill,
5531                        bfd_vma dot,
5532                        bfd_boolean *found_end)
5533 {
5534   for (; s != NULL; s = s->header.next)
5535     {
5536       switch (s->header.type)
5537         {
5538         case lang_constructors_statement_enum:
5539           dot = lang_do_assignments_1 (constructor_list.head,
5540                                        current_os, fill, dot, found_end);
5541           break;
5542
5543         case lang_output_section_statement_enum:
5544           {
5545             lang_output_section_statement_type *os;
5546
5547             os = &(s->output_section_statement);
5548             os->after_end = *found_end;
5549             if (os->bfd_section != NULL && !os->ignored)
5550               {
5551                 if ((os->bfd_section->flags & SEC_ALLOC) != 0)
5552                   {
5553                     current_section = os;
5554                     prefer_next_section = FALSE;
5555                   }
5556                 dot = os->bfd_section->vma;
5557
5558                 lang_do_assignments_1 (os->children.head,
5559                                        os, os->fill, dot, found_end);
5560
5561                 /* .tbss sections effectively have zero size.  */
5562                 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5563                     || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
5564                     || link_info.relocatable)
5565                   dot += TO_ADDR (os->bfd_section->size);
5566
5567                 if (os->update_dot_tree != NULL)
5568                   exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
5569               }
5570           }
5571           break;
5572
5573         case lang_wild_statement_enum:
5574
5575           dot = lang_do_assignments_1 (s->wild_statement.children.head,
5576                                        current_os, fill, dot, found_end);
5577           break;
5578
5579         case lang_object_symbols_statement_enum:
5580         case lang_output_statement_enum:
5581         case lang_target_statement_enum:
5582           break;
5583
5584         case lang_data_statement_enum:
5585           exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
5586           if (expld.result.valid_p)
5587             {
5588               s->data_statement.value = expld.result.value;
5589               if (expld.result.section != NULL)
5590                 s->data_statement.value += expld.result.section->vma;
5591             }
5592           else
5593             einfo (_("%F%P: invalid data statement\n"));
5594           {
5595             unsigned int size;
5596             switch (s->data_statement.type)
5597               {
5598               default:
5599                 abort ();
5600               case QUAD:
5601               case SQUAD:
5602                 size = QUAD_SIZE;
5603                 break;
5604               case LONG:
5605                 size = LONG_SIZE;
5606                 break;
5607               case SHORT:
5608                 size = SHORT_SIZE;
5609                 break;
5610               case BYTE:
5611                 size = BYTE_SIZE;
5612                 break;
5613               }
5614             if (size < TO_SIZE ((unsigned) 1))
5615               size = TO_SIZE ((unsigned) 1);
5616             dot += TO_ADDR (size);
5617           }
5618           break;
5619
5620         case lang_reloc_statement_enum:
5621           exp_fold_tree (s->reloc_statement.addend_exp,
5622                          bfd_abs_section_ptr, &dot);
5623           if (expld.result.valid_p)
5624             s->reloc_statement.addend_value = expld.result.value;
5625           else
5626             einfo (_("%F%P: invalid reloc statement\n"));
5627           dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
5628           break;
5629
5630         case lang_input_section_enum:
5631           {
5632             asection *in = s->input_section.section;
5633
5634             if ((in->flags & SEC_EXCLUDE) == 0)
5635               dot += TO_ADDR (in->size);
5636           }
5637           break;
5638
5639         case lang_input_statement_enum:
5640           break;
5641
5642         case lang_fill_statement_enum:
5643           fill = s->fill_statement.fill;
5644           break;
5645
5646         case lang_assignment_statement_enum:
5647           current_assign = &s->assignment_statement;
5648           if (current_assign->exp->type.node_class != etree_assert)
5649             {
5650               const char *p = current_assign->exp->assign.dst;
5651
5652               if (current_os == abs_output_section && p[0] == '.' && p[1] == 0)
5653                 prefer_next_section = TRUE;
5654
5655               while (*p == '_')
5656                 ++p;
5657               if (strcmp (p, "end") == 0)
5658                 *found_end = TRUE;
5659             }
5660           exp_fold_tree (s->assignment_statement.exp,
5661                          current_os->bfd_section,
5662                          &dot);
5663           break;
5664
5665         case lang_padding_statement_enum:
5666           dot += TO_ADDR (s->padding_statement.size);
5667           break;
5668
5669         case lang_group_statement_enum:
5670           dot = lang_do_assignments_1 (s->group_statement.children.head,
5671                                        current_os, fill, dot, found_end);
5672           break;
5673
5674         case lang_insert_statement_enum:
5675           break;
5676
5677         case lang_address_statement_enum:
5678           break;
5679
5680         default:
5681           FAIL ();
5682           break;
5683         }
5684     }
5685   return dot;
5686 }
5687
5688 void
5689 lang_do_assignments (lang_phase_type phase)
5690 {
5691   bfd_boolean found_end = FALSE;
5692
5693   current_section = NULL;
5694   prefer_next_section = FALSE;
5695   expld.phase = phase;
5696   lang_statement_iteration++;
5697   lang_do_assignments_1 (statement_list.head,
5698                          abs_output_section, NULL, 0, &found_end);
5699 }
5700
5701 /* For an assignment statement outside of an output section statement,
5702    choose the best of neighbouring output sections to use for values
5703    of "dot".  */
5704
5705 asection *
5706 section_for_dot (void)
5707 {
5708   asection *s;
5709
5710   /* Assignments belong to the previous output section, unless there
5711      has been an assignment to "dot", in which case following
5712      assignments belong to the next output section.  (The assumption
5713      is that an assignment to "dot" is setting up the address for the
5714      next output section.)  Except that past the assignment to "_end"
5715      we always associate with the previous section.  This exception is
5716      for targets like SH that define an alloc .stack or other
5717      weirdness after non-alloc sections.  */
5718   if (current_section == NULL || prefer_next_section)
5719     {
5720       lang_statement_union_type *stmt;
5721       lang_output_section_statement_type *os;
5722
5723       for (stmt = (lang_statement_union_type *) current_assign;
5724            stmt != NULL;
5725            stmt = stmt->header.next)
5726         if (stmt->header.type == lang_output_section_statement_enum)
5727           break;
5728
5729       os = &stmt->output_section_statement;
5730       while (os != NULL
5731              && !os->after_end
5732              && (os->bfd_section == NULL
5733                  || (os->bfd_section->flags & SEC_EXCLUDE) != 0
5734                  || bfd_section_removed_from_list (link_info.output_bfd,
5735                                                    os->bfd_section)))
5736         os = os->next;
5737
5738       if (current_section == NULL || os == NULL || !os->after_end)
5739         {
5740           if (os != NULL)
5741             s = os->bfd_section;
5742           else
5743             s = link_info.output_bfd->section_last;
5744           while (s != NULL
5745                  && ((s->flags & SEC_ALLOC) == 0
5746                      || (s->flags & SEC_THREAD_LOCAL) != 0))
5747             s = s->prev;
5748           if (s != NULL)
5749             return s;
5750
5751           return bfd_abs_section_ptr;
5752         }
5753     }
5754
5755   s = current_section->bfd_section;
5756
5757   /* The section may have been stripped.  */
5758   while (s != NULL
5759          && ((s->flags & SEC_EXCLUDE) != 0
5760              || (s->flags & SEC_ALLOC) == 0
5761              || (s->flags & SEC_THREAD_LOCAL) != 0
5762              || bfd_section_removed_from_list (link_info.output_bfd, s)))
5763     s = s->prev;
5764   if (s == NULL)
5765     s = link_info.output_bfd->sections;
5766   while (s != NULL
5767          && ((s->flags & SEC_ALLOC) == 0
5768              || (s->flags & SEC_THREAD_LOCAL) != 0))
5769     s = s->next;
5770   if (s != NULL)
5771     return s;
5772
5773   return bfd_abs_section_ptr;
5774 }
5775
5776 /* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
5777    operator .startof. (section_name), it produces an undefined symbol
5778    .startof.section_name.  Similarly, when it sees
5779    .sizeof. (section_name), it produces an undefined symbol
5780    .sizeof.section_name.  For all the output sections, we look for
5781    such symbols, and set them to the correct value.  */
5782
5783 static void
5784 lang_set_startof (void)
5785 {
5786   asection *s;
5787
5788   if (link_info.relocatable)
5789     return;
5790
5791   for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
5792     {
5793       const char *secname;
5794       char *buf;
5795       struct bfd_link_hash_entry *h;
5796
5797       secname = bfd_get_section_name (link_info.output_bfd, s);
5798       buf = (char *) xmalloc (10 + strlen (secname));
5799
5800       sprintf (buf, ".startof.%s", secname);
5801       h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5802       if (h != NULL && h->type == bfd_link_hash_undefined)
5803         {
5804           h->type = bfd_link_hash_defined;
5805           h->u.def.value = 0;
5806           h->u.def.section = s;
5807         }
5808
5809       sprintf (buf, ".sizeof.%s", secname);
5810       h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5811       if (h != NULL && h->type == bfd_link_hash_undefined)
5812         {
5813           h->type = bfd_link_hash_defined;
5814           h->u.def.value = TO_ADDR (s->size);
5815           h->u.def.section = bfd_abs_section_ptr;
5816         }
5817
5818       free (buf);
5819     }
5820 }
5821
5822 static void
5823 lang_end (void)
5824 {
5825   struct bfd_link_hash_entry *h;
5826   bfd_boolean warn;
5827
5828   if ((link_info.relocatable && !link_info.gc_sections)
5829       || (link_info.shared && !link_info.executable))
5830     warn = entry_from_cmdline;
5831   else
5832     warn = TRUE;
5833
5834   /* Force the user to specify a root when generating a relocatable with
5835      --gc-sections.  */
5836   if (link_info.gc_sections && link_info.relocatable
5837       && !(entry_from_cmdline || undef_from_cmdline))
5838     einfo (_("%P%F: gc-sections requires either an entry or "
5839              "an undefined symbol\n"));
5840
5841   if (entry_symbol.name == NULL)
5842     {
5843       /* No entry has been specified.  Look for the default entry, but
5844          don't warn if we don't find it.  */
5845       entry_symbol.name = entry_symbol_default;
5846       warn = FALSE;
5847     }
5848
5849   h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
5850                             FALSE, FALSE, TRUE);
5851   if (h != NULL
5852       && (h->type == bfd_link_hash_defined
5853           || h->type == bfd_link_hash_defweak)
5854       && h->u.def.section->output_section != NULL)
5855     {
5856       bfd_vma val;
5857
5858       val = (h->u.def.value
5859              + bfd_get_section_vma (link_info.output_bfd,
5860                                     h->u.def.section->output_section)
5861              + h->u.def.section->output_offset);
5862       if (! bfd_set_start_address (link_info.output_bfd, val))
5863         einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
5864     }
5865   else
5866     {
5867       bfd_vma val;
5868       const char *send;
5869
5870       /* We couldn't find the entry symbol.  Try parsing it as a
5871          number.  */
5872       val = bfd_scan_vma (entry_symbol.name, &send, 0);
5873       if (*send == '\0')
5874         {
5875           if (! bfd_set_start_address (link_info.output_bfd, val))
5876             einfo (_("%P%F: can't set start address\n"));
5877         }
5878       else
5879         {
5880           asection *ts;
5881
5882           /* Can't find the entry symbol, and it's not a number.  Use
5883              the first address in the text section.  */
5884           ts = bfd_get_section_by_name (link_info.output_bfd, entry_section);
5885           if (ts != NULL)
5886             {
5887               if (warn)
5888                 einfo (_("%P: warning: cannot find entry symbol %s;"
5889                          " defaulting to %V\n"),
5890                        entry_symbol.name,
5891                        bfd_get_section_vma (link_info.output_bfd, ts));
5892               if (!(bfd_set_start_address
5893                     (link_info.output_bfd,
5894                      bfd_get_section_vma (link_info.output_bfd, ts))))
5895                 einfo (_("%P%F: can't set start address\n"));
5896             }
5897           else
5898             {
5899               if (warn)
5900                 einfo (_("%P: warning: cannot find entry symbol %s;"
5901                          " not setting start address\n"),
5902                        entry_symbol.name);
5903             }
5904         }
5905     }
5906 }
5907
5908 /* This is a small function used when we want to ignore errors from
5909    BFD.  */
5910
5911 static void
5912 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
5913 {
5914   /* Don't do anything.  */
5915 }
5916
5917 /* Check that the architecture of all the input files is compatible
5918    with the output file.  Also call the backend to let it do any
5919    other checking that is needed.  */
5920
5921 static void
5922 lang_check (void)
5923 {
5924   lang_statement_union_type *file;
5925   bfd *input_bfd;
5926   const bfd_arch_info_type *compatible;
5927
5928   for (file = file_chain.head; file != NULL; file = file->input_statement.next)
5929     {
5930 #ifdef ENABLE_PLUGINS
5931       /* Don't check format of files claimed by plugin.  */
5932       if (file->input_statement.flags.claimed)
5933         continue;
5934 #endif /* ENABLE_PLUGINS */
5935       input_bfd = file->input_statement.the_bfd;
5936       compatible
5937         = bfd_arch_get_compatible (input_bfd, link_info.output_bfd,
5938                                    command_line.accept_unknown_input_arch);
5939
5940       /* In general it is not possible to perform a relocatable
5941          link between differing object formats when the input
5942          file has relocations, because the relocations in the
5943          input format may not have equivalent representations in
5944          the output format (and besides BFD does not translate
5945          relocs for other link purposes than a final link).  */
5946       if ((link_info.relocatable || link_info.emitrelocations)
5947           && (compatible == NULL
5948               || (bfd_get_flavour (input_bfd)
5949                   != bfd_get_flavour (link_info.output_bfd)))
5950           && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
5951         {
5952           einfo (_("%P%F: Relocatable linking with relocations from"
5953                    " format %s (%B) to format %s (%B) is not supported\n"),
5954                  bfd_get_target (input_bfd), input_bfd,
5955                  bfd_get_target (link_info.output_bfd), link_info.output_bfd);
5956           /* einfo with %F exits.  */
5957         }
5958
5959       if (compatible == NULL)
5960         {
5961           if (command_line.warn_mismatch)
5962             einfo (_("%P%X: %s architecture of input file `%B'"
5963                      " is incompatible with %s output\n"),
5964                    bfd_printable_name (input_bfd), input_bfd,
5965                    bfd_printable_name (link_info.output_bfd));
5966         }
5967       else if (bfd_count_sections (input_bfd))
5968         {
5969           /* If the input bfd has no contents, it shouldn't set the
5970              private data of the output bfd.  */
5971
5972           bfd_error_handler_type pfn = NULL;
5973
5974           /* If we aren't supposed to warn about mismatched input
5975              files, temporarily set the BFD error handler to a
5976              function which will do nothing.  We still want to call
5977              bfd_merge_private_bfd_data, since it may set up
5978              information which is needed in the output file.  */
5979           if (! command_line.warn_mismatch)
5980             pfn = bfd_set_error_handler (ignore_bfd_errors);
5981           if (! bfd_merge_private_bfd_data (input_bfd, link_info.output_bfd))
5982             {
5983               if (command_line.warn_mismatch)
5984                 einfo (_("%P%X: failed to merge target specific data"
5985                          " of file %B\n"), input_bfd);
5986             }
5987           if (! command_line.warn_mismatch)
5988             bfd_set_error_handler (pfn);
5989         }
5990     }
5991 }
5992
5993 /* Look through all the global common symbols and attach them to the
5994    correct section.  The -sort-common command line switch may be used
5995    to roughly sort the entries by alignment.  */
5996
5997 static void
5998 lang_common (void)
5999 {
6000   if (command_line.inhibit_common_definition)
6001     return;
6002   if (link_info.relocatable
6003       && ! command_line.force_common_definition)
6004     return;
6005
6006   if (! config.sort_common)
6007     bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
6008   else
6009     {
6010       unsigned int power;
6011
6012       if (config.sort_common == sort_descending)
6013         {
6014           for (power = 4; power > 0; power--)
6015             bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
6016
6017           power = 0;
6018           bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
6019         }
6020       else
6021         {
6022           for (power = 0; power <= 4; power++)
6023             bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
6024
6025           power = (unsigned int) -1;
6026           bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
6027         }
6028     }
6029 }
6030
6031 /* Place one common symbol in the correct section.  */
6032
6033 static bfd_boolean
6034 lang_one_common (struct bfd_link_hash_entry *h, void *info)
6035 {
6036   unsigned int power_of_two;
6037   bfd_vma size;
6038   asection *section;
6039
6040   if (h->type != bfd_link_hash_common)
6041     return TRUE;
6042
6043   size = h->u.c.size;
6044   power_of_two = h->u.c.p->alignment_power;
6045
6046   if (config.sort_common == sort_descending
6047       && power_of_two < *(unsigned int *) info)
6048     return TRUE;
6049   else if (config.sort_common == sort_ascending
6050            && power_of_two > *(unsigned int *) info)
6051     return TRUE;
6052
6053   section = h->u.c.p->section;
6054   if (!bfd_define_common_symbol (link_info.output_bfd, &link_info, h))
6055     einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
6056            h->root.string);
6057
6058   if (config.map_file != NULL)
6059     {
6060       static bfd_boolean header_printed;
6061       int len;
6062       char *name;
6063       char buf[50];
6064
6065       if (! header_printed)
6066         {
6067           minfo (_("\nAllocating common symbols\n"));
6068           minfo (_("Common symbol       size              file\n\n"));
6069           header_printed = TRUE;
6070         }
6071
6072       name = bfd_demangle (link_info.output_bfd, h->root.string,
6073                            DMGL_ANSI | DMGL_PARAMS);
6074       if (name == NULL)
6075         {
6076           minfo ("%s", h->root.string);
6077           len = strlen (h->root.string);
6078         }
6079       else
6080         {
6081           minfo ("%s", name);
6082           len = strlen (name);
6083           free (name);
6084         }
6085
6086       if (len >= 19)
6087         {
6088           print_nl ();
6089           len = 0;
6090         }
6091       while (len < 20)
6092         {
6093           print_space ();
6094           ++len;
6095         }
6096
6097       minfo ("0x");
6098       if (size <= 0xffffffff)
6099         sprintf (buf, "%lx", (unsigned long) size);
6100       else
6101         sprintf_vma (buf, size);
6102       minfo ("%s", buf);
6103       len = strlen (buf);
6104
6105       while (len < 16)
6106         {
6107           print_space ();
6108           ++len;
6109         }
6110
6111       minfo ("%B\n", section->owner);
6112     }
6113
6114   return TRUE;
6115 }
6116
6117 /* Run through the input files and ensure that every input section has
6118    somewhere to go.  If one is found without a destination then create
6119    an input request and place it into the statement tree.  */
6120
6121 static void
6122 lang_place_orphans (void)
6123 {
6124   LANG_FOR_EACH_INPUT_STATEMENT (file)
6125     {
6126       asection *s;
6127
6128       for (s = file->the_bfd->sections; s != NULL; s = s->next)
6129         {
6130           if (s->output_section == NULL)
6131             {
6132               /* This section of the file is not attached, root
6133                  around for a sensible place for it to go.  */
6134
6135               if (file->flags.just_syms)
6136                 bfd_link_just_syms (file->the_bfd, s, &link_info);
6137               else if ((s->flags & SEC_EXCLUDE) != 0)
6138                 s->output_section = bfd_abs_section_ptr;
6139               else if (strcmp (s->name, "COMMON") == 0)
6140                 {
6141                   /* This is a lonely common section which must have
6142                      come from an archive.  We attach to the section
6143                      with the wildcard.  */
6144                   if (! link_info.relocatable
6145                       || command_line.force_common_definition)
6146                     {
6147                       if (default_common_section == NULL)
6148                         default_common_section
6149                           = lang_output_section_statement_lookup (".bss", 0,
6150                                                                   TRUE);
6151                       lang_add_section (&default_common_section->children, s,
6152                                         NULL, default_common_section);
6153                     }
6154                 }
6155               else
6156                 {
6157                   const char *name = s->name;
6158                   int constraint = 0;
6159
6160                   if (config.unique_orphan_sections
6161                       || unique_section_p (s, NULL))
6162                     constraint = SPECIAL;
6163
6164                   if (!ldemul_place_orphan (s, name, constraint))
6165                     {
6166                       lang_output_section_statement_type *os;
6167                       os = lang_output_section_statement_lookup (name,
6168                                                                  constraint,
6169                                                                  TRUE);
6170                       if (os->addr_tree == NULL
6171                           && (link_info.relocatable
6172                               || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0))
6173                         os->addr_tree = exp_intop (0);
6174                       lang_add_section (&os->children, s, NULL, os);
6175                     }
6176                 }
6177             }
6178         }
6179     }
6180 }
6181
6182 void
6183 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
6184 {
6185   flagword *ptr_flags;
6186
6187   ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
6188   while (*flags)
6189     {
6190       switch (*flags)
6191         {
6192         case 'A': case 'a':
6193           *ptr_flags |= SEC_ALLOC;
6194           break;
6195
6196         case 'R': case 'r':
6197           *ptr_flags |= SEC_READONLY;
6198           break;
6199
6200         case 'W': case 'w':
6201           *ptr_flags |= SEC_DATA;
6202           break;
6203
6204         case 'X': case 'x':
6205           *ptr_flags |= SEC_CODE;
6206           break;
6207
6208         case 'L': case 'l':
6209         case 'I': case 'i':
6210           *ptr_flags |= SEC_LOAD;
6211           break;
6212
6213         default:
6214           einfo (_("%P%F: invalid syntax in flags\n"));
6215           break;
6216         }
6217       flags++;
6218     }
6219 }
6220
6221 /* Call a function on each input file.  This function will be called
6222    on an archive, but not on the elements.  */
6223
6224 void
6225 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
6226 {
6227   lang_input_statement_type *f;
6228
6229   for (f = (lang_input_statement_type *) input_file_chain.head;
6230        f != NULL;
6231        f = (lang_input_statement_type *) f->next_real_file)
6232     func (f);
6233 }
6234
6235 /* Call a function on each file.  The function will be called on all
6236    the elements of an archive which are included in the link, but will
6237    not be called on the archive file itself.  */
6238
6239 void
6240 lang_for_each_file (void (*func) (lang_input_statement_type *))
6241 {
6242   LANG_FOR_EACH_INPUT_STATEMENT (f)
6243     {
6244       func (f);
6245     }
6246 }
6247
6248 void
6249 ldlang_add_file (lang_input_statement_type *entry)
6250 {
6251   lang_statement_append (&file_chain,
6252                          (lang_statement_union_type *) entry,
6253                          &entry->next);
6254
6255   /* The BFD linker needs to have a list of all input BFDs involved in
6256      a link.  */
6257   ASSERT (entry->the_bfd->link.next == NULL);
6258   ASSERT (entry->the_bfd != link_info.output_bfd);
6259
6260   *link_info.input_bfds_tail = entry->the_bfd;
6261   link_info.input_bfds_tail = &entry->the_bfd->link.next;
6262   entry->the_bfd->usrdata = entry;
6263   bfd_set_gp_size (entry->the_bfd, g_switch_value);
6264
6265   /* Look through the sections and check for any which should not be
6266      included in the link.  We need to do this now, so that we can
6267      notice when the backend linker tries to report multiple
6268      definition errors for symbols which are in sections we aren't
6269      going to link.  FIXME: It might be better to entirely ignore
6270      symbols which are defined in sections which are going to be
6271      discarded.  This would require modifying the backend linker for
6272      each backend which might set the SEC_LINK_ONCE flag.  If we do
6273      this, we should probably handle SEC_EXCLUDE in the same way.  */
6274
6275   bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
6276 }
6277
6278 void
6279 lang_add_output (const char *name, int from_script)
6280 {
6281   /* Make -o on command line override OUTPUT in script.  */
6282   if (!had_output_filename || !from_script)
6283     {
6284       output_filename = name;
6285       had_output_filename = TRUE;
6286     }
6287 }
6288
6289 static int
6290 topower (int x)
6291 {
6292   unsigned int i = 1;
6293   int l;
6294
6295   if (x < 0)
6296     return -1;
6297
6298   for (l = 0; l < 32; l++)
6299     {
6300       if (i >= (unsigned int) x)
6301         return l;
6302       i <<= 1;
6303     }
6304
6305   return 0;
6306 }
6307
6308 lang_output_section_statement_type *
6309 lang_enter_output_section_statement (const char *output_section_statement_name,
6310                                      etree_type *address_exp,
6311                                      enum section_type sectype,
6312                                      etree_type *align,
6313                                      etree_type *subalign,
6314                                      etree_type *ebase,
6315                                      int constraint,
6316                                      int align_with_input)
6317 {
6318   lang_output_section_statement_type *os;
6319
6320   os = lang_output_section_statement_lookup (output_section_statement_name,
6321                                              constraint, TRUE);
6322   current_section = os;
6323
6324   if (os->addr_tree == NULL)
6325     {
6326       os->addr_tree = address_exp;
6327     }
6328   os->sectype = sectype;
6329   if (sectype != noload_section)
6330     os->flags = SEC_NO_FLAGS;
6331   else
6332     os->flags = SEC_NEVER_LOAD;
6333   os->block_value = 1;
6334
6335   /* Make next things chain into subchain of this.  */
6336   push_stat_ptr (&os->children);
6337
6338   os->align_lma_with_input = align_with_input == ALIGN_WITH_INPUT;
6339   if (os->align_lma_with_input && align != NULL)
6340     einfo (_("%F%P:%S: error: align with input and explicit align specified\n"), NULL);
6341
6342   os->subsection_alignment =
6343     topower (exp_get_value_int (subalign, -1, "subsection alignment"));
6344   os->section_alignment =
6345     topower (exp_get_value_int (align, -1, "section alignment"));
6346
6347   os->load_base = ebase;
6348   return os;
6349 }
6350
6351 void
6352 lang_final (void)
6353 {
6354   lang_output_statement_type *new_stmt;
6355
6356   new_stmt = new_stat (lang_output_statement, stat_ptr);
6357   new_stmt->name = output_filename;
6358
6359 }
6360
6361 /* Reset the current counters in the regions.  */
6362
6363 void
6364 lang_reset_memory_regions (void)
6365 {
6366   lang_memory_region_type *p = lang_memory_region_list;
6367   asection *o;
6368   lang_output_section_statement_type *os;
6369
6370   for (p = lang_memory_region_list; p != NULL; p = p->next)
6371     {
6372       p->current = p->origin;
6373       p->last_os = NULL;
6374     }
6375
6376   for (os = &lang_output_section_statement.head->output_section_statement;
6377        os != NULL;
6378        os = os->next)
6379     {
6380       os->processed_vma = FALSE;
6381       os->processed_lma = FALSE;
6382     }
6383
6384   for (o = link_info.output_bfd->sections; o != NULL; o = o->next)
6385     {
6386       /* Save the last size for possible use by bfd_relax_section.  */
6387       o->rawsize = o->size;
6388       o->size = 0;
6389     }
6390 }
6391
6392 /* Worker for lang_gc_sections_1.  */
6393
6394 static void
6395 gc_section_callback (lang_wild_statement_type *ptr,
6396                      struct wildcard_list *sec ATTRIBUTE_UNUSED,
6397                      asection *section,
6398                      struct flag_info *sflag_info ATTRIBUTE_UNUSED,
6399                      lang_input_statement_type *file ATTRIBUTE_UNUSED,
6400                      void *data ATTRIBUTE_UNUSED)
6401 {
6402   /* If the wild pattern was marked KEEP, the member sections
6403      should be as well.  */
6404   if (ptr->keep_sections)
6405     section->flags |= SEC_KEEP;
6406 }
6407
6408 /* Iterate over sections marking them against GC.  */
6409
6410 static void
6411 lang_gc_sections_1 (lang_statement_union_type *s)
6412 {
6413   for (; s != NULL; s = s->header.next)
6414     {
6415       switch (s->header.type)
6416         {
6417         case lang_wild_statement_enum:
6418           walk_wild (&s->wild_statement, gc_section_callback, NULL);
6419           break;
6420         case lang_constructors_statement_enum:
6421           lang_gc_sections_1 (constructor_list.head);
6422           break;
6423         case lang_output_section_statement_enum:
6424           lang_gc_sections_1 (s->output_section_statement.children.head);
6425           break;
6426         case lang_group_statement_enum:
6427           lang_gc_sections_1 (s->group_statement.children.head);
6428           break;
6429         default:
6430           break;
6431         }
6432     }
6433 }
6434
6435 static void
6436 lang_gc_sections (void)
6437 {
6438   /* Keep all sections so marked in the link script.  */
6439
6440   lang_gc_sections_1 (statement_list.head);
6441
6442   /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6443      the special case of debug info.  (See bfd/stabs.c)
6444      Twiddle the flag here, to simplify later linker code.  */
6445   if (link_info.relocatable)
6446     {
6447       LANG_FOR_EACH_INPUT_STATEMENT (f)
6448         {
6449           asection *sec;
6450 #ifdef ENABLE_PLUGINS
6451           if (f->flags.claimed)
6452             continue;
6453 #endif
6454           for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
6455             if ((sec->flags & SEC_DEBUGGING) == 0)
6456               sec->flags &= ~SEC_EXCLUDE;
6457         }
6458     }
6459
6460   if (link_info.gc_sections)
6461     bfd_gc_sections (link_info.output_bfd, &link_info);
6462 }
6463
6464 /* Worker for lang_find_relro_sections_1.  */
6465
6466 static void
6467 find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
6468                              struct wildcard_list *sec ATTRIBUTE_UNUSED,
6469                              asection *section,
6470                              struct flag_info *sflag_info ATTRIBUTE_UNUSED,
6471                              lang_input_statement_type *file ATTRIBUTE_UNUSED,
6472                              void *data)
6473 {
6474   /* Discarded, excluded and ignored sections effectively have zero
6475      size.  */
6476   if (section->output_section != NULL
6477       && section->output_section->owner == link_info.output_bfd
6478       && (section->output_section->flags & SEC_EXCLUDE) == 0
6479       && !IGNORE_SECTION (section)
6480       && section->size != 0)
6481     {
6482       bfd_boolean *has_relro_section = (bfd_boolean *) data;
6483       *has_relro_section = TRUE;
6484     }
6485 }
6486
6487 /* Iterate over sections for relro sections.  */
6488
6489 static void
6490 lang_find_relro_sections_1 (lang_statement_union_type *s,
6491                             bfd_boolean *has_relro_section)
6492 {
6493   if (*has_relro_section)
6494     return;
6495
6496   for (; s != NULL; s = s->header.next)
6497     {
6498       if (s == expld.dataseg.relro_end_stat)
6499         break;
6500
6501       switch (s->header.type)
6502         {
6503         case lang_wild_statement_enum:
6504           walk_wild (&s->wild_statement,
6505                      find_relro_section_callback,
6506                      has_relro_section);
6507           break;
6508         case lang_constructors_statement_enum:
6509           lang_find_relro_sections_1 (constructor_list.head,
6510                                       has_relro_section);
6511           break;
6512         case lang_output_section_statement_enum:
6513           lang_find_relro_sections_1 (s->output_section_statement.children.head,
6514                                       has_relro_section);
6515           break;
6516         case lang_group_statement_enum:
6517           lang_find_relro_sections_1 (s->group_statement.children.head,
6518                                       has_relro_section);
6519           break;
6520         default:
6521           break;
6522         }
6523     }
6524 }
6525
6526 static void
6527 lang_find_relro_sections (void)
6528 {
6529   bfd_boolean has_relro_section = FALSE;
6530
6531   /* Check all sections in the link script.  */
6532
6533   lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,
6534                               &has_relro_section);
6535
6536   if (!has_relro_section)
6537     link_info.relro = FALSE;
6538 }
6539
6540 /* Relax all sections until bfd_relax_section gives up.  */
6541
6542 void
6543 lang_relax_sections (bfd_boolean need_layout)
6544 {
6545   if (RELAXATION_ENABLED)
6546     {
6547       /* We may need more than one relaxation pass.  */
6548       int i = link_info.relax_pass;
6549
6550       /* The backend can use it to determine the current pass.  */
6551       link_info.relax_pass = 0;
6552
6553       while (i--)
6554         {
6555           /* Keep relaxing until bfd_relax_section gives up.  */
6556           bfd_boolean relax_again;
6557
6558           link_info.relax_trip = -1;
6559           do
6560             {
6561               link_info.relax_trip++;
6562
6563               /* Note: pe-dll.c does something like this also.  If you find
6564                  you need to change this code, you probably need to change
6565                  pe-dll.c also.  DJ  */
6566
6567               /* Do all the assignments with our current guesses as to
6568                  section sizes.  */
6569               lang_do_assignments (lang_assigning_phase_enum);
6570
6571               /* We must do this after lang_do_assignments, because it uses
6572                  size.  */
6573               lang_reset_memory_regions ();
6574
6575               /* Perform another relax pass - this time we know where the
6576                  globals are, so can make a better guess.  */
6577               relax_again = FALSE;
6578               lang_size_sections (&relax_again, FALSE);
6579             }
6580           while (relax_again);
6581
6582           link_info.relax_pass++;
6583         }
6584       need_layout = TRUE;
6585     }
6586
6587   if (need_layout)
6588     {
6589       /* Final extra sizing to report errors.  */
6590       lang_do_assignments (lang_assigning_phase_enum);
6591       lang_reset_memory_regions ();
6592       lang_size_sections (NULL, TRUE);
6593     }
6594 }
6595
6596 #ifdef ENABLE_PLUGINS
6597 /* Find the insert point for the plugin's replacement files.  We
6598    place them after the first claimed real object file, or if the
6599    first claimed object is an archive member, after the last real
6600    object file immediately preceding the archive.  In the event
6601    no objects have been claimed at all, we return the first dummy
6602    object file on the list as the insert point; that works, but
6603    the callee must be careful when relinking the file_chain as it
6604    is not actually on that chain, only the statement_list and the
6605    input_file list; in that case, the replacement files must be
6606    inserted at the head of the file_chain.  */
6607
6608 static lang_input_statement_type *
6609 find_replacements_insert_point (void)
6610 {
6611   lang_input_statement_type *claim1, *lastobject;
6612   lastobject = &input_file_chain.head->input_statement;
6613   for (claim1 = &file_chain.head->input_statement;
6614        claim1 != NULL;
6615        claim1 = &claim1->next->input_statement)
6616     {
6617       if (claim1->flags.claimed)
6618         return claim1->flags.claim_archive ? lastobject : claim1;
6619       /* Update lastobject if this is a real object file.  */
6620       if (claim1->the_bfd && (claim1->the_bfd->my_archive == NULL))
6621         lastobject = claim1;
6622     }
6623   /* No files were claimed by the plugin.  Choose the last object
6624      file found on the list (maybe the first, dummy entry) as the
6625      insert point.  */
6626   return lastobject;
6627 }
6628
6629 /* Insert SRCLIST into DESTLIST after given element by chaining
6630    on FIELD as the next-pointer.  (Counterintuitively does not need
6631    a pointer to the actual after-node itself, just its chain field.)  */
6632
6633 static void
6634 lang_list_insert_after (lang_statement_list_type *destlist,
6635                         lang_statement_list_type *srclist,
6636                         lang_statement_union_type **field)
6637 {
6638   *(srclist->tail) = *field;
6639   *field = srclist->head;
6640   if (destlist->tail == field)
6641     destlist->tail = srclist->tail;
6642 }
6643
6644 /* Detach new nodes added to DESTLIST since the time ORIGLIST
6645    was taken as a copy of it and leave them in ORIGLIST.  */
6646
6647 static void
6648 lang_list_remove_tail (lang_statement_list_type *destlist,
6649                        lang_statement_list_type *origlist)
6650 {
6651   union lang_statement_union **savetail;
6652   /* Check that ORIGLIST really is an earlier state of DESTLIST.  */
6653   ASSERT (origlist->head == destlist->head);
6654   savetail = origlist->tail;
6655   origlist->head = *(savetail);
6656   origlist->tail = destlist->tail;
6657   destlist->tail = savetail;
6658   *savetail = NULL;
6659 }
6660 #endif /* ENABLE_PLUGINS */
6661
6662 void
6663 lang_process (void)
6664 {
6665   /* Finalize dynamic list.  */
6666   if (link_info.dynamic_list)
6667     lang_finalize_version_expr_head (&link_info.dynamic_list->head);
6668
6669   current_target = default_target;
6670
6671   /* Open the output file.  */
6672   lang_for_each_statement (ldlang_open_output);
6673   init_opb ();
6674
6675   ldemul_create_output_section_statements ();
6676
6677   /* Add to the hash table all undefineds on the command line.  */
6678   lang_place_undefineds ();
6679
6680   if (!bfd_section_already_linked_table_init ())
6681     einfo (_("%P%F: Failed to create hash table\n"));
6682
6683   /* Create a bfd for each input file.  */
6684   current_target = default_target;
6685   open_input_bfds (statement_list.head, OPEN_BFD_NORMAL);
6686
6687 #ifdef ENABLE_PLUGINS
6688   if (plugin_active_plugins_p ())
6689     {
6690       lang_statement_list_type added;
6691       lang_statement_list_type files, inputfiles;
6692
6693       /* Now all files are read, let the plugin(s) decide if there
6694          are any more to be added to the link before we call the
6695          emulation's after_open hook.  We create a private list of
6696          input statements for this purpose, which we will eventually
6697          insert into the global statment list after the first claimed
6698          file.  */
6699       added = *stat_ptr;
6700       /* We need to manipulate all three chains in synchrony.  */
6701       files = file_chain;
6702       inputfiles = input_file_chain;
6703       if (plugin_call_all_symbols_read ())
6704         einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
6705                plugin_error_plugin ());
6706       /* Open any newly added files, updating the file chains.  */
6707       link_info.loading_lto_outputs = TRUE;
6708       open_input_bfds (*added.tail, OPEN_BFD_NORMAL);
6709       /* Restore the global list pointer now they have all been added.  */
6710       lang_list_remove_tail (stat_ptr, &added);
6711       /* And detach the fresh ends of the file lists.  */
6712       lang_list_remove_tail (&file_chain, &files);
6713       lang_list_remove_tail (&input_file_chain, &inputfiles);
6714       /* Were any new files added?  */
6715       if (added.head != NULL)
6716         {
6717           /* If so, we will insert them into the statement list immediately
6718              after the first input file that was claimed by the plugin.  */
6719           plugin_insert = find_replacements_insert_point ();
6720           /* If a plugin adds input files without having claimed any, we
6721              don't really have a good idea where to place them.  Just putting
6722              them at the start or end of the list is liable to leave them
6723              outside the crtbegin...crtend range.  */
6724           ASSERT (plugin_insert != NULL);
6725           /* Splice the new statement list into the old one.  */
6726           lang_list_insert_after (stat_ptr, &added,
6727                                   &plugin_insert->header.next);
6728           /* Likewise for the file chains.  */
6729           lang_list_insert_after (&input_file_chain, &inputfiles,
6730                                   &plugin_insert->next_real_file);
6731           /* We must be careful when relinking file_chain; we may need to
6732              insert the new files at the head of the list if the insert
6733              point chosen is the dummy first input file.  */
6734           if (plugin_insert->filename)
6735             lang_list_insert_after (&file_chain, &files, &plugin_insert->next);
6736           else
6737             lang_list_insert_after (&file_chain, &files, &file_chain.head);
6738
6739           /* Rescan archives in case new undefined symbols have appeared.  */
6740           open_input_bfds (statement_list.head, OPEN_BFD_RESCAN);
6741         }
6742     }
6743 #endif /* ENABLE_PLUGINS */
6744
6745   link_info.gc_sym_list = &entry_symbol;
6746   if (entry_symbol.name == NULL)
6747     link_info.gc_sym_list = ldlang_undef_chain_list_head;
6748
6749   ldemul_after_open ();
6750   if (config.map_file != NULL)
6751     lang_print_asneeded ();
6752
6753   bfd_section_already_linked_table_free ();
6754
6755   /* Make sure that we're not mixing architectures.  We call this
6756      after all the input files have been opened, but before we do any
6757      other processing, so that any operations merge_private_bfd_data
6758      does on the output file will be known during the rest of the
6759      link.  */
6760   lang_check ();
6761
6762   /* Handle .exports instead of a version script if we're told to do so.  */
6763   if (command_line.version_exports_section)
6764     lang_do_version_exports_section ();
6765
6766   /* Build all sets based on the information gathered from the input
6767      files.  */
6768   ldctor_build_sets ();
6769
6770   /* PR 13683: We must rerun the assignments prior to running garbage
6771      collection in order to make sure that all symbol aliases are resolved.  */
6772   lang_do_assignments (lang_mark_phase_enum);
6773   expld.phase = lang_first_phase_enum;
6774
6775   /* Remove unreferenced sections if asked to.  */
6776   lang_gc_sections ();
6777
6778   /* Size up the common data.  */
6779   lang_common ();
6780
6781   /* Update wild statements.  */
6782   update_wild_statements (statement_list.head);
6783
6784   /* Run through the contours of the script and attach input sections
6785      to the correct output sections.  */
6786   lang_statement_iteration++;
6787   map_input_to_output_sections (statement_list.head, NULL, NULL);
6788
6789   process_insert_statements ();
6790
6791   /* Find any sections not attached explicitly and handle them.  */
6792   lang_place_orphans ();
6793
6794   if (! link_info.relocatable)
6795     {
6796       asection *found;
6797
6798       /* Merge SEC_MERGE sections.  This has to be done after GC of
6799          sections, so that GCed sections are not merged, but before
6800          assigning dynamic symbols, since removing whole input sections
6801          is hard then.  */
6802       bfd_merge_sections (link_info.output_bfd, &link_info);
6803
6804       /* Look for a text section and set the readonly attribute in it.  */
6805       found = bfd_get_section_by_name (link_info.output_bfd, ".text");
6806
6807       if (found != NULL)
6808         {
6809           if (config.text_read_only)
6810             found->flags |= SEC_READONLY;
6811           else
6812             found->flags &= ~SEC_READONLY;
6813         }
6814     }
6815
6816   /* Do anything special before sizing sections.  This is where ELF
6817      and other back-ends size dynamic sections.  */
6818   ldemul_before_allocation ();
6819
6820   /* We must record the program headers before we try to fix the
6821      section positions, since they will affect SIZEOF_HEADERS.  */
6822   lang_record_phdrs ();
6823
6824   /* Check relro sections.  */
6825   if (link_info.relro && ! link_info.relocatable)
6826     lang_find_relro_sections ();
6827
6828   /* Size up the sections.  */
6829   lang_size_sections (NULL, ! RELAXATION_ENABLED);
6830
6831   /* See if anything special should be done now we know how big
6832      everything is.  This is where relaxation is done.  */
6833   ldemul_after_allocation ();
6834
6835   /* Fix any .startof. or .sizeof. symbols.  */
6836   lang_set_startof ();
6837
6838   /* Do all the assignments, now that we know the final resting places
6839      of all the symbols.  */
6840   lang_do_assignments (lang_final_phase_enum);
6841
6842   ldemul_finish ();
6843
6844   /* Make sure that the section addresses make sense.  */
6845   if (command_line.check_section_addresses)
6846     lang_check_section_addresses ();
6847
6848   lang_end ();
6849 }
6850
6851 /* EXPORTED TO YACC */
6852
6853 void
6854 lang_add_wild (struct wildcard_spec *filespec,
6855                struct wildcard_list *section_list,
6856                bfd_boolean keep_sections)
6857 {
6858   struct wildcard_list *curr, *next;
6859   lang_wild_statement_type *new_stmt;
6860
6861   /* Reverse the list as the parser puts it back to front.  */
6862   for (curr = section_list, section_list = NULL;
6863        curr != NULL;
6864        section_list = curr, curr = next)
6865     {
6866       if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
6867         placed_commons = TRUE;
6868
6869       next = curr->next;
6870       curr->next = section_list;
6871     }
6872
6873   if (filespec != NULL && filespec->name != NULL)
6874     {
6875       if (strcmp (filespec->name, "*") == 0)
6876         filespec->name = NULL;
6877       else if (! wildcardp (filespec->name))
6878         lang_has_input_file = TRUE;
6879     }
6880
6881   new_stmt = new_stat (lang_wild_statement, stat_ptr);
6882   new_stmt->filename = NULL;
6883   new_stmt->filenames_sorted = FALSE;
6884   new_stmt->section_flag_list = NULL;
6885   if (filespec != NULL)
6886     {
6887       new_stmt->filename = filespec->name;
6888       new_stmt->filenames_sorted = filespec->sorted == by_name;
6889       new_stmt->section_flag_list = filespec->section_flag_list;
6890     }
6891   new_stmt->section_list = section_list;
6892   new_stmt->keep_sections = keep_sections;
6893   lang_list_init (&new_stmt->children);
6894   analyze_walk_wild_section_handler (new_stmt);
6895 }
6896
6897 void
6898 lang_section_start (const char *name, etree_type *address,
6899                     const segment_type *segment)
6900 {
6901   lang_address_statement_type *ad;
6902
6903   ad = new_stat (lang_address_statement, stat_ptr);
6904   ad->section_name = name;
6905   ad->address = address;
6906   ad->segment = segment;
6907 }
6908
6909 /* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
6910    because of a -e argument on the command line, or zero if this is
6911    called by ENTRY in a linker script.  Command line arguments take
6912    precedence.  */
6913
6914 void
6915 lang_add_entry (const char *name, bfd_boolean cmdline)
6916 {
6917   if (entry_symbol.name == NULL
6918       || cmdline
6919       || ! entry_from_cmdline)
6920     {
6921       entry_symbol.name = name;
6922       entry_from_cmdline = cmdline;
6923     }
6924 }
6925
6926 /* Set the default start symbol to NAME.  .em files should use this,
6927    not lang_add_entry, to override the use of "start" if neither the
6928    linker script nor the command line specifies an entry point.  NAME
6929    must be permanently allocated.  */
6930 void
6931 lang_default_entry (const char *name)
6932 {
6933   entry_symbol_default = name;
6934 }
6935
6936 void
6937 lang_add_target (const char *name)
6938 {
6939   lang_target_statement_type *new_stmt;
6940
6941   new_stmt = new_stat (lang_target_statement, stat_ptr);
6942   new_stmt->target = name;
6943 }
6944
6945 void
6946 lang_add_map (const char *name)
6947 {
6948   while (*name)
6949     {
6950       switch (*name)
6951         {
6952         case 'F':
6953           map_option_f = TRUE;
6954           break;
6955         }
6956       name++;
6957     }
6958 }
6959
6960 void
6961 lang_add_fill (fill_type *fill)
6962 {
6963   lang_fill_statement_type *new_stmt;
6964
6965   new_stmt = new_stat (lang_fill_statement, stat_ptr);
6966   new_stmt->fill = fill;
6967 }
6968
6969 void
6970 lang_add_data (int type, union etree_union *exp)
6971 {
6972   lang_data_statement_type *new_stmt;
6973
6974   new_stmt = new_stat (lang_data_statement, stat_ptr);
6975   new_stmt->exp = exp;
6976   new_stmt->type = type;
6977 }
6978
6979 /* Create a new reloc statement.  RELOC is the BFD relocation type to
6980    generate.  HOWTO is the corresponding howto structure (we could
6981    look this up, but the caller has already done so).  SECTION is the
6982    section to generate a reloc against, or NAME is the name of the
6983    symbol to generate a reloc against.  Exactly one of SECTION and
6984    NAME must be NULL.  ADDEND is an expression for the addend.  */
6985
6986 void
6987 lang_add_reloc (bfd_reloc_code_real_type reloc,
6988                 reloc_howto_type *howto,
6989                 asection *section,
6990                 const char *name,
6991                 union etree_union *addend)
6992 {
6993   lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
6994
6995   p->reloc = reloc;
6996   p->howto = howto;
6997   p->section = section;
6998   p->name = name;
6999   p->addend_exp = addend;
7000
7001   p->addend_value = 0;
7002   p->output_section = NULL;
7003   p->output_offset = 0;
7004 }
7005
7006 lang_assignment_statement_type *
7007 lang_add_assignment (etree_type *exp)
7008 {
7009   lang_assignment_statement_type *new_stmt;
7010
7011   new_stmt = new_stat (lang_assignment_statement, stat_ptr);
7012   new_stmt->exp = exp;
7013   return new_stmt;
7014 }
7015
7016 void
7017 lang_add_attribute (enum statement_enum attribute)
7018 {
7019   new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
7020 }
7021
7022 void
7023 lang_startup (const char *name)
7024 {
7025   if (first_file->filename != NULL)
7026     {
7027       einfo (_("%P%F: multiple STARTUP files\n"));
7028     }
7029   first_file->filename = name;
7030   first_file->local_sym_name = name;
7031   first_file->flags.real = TRUE;
7032 }
7033
7034 void
7035 lang_float (bfd_boolean maybe)
7036 {
7037   lang_float_flag = maybe;
7038 }
7039
7040
7041 /* Work out the load- and run-time regions from a script statement, and
7042    store them in *LMA_REGION and *REGION respectively.
7043
7044    MEMSPEC is the name of the run-time region, or the value of
7045    DEFAULT_MEMORY_REGION if the statement didn't specify one.
7046    LMA_MEMSPEC is the name of the load-time region, or null if the
7047    statement didn't specify one.HAVE_LMA_P is TRUE if the statement
7048    had an explicit load address.
7049
7050    It is an error to specify both a load region and a load address.  */
7051
7052 static void
7053 lang_get_regions (lang_memory_region_type **region,
7054                   lang_memory_region_type **lma_region,
7055                   const char *memspec,
7056                   const char *lma_memspec,
7057                   bfd_boolean have_lma,
7058                   bfd_boolean have_vma)
7059 {
7060   *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
7061
7062   /* If no runtime region or VMA has been specified, but the load region
7063      has been specified, then use the load region for the runtime region
7064      as well.  */
7065   if (lma_memspec != NULL
7066       && ! have_vma
7067       && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
7068     *region = *lma_region;
7069   else
7070     *region = lang_memory_region_lookup (memspec, FALSE);
7071
7072   if (have_lma && lma_memspec != 0)
7073     einfo (_("%X%P:%S: section has both a load address and a load region\n"),
7074            NULL);
7075 }
7076
7077 void
7078 lang_leave_output_section_statement (fill_type *fill, const char *memspec,
7079                                      lang_output_section_phdr_list *phdrs,
7080                                      const char *lma_memspec)
7081 {
7082   lang_get_regions (&current_section->region,
7083                     &current_section->lma_region,
7084                     memspec, lma_memspec,
7085                     current_section->load_base != NULL,
7086                     current_section->addr_tree != NULL);
7087
7088   /* If this section has no load region or base, but uses the same
7089      region as the previous section, then propagate the previous
7090      section's load region.  */
7091
7092   if (current_section->lma_region == NULL
7093       && current_section->load_base == NULL
7094       && current_section->addr_tree == NULL
7095       && current_section->region == current_section->prev->region)
7096     current_section->lma_region = current_section->prev->lma_region;
7097
7098   current_section->fill = fill;
7099   current_section->phdrs = phdrs;
7100   pop_stat_ptr ();
7101 }
7102
7103 void
7104 lang_statement_append (lang_statement_list_type *list,
7105                        lang_statement_union_type *element,
7106                        lang_statement_union_type **field)
7107 {
7108   *(list->tail) = element;
7109   list->tail = field;
7110 }
7111
7112 /* Set the output format type.  -oformat overrides scripts.  */
7113
7114 void
7115 lang_add_output_format (const char *format,
7116                         const char *big,
7117                         const char *little,
7118                         int from_script)
7119 {
7120   if (output_target == NULL || !from_script)
7121     {
7122       if (command_line.endian == ENDIAN_BIG
7123           && big != NULL)
7124         format = big;
7125       else if (command_line.endian == ENDIAN_LITTLE
7126                && little != NULL)
7127         format = little;
7128
7129       output_target = format;
7130     }
7131 }
7132
7133 void
7134 lang_add_insert (const char *where, int is_before)
7135 {
7136   lang_insert_statement_type *new_stmt;
7137
7138   new_stmt = new_stat (lang_insert_statement, stat_ptr);
7139   new_stmt->where = where;
7140   new_stmt->is_before = is_before;
7141   saved_script_handle = previous_script_handle;
7142 }
7143
7144 /* Enter a group.  This creates a new lang_group_statement, and sets
7145    stat_ptr to build new statements within the group.  */
7146
7147 void
7148 lang_enter_group (void)
7149 {
7150   lang_group_statement_type *g;
7151
7152   g = new_stat (lang_group_statement, stat_ptr);
7153   lang_list_init (&g->children);
7154   push_stat_ptr (&g->children);
7155 }
7156
7157 /* Leave a group.  This just resets stat_ptr to start writing to the
7158    regular list of statements again.  Note that this will not work if
7159    groups can occur inside anything else which can adjust stat_ptr,
7160    but currently they can't.  */
7161
7162 void
7163 lang_leave_group (void)
7164 {
7165   pop_stat_ptr ();
7166 }
7167
7168 /* Add a new program header.  This is called for each entry in a PHDRS
7169    command in a linker script.  */
7170
7171 void
7172 lang_new_phdr (const char *name,
7173                etree_type *type,
7174                bfd_boolean filehdr,
7175                bfd_boolean phdrs,
7176                etree_type *at,
7177                etree_type *flags)
7178 {
7179   struct lang_phdr *n, **pp;
7180   bfd_boolean hdrs;
7181
7182   n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
7183   n->next = NULL;
7184   n->name = name;
7185   n->type = exp_get_value_int (type, 0, "program header type");
7186   n->filehdr = filehdr;
7187   n->phdrs = phdrs;
7188   n->at = at;
7189   n->flags = flags;
7190
7191   hdrs = n->type == 1 && (phdrs || filehdr);
7192
7193   for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
7194     if (hdrs
7195         && (*pp)->type == 1
7196         && !((*pp)->filehdr || (*pp)->phdrs))
7197       {
7198         einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported"
7199                  " when prior PT_LOAD headers lack them\n"), NULL);
7200         hdrs = FALSE;
7201       }
7202
7203   *pp = n;
7204 }
7205
7206 /* Record the program header information in the output BFD.  FIXME: We
7207    should not be calling an ELF specific function here.  */
7208
7209 static void
7210 lang_record_phdrs (void)
7211 {
7212   unsigned int alc;
7213   asection **secs;
7214   lang_output_section_phdr_list *last;
7215   struct lang_phdr *l;
7216   lang_output_section_statement_type *os;
7217
7218   alc = 10;
7219   secs = (asection **) xmalloc (alc * sizeof (asection *));
7220   last = NULL;
7221
7222   for (l = lang_phdr_list; l != NULL; l = l->next)
7223     {
7224       unsigned int c;
7225       flagword flags;
7226       bfd_vma at;
7227
7228       c = 0;
7229       for (os = &lang_output_section_statement.head->output_section_statement;
7230            os != NULL;
7231            os = os->next)
7232         {
7233           lang_output_section_phdr_list *pl;
7234
7235           if (os->constraint < 0)
7236             continue;
7237
7238           pl = os->phdrs;
7239           if (pl != NULL)
7240             last = pl;
7241           else
7242             {
7243               if (os->sectype == noload_section
7244                   || os->bfd_section == NULL
7245                   || (os->bfd_section->flags & SEC_ALLOC) == 0)
7246                 continue;
7247
7248               /* Don't add orphans to PT_INTERP header.  */
7249               if (l->type == 3)
7250                 continue;
7251
7252               if (last == NULL)
7253                 {
7254                   lang_output_section_statement_type * tmp_os;
7255
7256                   /* If we have not run across a section with a program
7257                      header assigned to it yet, then scan forwards to find
7258                      one.  This prevents inconsistencies in the linker's
7259                      behaviour when a script has specified just a single
7260                      header and there are sections in that script which are
7261                      not assigned to it, and which occur before the first
7262                      use of that header. See here for more details:
7263                      http://sourceware.org/ml/binutils/2007-02/msg00291.html  */
7264                   for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)
7265                     if (tmp_os->phdrs)
7266                       {
7267                         last = tmp_os->phdrs;
7268                         break;
7269                       }
7270                   if (last == NULL)
7271                     einfo (_("%F%P: no sections assigned to phdrs\n"));
7272                 }
7273               pl = last;
7274             }
7275
7276           if (os->bfd_section == NULL)
7277             continue;
7278
7279           for (; pl != NULL; pl = pl->next)
7280             {
7281               if (strcmp (pl->name, l->name) == 0)
7282                 {
7283                   if (c >= alc)
7284                     {
7285                       alc *= 2;
7286                       secs = (asection **) xrealloc (secs,
7287                                                      alc * sizeof (asection *));
7288                     }
7289                   secs[c] = os->bfd_section;
7290                   ++c;
7291                   pl->used = TRUE;
7292                 }
7293             }
7294         }
7295
7296       if (l->flags == NULL)
7297         flags = 0;
7298       else
7299         flags = exp_get_vma (l->flags, 0, "phdr flags");
7300
7301       if (l->at == NULL)
7302         at = 0;
7303       else
7304         at = exp_get_vma (l->at, 0, "phdr load address");
7305
7306       if (! bfd_record_phdr (link_info.output_bfd, l->type,
7307                              l->flags != NULL, flags, l->at != NULL,
7308                              at, l->filehdr, l->phdrs, c, secs))
7309         einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
7310     }
7311
7312   free (secs);
7313
7314   /* Make sure all the phdr assignments succeeded.  */
7315   for (os = &lang_output_section_statement.head->output_section_statement;
7316        os != NULL;
7317        os = os->next)
7318     {
7319       lang_output_section_phdr_list *pl;
7320
7321       if (os->constraint < 0
7322           || os->bfd_section == NULL)
7323         continue;
7324
7325       for (pl = os->phdrs;
7326            pl != NULL;
7327            pl = pl->next)
7328         if (! pl->used && strcmp (pl->name, "NONE") != 0)
7329           einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
7330                  os->name, pl->name);
7331     }
7332 }
7333
7334 /* Record a list of sections which may not be cross referenced.  */
7335
7336 void
7337 lang_add_nocrossref (lang_nocrossref_type *l)
7338 {
7339   struct lang_nocrossrefs *n;
7340
7341   n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
7342   n->next = nocrossref_list;
7343   n->list = l;
7344   nocrossref_list = n;
7345
7346   /* Set notice_all so that we get informed about all symbols.  */
7347   link_info.notice_all = TRUE;
7348 }
7349 \f
7350 /* Overlay handling.  We handle overlays with some static variables.  */
7351
7352 /* The overlay virtual address.  */
7353 static etree_type *overlay_vma;
7354 /* And subsection alignment.  */
7355 static etree_type *overlay_subalign;
7356
7357 /* An expression for the maximum section size seen so far.  */
7358 static etree_type *overlay_max;
7359
7360 /* A list of all the sections in this overlay.  */
7361
7362 struct overlay_list {
7363   struct overlay_list *next;
7364   lang_output_section_statement_type *os;
7365 };
7366
7367 static struct overlay_list *overlay_list;
7368
7369 /* Start handling an overlay.  */
7370
7371 void
7372 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
7373 {
7374   /* The grammar should prevent nested overlays from occurring.  */
7375   ASSERT (overlay_vma == NULL
7376           && overlay_subalign == NULL
7377           && overlay_max == NULL);
7378
7379   overlay_vma = vma_expr;
7380   overlay_subalign = subalign;
7381 }
7382
7383 /* Start a section in an overlay.  We handle this by calling
7384    lang_enter_output_section_statement with the correct VMA.
7385    lang_leave_overlay sets up the LMA and memory regions.  */
7386
7387 void
7388 lang_enter_overlay_section (const char *name)
7389 {
7390   struct overlay_list *n;
7391   etree_type *size;
7392
7393   lang_enter_output_section_statement (name, overlay_vma, overlay_section,
7394                                        0, overlay_subalign, 0, 0, 0);
7395
7396   /* If this is the first section, then base the VMA of future
7397      sections on this one.  This will work correctly even if `.' is
7398      used in the addresses.  */
7399   if (overlay_list == NULL)
7400     overlay_vma = exp_nameop (ADDR, name);
7401
7402   /* Remember the section.  */
7403   n = (struct overlay_list *) xmalloc (sizeof *n);
7404   n->os = current_section;
7405   n->next = overlay_list;
7406   overlay_list = n;
7407
7408   size = exp_nameop (SIZEOF, name);
7409
7410   /* Arrange to work out the maximum section end address.  */
7411   if (overlay_max == NULL)
7412     overlay_max = size;
7413   else
7414     overlay_max = exp_binop (MAX_K, overlay_max, size);
7415 }
7416
7417 /* Finish a section in an overlay.  There isn't any special to do
7418    here.  */
7419
7420 void
7421 lang_leave_overlay_section (fill_type *fill,
7422                             lang_output_section_phdr_list *phdrs)
7423 {
7424   const char *name;
7425   char *clean, *s2;
7426   const char *s1;
7427   char *buf;
7428
7429   name = current_section->name;
7430
7431   /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
7432      region and that no load-time region has been specified.  It doesn't
7433      really matter what we say here, since lang_leave_overlay will
7434      override it.  */
7435   lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
7436
7437   /* Define the magic symbols.  */
7438
7439   clean = (char *) xmalloc (strlen (name) + 1);
7440   s2 = clean;
7441   for (s1 = name; *s1 != '\0'; s1++)
7442     if (ISALNUM (*s1) || *s1 == '_')
7443       *s2++ = *s1;
7444   *s2 = '\0';
7445
7446   buf = (char *) xmalloc (strlen (clean) + sizeof "__load_start_");
7447   sprintf (buf, "__load_start_%s", clean);
7448   lang_add_assignment (exp_provide (buf,
7449                                     exp_nameop (LOADADDR, name),
7450                                     FALSE));
7451
7452   buf = (char *) xmalloc (strlen (clean) + sizeof "__load_stop_");
7453   sprintf (buf, "__load_stop_%s", clean);
7454   lang_add_assignment (exp_provide (buf,
7455                                     exp_binop ('+',
7456                                                exp_nameop (LOADADDR, name),
7457                                                exp_nameop (SIZEOF, name)),
7458                                     FALSE));
7459
7460   free (clean);
7461 }
7462
7463 /* Finish an overlay.  If there are any overlay wide settings, this
7464    looks through all the sections in the overlay and sets them.  */
7465
7466 void
7467 lang_leave_overlay (etree_type *lma_expr,
7468                     int nocrossrefs,
7469                     fill_type *fill,
7470                     const char *memspec,
7471                     lang_output_section_phdr_list *phdrs,
7472                     const char *lma_memspec)
7473 {
7474   lang_memory_region_type *region;
7475   lang_memory_region_type *lma_region;
7476   struct overlay_list *l;
7477   lang_nocrossref_type *nocrossref;
7478
7479   lang_get_regions (&region, &lma_region,
7480                     memspec, lma_memspec,
7481                     lma_expr != NULL, FALSE);
7482
7483   nocrossref = NULL;
7484
7485   /* After setting the size of the last section, set '.' to end of the
7486      overlay region.  */
7487   if (overlay_list != NULL)
7488     {
7489       overlay_list->os->update_dot = 1;
7490       overlay_list->os->update_dot_tree
7491         = exp_assign (".", exp_binop ('+', overlay_vma, overlay_max), FALSE);
7492     }
7493
7494   l = overlay_list;
7495   while (l != NULL)
7496     {
7497       struct overlay_list *next;
7498
7499       if (fill != NULL && l->os->fill == NULL)
7500         l->os->fill = fill;
7501
7502       l->os->region = region;
7503       l->os->lma_region = lma_region;
7504
7505       /* The first section has the load address specified in the
7506          OVERLAY statement.  The rest are worked out from that.
7507          The base address is not needed (and should be null) if
7508          an LMA region was specified.  */
7509       if (l->next == 0)
7510         {
7511           l->os->load_base = lma_expr;
7512           l->os->sectype = normal_section;
7513         }
7514       if (phdrs != NULL && l->os->phdrs == NULL)
7515         l->os->phdrs = phdrs;
7516
7517       if (nocrossrefs)
7518         {
7519           lang_nocrossref_type *nc;
7520
7521           nc = (lang_nocrossref_type *) xmalloc (sizeof *nc);
7522           nc->name = l->os->name;
7523           nc->next = nocrossref;
7524           nocrossref = nc;
7525         }
7526
7527       next = l->next;
7528       free (l);
7529       l = next;
7530     }
7531
7532   if (nocrossref != NULL)
7533     lang_add_nocrossref (nocrossref);
7534
7535   overlay_vma = NULL;
7536   overlay_list = NULL;
7537   overlay_max = NULL;
7538 }
7539 \f
7540 /* Version handling.  This is only useful for ELF.  */
7541
7542 /* If PREV is NULL, return first version pattern matching particular symbol.
7543    If PREV is non-NULL, return first version pattern matching particular
7544    symbol after PREV (previously returned by lang_vers_match).  */
7545
7546 static struct bfd_elf_version_expr *
7547 lang_vers_match (struct bfd_elf_version_expr_head *head,
7548                  struct bfd_elf_version_expr *prev,
7549                  const char *sym)
7550 {
7551   const char *c_sym;
7552   const char *cxx_sym = sym;
7553   const char *java_sym = sym;
7554   struct bfd_elf_version_expr *expr = NULL;
7555   enum demangling_styles curr_style;
7556
7557   curr_style = CURRENT_DEMANGLING_STYLE;
7558   cplus_demangle_set_style (no_demangling);
7559   c_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_NO_OPTS);
7560   if (!c_sym)
7561     c_sym = sym;
7562   cplus_demangle_set_style (curr_style);
7563
7564   if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
7565     {
7566       cxx_sym = bfd_demangle (link_info.output_bfd, sym,
7567                               DMGL_PARAMS | DMGL_ANSI);
7568       if (!cxx_sym)
7569         cxx_sym = sym;
7570     }
7571   if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
7572     {
7573       java_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_JAVA);
7574       if (!java_sym)
7575         java_sym = sym;
7576     }
7577
7578   if (head->htab && (prev == NULL || prev->literal))
7579     {
7580       struct bfd_elf_version_expr e;
7581
7582       switch (prev ? prev->mask : 0)
7583         {
7584         case 0:
7585           if (head->mask & BFD_ELF_VERSION_C_TYPE)
7586             {
7587               e.pattern = c_sym;
7588               expr = (struct bfd_elf_version_expr *)
7589                   htab_find ((htab_t) head->htab, &e);
7590               while (expr && strcmp (expr->pattern, c_sym) == 0)
7591                 if (expr->mask == BFD_ELF_VERSION_C_TYPE)
7592                   goto out_ret;
7593                 else
7594                   expr = expr->next;
7595             }
7596           /* Fallthrough */
7597         case BFD_ELF_VERSION_C_TYPE:
7598           if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
7599             {
7600               e.pattern = cxx_sym;
7601               expr = (struct bfd_elf_version_expr *)
7602                   htab_find ((htab_t) head->htab, &e);
7603               while (expr && strcmp (expr->pattern, cxx_sym) == 0)
7604                 if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
7605                   goto out_ret;
7606                 else
7607                   expr = expr->next;
7608             }
7609           /* Fallthrough */
7610         case BFD_ELF_VERSION_CXX_TYPE:
7611           if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
7612             {
7613               e.pattern = java_sym;
7614               expr = (struct bfd_elf_version_expr *)
7615                   htab_find ((htab_t) head->htab, &e);
7616               while (expr && strcmp (expr->pattern, java_sym) == 0)
7617                 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
7618                   goto out_ret;
7619                 else
7620                   expr = expr->next;
7621             }
7622           /* Fallthrough */
7623         default:
7624           break;
7625         }
7626     }
7627
7628   /* Finally, try the wildcards.  */
7629   if (prev == NULL || prev->literal)
7630     expr = head->remaining;
7631   else
7632     expr = prev->next;
7633   for (; expr; expr = expr->next)
7634     {
7635       const char *s;
7636
7637       if (!expr->pattern)
7638         continue;
7639
7640       if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
7641         break;
7642
7643       if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
7644         s = java_sym;
7645       else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
7646         s = cxx_sym;
7647       else
7648         s = c_sym;
7649       if (fnmatch (expr->pattern, s, 0) == 0)
7650         break;
7651     }
7652
7653  out_ret:
7654   if (c_sym != sym)
7655     free ((char *) c_sym);
7656   if (cxx_sym != sym)
7657     free ((char *) cxx_sym);
7658   if (java_sym != sym)
7659     free ((char *) java_sym);
7660   return expr;
7661 }
7662
7663 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7664    return a pointer to the symbol name with any backslash quotes removed.  */
7665
7666 static const char *
7667 realsymbol (const char *pattern)
7668 {
7669   const char *p;
7670   bfd_boolean changed = FALSE, backslash = FALSE;
7671   char *s, *symbol = (char *) xmalloc (strlen (pattern) + 1);
7672
7673   for (p = pattern, s = symbol; *p != '\0'; ++p)
7674     {
7675       /* It is a glob pattern only if there is no preceding
7676          backslash.  */
7677       if (backslash)
7678         {
7679           /* Remove the preceding backslash.  */
7680           *(s - 1) = *p;
7681           backslash = FALSE;
7682           changed = TRUE;
7683         }
7684       else
7685         {
7686           if (*p == '?' || *p == '*' || *p == '[')
7687             {
7688               free (symbol);
7689               return NULL;
7690             }
7691
7692           *s++ = *p;
7693           backslash = *p == '\\';
7694         }
7695     }
7696
7697   if (changed)
7698     {
7699       *s = '\0';
7700       return symbol;
7701     }
7702   else
7703     {
7704       free (symbol);
7705       return pattern;
7706     }
7707 }
7708
7709 /* This is called for each variable name or match expression.  NEW_NAME is
7710    the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7711    pattern to be matched against symbol names.  */
7712
7713 struct bfd_elf_version_expr *
7714 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
7715                        const char *new_name,
7716                        const char *lang,
7717                        bfd_boolean literal_p)
7718 {
7719   struct bfd_elf_version_expr *ret;
7720
7721   ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
7722   ret->next = orig;
7723   ret->symver = 0;
7724   ret->script = 0;
7725   ret->literal = TRUE;
7726   ret->pattern = literal_p ? new_name : realsymbol (new_name);
7727   if (ret->pattern == NULL)
7728     {
7729       ret->pattern = new_name;
7730       ret->literal = FALSE;
7731     }
7732
7733   if (lang == NULL || strcasecmp (lang, "C") == 0)
7734     ret->mask = BFD_ELF_VERSION_C_TYPE;
7735   else if (strcasecmp (lang, "C++") == 0)
7736     ret->mask = BFD_ELF_VERSION_CXX_TYPE;
7737   else if (strcasecmp (lang, "Java") == 0)
7738     ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
7739   else
7740     {
7741       einfo (_("%X%P: unknown language `%s' in version information\n"),
7742              lang);
7743       ret->mask = BFD_ELF_VERSION_C_TYPE;
7744     }
7745
7746   return ldemul_new_vers_pattern (ret);
7747 }
7748
7749 /* This is called for each set of variable names and match
7750    expressions.  */
7751
7752 struct bfd_elf_version_tree *
7753 lang_new_vers_node (struct bfd_elf_version_expr *globals,
7754                     struct bfd_elf_version_expr *locals)
7755 {
7756   struct bfd_elf_version_tree *ret;
7757
7758   ret = (struct bfd_elf_version_tree *) xcalloc (1, sizeof *ret);
7759   ret->globals.list = globals;
7760   ret->locals.list = locals;
7761   ret->match = lang_vers_match;
7762   ret->name_indx = (unsigned int) -1;
7763   return ret;
7764 }
7765
7766 /* This static variable keeps track of version indices.  */
7767
7768 static int version_index;
7769
7770 static hashval_t
7771 version_expr_head_hash (const void *p)
7772 {
7773   const struct bfd_elf_version_expr *e =
7774       (const struct bfd_elf_version_expr *) p;
7775
7776   return htab_hash_string (e->pattern);
7777 }
7778
7779 static int
7780 version_expr_head_eq (const void *p1, const void *p2)
7781 {
7782   const struct bfd_elf_version_expr *e1 =
7783       (const struct bfd_elf_version_expr *) p1;
7784   const struct bfd_elf_version_expr *e2 =
7785       (const struct bfd_elf_version_expr *) p2;
7786
7787   return strcmp (e1->pattern, e2->pattern) == 0;
7788 }
7789
7790 static void
7791 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
7792 {
7793   size_t count = 0;
7794   struct bfd_elf_version_expr *e, *next;
7795   struct bfd_elf_version_expr **list_loc, **remaining_loc;
7796
7797   for (e = head->list; e; e = e->next)
7798     {
7799       if (e->literal)
7800         count++;
7801       head->mask |= e->mask;
7802     }
7803
7804   if (count)
7805     {
7806       head->htab = htab_create (count * 2, version_expr_head_hash,
7807                                 version_expr_head_eq, NULL);
7808       list_loc = &head->list;
7809       remaining_loc = &head->remaining;
7810       for (e = head->list; e; e = next)
7811         {
7812           next = e->next;
7813           if (!e->literal)
7814             {
7815               *remaining_loc = e;
7816               remaining_loc = &e->next;
7817             }
7818           else
7819             {
7820               void **loc = htab_find_slot ((htab_t) head->htab, e, INSERT);
7821
7822               if (*loc)
7823                 {
7824                   struct bfd_elf_version_expr *e1, *last;
7825
7826                   e1 = (struct bfd_elf_version_expr *) *loc;
7827                   last = NULL;
7828                   do
7829                     {
7830                       if (e1->mask == e->mask)
7831                         {
7832                           last = NULL;
7833                           break;
7834                         }
7835                       last = e1;
7836                       e1 = e1->next;
7837                     }
7838                   while (e1 && strcmp (e1->pattern, e->pattern) == 0);
7839
7840                   if (last == NULL)
7841                     {
7842                       /* This is a duplicate.  */
7843                       /* FIXME: Memory leak.  Sometimes pattern is not
7844                          xmalloced alone, but in larger chunk of memory.  */
7845                       /* free (e->pattern); */
7846                       free (e);
7847                     }
7848                   else
7849                     {
7850                       e->next = last->next;
7851                       last->next = e;
7852                     }
7853                 }
7854               else
7855                 {
7856                   *loc = e;
7857                   *list_loc = e;
7858                   list_loc = &e->next;
7859                 }
7860             }
7861         }
7862       *remaining_loc = NULL;
7863       *list_loc = head->remaining;
7864     }
7865   else
7866     head->remaining = head->list;
7867 }
7868
7869 /* This is called when we know the name and dependencies of the
7870    version.  */
7871
7872 void
7873 lang_register_vers_node (const char *name,
7874                          struct bfd_elf_version_tree *version,
7875                          struct bfd_elf_version_deps *deps)
7876 {
7877   struct bfd_elf_version_tree *t, **pp;
7878   struct bfd_elf_version_expr *e1;
7879
7880   if (name == NULL)
7881     name = "";
7882
7883   if (link_info.version_info != NULL
7884       && (name[0] == '\0' || link_info.version_info->name[0] == '\0'))
7885     {
7886       einfo (_("%X%P: anonymous version tag cannot be combined"
7887                " with other version tags\n"));
7888       free (version);
7889       return;
7890     }
7891
7892   /* Make sure this node has a unique name.  */
7893   for (t = link_info.version_info; t != NULL; t = t->next)
7894     if (strcmp (t->name, name) == 0)
7895       einfo (_("%X%P: duplicate version tag `%s'\n"), name);
7896
7897   lang_finalize_version_expr_head (&version->globals);
7898   lang_finalize_version_expr_head (&version->locals);
7899
7900   /* Check the global and local match names, and make sure there
7901      aren't any duplicates.  */
7902
7903   for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
7904     {
7905       for (t = link_info.version_info; t != NULL; t = t->next)
7906         {
7907           struct bfd_elf_version_expr *e2;
7908
7909           if (t->locals.htab && e1->literal)
7910             {
7911               e2 = (struct bfd_elf_version_expr *)
7912                   htab_find ((htab_t) t->locals.htab, e1);
7913               while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
7914                 {
7915                   if (e1->mask == e2->mask)
7916                     einfo (_("%X%P: duplicate expression `%s'"
7917                              " in version information\n"), e1->pattern);
7918                   e2 = e2->next;
7919                 }
7920             }
7921           else if (!e1->literal)
7922             for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
7923               if (strcmp (e1->pattern, e2->pattern) == 0
7924                   && e1->mask == e2->mask)
7925                 einfo (_("%X%P: duplicate expression `%s'"
7926                          " in version information\n"), e1->pattern);
7927         }
7928     }
7929
7930   for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
7931     {
7932       for (t = link_info.version_info; t != NULL; t = t->next)
7933         {
7934           struct bfd_elf_version_expr *e2;
7935
7936           if (t->globals.htab && e1->literal)
7937             {
7938               e2 = (struct bfd_elf_version_expr *)
7939                   htab_find ((htab_t) t->globals.htab, e1);
7940               while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
7941                 {
7942                   if (e1->mask == e2->mask)
7943                     einfo (_("%X%P: duplicate expression `%s'"
7944                              " in version information\n"),
7945                            e1->pattern);
7946                   e2 = e2->next;
7947                 }
7948             }
7949           else if (!e1->literal)
7950             for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
7951               if (strcmp (e1->pattern, e2->pattern) == 0
7952                   && e1->mask == e2->mask)
7953                 einfo (_("%X%P: duplicate expression `%s'"
7954                          " in version information\n"), e1->pattern);
7955         }
7956     }
7957
7958   version->deps = deps;
7959   version->name = name;
7960   if (name[0] != '\0')
7961     {
7962       ++version_index;
7963       version->vernum = version_index;
7964     }
7965   else
7966     version->vernum = 0;
7967
7968   for (pp = &link_info.version_info; *pp != NULL; pp = &(*pp)->next)
7969     ;
7970   *pp = version;
7971 }
7972
7973 /* This is called when we see a version dependency.  */
7974
7975 struct bfd_elf_version_deps *
7976 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
7977 {
7978   struct bfd_elf_version_deps *ret;
7979   struct bfd_elf_version_tree *t;
7980
7981   ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
7982   ret->next = list;
7983
7984   for (t = link_info.version_info; t != NULL; t = t->next)
7985     {
7986       if (strcmp (t->name, name) == 0)
7987         {
7988           ret->version_needed = t;
7989           return ret;
7990         }
7991     }
7992
7993   einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
7994
7995   ret->version_needed = NULL;
7996   return ret;
7997 }
7998
7999 static void
8000 lang_do_version_exports_section (void)
8001 {
8002   struct bfd_elf_version_expr *greg = NULL, *lreg;
8003
8004   LANG_FOR_EACH_INPUT_STATEMENT (is)
8005     {
8006       asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
8007       char *contents, *p;
8008       bfd_size_type len;
8009
8010       if (sec == NULL)
8011         continue;
8012
8013       len = sec->size;
8014       contents = (char *) xmalloc (len);
8015       if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
8016         einfo (_("%X%P: unable to read .exports section contents\n"), sec);
8017
8018       p = contents;
8019       while (p < contents + len)
8020         {
8021           greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
8022           p = strchr (p, '\0') + 1;
8023         }
8024
8025       /* Do not free the contents, as we used them creating the regex.  */
8026
8027       /* Do not include this section in the link.  */
8028       sec->flags |= SEC_EXCLUDE | SEC_KEEP;
8029     }
8030
8031   lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
8032   lang_register_vers_node (command_line.version_exports_section,
8033                            lang_new_vers_node (greg, lreg), NULL);
8034 }
8035
8036 void
8037 lang_add_unique (const char *name)
8038 {
8039   struct unique_sections *ent;
8040
8041   for (ent = unique_section_list; ent; ent = ent->next)
8042     if (strcmp (ent->name, name) == 0)
8043       return;
8044
8045   ent = (struct unique_sections *) xmalloc (sizeof *ent);
8046   ent->name = xstrdup (name);
8047   ent->next = unique_section_list;
8048   unique_section_list = ent;
8049 }
8050
8051 /* Append the list of dynamic symbols to the existing one.  */
8052
8053 void
8054 lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
8055 {
8056   if (link_info.dynamic_list)
8057     {
8058       struct bfd_elf_version_expr *tail;
8059       for (tail = dynamic; tail->next != NULL; tail = tail->next)
8060         ;
8061       tail->next = link_info.dynamic_list->head.list;
8062       link_info.dynamic_list->head.list = dynamic;
8063     }
8064   else
8065     {
8066       struct bfd_elf_dynamic_list *d;
8067
8068       d = (struct bfd_elf_dynamic_list *) xcalloc (1, sizeof *d);
8069       d->head.list = dynamic;
8070       d->match = lang_vers_match;
8071       link_info.dynamic_list = d;
8072     }
8073 }
8074
8075 /* Append the list of C++ typeinfo dynamic symbols to the existing
8076    one.  */
8077
8078 void
8079 lang_append_dynamic_list_cpp_typeinfo (void)
8080 {
8081   const char * symbols [] =
8082     {
8083       "typeinfo name for*",
8084       "typeinfo for*"
8085     };
8086   struct bfd_elf_version_expr *dynamic = NULL;
8087   unsigned int i;
8088
8089   for (i = 0; i < ARRAY_SIZE (symbols); i++)
8090     dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
8091                                      FALSE);
8092
8093   lang_append_dynamic_list (dynamic);
8094 }
8095
8096 /* Append the list of C++ operator new and delete dynamic symbols to the
8097    existing one.  */
8098
8099 void
8100 lang_append_dynamic_list_cpp_new (void)
8101 {
8102   const char * symbols [] =
8103     {
8104       "operator new*",
8105       "operator delete*"
8106     };
8107   struct bfd_elf_version_expr *dynamic = NULL;
8108   unsigned int i;
8109
8110   for (i = 0; i < ARRAY_SIZE (symbols); i++)
8111     dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
8112                                      FALSE);
8113
8114   lang_append_dynamic_list (dynamic);
8115 }
8116
8117 /* Scan a space and/or comma separated string of features.  */
8118
8119 void
8120 lang_ld_feature (char *str)
8121 {
8122   char *p, *q;
8123
8124   p = str;
8125   while (*p)
8126     {
8127       char sep;
8128       while (*p == ',' || ISSPACE (*p))
8129         ++p;
8130       if (!*p)
8131         break;
8132       q = p + 1;
8133       while (*q && *q != ',' && !ISSPACE (*q))
8134         ++q;
8135       sep = *q;
8136       *q = 0;
8137       if (strcasecmp (p, "SANE_EXPR") == 0)
8138         config.sane_expr = TRUE;
8139       else
8140         einfo (_("%X%P: unknown feature `%s'\n"), p);
8141       *q = sep;
8142       p = q;
8143     }
8144 }