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