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