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