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