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