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