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