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