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