1 /* Linker command language support.
2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005
4 Free Software Foundation, Inc.
5
6 This file is part of GLD, the Gnu Linker.
7
8 GLD is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GLD is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GLD; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21 02111-1307, USA. */
22
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include "libiberty.h"
26 #include "safe-ctype.h"
27 #include "obstack.h"
28 #include "bfdlink.h"
29
30 #include "ld.h"
31 #include "ldmain.h"
32 #include "ldexp.h"
33 #include "ldlang.h"
34 #include <ldgram.h>
35 #include "ldlex.h"
36 #include "ldmisc.h"
37 #include "ldctor.h"
38 #include "ldfile.h"
39 #include "ldemul.h"
40 #include "fnmatch.h"
41 #include "demangle.h"
42 #include "hashtab.h"
43
44 #ifndef offsetof
45 #define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
46 #endif
47
48 /* Locals variables. */
49 static struct obstack stat_obstack;
50 static struct obstack map_obstack;
51
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
54 static const char *startup_file;
55 static lang_statement_list_type input_file_chain;
56 static bfd_boolean placed_commons = FALSE;
57 static lang_output_section_statement_type *default_common_section;
58 static bfd_boolean map_option_f;
59 static bfd_vma print_dot;
60 static lang_input_statement_type *first_file;
61 static const char *current_target;
62 static const char *output_target;
63 static lang_statement_list_type statement_list;
64 static struct lang_phdr *lang_phdr_list;
65 static struct bfd_hash_table lang_definedness_table;
66
67 /* Forward declarations. */
68 static void exp_init_os (etree_type *);
69 static void init_map_userdata (bfd *, asection *, void *);
70 static lang_input_statement_type *lookup_name (const char *);
71 static bfd_boolean load_symbols (lang_input_statement_type *,
72 lang_statement_list_type *);
73 static struct bfd_hash_entry *lang_definedness_newfunc
74 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
75 static void insert_undefined (const char *);
76 static void print_all_symbols (asection *);
77 static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
78 static void print_statement (lang_statement_union_type *,
79 lang_output_section_statement_type *);
80 static void print_statement_list (lang_statement_union_type *,
81 lang_output_section_statement_type *);
82 static void print_statements (void);
83 static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
84 static void lang_record_phdrs (void);
85 static void lang_do_version_exports_section (void);
86
87 typedef void (*callback_t) (lang_wild_statement_type *, struct wildcard_list *,
88 asection *, lang_input_statement_type *, void *);
89
90 /* Exported variables. */
91 lang_output_section_statement_type *abs_output_section;
92 lang_statement_list_type lang_output_section_statement;
93 lang_statement_list_type *stat_ptr = &statement_list;
94 lang_statement_list_type file_chain = { NULL, NULL };
95 struct bfd_sym_chain entry_symbol = { NULL, NULL };
96 const char *entry_section = ".text";
97 bfd_boolean entry_from_cmdline;
98 bfd_boolean lang_has_input_file = FALSE;
99 bfd_boolean had_output_filename = FALSE;
100 bfd_boolean lang_float_flag = FALSE;
101 bfd_boolean delete_output_file_on_failure = FALSE;
102 struct lang_nocrossrefs *nocrossref_list;
103 struct unique_sections *unique_section_list;
104 static bfd_boolean ldlang_sysrooted_script = FALSE;
105 int lang_statement_iteration = 0;
106
107 etree_type *base; /* Relocation base - or null */
108
109 /* Return TRUE if the PATTERN argument is a wildcard pattern.
110 Although backslashes are treated specially if a pattern contains
111 wildcards, we do not consider the mere presence of a backslash to
112 be enough to cause the pattern to be treated as a wildcard.
113 That lets us handle DOS filenames more naturally. */
114 #define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
115
116 #define new_stat(x, y) \
117 (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
118
119 #define outside_section_address(q) \
120 ((q)->output_offset + (q)->output_section->vma)
121
122 #define outside_symbol_address(q) \
123 ((q)->value + outside_section_address (q->section))
124
125 #define SECTION_NAME_MAP_LENGTH (16)
126
127 void *
stat_alloc(size_t size)128 stat_alloc (size_t size)
129 {
130 return obstack_alloc (&stat_obstack, size);
131 }
132
133 bfd_boolean
unique_section_p(const asection * sec)134 unique_section_p (const asection *sec)
135 {
136 struct unique_sections *unam;
137 const char *secnam;
138
139 if (link_info.relocatable
140 && sec->owner != NULL
141 && bfd_is_group_section (sec->owner, sec))
142 return TRUE;
143
144 secnam = sec->name;
145 for (unam = unique_section_list; unam; unam = unam->next)
146 if (wildcardp (unam->name)
147 ? fnmatch (unam->name, secnam, 0) == 0
148 : strcmp (unam->name, secnam) == 0)
149 {
150 return TRUE;
151 }
152
153 return FALSE;
154 }
155
156 /* Generic traversal routines for finding matching sections. */
157
158 static void
walk_wild_section(lang_wild_statement_type * ptr,lang_input_statement_type * file,callback_t callback,void * data)159 walk_wild_section (lang_wild_statement_type *ptr,
160 lang_input_statement_type *file,
161 callback_t callback,
162 void *data)
163 {
164 asection *s;
165
166 if (file->just_syms_flag)
167 return;
168
169 for (s = file->the_bfd->sections; s != NULL; s = s->next)
170 {
171 struct wildcard_list *sec;
172
173 sec = ptr->section_list;
174 if (sec == NULL)
175 (*callback) (ptr, sec, s, file, data);
176
177 while (sec != NULL)
178 {
179 bfd_boolean skip = FALSE;
180 struct name_list *list_tmp;
181
182 /* Don't process sections from files which were
183 excluded. */
184 for (list_tmp = sec->spec.exclude_name_list;
185 list_tmp;
186 list_tmp = list_tmp->next)
187 {
188 if (wildcardp (list_tmp->name))
189 skip = fnmatch (list_tmp->name, file->filename, 0) == 0;
190 else
191 skip = strcmp (list_tmp->name, file->filename) == 0;
192
193 /* If this file is part of an archive, and the archive is
194 excluded, exclude this file. */
195 if (! skip && file->the_bfd != NULL
196 && file->the_bfd->my_archive != NULL
197 && file->the_bfd->my_archive->filename != NULL)
198 {
199 if (wildcardp (list_tmp->name))
200 skip = fnmatch (list_tmp->name,
201 file->the_bfd->my_archive->filename,
202 0) == 0;
203 else
204 skip = strcmp (list_tmp->name,
205 file->the_bfd->my_archive->filename) == 0;
206 }
207
208 if (skip)
209 break;
210 }
211
212 if (!skip && sec->spec.name != NULL)
213 {
214 const char *sname = bfd_get_section_name (file->the_bfd, s);
215
216 if (wildcardp (sec->spec.name))
217 skip = fnmatch (sec->spec.name, sname, 0) != 0;
218 else
219 skip = strcmp (sec->spec.name, sname) != 0;
220 }
221
222 if (!skip)
223 (*callback) (ptr, sec, s, file, data);
224
225 sec = sec->next;
226 }
227 }
228 }
229
230 /* Handle a wild statement for a single file F. */
231
232 static void
walk_wild_file(lang_wild_statement_type * s,lang_input_statement_type * f,callback_t callback,void * data)233 walk_wild_file (lang_wild_statement_type *s,
234 lang_input_statement_type *f,
235 callback_t callback,
236 void *data)
237 {
238 if (f->the_bfd == NULL
239 || ! bfd_check_format (f->the_bfd, bfd_archive))
240 walk_wild_section (s, f, callback, data);
241 else
242 {
243 bfd *member;
244
245 /* This is an archive file. We must map each member of the
246 archive separately. */
247 member = bfd_openr_next_archived_file (f->the_bfd, NULL);
248 while (member != NULL)
249 {
250 /* When lookup_name is called, it will call the add_symbols
251 entry point for the archive. For each element of the
252 archive which is included, BFD will call ldlang_add_file,
253 which will set the usrdata field of the member to the
254 lang_input_statement. */
255 if (member->usrdata != NULL)
256 {
257 walk_wild_section (s, member->usrdata, callback, data);
258 }
259
260 member = bfd_openr_next_archived_file (f->the_bfd, member);
261 }
262 }
263 }
264
265 static void
walk_wild(lang_wild_statement_type * s,callback_t callback,void * data)266 walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
267 {
268 const char *file_spec = s->filename;
269
270 if (file_spec == NULL)
271 {
272 /* Perform the iteration over all files in the list. */
273 LANG_FOR_EACH_INPUT_STATEMENT (f)
274 {
275 walk_wild_file (s, f, callback, data);
276 }
277 }
278 else if (wildcardp (file_spec))
279 {
280 LANG_FOR_EACH_INPUT_STATEMENT (f)
281 {
282 if (fnmatch (file_spec, f->filename, FNM_FILE_NAME) == 0)
283 walk_wild_file (s, f, callback, data);
284 }
285 }
286 else
287 {
288 lang_input_statement_type *f;
289
290 /* Perform the iteration over a single file. */
291 f = lookup_name (file_spec);
292 if (f)
293 walk_wild_file (s, f, callback, data);
294 }
295 }
296
297 /* lang_for_each_statement walks the parse tree and calls the provided
298 function for each node. */
299
300 static void
lang_for_each_statement_worker(void (* func)(lang_statement_union_type *),lang_statement_union_type * s)301 lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
302 lang_statement_union_type *s)
303 {
304 for (; s != NULL; s = s->header.next)
305 {
306 func (s);
307
308 switch (s->header.type)
309 {
310 case lang_constructors_statement_enum:
311 lang_for_each_statement_worker (func, constructor_list.head);
312 break;
313 case lang_output_section_statement_enum:
314 lang_for_each_statement_worker
315 (func, s->output_section_statement.children.head);
316 break;
317 case lang_wild_statement_enum:
318 lang_for_each_statement_worker (func,
319 s->wild_statement.children.head);
320 break;
321 case lang_group_statement_enum:
322 lang_for_each_statement_worker (func,
323 s->group_statement.children.head);
324 break;
325 case lang_data_statement_enum:
326 case lang_reloc_statement_enum:
327 case lang_object_symbols_statement_enum:
328 case lang_output_statement_enum:
329 case lang_target_statement_enum:
330 case lang_input_section_enum:
331 case lang_input_statement_enum:
332 case lang_assignment_statement_enum:
333 case lang_padding_statement_enum:
334 case lang_address_statement_enum:
335 case lang_fill_statement_enum:
336 break;
337 default:
338 FAIL ();
339 break;
340 }
341 }
342 }
343
344 void
lang_for_each_statement(void (* func)(lang_statement_union_type *))345 lang_for_each_statement (void (*func) (lang_statement_union_type *))
346 {
347 lang_for_each_statement_worker (func, statement_list.head);
348 }
349
350 /*----------------------------------------------------------------------*/
351
352 void
lang_list_init(lang_statement_list_type * list)353 lang_list_init (lang_statement_list_type *list)
354 {
355 list->head = NULL;
356 list->tail = &list->head;
357 }
358
359 /* Build a new statement node for the parse tree. */
360
361 static lang_statement_union_type *
new_statement(enum statement_enum type,size_t size,lang_statement_list_type * list)362 new_statement (enum statement_enum type,
363 size_t size,
364 lang_statement_list_type *list)
365 {
366 lang_statement_union_type *new;
367
368 new = stat_alloc (size);
369 new->header.type = type;
370 new->header.next = NULL;
371 lang_statement_append (list, new, &new->header.next);
372 return new;
373 }
374
375 /* Build a new input file node for the language. There are several
376 ways in which we treat an input file, eg, we only look at symbols,
377 or prefix it with a -l etc.
378
379 We can be supplied with requests for input files more than once;
380 they may, for example be split over several lines like foo.o(.text)
381 foo.o(.data) etc, so when asked for a file we check that we haven't
382 got it already so we don't duplicate the bfd. */
383
384 static lang_input_statement_type *
new_afile(const char * name,lang_input_file_enum_type file_type,const char * target,bfd_boolean add_to_list)385 new_afile (const char *name,
386 lang_input_file_enum_type file_type,
387 const char *target,
388 bfd_boolean add_to_list)
389 {
390 lang_input_statement_type *p;
391
392 if (add_to_list)
393 p = new_stat (lang_input_statement, stat_ptr);
394 else
395 {
396 p = stat_alloc (sizeof (lang_input_statement_type));
397 p->header.next = NULL;
398 }
399
400 lang_has_input_file = TRUE;
401 p->target = target;
402 p->sysrooted = FALSE;
403 switch (file_type)
404 {
405 case lang_input_file_is_symbols_only_enum:
406 p->filename = name;
407 p->is_archive = FALSE;
408 p->real = TRUE;
409 p->local_sym_name = name;
410 p->just_syms_flag = TRUE;
411 p->search_dirs_flag = FALSE;
412 break;
413 case lang_input_file_is_fake_enum:
414 p->filename = name;
415 p->is_archive = FALSE;
416 p->real = FALSE;
417 p->local_sym_name = name;
418 p->just_syms_flag = FALSE;
419 p->search_dirs_flag = FALSE;
420 break;
421 case lang_input_file_is_l_enum:
422 p->is_archive = TRUE;
423 p->filename = name;
424 p->real = TRUE;
425 p->local_sym_name = concat ("-l", name, NULL);
426 p->just_syms_flag = FALSE;
427 p->search_dirs_flag = TRUE;
428 break;
429 case lang_input_file_is_marker_enum:
430 p->filename = name;
431 p->is_archive = FALSE;
432 p->real = FALSE;
433 p->local_sym_name = name;
434 p->just_syms_flag = FALSE;
435 p->search_dirs_flag = TRUE;
436 break;
437 case lang_input_file_is_search_file_enum:
438 p->sysrooted = ldlang_sysrooted_script;
439 p->filename = name;
440 p->is_archive = FALSE;
441 p->real = TRUE;
442 p->local_sym_name = name;
443 p->just_syms_flag = FALSE;
444 p->search_dirs_flag = TRUE;
445 break;
446 case lang_input_file_is_file_enum:
447 p->filename = name;
448 p->is_archive = FALSE;
449 p->real = TRUE;
450 p->local_sym_name = name;
451 p->just_syms_flag = FALSE;
452 p->search_dirs_flag = FALSE;
453 break;
454 default:
455 FAIL ();
456 }
457 p->the_bfd = NULL;
458 p->asymbols = NULL;
459 p->next_real_file = NULL;
460 p->next = NULL;
461 p->symbol_count = 0;
462 p->dynamic = config.dynamic_link;
463 p->add_needed = add_needed;
464 p->as_needed = as_needed;
465 p->whole_archive = whole_archive;
466 p->loaded = FALSE;
467 lang_statement_append (&input_file_chain,
468 (lang_statement_union_type *) p,
469 &p->next_real_file);
470 return p;
471 }
472
473 lang_input_statement_type *
lang_add_input_file(const char * name,lang_input_file_enum_type file_type,const char * target)474 lang_add_input_file (const char *name,
475 lang_input_file_enum_type file_type,
476 const char *target)
477 {
478 lang_has_input_file = TRUE;
479 return new_afile (name, file_type, target, TRUE);
480 }
481
482 /* Build enough state so that the parser can build its tree. */
483
484 void
lang_init(void)485 lang_init (void)
486 {
487 obstack_begin (&stat_obstack, 1000);
488
489 stat_ptr = &statement_list;
490
491 lang_list_init (stat_ptr);
492
493 lang_list_init (&input_file_chain);
494 lang_list_init (&lang_output_section_statement);
495 lang_list_init (&file_chain);
496 first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
497 NULL);
498 abs_output_section =
499 lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
500
501 abs_output_section->bfd_section = bfd_abs_section_ptr;
502
503 /* The value "3" is ad-hoc, somewhat related to the expected number of
504 DEFINED expressions in a linker script. For most default linker
505 scripts, there are none. Why a hash table then? Well, it's somewhat
506 simpler to re-use working machinery than using a linked list in terms
507 of code-complexity here in ld, besides the initialization which just
508 looks like other code here. */
509 if (!bfd_hash_table_init_n (&lang_definedness_table,
510 lang_definedness_newfunc, 3))
511 einfo (_("%P%F: out of memory during initialization"));
512
513 /* Callers of exp_fold_tree need to increment this. */
514 lang_statement_iteration = 0;
515 }
516
517 /*----------------------------------------------------------------------
518 A region is an area of memory declared with the
519 MEMORY { name:org=exp, len=exp ... }
520 syntax.
521
522 We maintain a list of all the regions here.
523
524 If no regions are specified in the script, then the default is used
525 which is created when looked up to be the entire data space.
526
527 If create is true we are creating a region inside a MEMORY block.
528 In this case it is probably an error to create a region that has
529 already been created. If we are not inside a MEMORY block it is
530 dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
531 and so we issue a warning. */
532
533 static lang_memory_region_type *lang_memory_region_list;
534 static lang_memory_region_type **lang_memory_region_list_tail
535 = &lang_memory_region_list;
536
537 lang_memory_region_type *
lang_memory_region_lookup(const char * const name,bfd_boolean create)538 lang_memory_region_lookup (const char *const name, bfd_boolean create)
539 {
540 lang_memory_region_type *p;
541 lang_memory_region_type *new;
542
543 /* NAME is NULL for LMA memspecs if no region was specified. */
544 if (name == NULL)
545 return NULL;
546
547 for (p = lang_memory_region_list; p != NULL; p = p->next)
548 if (strcmp (p->name, name) == 0)
549 {
550 if (create)
551 einfo (_("%P:%S: warning: redeclaration of memory region '%s'\n"),
552 name);
553 return p;
554 }
555
556 if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
557 einfo (_("%P:%S: warning: memory region %s not declared\n"), name);
558
559 new = stat_alloc (sizeof (lang_memory_region_type));
560
561 new->name = xstrdup (name);
562 new->next = NULL;
563
564 *lang_memory_region_list_tail = new;
565 lang_memory_region_list_tail = &new->next;
566 new->origin = 0;
567 new->flags = 0;
568 new->not_flags = 0;
569 new->length = ~(bfd_size_type) 0;
570 new->current = 0;
571 new->had_full_message = FALSE;
572
573 return new;
574 }
575
576 static lang_memory_region_type *
lang_memory_default(asection * section)577 lang_memory_default (asection *section)
578 {
579 lang_memory_region_type *p;
580
581 flagword sec_flags = section->flags;
582
583 /* Override SEC_DATA to mean a writable section. */
584 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
585 sec_flags |= SEC_DATA;
586
587 for (p = lang_memory_region_list; p != NULL; p = p->next)
588 {
589 if ((p->flags & sec_flags) != 0
590 && (p->not_flags & sec_flags) == 0)
591 {
592 return p;
593 }
594 }
595 return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
596 }
597
598 static lang_output_section_statement_type *
lang_output_section_find_1(const char * const name,int constraint)599 lang_output_section_find_1 (const char *const name, int constraint)
600 {
601 lang_output_section_statement_type *lookup;
602
603 for (lookup = &lang_output_section_statement.head->output_section_statement;
604 lookup != NULL;
605 lookup = lookup->next)
606 {
607 if (strcmp (name, lookup->name) == 0
608 && lookup->constraint != -1
609 && (constraint == 0 || constraint == lookup->constraint))
610 return lookup;
611 }
612 return NULL;
613 }
614
615 lang_output_section_statement_type *
lang_output_section_find(const char * const name)616 lang_output_section_find (const char *const name)
617 {
618 return lang_output_section_find_1 (name, 0);
619 }
620
621 static lang_output_section_statement_type *
lang_output_section_statement_lookup_1(const char * const name,int constraint)622 lang_output_section_statement_lookup_1 (const char *const name, int constraint)
623 {
624 lang_output_section_statement_type *lookup;
625
626 lookup = lang_output_section_find_1 (name, constraint);
627 if (lookup == NULL)
628 {
629 lookup = new_stat (lang_output_section_statement, stat_ptr);
630 lookup->region = NULL;
631 lookup->lma_region = NULL;
632 lookup->fill = 0;
633 lookup->block_value = 1;
634 lookup->name = name;
635
636 lookup->next = NULL;
637 lookup->bfd_section = NULL;
638 lookup->processed = 0;
639 lookup->constraint = constraint;
640 lookup->sectype = normal_section;
641 lookup->addr_tree = NULL;
642 lang_list_init (&lookup->children);
643
644 lookup->memspec = NULL;
645 lookup->flags = 0;
646 lookup->subsection_alignment = -1;
647 lookup->section_alignment = -1;
648 lookup->load_base = NULL;
649 lookup->update_dot_tree = NULL;
650 lookup->phdrs = NULL;
651
652 lang_statement_append (&lang_output_section_statement,
653 (lang_statement_union_type *) lookup,
654 (lang_statement_union_type **) &lookup->next);
655 }
656 return lookup;
657 }
658
659 lang_output_section_statement_type *
lang_output_section_statement_lookup(const char * const name)660 lang_output_section_statement_lookup (const char *const name)
661 {
662 return lang_output_section_statement_lookup_1 (name, 0);
663 }
664
665 /* A variant of lang_output_section_find used by place_orphan.
666 Returns the output statement that should precede a new output
667 statement for SEC. If an exact match is found on certain flags,
668 sets *EXACT too. */
669
670 lang_output_section_statement_type *
lang_output_section_find_by_flags(const asection * sec,lang_output_section_statement_type ** exact)671 lang_output_section_find_by_flags (const asection *sec,
672 lang_output_section_statement_type **exact)
673 {
674 lang_output_section_statement_type *first, *look, *found;
675 flagword flags;
676
677 /* We know the first statement on this list is *ABS*. May as well
678 skip it. */
679 first = &lang_output_section_statement.head->output_section_statement;
680 first = first->next;
681
682 /* First try for an exact match. */
683 found = NULL;
684 for (look = first; look; look = look->next)
685 {
686 flags = look->flags;
687 if (look->bfd_section != NULL)
688 flags = look->bfd_section->flags;
689 flags ^= sec->flags;
690 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
691 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
692 found = look;
693 }
694 if (found != NULL)
695 {
696 *exact = found;
697 return found;
698 }
699
700 if (sec->flags & SEC_CODE)
701 {
702 /* Try for a rw code section. */
703 for (look = first; look; look = look->next)
704 {
705 flags = look->flags;
706 if (look->bfd_section != NULL)
707 flags = look->bfd_section->flags;
708 flags ^= sec->flags;
709 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
710 | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
711 found = look;
712 }
713 return found;
714 }
715
716 if (sec->flags & (SEC_READONLY | SEC_THREAD_LOCAL))
717 {
718 /* .rodata can go after .text, .sdata2 after .rodata. */
719 for (look = first; look; look = look->next)
720 {
721 flags = look->flags;
722 if (look->bfd_section != NULL)
723 flags = look->bfd_section->flags;
724 flags ^= sec->flags;
725 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
726 | SEC_READONLY))
727 && !(look->flags & (SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
728 found = look;
729 }
730 return found;
731 }
732
733 if (sec->flags & SEC_SMALL_DATA)
734 {
735 /* .sdata goes after .data, .sbss after .sdata. */
736 for (look = first; look; look = look->next)
737 {
738 flags = look->flags;
739 if (look->bfd_section != NULL)
740 flags = look->bfd_section->flags;
741 flags ^= sec->flags;
742 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
743 | SEC_THREAD_LOCAL))
744 || ((look->flags & SEC_SMALL_DATA)
745 && !(sec->flags & SEC_HAS_CONTENTS)))
746 found = look;
747 }
748 return found;
749 }
750
751 if (sec->flags & SEC_HAS_CONTENTS)
752 {
753 /* .data goes after .rodata. */
754 for (look = first; look; look = look->next)
755 {
756 flags = look->flags;
757 if (look->bfd_section != NULL)
758 flags = look->bfd_section->flags;
759 flags ^= sec->flags;
760 if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
761 | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
762 found = look;
763 }
764 return found;
765 }
766
767 /* .bss goes last. */
768 for (look = first; look; look = look->next)
769 {
770 flags = look->flags;
771 if (look->bfd_section != NULL)
772 flags = look->bfd_section->flags;
773 flags ^= sec->flags;
774 if (!(flags & SEC_ALLOC))
775 found = look;
776 }
777
778 return found;
779 }
780
781 /* Find the last output section before given output statement.
782 Used by place_orphan. */
783
784 static asection *
output_prev_sec_find(lang_output_section_statement_type * os)785 output_prev_sec_find (lang_output_section_statement_type *os)
786 {
787 asection *s = (asection *) NULL;
788 lang_output_section_statement_type *lookup;
789
790 for (lookup = &lang_output_section_statement.head->output_section_statement;
791 lookup != NULL;
792 lookup = lookup->next)
793 {
794 if (lookup->constraint == -1)
795 continue;
796 if (lookup == os)
797 return s;
798
799 if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
800 s = lookup->bfd_section;
801 }
802
803 return NULL;
804 }
805
806 lang_output_section_statement_type *
lang_insert_orphan(lang_input_statement_type * file,asection * s,const char * secname,lang_output_section_statement_type * after,struct orphan_save * place,etree_type * address,lang_statement_list_type * add_child)807 lang_insert_orphan (lang_input_statement_type *file,
808 asection *s,
809 const char *secname,
810 lang_output_section_statement_type *after,
811 struct orphan_save *place,
812 etree_type *address,
813 lang_statement_list_type *add_child)
814 {
815 lang_statement_list_type *old;
816 lang_statement_list_type add;
817 const char *ps;
818 etree_type *load_base;
819 lang_output_section_statement_type *os;
820 lang_output_section_statement_type **os_tail;
821
822 /* Start building a list of statements for this section.
823 First save the current statement pointer. */
824 old = stat_ptr;
825
826 /* If we have found an appropriate place for the output section
827 statements for this orphan, add them to our own private list,
828 inserting them later into the global statement list. */
829 if (after != NULL)
830 {
831 stat_ptr = &add;
832 lang_list_init (stat_ptr);
833 }
834
835 ps = NULL;
836 if (config.build_constructors)
837 {
838 /* If the name of the section is representable in C, then create
839 symbols to mark the start and the end of the section. */
840 for (ps = secname; *ps != '\0'; ps++)
841 if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
842 break;
843 if (*ps == '\0')
844 {
845 char *symname;
846 etree_type *e_align;
847
848 symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
849 symname[0] = bfd_get_symbol_leading_char (output_bfd);
850 sprintf (symname + (symname[0] != 0), "__start_%s", secname);
851 e_align = exp_unop (ALIGN_K,
852 exp_intop ((bfd_vma) 1 << s->alignment_power));
853 lang_add_assignment (exp_assop ('=', ".", e_align));
854 lang_add_assignment (exp_assop ('=', symname,
855 exp_nameop (NAME, ".")));
856 }
857 }
858
859 if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
860 address = exp_intop (0);
861
862 load_base = NULL;
863 if (after != NULL && after->load_base != NULL)
864 {
865 etree_type *lma_from_vma;
866 lma_from_vma = exp_binop ('-', after->load_base,
867 exp_nameop (ADDR, after->name));
868 load_base = exp_binop ('+', lma_from_vma,
869 exp_nameop (ADDR, secname));
870 }
871
872 os_tail = ((lang_output_section_statement_type **)
873 lang_output_section_statement.tail);
874 os = lang_enter_output_section_statement (secname, address, 0, NULL, NULL,
875 load_base, 0);
876
877 if (add_child == NULL)
878 add_child = &os->children;
879 lang_add_section (add_child, s, os, file);
880
881 lang_leave_output_section_statement (0, "*default*", NULL, NULL);
882
883 if (config.build_constructors && *ps == '\0')
884 {
885 char *symname;
886
887 /* lang_leave_ouput_section_statement resets stat_ptr.
888 Put stat_ptr back where we want it. */
889 if (after != NULL)
890 stat_ptr = &add;
891
892 symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
893 symname[0] = bfd_get_symbol_leading_char (output_bfd);
894 sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
895 lang_add_assignment (exp_assop ('=', symname,
896 exp_nameop (NAME, ".")));
897 }
898
899 /* Restore the global list pointer. */
900 if (after != NULL)
901 stat_ptr = old;
902
903 if (after != NULL && os->bfd_section != NULL)
904 {
905 asection *snew, **pps;
906
907 snew = os->bfd_section;
908
909 /* Shuffle the bfd section list to make the output file look
910 neater. This is really only cosmetic. */
911 if (place->section == NULL
912 && after != (&lang_output_section_statement.head
913 ->output_section_statement))
914 {
915 asection *bfd_section = after->bfd_section;
916
917 /* If the output statement hasn't been used to place any input
918 sections (and thus doesn't have an output bfd_section),
919 look for the closest prior output statement having an
920 output section. */
921 if (bfd_section == NULL)
922 bfd_section = output_prev_sec_find (after);
923
924 if (bfd_section != NULL && bfd_section != snew)
925 place->section = &bfd_section->next;
926 }
927
928 if (place->section == NULL)
929 place->section = &output_bfd->sections;
930
931 /* Unlink the section. */
932 for (pps = &output_bfd->sections; *pps != snew; pps = &(*pps)->next)
933 continue;
934 bfd_section_list_remove (output_bfd, pps);
935
936 /* Now tack it back on in the right place. */
937 bfd_section_list_insert (output_bfd, place->section, snew);
938
939 /* Save the end of this list. Further ophans of this type will
940 follow the one we've just added. */
941 place->section = &snew->next;
942
943 /* The following is non-cosmetic. We try to put the output
944 statements in some sort of reasonable order here, because they
945 determine the final load addresses of the orphan sections.
946 In addition, placing output statements in the wrong order may
947 require extra segments. For instance, given a typical
948 situation of all read-only sections placed in one segment and
949 following that a segment containing all the read-write
950 sections, we wouldn't want to place an orphan read/write
951 section before or amongst the read-only ones. */
952 if (add.head != NULL)
953 {
954 lang_output_section_statement_type *newly_added_os;
955
956 if (place->stmt == NULL)
957 {
958 lang_statement_union_type **where;
959 lang_statement_union_type **assign = NULL;
960
961 /* Look for a suitable place for the new statement list.
962 The idea is to skip over anything that might be inside
963 a SECTIONS {} statement in a script, before we find
964 another output_section_statement. Assignments to "dot"
965 before an output section statement are assumed to
966 belong to it. */
967 for (where = &after->header.next;
968 *where != NULL;
969 where = &(*where)->header.next)
970 {
971 switch ((*where)->header.type)
972 {
973 case lang_assignment_statement_enum:
974 if (assign == NULL)
975 {
976 lang_assignment_statement_type *ass;
977 ass = &(*where)->assignment_statement;
978 if (ass->exp->type.node_class != etree_assert
979 && ass->exp->assign.dst[0] == '.'
980 && ass->exp->assign.dst[1] == 0)
981 assign = where;
982 }
983 continue;
984 case lang_wild_statement_enum:
985 case lang_input_section_enum:
986 case lang_object_symbols_statement_enum:
987 case lang_fill_statement_enum:
988 case lang_data_statement_enum:
989 case lang_reloc_statement_enum:
990 case lang_padding_statement_enum:
991 case lang_constructors_statement_enum:
992 assign = NULL;
993 continue;
994 case lang_output_section_statement_enum:
995 if (assign != NULL)
996 where = assign;
997 case lang_input_statement_enum:
998 case lang_address_statement_enum:
999 case lang_target_statement_enum:
1000 case lang_output_statement_enum:
1001 case lang_group_statement_enum:
1002 case lang_afile_asection_pair_statement_enum:
1003 break;
1004 }
1005 break;
1006 }
1007
1008 *add.tail = *where;
1009 *where = add.head;
1010
1011 place->os_tail = &after->next;
1012 }
1013 else
1014 {
1015 /* Put it after the last orphan statement we added. */
1016 *add.tail = *place->stmt;
1017 *place->stmt = add.head;
1018 }
1019
1020 /* Fix the global list pointer if we happened to tack our
1021 new list at the tail. */
1022 if (*old->tail == add.head)
1023 old->tail = add.tail;
1024
1025 /* Save the end of this list. */
1026 place->stmt = add.tail;
1027
1028 /* Do the same for the list of output section statements. */
1029 newly_added_os = *os_tail;
1030 *os_tail = NULL;
1031 newly_added_os->next = *place->os_tail;
1032 *place->os_tail = newly_added_os;
1033 place->os_tail = &newly_added_os->next;
1034
1035 /* Fixing the global list pointer here is a little different.
1036 We added to the list in lang_enter_output_section_statement,
1037 trimmed off the new output_section_statment above when
1038 assigning *os_tail = NULL, but possibly added it back in
1039 the same place when assigning *place->os_tail. */
1040 if (*os_tail == NULL)
1041 lang_output_section_statement.tail
1042 = (lang_statement_union_type **) os_tail;
1043 }
1044 }
1045 return os;
1046 }
1047
1048 static void
lang_map_flags(flagword flag)1049 lang_map_flags (flagword flag)
1050 {
1051 if (flag & SEC_ALLOC)
1052 minfo ("a");
1053
1054 if (flag & SEC_CODE)
1055 minfo ("x");
1056
1057 if (flag & SEC_READONLY)
1058 minfo ("r");
1059
1060 if (flag & SEC_DATA)
1061 minfo ("w");
1062
1063 if (flag & SEC_LOAD)
1064 minfo ("l");
1065 }
1066
1067 void
lang_map(void)1068 lang_map (void)
1069 {
1070 lang_memory_region_type *m;
1071 bfd *p;
1072
1073 minfo (_("\nMemory Configuration\n\n"));
1074 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
1075 _("Name"), _("Origin"), _("Length"), _("Attributes"));
1076
1077 for (m = lang_memory_region_list; m != NULL; m = m->next)
1078 {
1079 char buf[100];
1080 int len;
1081
1082 fprintf (config.map_file, "%-16s ", m->name);
1083
1084 sprintf_vma (buf, m->origin);
1085 minfo ("0x%s ", buf);
1086 len = strlen (buf);
1087 while (len < 16)
1088 {
1089 print_space ();
1090 ++len;
1091 }
1092
1093 minfo ("0x%V", m->length);
1094 if (m->flags || m->not_flags)
1095 {
1096 #ifndef BFD64
1097 minfo (" ");
1098 #endif
1099 if (m->flags)
1100 {
1101 print_space ();
1102 lang_map_flags (m->flags);
1103 }
1104
1105 if (m->not_flags)
1106 {
1107 minfo (" !");
1108 lang_map_flags (m->not_flags);
1109 }
1110 }
1111
1112 print_nl ();
1113 }
1114
1115 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
1116
1117 if (! command_line.reduce_memory_overheads)
1118 {
1119 obstack_begin (&map_obstack, 1000);
1120 for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
1121 bfd_map_over_sections (p, init_map_userdata, 0);
1122 bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
1123 }
1124 print_statements ();
1125 }
1126
1127 static void
init_map_userdata(abfd,sec,data)1128 init_map_userdata (abfd, sec, data)
1129 bfd *abfd ATTRIBUTE_UNUSED;
1130 asection *sec;
1131 void *data ATTRIBUTE_UNUSED;
1132 {
1133 fat_section_userdata_type *new_data
1134 = ((fat_section_userdata_type *) (stat_alloc
1135 (sizeof (fat_section_userdata_type))));
1136
1137 ASSERT (get_userdata (sec) == NULL);
1138 get_userdata (sec) = new_data;
1139 new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
1140 }
1141
1142 static bfd_boolean
sort_def_symbol(hash_entry,info)1143 sort_def_symbol (hash_entry, info)
1144 struct bfd_link_hash_entry *hash_entry;
1145 void *info ATTRIBUTE_UNUSED;
1146 {
1147 if (hash_entry->type == bfd_link_hash_defined
1148 || hash_entry->type == bfd_link_hash_defweak)
1149 {
1150 struct fat_user_section_struct *ud;
1151 struct map_symbol_def *def;
1152
1153 ud = get_userdata (hash_entry->u.def.section);
1154 if (! ud)
1155 {
1156 /* ??? What do we have to do to initialize this beforehand? */
1157 /* The first time we get here is bfd_abs_section... */
1158 init_map_userdata (0, hash_entry->u.def.section, 0);
1159 ud = get_userdata (hash_entry->u.def.section);
1160 }
1161 else if (!ud->map_symbol_def_tail)
1162 ud->map_symbol_def_tail = &ud->map_symbol_def_head;
1163
1164 def = obstack_alloc (&map_obstack, sizeof *def);
1165 def->entry = hash_entry;
1166 *(ud->map_symbol_def_tail) = def;
1167 ud->map_symbol_def_tail = &def->next;
1168 }
1169 return TRUE;
1170 }
1171
1172 /* Initialize an output section. */
1173
1174 static void
init_os(lang_output_section_statement_type * s)1175 init_os (lang_output_section_statement_type *s)
1176 {
1177 lean_section_userdata_type *new;
1178
1179 if (s->bfd_section != NULL)
1180 return;
1181
1182 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
1183 einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
1184
1185 new = stat_alloc (SECTION_USERDATA_SIZE);
1186 memset (new, 0, SECTION_USERDATA_SIZE);
1187
1188 s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
1189 if (s->bfd_section == NULL)
1190 s->bfd_section = bfd_make_section (output_bfd, s->name);
1191 if (s->bfd_section == NULL)
1192 {
1193 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
1194 output_bfd->xvec->name, s->name);
1195 }
1196 s->bfd_section->output_section = s->bfd_section;
1197
1198 /* We initialize an output sections output offset to minus its own
1199 vma to allow us to output a section through itself. */
1200 s->bfd_section->output_offset = 0;
1201 get_userdata (s->bfd_section) = new;
1202
1203 /* If there is a base address, make sure that any sections it might
1204 mention are initialized. */
1205 if (s->addr_tree != NULL)
1206 exp_init_os (s->addr_tree);
1207
1208 if (s->load_base != NULL)
1209 exp_init_os (s->load_base);
1210 }
1211
1212 /* Make sure that all output sections mentioned in an expression are
1213 initialized. */
1214
1215 static void
exp_init_os(etree_type * exp)1216 exp_init_os (etree_type *exp)
1217 {
1218 switch (exp->type.node_class)
1219 {
1220 case etree_assign:
1221 exp_init_os (exp->assign.src);
1222 break;
1223
1224 case etree_binary:
1225 exp_init_os (exp->binary.lhs);
1226 exp_init_os (exp->binary.rhs);
1227 break;
1228
1229 case etree_trinary:
1230 exp_init_os (exp->trinary.cond);
1231 exp_init_os (exp->trinary.lhs);
1232 exp_init_os (exp->trinary.rhs);
1233 break;
1234
1235 case etree_assert:
1236 exp_init_os (exp->assert_s.child);
1237 break;
1238
1239 case etree_unary:
1240 exp_init_os (exp->unary.child);
1241 break;
1242
1243 case etree_name:
1244 switch (exp->type.node_code)
1245 {
1246 case ADDR:
1247 case LOADADDR:
1248 case SIZEOF:
1249 {
1250 lang_output_section_statement_type *os;
1251
1252 os = lang_output_section_find (exp->name.name);
1253 if (os != NULL && os->bfd_section == NULL)
1254 init_os (os);
1255 }
1256 }
1257 break;
1258
1259 default:
1260 break;
1261 }
1262 }
1263
1264 static void
section_already_linked(bfd * abfd,asection * sec,void * data)1265 section_already_linked (bfd *abfd, asection *sec, void *data)
1266 {
1267 lang_input_statement_type *entry = data;
1268
1269 /* If we are only reading symbols from this object, then we want to
1270 discard all sections. */
1271 if (entry->just_syms_flag)
1272 {
1273 bfd_link_just_syms (abfd, sec, &link_info);
1274 return;
1275 }
1276
1277 if (!(abfd->flags & DYNAMIC))
1278 bfd_section_already_linked (abfd, sec);
1279 }
1280
1281 /* The wild routines.
1282
1283 These expand statements like *(.text) and foo.o to a list of
1284 explicit actions, like foo.o(.text), bar.o(.text) and
1285 foo.o(.text, .data). */
1286
1287 /* Add SECTION to the output section OUTPUT. Do this by creating a
1288 lang_input_section statement which is placed at PTR. FILE is the
1289 input file which holds SECTION. */
1290
1291 void
lang_add_section(lang_statement_list_type * ptr,asection * section,lang_output_section_statement_type * output,lang_input_statement_type * file)1292 lang_add_section (lang_statement_list_type *ptr,
1293 asection *section,
1294 lang_output_section_statement_type *output,
1295 lang_input_statement_type *file)
1296 {
1297 flagword flags = section->flags;
1298 bfd_boolean discard;
1299
1300 /* Discard sections marked with SEC_EXCLUDE. */
1301 discard = (flags & SEC_EXCLUDE) != 0;
1302
1303 /* Discard input sections which are assigned to a section named
1304 DISCARD_SECTION_NAME. */
1305 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1306 discard = TRUE;
1307
1308 /* Discard debugging sections if we are stripping debugging
1309 information. */
1310 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1311 && (flags & SEC_DEBUGGING) != 0)
1312 discard = TRUE;
1313
1314 if (discard)
1315 {
1316 if (section->output_section == NULL)
1317 {
1318 /* This prevents future calls from assigning this section. */
1319 section->output_section = bfd_abs_section_ptr;
1320 }
1321 return;
1322 }
1323
1324 if (section->output_section == NULL)
1325 {
1326 bfd_boolean first;
1327 lang_input_section_type *new;
1328 flagword flags;
1329
1330 if (output->bfd_section == NULL)
1331 init_os (output);
1332
1333 first = ! output->bfd_section->linker_has_input;
1334 output->bfd_section->linker_has_input = 1;
1335
1336 /* Add a section reference to the list. */
1337 new = new_stat (lang_input_section, ptr);
1338
1339 new->section = section;
1340 new->ifile = file;
1341 section->output_section = output->bfd_section;
1342
1343 flags = section->flags;
1344
1345 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1346 to an output section, because we want to be able to include a
1347 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1348 section (I don't know why we want to do this, but we do).
1349 build_link_order in ldwrite.c handles this case by turning
1350 the embedded SEC_NEVER_LOAD section into a fill. */
1351
1352 flags &= ~ SEC_NEVER_LOAD;
1353
1354 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1355 already been processed. One reason to do this is that on pe
1356 format targets, .text$foo sections go into .text and it's odd
1357 to see .text with SEC_LINK_ONCE set. */
1358
1359 if (! link_info.relocatable)
1360 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1361
1362 /* If this is not the first input section, and the SEC_READONLY
1363 flag is not currently set, then don't set it just because the
1364 input section has it set. */
1365
1366 if (! first && (output->bfd_section->flags & SEC_READONLY) == 0)
1367 flags &= ~ SEC_READONLY;
1368
1369 /* Keep SEC_MERGE and SEC_STRINGS only if they are the same. */
1370 if (! first
1371 && ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
1372 != (flags & (SEC_MERGE | SEC_STRINGS))
1373 || ((flags & SEC_MERGE)
1374 && output->bfd_section->entsize != section->entsize)))
1375 {
1376 output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
1377 flags &= ~ (SEC_MERGE | SEC_STRINGS);
1378 }
1379
1380 output->bfd_section->flags |= flags;
1381
1382 if (flags & SEC_MERGE)
1383 output->bfd_section->entsize = section->entsize;
1384
1385 /* If SEC_READONLY is not set in the input section, then clear
1386 it from the output section. */
1387 if ((section->flags & SEC_READONLY) == 0)
1388 output->bfd_section->flags &= ~SEC_READONLY;
1389
1390 switch (output->sectype)
1391 {
1392 case normal_section:
1393 break;
1394 case dsect_section:
1395 case copy_section:
1396 case info_section:
1397 case overlay_section:
1398 output->bfd_section->flags &= ~SEC_ALLOC;
1399 break;
1400 case noload_section:
1401 output->bfd_section->flags &= ~SEC_LOAD;
1402 output->bfd_section->flags |= SEC_NEVER_LOAD;
1403 break;
1404 }
1405
1406 /* Copy over SEC_SMALL_DATA. */
1407 if (section->flags & SEC_SMALL_DATA)
1408 output->bfd_section->flags |= SEC_SMALL_DATA;
1409
1410 if (section->alignment_power > output->bfd_section->alignment_power)
1411 output->bfd_section->alignment_power = section->alignment_power;
1412
1413 /* If supplied an alignment, then force it. */
1414 if (output->section_alignment != -1)
1415 output->bfd_section->alignment_power = output->section_alignment;
1416
1417 if (bfd_get_arch (section->owner) == bfd_arch_tic54x
1418 && (section->flags & SEC_TIC54X_BLOCK) != 0)
1419 {
1420 output->bfd_section->flags |= SEC_TIC54X_BLOCK;
1421 /* FIXME: This value should really be obtained from the bfd... */
1422 output->block_value = 128;
1423 }
1424 }
1425 }
1426
1427 /* Compare sections ASEC and BSEC according to SORT. */
1428
1429 static int
compare_section(sort_type sort,asection * asec,asection * bsec)1430 compare_section (sort_type sort, asection *asec, asection *bsec)
1431 {
1432 int ret;
1433
1434 switch (sort)
1435 {
1436 default:
1437 abort ();
1438
1439 case by_alignment_name:
1440 ret = (bfd_section_alignment (bsec->owner, bsec)
1441 - bfd_section_alignment (asec->owner, asec));
1442 if (ret)
1443 break;
1444 /* Fall through. */
1445
1446 case by_name:
1447 ret = strcmp (bfd_get_section_name (asec->owner, asec),
1448 bfd_get_section_name (bsec->owner, bsec));
1449 break;
1450
1451 case by_name_alignment:
1452 ret = strcmp (bfd_get_section_name (asec->owner, asec),
1453 bfd_get_section_name (bsec->owner, bsec));
1454 if (ret)
1455 break;
1456 /* Fall through. */
1457
1458 case by_alignment:
1459 ret = (bfd_section_alignment (bsec->owner, bsec)
1460 - bfd_section_alignment (asec->owner, asec));
1461 break;
1462 }
1463
1464 return ret;
1465 }
1466
1467 /* Handle wildcard sorting. This returns the lang_input_section which
1468 should follow the one we are going to create for SECTION and FILE,
1469 based on the sorting requirements of WILD. It returns NULL if the
1470 new section should just go at the end of the current list. */
1471
1472 static lang_statement_union_type *
wild_sort(lang_wild_statement_type * wild,struct wildcard_list * sec,lang_input_statement_type * file,asection * section)1473 wild_sort (lang_wild_statement_type *wild,
1474 struct wildcard_list *sec,
1475 lang_input_statement_type *file,
1476 asection *section)
1477 {
1478 const char *section_name;
1479 lang_statement_union_type *l;
1480
1481 if (!wild->filenames_sorted
1482 && (sec == NULL || sec->spec.sorted == none))
1483 return NULL;
1484
1485 section_name = bfd_get_section_name (file->the_bfd, section);
1486 for (l = wild->children.head; l != NULL; l = l->header.next)
1487 {
1488 lang_input_section_type *ls;
1489
1490 if (l->header.type != lang_input_section_enum)
1491 continue;
1492 ls = &l->input_section;
1493
1494 /* Sorting by filename takes precedence over sorting by section
1495 name. */
1496
1497 if (wild->filenames_sorted)
1498 {
1499 const char *fn, *ln;
1500 bfd_boolean fa, la;
1501 int i;
1502
1503 /* The PE support for the .idata section as generated by
1504 dlltool assumes that files will be sorted by the name of
1505 the archive and then the name of the file within the
1506 archive. */
1507
1508 if (file->the_bfd != NULL
1509 && bfd_my_archive (file->the_bfd) != NULL)
1510 {
1511 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1512 fa = TRUE;
1513 }
1514 else
1515 {
1516 fn = file->filename;
1517 fa = FALSE;
1518 }
1519
1520 if (ls->ifile->the_bfd != NULL
1521 && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1522 {
1523 ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1524 la = TRUE;
1525 }
1526 else
1527 {
1528 ln = ls->ifile->filename;
1529 la = FALSE;
1530 }
1531
1532 i = strcmp (fn, ln);
1533 if (i > 0)
1534 continue;
1535 else if (i < 0)
1536 break;
1537
1538 if (fa || la)
1539 {
1540 if (fa)
1541 fn = file->filename;
1542 if (la)
1543 ln = ls->ifile->filename;
1544
1545 i = strcmp (fn, ln);
1546 if (i > 0)
1547 continue;
1548 else if (i < 0)
1549 break;
1550 }
1551 }
1552
1553 /* Here either the files are not sorted by name, or we are
1554 looking at the sections for this file. */
1555
1556 if (sec != NULL && sec->spec.sorted != none)
1557 {
1558 if (compare_section (sec->spec.sorted, section,
1559 ls->section) < 0)
1560 break;
1561 }
1562 }
1563
1564 return l;
1565 }
1566
1567 /* Expand a wild statement for a particular FILE. SECTION may be
1568 NULL, in which case it is a wild card. */
1569
1570 static void
output_section_callback(lang_wild_statement_type * ptr,struct wildcard_list * sec,asection * section,lang_input_statement_type * file,void * output)1571 output_section_callback (lang_wild_statement_type *ptr,
1572 struct wildcard_list *sec,
1573 asection *section,
1574 lang_input_statement_type *file,
1575 void *output)
1576 {
1577 lang_statement_union_type *before;
1578
1579 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1580 if (unique_section_p (section))
1581 return;
1582
1583 before = wild_sort (ptr, sec, file, section);
1584
1585 /* Here BEFORE points to the lang_input_section which
1586 should follow the one we are about to add. If BEFORE
1587 is NULL, then the section should just go at the end
1588 of the current list. */
1589
1590 if (before == NULL)
1591 lang_add_section (&ptr->children, section,
1592 (lang_output_section_statement_type *) output,
1593 file);
1594 else
1595 {
1596 lang_statement_list_type list;
1597 lang_statement_union_type **pp;
1598
1599 lang_list_init (&list);
1600 lang_add_section (&list, section,
1601 (lang_output_section_statement_type *) output,
1602 file);
1603
1604 /* If we are discarding the section, LIST.HEAD will
1605 be NULL. */
1606 if (list.head != NULL)
1607 {
1608 ASSERT (list.head->header.next == NULL);
1609
1610 for (pp = &ptr->children.head;
1611 *pp != before;
1612 pp = &(*pp)->header.next)
1613 ASSERT (*pp != NULL);
1614
1615 list.head->header.next = *pp;
1616 *pp = list.head;
1617 }
1618 }
1619 }
1620
1621 /* Check if all sections in a wild statement for a particular FILE
1622 are readonly. */
1623
1624 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 * data)1625 check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
1626 struct wildcard_list *sec ATTRIBUTE_UNUSED,
1627 asection *section,
1628 lang_input_statement_type *file ATTRIBUTE_UNUSED,
1629 void *data)
1630 {
1631 /* Exclude sections that match UNIQUE_SECTION_LIST. */
1632 if (unique_section_p (section))
1633 return;
1634
1635 if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
1636 ((lang_output_section_statement_type *) data)->all_input_readonly = FALSE;
1637 }
1638
1639 /* This is passed a file name which must have been seen already and
1640 added to the statement tree. We will see if it has been opened
1641 already and had its symbols read. If not then we'll read it. */
1642
1643 static lang_input_statement_type *
lookup_name(const char * name)1644 lookup_name (const char *name)
1645 {
1646 lang_input_statement_type *search;
1647
1648 for (search = (lang_input_statement_type *) input_file_chain.head;
1649 search != NULL;
1650 search = (lang_input_statement_type *) search->next_real_file)
1651 {
1652 /* Use the local_sym_name as the name of the file that has
1653 already been loaded as filename might have been transformed
1654 via the search directory lookup mechanism. */
1655 const char * filename = search->local_sym_name;
1656
1657 if (filename == NULL && name == NULL)
1658 return search;
1659 if (filename != NULL
1660 && name != NULL
1661 && strcmp (filename, name) == 0)
1662 break;
1663 }
1664
1665 if (search == NULL)
1666 search = new_afile (name, lang_input_file_is_search_file_enum,
1667 default_target, FALSE);
1668
1669 /* If we have already added this file, or this file is not real
1670 (FIXME: can that ever actually happen?) or the name is NULL
1671 (FIXME: can that ever actually happen?) don't add this file. */
1672 if (search->loaded
1673 || ! search->real
1674 || search->filename == NULL)
1675 return search;
1676
1677 if (! load_symbols (search, NULL))
1678 return NULL;
1679
1680 return search;
1681 }
1682
1683 /* Save LIST as a list of libraries whose symbols should not be exported. */
1684
1685 struct excluded_lib
1686 {
1687 char *name;
1688 struct excluded_lib *next;
1689 };
1690 static struct excluded_lib *excluded_libs;
1691
1692 void
add_excluded_libs(const char * list)1693 add_excluded_libs (const char *list)
1694 {
1695 const char *p = list, *end;
1696
1697 while (*p != '\0')
1698 {
1699 struct excluded_lib *entry;
1700 end = strpbrk (p, ",:");
1701 if (end == NULL)
1702 end = p + strlen (p);
1703 entry = xmalloc (sizeof (*entry));
1704 entry->next = excluded_libs;
1705 entry->name = xmalloc (end - p + 1);
1706 memcpy (entry->name, p, end - p);
1707 entry->name[end - p] = '\0';
1708 excluded_libs = entry;
1709 if (*end == '\0')
1710 break;
1711 p = end + 1;
1712 }
1713 }
1714
1715 static void
check_excluded_libs(bfd * abfd)1716 check_excluded_libs (bfd *abfd)
1717 {
1718 struct excluded_lib *lib = excluded_libs;
1719
1720 while (lib)
1721 {
1722 int len = strlen (lib->name);
1723 const char *filename = lbasename (abfd->filename);
1724
1725 if (strcmp (lib->name, "ALL") == 0)
1726 {
1727 abfd->no_export = TRUE;
1728 return;
1729 }
1730
1731 if (strncmp (lib->name, filename, len) == 0
1732 && (filename[len] == '\0'
1733 || (filename[len] == '.' && filename[len + 1] == 'a'
1734 && filename[len + 2] == '\0')))
1735 {
1736 abfd->no_export = TRUE;
1737 return;
1738 }
1739
1740 lib = lib->next;
1741 }
1742 }
1743
1744 /* Get the symbols for an input file. */
1745
1746 static bfd_boolean
load_symbols(lang_input_statement_type * entry,lang_statement_list_type * place)1747 load_symbols (lang_input_statement_type *entry,
1748 lang_statement_list_type *place)
1749 {
1750 char **matching;
1751
1752 if (entry->loaded)
1753 return TRUE;
1754
1755 ldfile_open_file (entry);
1756
1757 if (! bfd_check_format (entry->the_bfd, bfd_archive)
1758 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1759 {
1760 bfd_error_type err;
1761 lang_statement_list_type *hold;
1762 bfd_boolean bad_load = TRUE;
1763 bfd_boolean save_ldlang_sysrooted_script;
1764
1765 err = bfd_get_error ();
1766
1767 /* See if the emulation has some special knowledge. */
1768 if (ldemul_unrecognized_file (entry))
1769 return TRUE;
1770
1771 if (err == bfd_error_file_ambiguously_recognized)
1772 {
1773 char **p;
1774
1775 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1776 einfo (_("%B: matching formats:"), entry->the_bfd);
1777 for (p = matching; *p != NULL; p++)
1778 einfo (" %s", *p);
1779 einfo ("%F\n");
1780 }
1781 else if (err != bfd_error_file_not_recognized
1782 || place == NULL)
1783 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1784 else
1785 bad_load = FALSE;
1786
1787 bfd_close (entry->the_bfd);
1788 entry->the_bfd = NULL;
1789
1790 /* Try to interpret the file as a linker script. */
1791 ldfile_open_command_file (entry->filename);
1792
1793 hold = stat_ptr;
1794 stat_ptr = place;
1795 save_ldlang_sysrooted_script = ldlang_sysrooted_script;
1796 ldlang_sysrooted_script = entry->sysrooted;
1797
1798 ldfile_assumed_script = TRUE;
1799 parser_input = input_script;
1800 /* We want to use the same -Bdynamic/-Bstatic as the one for
1801 ENTRY. */
1802 config.dynamic_link = entry->dynamic;
1803 yyparse ();
1804 ldfile_assumed_script = FALSE;
1805
1806 ldlang_sysrooted_script = save_ldlang_sysrooted_script;
1807 stat_ptr = hold;
1808
1809 return ! bad_load;
1810 }
1811
1812 if (ldemul_recognized_file (entry))
1813 return TRUE;
1814
1815 /* We don't call ldlang_add_file for an archive. Instead, the
1816 add_symbols entry point will call ldlang_add_file, via the
1817 add_archive_element callback, for each element of the archive
1818 which is used. */
1819 switch (bfd_get_format (entry->the_bfd))
1820 {
1821 default:
1822 break;
1823
1824 case bfd_object:
1825 ldlang_add_file (entry);
1826 if (trace_files || trace_file_tries)
1827 info_msg ("%I\n", entry);
1828 break;
1829
1830 case bfd_archive:
1831 check_excluded_libs (entry->the_bfd);
1832
1833 if (entry->whole_archive)
1834 {
1835 bfd *member = NULL;
1836 bfd_boolean loaded = TRUE;
1837
1838 for (;;)
1839 {
1840 member = bfd_openr_next_archived_file (entry->the_bfd, member);
1841
1842 if (member == NULL)
1843 break;
1844
1845 if (! bfd_check_format (member, bfd_object))
1846 {
1847 einfo (_("%F%B: member %B in archive is not an object\n"),
1848 entry->the_bfd, member);
1849 loaded = FALSE;
1850 }
1851
1852 if (! ((*link_info.callbacks->add_archive_element)
1853 (&link_info, member, "--whole-archive")))
1854 abort ();
1855
1856 if (! bfd_link_add_symbols (member, &link_info))
1857 {
1858 einfo (_("%F%B: could not read symbols: %E\n"), member);
1859 loaded = FALSE;
1860 }
1861 }
1862
1863 entry->loaded = loaded;
1864 return loaded;
1865 }
1866 break;
1867 }
1868
1869 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
1870 entry->loaded = TRUE;
1871 else
1872 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1873
1874 return entry->loaded;
1875 }
1876
1877 /* Handle a wild statement. S->FILENAME or S->SECTION_LIST or both
1878 may be NULL, indicating that it is a wildcard. Separate
1879 lang_input_section statements are created for each part of the
1880 expansion; they are added after the wild statement S. OUTPUT is
1881 the output section. */
1882
1883 static void
wild(lang_wild_statement_type * s,const char * target ATTRIBUTE_UNUSED,lang_output_section_statement_type * output)1884 wild (lang_wild_statement_type *s,
1885 const char *target ATTRIBUTE_UNUSED,
1886 lang_output_section_statement_type *output)
1887 {
1888 struct wildcard_list *sec;
1889
1890 walk_wild (s, output_section_callback, output);
1891
1892 for (sec = s->section_list; sec != NULL; sec = sec->next)
1893 {
1894 if (default_common_section != NULL)
1895 break;
1896 if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
1897 {
1898 /* Remember the section that common is going to in case we
1899 later get something which doesn't know where to put it. */
1900 default_common_section = output;
1901 }
1902 }
1903 }
1904
1905 /* Return TRUE iff target is the sought target. */
1906
1907 static int
get_target(const bfd_target * target,void * data)1908 get_target (const bfd_target *target, void *data)
1909 {
1910 const char *sought = data;
1911
1912 return strcmp (target->name, sought) == 0;
1913 }
1914
1915 /* Like strcpy() but convert to lower case as well. */
1916
1917 static void
stricpy(char * dest,char * src)1918 stricpy (char *dest, char *src)
1919 {
1920 char c;
1921
1922 while ((c = *src++) != 0)
1923 *dest++ = TOLOWER (c);
1924
1925 *dest = 0;
1926 }
1927
1928 /* Remove the first occurrence of needle (if any) in haystack
1929 from haystack. */
1930
1931 static void
strcut(char * haystack,char * needle)1932 strcut (char *haystack, char *needle)
1933 {
1934 haystack = strstr (haystack, needle);
1935
1936 if (haystack)
1937 {
1938 char *src;
1939
1940 for (src = haystack + strlen (needle); *src;)
1941 *haystack++ = *src++;
1942
1943 *haystack = 0;
1944 }
1945 }
1946
1947 /* Compare two target format name strings.
1948 Return a value indicating how "similar" they are. */
1949
1950 static int
name_compare(char * first,char * second)1951 name_compare (char *first, char *second)
1952 {
1953 char *copy1;
1954 char *copy2;
1955 int result;
1956
1957 copy1 = xmalloc (strlen (first) + 1);
1958 copy2 = xmalloc (strlen (second) + 1);
1959
1960 /* Convert the names to lower case. */
1961 stricpy (copy1, first);
1962 stricpy (copy2, second);
1963
1964 /* Remove size and endian strings from the name. */
1965 strcut (copy1, "big");
1966 strcut (copy1, "little");
1967 strcut (copy2, "big");
1968 strcut (copy2, "little");
1969
1970 /* Return a value based on how many characters match,
1971 starting from the beginning. If both strings are
1972 the same then return 10 * their length. */
1973 for (result = 0; copy1[result] == copy2[result]; result++)
1974 if (copy1[result] == 0)
1975 {
1976 result *= 10;
1977 break;
1978 }
1979
1980 free (copy1);
1981 free (copy2);
1982
1983 return result;
1984 }
1985
1986 /* Set by closest_target_match() below. */
1987 static const bfd_target *winner;
1988
1989 /* Scan all the valid bfd targets looking for one that has the endianness
1990 requirement that was specified on the command line, and is the nearest
1991 match to the original output target. */
1992
1993 static int
closest_target_match(const bfd_target * target,void * data)1994 closest_target_match (const bfd_target *target, void *data)
1995 {
1996 const bfd_target *original = data;
1997
1998 if (command_line.endian == ENDIAN_BIG
1999 && target->byteorder != BFD_ENDIAN_BIG)
2000 return 0;
2001
2002 if (command_line.endian == ENDIAN_LITTLE
2003 && target->byteorder != BFD_ENDIAN_LITTLE)
2004 return 0;
2005
2006 /* Must be the same flavour. */
2007 if (target->flavour != original->flavour)
2008 return 0;
2009
2010 /* If we have not found a potential winner yet, then record this one. */
2011 if (winner == NULL)
2012 {
2013 winner = target;
2014 return 0;
2015 }
2016
2017 /* Oh dear, we now have two potential candidates for a successful match.
2018 Compare their names and choose the better one. */
2019 if (name_compare (target->name, original->name)
2020 > name_compare (winner->name, original->name))
2021 winner = target;
2022
2023 /* Keep on searching until wqe have checked them all. */
2024 return 0;
2025 }
2026
2027 /* Return the BFD target format of the first input file. */
2028
2029 static char *
get_first_input_target(void)2030 get_first_input_target (void)
2031 {
2032 char *target = NULL;
2033
2034 LANG_FOR_EACH_INPUT_STATEMENT (s)
2035 {
2036 if (s->header.type == lang_input_statement_enum
2037 && s->real)
2038 {
2039 ldfile_open_file (s);
2040
2041 if (s->the_bfd != NULL
2042 && bfd_check_format (s->the_bfd, bfd_object))
2043 {
2044 target = bfd_get_target (s->the_bfd);
2045
2046 if (target != NULL)
2047 break;
2048 }
2049 }
2050 }
2051
2052 return target;
2053 }
2054
2055 const char *
lang_get_output_target(void)2056 lang_get_output_target (void)
2057 {
2058 const char *target;
2059
2060 /* Has the user told us which output format to use? */
2061 if (output_target != NULL)
2062 return output_target;
2063
2064 /* No - has the current target been set to something other than
2065 the default? */
2066 if (current_target != default_target)
2067 return current_target;
2068
2069 /* No - can we determine the format of the first input file? */
2070 target = get_first_input_target ();
2071 if (target != NULL)
2072 return target;
2073
2074 /* Failed - use the default output target. */
2075 return default_target;
2076 }
2077
2078 /* Open the output file. */
2079
2080 static bfd *
open_output(const char * name)2081 open_output (const char *name)
2082 {
2083 bfd *output;
2084
2085 output_target = lang_get_output_target ();
2086
2087 /* Has the user requested a particular endianness on the command
2088 line? */
2089 if (command_line.endian != ENDIAN_UNSET)
2090 {
2091 const bfd_target *target;
2092 enum bfd_endian desired_endian;
2093
2094 /* Get the chosen target. */
2095 target = bfd_search_for_target (get_target, (void *) output_target);
2096
2097 /* If the target is not supported, we cannot do anything. */
2098 if (target != NULL)
2099 {
2100 if (command_line.endian == ENDIAN_BIG)
2101 desired_endian = BFD_ENDIAN_BIG;
2102 else
2103 desired_endian = BFD_ENDIAN_LITTLE;
2104
2105 /* See if the target has the wrong endianness. This should
2106 not happen if the linker script has provided big and
2107 little endian alternatives, but some scrips don't do
2108 this. */
2109 if (target->byteorder != desired_endian)
2110 {
2111 /* If it does, then see if the target provides
2112 an alternative with the correct endianness. */
2113 if (target->alternative_target != NULL
2114 && (target->alternative_target->byteorder == desired_endian))
2115 output_target = target->alternative_target->name;
2116 else
2117 {
2118 /* Try to find a target as similar as possible to
2119 the default target, but which has the desired
2120 endian characteristic. */
2121 bfd_search_for_target (closest_target_match,
2122 (void *) target);
2123
2124 /* Oh dear - we could not find any targets that
2125 satisfy our requirements. */
2126 if (winner == NULL)
2127 einfo (_("%P: warning: could not find any targets"
2128 " that match endianness requirement\n"));
2129 else
2130 output_target = winner->name;
2131 }
2132 }
2133 }
2134 }
2135
2136 output = bfd_openw (name, output_target);
2137
2138 if (output == NULL)
2139 {
2140 if (bfd_get_error () == bfd_error_invalid_target)
2141 einfo (_("%P%F: target %s not found\n"), output_target);
2142
2143 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
2144 }
2145
2146 delete_output_file_on_failure = TRUE;
2147
2148 if (! bfd_set_format (output, bfd_object))
2149 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
2150 if (! bfd_set_arch_mach (output,
2151 ldfile_output_architecture,
2152 ldfile_output_machine))
2153 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
2154
2155 link_info.hash = bfd_link_hash_table_create (output);
2156 if (link_info.hash == NULL)
2157 einfo (_("%P%F: can not create link hash table: %E\n"));
2158
2159 bfd_set_gp_size (output, g_switch_value);
2160 return output;
2161 }
2162
2163 static void
ldlang_open_output(lang_statement_union_type * statement)2164 ldlang_open_output (lang_statement_union_type *statement)
2165 {
2166 switch (statement->header.type)
2167 {
2168 case lang_output_statement_enum:
2169 ASSERT (output_bfd == NULL);
2170 output_bfd = open_output (statement->output_statement.name);
2171 ldemul_set_output_arch ();
2172 if (config.magic_demand_paged && !link_info.relocatable)
2173 output_bfd->flags |= D_PAGED;
2174 else
2175 output_bfd->flags &= ~D_PAGED;
2176 if (config.text_read_only)
2177 output_bfd->flags |= WP_TEXT;
2178 else
2179 output_bfd->flags &= ~WP_TEXT;
2180 if (link_info.traditional_format)
2181 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
2182 else
2183 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
2184 break;
2185
2186 case lang_target_statement_enum:
2187 current_target = statement->target_statement.target;
2188 break;
2189 default:
2190 break;
2191 }
2192 }
2193
2194 /* Convert between addresses in bytes and sizes in octets.
2195 For currently supported targets, octets_per_byte is always a power
2196 of two, so we can use shifts. */
2197 #define TO_ADDR(X) ((X) >> opb_shift)
2198 #define TO_SIZE(X) ((X) << opb_shift)
2199
2200 /* Support the above. */
2201 static unsigned int opb_shift = 0;
2202
2203 static void
init_opb(void)2204 init_opb (void)
2205 {
2206 unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2207 ldfile_output_machine);
2208 opb_shift = 0;
2209 if (x > 1)
2210 while ((x & 1) == 0)
2211 {
2212 x >>= 1;
2213 ++opb_shift;
2214 }
2215 ASSERT (x == 1);
2216 }
2217
2218 /* Open all the input files. */
2219
2220 static void
open_input_bfds(lang_statement_union_type * s,bfd_boolean force)2221 open_input_bfds (lang_statement_union_type *s, bfd_boolean force)
2222 {
2223 for (; s != NULL; s = s->header.next)
2224 {
2225 switch (s->header.type)
2226 {
2227 case lang_constructors_statement_enum:
2228 open_input_bfds (constructor_list.head, force);
2229 break;
2230 case lang_output_section_statement_enum:
2231 open_input_bfds (s->output_section_statement.children.head, force);
2232 break;
2233 case lang_wild_statement_enum:
2234 /* Maybe we should load the file's symbols. */
2235 if (s->wild_statement.filename
2236 && ! wildcardp (s->wild_statement.filename))
2237 lookup_name (s->wild_statement.filename);
2238 open_input_bfds (s->wild_statement.children.head, force);
2239 break;
2240 case lang_group_statement_enum:
2241 {
2242 struct bfd_link_hash_entry *undefs;
2243
2244 /* We must continually search the entries in the group
2245 until no new symbols are added to the list of undefined
2246 symbols. */
2247
2248 do
2249 {
2250 undefs = link_info.hash->undefs_tail;
2251 open_input_bfds (s->group_statement.children.head, TRUE);
2252 }
2253 while (undefs != link_info.hash->undefs_tail);
2254 }
2255 break;
2256 case lang_target_statement_enum:
2257 current_target = s->target_statement.target;
2258 break;
2259 case lang_input_statement_enum:
2260 if (s->input_statement.real)
2261 {
2262 lang_statement_list_type add;
2263
2264 s->input_statement.target = current_target;
2265
2266 /* If we are being called from within a group, and this
2267 is an archive which has already been searched, then
2268 force it to be researched unless the whole archive
2269 has been loaded already. */
2270 if (force
2271 && !s->input_statement.whole_archive
2272 && s->input_statement.loaded
2273 && bfd_check_format (s->input_statement.the_bfd,
2274 bfd_archive))
2275 s->input_statement.loaded = FALSE;
2276
2277 lang_list_init (&add);
2278
2279 if (! load_symbols (&s->input_statement, &add))
2280 config.make_executable = FALSE;
2281
2282 if (add.head != NULL)
2283 {
2284 *add.tail = s->header.next;
2285 s->header.next = add.head;
2286 }
2287 }
2288 break;
2289 default:
2290 break;
2291 }
2292 }
2293 }
2294
2295 /* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions. */
2296
2297 void
lang_track_definedness(const char * name)2298 lang_track_definedness (const char *name)
2299 {
2300 if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
2301 einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
2302 }
2303
2304 /* New-function for the definedness hash table. */
2305
2306 static struct bfd_hash_entry *
lang_definedness_newfunc(struct bfd_hash_entry * entry,struct bfd_hash_table * table ATTRIBUTE_UNUSED,const char * name ATTRIBUTE_UNUSED)2307 lang_definedness_newfunc (struct bfd_hash_entry *entry,
2308 struct bfd_hash_table *table ATTRIBUTE_UNUSED,
2309 const char *name ATTRIBUTE_UNUSED)
2310 {
2311 struct lang_definedness_hash_entry *ret
2312 = (struct lang_definedness_hash_entry *) entry;
2313
2314 if (ret == NULL)
2315 ret = (struct lang_definedness_hash_entry *)
2316 bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
2317
2318 if (ret == NULL)
2319 einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
2320
2321 ret->iteration = -1;
2322 return &ret->root;
2323 }
2324
2325 /* Return the iteration when the definition of NAME was last updated. A
2326 value of -1 means that the symbol is not defined in the linker script
2327 or the command line, but may be defined in the linker symbol table. */
2328
2329 int
lang_symbol_definition_iteration(const char * name)2330 lang_symbol_definition_iteration (const char *name)
2331 {
2332 struct lang_definedness_hash_entry *defentry
2333 = (struct lang_definedness_hash_entry *)
2334 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
2335
2336 /* We've already created this one on the presence of DEFINED in the
2337 script, so it can't be NULL unless something is borked elsewhere in
2338 the code. */
2339 if (defentry == NULL)
2340 FAIL ();
2341
2342 return defentry->iteration;
2343 }
2344
2345 /* Update the definedness state of NAME. */
2346
2347 void
lang_update_definedness(const char * name,struct bfd_link_hash_entry * h)2348 lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
2349 {
2350 struct lang_definedness_hash_entry *defentry
2351 = (struct lang_definedness_hash_entry *)
2352 bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
2353
2354 /* We don't keep track of symbols not tested with DEFINED. */
2355 if (defentry == NULL)
2356 return;
2357
2358 /* If the symbol was already defined, and not from an earlier statement
2359 iteration, don't update the definedness iteration, because that'd
2360 make the symbol seem defined in the linker script at this point, and
2361 it wasn't; it was defined in some object. If we do anyway, DEFINED
2362 would start to yield false before this point and the construct "sym =
2363 DEFINED (sym) ? sym : X;" would change sym to X despite being defined
2364 in an object. */
2365 if (h->type != bfd_link_hash_undefined
2366 && h->type != bfd_link_hash_common
2367 && h->type != bfd_link_hash_new
2368 && defentry->iteration == -1)
2369 return;
2370
2371 defentry->iteration = lang_statement_iteration;
2372 }
2373
2374 /* Add the supplied name to the symbol table as an undefined reference.
2375 This is a two step process as the symbol table doesn't even exist at
2376 the time the ld command line is processed. First we put the name
2377 on a list, then, once the output file has been opened, transfer the
2378 name to the symbol table. */
2379
2380 typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
2381
2382 #define ldlang_undef_chain_list_head entry_symbol.next
2383
2384 void
ldlang_add_undef(const char * const name)2385 ldlang_add_undef (const char *const name)
2386 {
2387 ldlang_undef_chain_list_type *new =
2388 stat_alloc (sizeof (ldlang_undef_chain_list_type));
2389
2390 new->next = ldlang_undef_chain_list_head;
2391 ldlang_undef_chain_list_head = new;
2392
2393 new->name = xstrdup (name);
2394
2395 if (output_bfd != NULL)
2396 insert_undefined (new->name);
2397 }
2398
2399 /* Insert NAME as undefined in the symbol table. */
2400
2401 static void
insert_undefined(const char * name)2402 insert_undefined (const char *name)
2403 {
2404 struct bfd_link_hash_entry *h;
2405
2406 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
2407 if (h == NULL)
2408 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2409 if (h->type == bfd_link_hash_new)
2410 {
2411 h->type = bfd_link_hash_undefined;
2412 h->u.undef.abfd = NULL;
2413 bfd_link_add_undef (link_info.hash, h);
2414 }
2415 }
2416
2417 /* Run through the list of undefineds created above and place them
2418 into the linker hash table as undefined symbols belonging to the
2419 script file. */
2420
2421 static void
lang_place_undefineds(void)2422 lang_place_undefineds (void)
2423 {
2424 ldlang_undef_chain_list_type *ptr;
2425
2426 for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
2427 insert_undefined (ptr->name);
2428 }
2429
2430 /* Check for all readonly or some readwrite sections. */
2431
2432 static void
check_input_sections(lang_statement_union_type * s,lang_output_section_statement_type * output_section_statement)2433 check_input_sections
2434 (lang_statement_union_type *s,
2435 lang_output_section_statement_type *output_section_statement)
2436 {
2437 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
2438 {
2439 switch (s->header.type)
2440 {
2441 case lang_wild_statement_enum:
2442 walk_wild (&s->wild_statement, check_section_callback,
2443 output_section_statement);
2444 if (! output_section_statement->all_input_readonly)
2445 return;
2446 break;
2447 case lang_constructors_statement_enum:
2448 check_input_sections (constructor_list.head,
2449 output_section_statement);
2450 if (! output_section_statement->all_input_readonly)
2451 return;
2452 break;
2453 case lang_group_statement_enum:
2454 check_input_sections (s->group_statement.children.head,
2455 output_section_statement);
2456 if (! output_section_statement->all_input_readonly)
2457 return;
2458 break;
2459 default:
2460 break;
2461 }
2462 }
2463 }
2464
2465 /* Update wildcard statements if needed. */
2466
2467 static void
update_wild_statements(lang_statement_union_type * s)2468 update_wild_statements (lang_statement_union_type *s)
2469 {
2470 struct wildcard_list *sec;
2471
2472 switch (sort_section)
2473 {
2474 default:
2475 FAIL ();
2476
2477 case none:
2478 break;
2479
2480 case by_name:
2481 case by_alignment:
2482 for (; s != NULL; s = s->header.next)
2483 {
2484 switch (s->header.type)
2485 {
2486 default:
2487 break;
2488
2489 case lang_wild_statement_enum:
2490 sec = s->wild_statement.section_list;
2491 if (sec != NULL)
2492 {
2493 switch (sec->spec.sorted)
2494 {
2495 case none:
2496 sec->spec.sorted = sort_section;
2497 break;
2498 case by_name:
2499 if (sort_section == by_alignment)
2500 sec->spec.sorted = by_name_alignment;
2501 break;
2502 case by_alignment:
2503 if (sort_section == by_name)
2504 sec->spec.sorted = by_alignment_name;
2505 break;
2506 default:
2507 break;
2508 }
2509 }
2510 break;
2511
2512 case lang_constructors_statement_enum:
2513 update_wild_statements (constructor_list.head);
2514 break;
2515
2516 case lang_output_section_statement_enum:
2517 update_wild_statements
2518 (s->output_section_statement.children.head);
2519 break;
2520
2521 case lang_group_statement_enum:
2522 update_wild_statements (s->group_statement.children.head);
2523 break;
2524 }
2525 }
2526 break;
2527 }
2528 }
2529
2530 /* Open input files and attach to output sections. */
2531
2532 static void
map_input_to_output_sections(lang_statement_union_type * s,const char * target,lang_output_section_statement_type * os)2533 map_input_to_output_sections
2534 (lang_statement_union_type *s, const char *target,
2535 lang_output_section_statement_type *os)
2536 {
2537 for (; s != NULL; s = s->header.next)
2538 {
2539 switch (s->header.type)
2540 {
2541 case lang_wild_statement_enum:
2542 wild (&s->wild_statement, target, os);
2543 break;
2544 case lang_constructors_statement_enum:
2545 map_input_to_output_sections (constructor_list.head,
2546 target,
2547 os);
2548 break;
2549 case lang_output_section_statement_enum:
2550 if (s->output_section_statement.constraint)
2551 {
2552 if (s->output_section_statement.constraint == -1)
2553 break;
2554 s->output_section_statement.all_input_readonly = TRUE;
2555 check_input_sections (s->output_section_statement.children.head,
2556 &s->output_section_statement);
2557 if ((s->output_section_statement.all_input_readonly
2558 && s->output_section_statement.constraint == ONLY_IF_RW)
2559 || (!s->output_section_statement.all_input_readonly
2560 && s->output_section_statement.constraint == ONLY_IF_RO))
2561 {
2562 s->output_section_statement.constraint = -1;
2563 break;
2564 }
2565 }
2566
2567 map_input_to_output_sections (s->output_section_statement.children.head,
2568 target,
2569 &s->output_section_statement);
2570 break;
2571 case lang_output_statement_enum:
2572 break;
2573 case lang_target_statement_enum:
2574 target = s->target_statement.target;
2575 break;
2576 case lang_group_statement_enum:
2577 map_input_to_output_sections (s->group_statement.children.head,
2578 target,
2579 os);
2580 break;
2581 case lang_data_statement_enum:
2582 /* Make sure that any sections mentioned in the expression
2583 are initialized. */
2584 exp_init_os (s->data_statement.exp);
2585 if (os != NULL && os->bfd_section == NULL)
2586 init_os (os);
2587 /* The output section gets contents, and then we inspect for
2588 any flags set in the input script which override any ALLOC. */
2589 os->bfd_section->flags |= SEC_HAS_CONTENTS;
2590 if (!(os->flags & SEC_NEVER_LOAD))
2591 os->bfd_section->flags |= SEC_ALLOC | SEC_LOAD;
2592 break;
2593 case lang_fill_statement_enum:
2594 case lang_input_section_enum:
2595 case lang_object_symbols_statement_enum:
2596 case lang_reloc_statement_enum:
2597 case lang_padding_statement_enum:
2598 case lang_input_statement_enum:
2599 if (os != NULL && os->bfd_section == NULL)
2600 init_os (os);
2601 break;
2602 case lang_assignment_statement_enum:
2603 if (os != NULL && os->bfd_section == NULL)
2604 init_os (os);
2605
2606 /* Make sure that any sections mentioned in the assignment
2607 are initialized. */
2608 exp_init_os (s->assignment_statement.exp);
2609 break;
2610 case lang_afile_asection_pair_statement_enum:
2611 FAIL ();
2612 break;
2613 case lang_address_statement_enum:
2614 /* Mark the specified section with the supplied address.
2615
2616 If this section was actually a segment marker, then the
2617 directive is ignored if the linker script explicitly
2618 processed the segment marker. Originally, the linker
2619 treated segment directives (like -Ttext on the
2620 command-line) as section directives. We honor the
2621 section directive semantics for backwards compatibilty;
2622 linker scripts that do not specifically check for
2623 SEGMENT_START automatically get the old semantics. */
2624 if (!s->address_statement.segment
2625 || !s->address_statement.segment->used)
2626 {
2627 lang_output_section_statement_type *aos
2628 = (lang_output_section_statement_lookup
2629 (s->address_statement.section_name));
2630
2631 if (aos->bfd_section == NULL)
2632 init_os (aos);
2633 aos->addr_tree = s->address_statement.address;
2634 }
2635 break;
2636 }
2637 }
2638 }
2639
2640 /* An output section might have been removed after its statement was
2641 added. For example, ldemul_before_allocation can remove dynamic
2642 sections if they turn out to be not needed. Clean them up here. */
2643
2644 static void
strip_excluded_output_sections(void)2645 strip_excluded_output_sections (void)
2646 {
2647 lang_output_section_statement_type *os;
2648
2649 for (os = &lang_output_section_statement.head->output_section_statement;
2650 os != NULL;
2651 os = os->next)
2652 {
2653 asection *s;
2654
2655 if (os->constraint == -1)
2656 continue;
2657 s = os->bfd_section;
2658 if (s != NULL && (s->flags & SEC_EXCLUDE) != 0)
2659 {
2660 asection **p;
2661
2662 os->bfd_section = NULL;
2663
2664 for (p = &output_bfd->sections; *p; p = &(*p)->next)
2665 if (*p == s)
2666 {
2667 bfd_section_list_remove (output_bfd, p);
2668 output_bfd->section_count--;
2669 break;
2670 }
2671 }
2672 }
2673 }
2674
2675 static void
print_output_section_statement(lang_output_section_statement_type * output_section_statement)2676 print_output_section_statement
2677 (lang_output_section_statement_type *output_section_statement)
2678 {
2679 asection *section = output_section_statement->bfd_section;
2680 int len;
2681
2682 if (output_section_statement != abs_output_section)
2683 {
2684 minfo ("\n%s", output_section_statement->name);
2685
2686 if (section != NULL)
2687 {
2688 print_dot = section->vma;
2689
2690 len = strlen (output_section_statement->name);
2691 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2692 {
2693 print_nl ();
2694 len = 0;
2695 }
2696 while (len < SECTION_NAME_MAP_LENGTH)
2697 {
2698 print_space ();
2699 ++len;
2700 }
2701
2702 minfo ("0x%V %W", section->vma, section->size);
2703
2704 if (output_section_statement->load_base != NULL)
2705 {
2706 bfd_vma addr;
2707
2708 addr = exp_get_abs_int (output_section_statement->load_base, 0,
2709 "load base", lang_final_phase_enum);
2710 minfo (_(" load address 0x%V"), addr);
2711 }
2712 }
2713
2714 print_nl ();
2715 }
2716
2717 print_statement_list (output_section_statement->children.head,
2718 output_section_statement);
2719 }
2720
2721 static void
print_assignment(lang_assignment_statement_type * assignment,lang_output_section_statement_type * output_section)2722 print_assignment (lang_assignment_statement_type *assignment,
2723 lang_output_section_statement_type *output_section)
2724 {
2725 int i;
2726 int is_dot;
2727 etree_type *tree;
2728 etree_value_type result;
2729
2730 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2731 print_space ();
2732
2733 if (assignment->exp->type.node_class == etree_assert)
2734 {
2735 is_dot = 0;
2736 tree = assignment->exp->assert_s.child;
2737 }
2738 else
2739 {
2740 const char *dst = assignment->exp->assign.dst;
2741 is_dot = dst[0] == '.' && dst[1] == 0;
2742 tree = assignment->exp->assign.src;
2743 }
2744
2745 result = exp_fold_tree (tree, output_section, lang_final_phase_enum,
2746 print_dot, &print_dot);
2747 if (result.valid_p)
2748 {
2749 bfd_vma value;
2750
2751 value = result.value + result.section->bfd_section->vma;
2752
2753 minfo ("0x%V", value);
2754 if (is_dot)
2755 print_dot = value;
2756 }
2757 else
2758 {
2759 minfo ("*undef* ");
2760 #ifdef BFD64
2761 minfo (" ");
2762 #endif
2763 }
2764
2765 minfo (" ");
2766 exp_print_tree (assignment->exp);
2767 print_nl ();
2768 }
2769
2770 static void
print_input_statement(lang_input_statement_type * statm)2771 print_input_statement (lang_input_statement_type *statm)
2772 {
2773 if (statm->filename != NULL)
2774 {
2775 fprintf (config.map_file, "LOAD %s\n", statm->filename);
2776 }
2777 }
2778
2779 /* Print all symbols defined in a particular section. This is called
2780 via bfd_link_hash_traverse, or by print_all_symbols. */
2781
2782 static bfd_boolean
print_one_symbol(struct bfd_link_hash_entry * hash_entry,void * ptr)2783 print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
2784 {
2785 asection *sec = ptr;
2786
2787 if ((hash_entry->type == bfd_link_hash_defined
2788 || hash_entry->type == bfd_link_hash_defweak)
2789 && sec == hash_entry->u.def.section)
2790 {
2791 int i;
2792
2793 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2794 print_space ();
2795 minfo ("0x%V ",
2796 (hash_entry->u.def.value
2797 + hash_entry->u.def.section->output_offset
2798 + hash_entry->u.def.section->output_section->vma));
2799
2800 minfo (" %T\n", hash_entry->root.string);
2801 }
2802
2803 return TRUE;
2804 }
2805
2806 static void
print_all_symbols(sec)2807 print_all_symbols (sec)
2808 asection *sec;
2809 {
2810 struct fat_user_section_struct *ud = get_userdata (sec);
2811 struct map_symbol_def *def;
2812
2813 if (!ud)
2814 return;
2815
2816 *ud->map_symbol_def_tail = 0;
2817 for (def = ud->map_symbol_def_head; def; def = def->next)
2818 print_one_symbol (def->entry, sec);
2819 }
2820
2821 /* Print information about an input section to the map file. */
2822
2823 static void
print_input_section(lang_input_section_type * in)2824 print_input_section (lang_input_section_type *in)
2825 {
2826 asection *i = in->section;
2827 bfd_size_type size = i->size;
2828
2829 init_opb ();
2830 if (size != 0)
2831 {
2832 int len;
2833 bfd_vma addr;
2834
2835 print_space ();
2836 minfo ("%s", i->name);
2837
2838 len = 1 + strlen (i->name);
2839 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2840 {
2841 print_nl ();
2842 len = 0;
2843 }
2844 while (len < SECTION_NAME_MAP_LENGTH)
2845 {
2846 print_space ();
2847 ++len;
2848 }
2849
2850 if (i->output_section != NULL && (i->flags & SEC_EXCLUDE) == 0)
2851 addr = i->output_section->vma + i->output_offset;
2852 else
2853 {
2854 addr = print_dot;
2855 size = 0;
2856 }
2857
2858 minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
2859
2860 if (size != i->rawsize && i->rawsize != 0)
2861 {
2862 len = SECTION_NAME_MAP_LENGTH + 3;
2863 #ifdef BFD64
2864 len += 16;
2865 #else
2866 len += 8;
2867 #endif
2868 while (len > 0)
2869 {
2870 print_space ();
2871 --len;
2872 }
2873
2874 minfo (_("%W (size before relaxing)\n"), i->rawsize);
2875 }
2876
2877 if (i->output_section != NULL && (i->flags & SEC_EXCLUDE) == 0)
2878 {
2879 if (command_line.reduce_memory_overheads)
2880 bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
2881 else
2882 print_all_symbols (i);
2883
2884 print_dot = addr + TO_ADDR (size);
2885 }
2886 }
2887 }
2888
2889 static void
print_fill_statement(lang_fill_statement_type * fill)2890 print_fill_statement (lang_fill_statement_type *fill)
2891 {
2892 size_t size;
2893 unsigned char *p;
2894 fputs (" FILL mask 0x", config.map_file);
2895 for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
2896 fprintf (config.map_file, "%02x", *p);
2897 fputs ("\n", config.map_file);
2898 }
2899
2900 static void
print_data_statement(lang_data_statement_type * data)2901 print_data_statement (lang_data_statement_type *data)
2902 {
2903 int i;
2904 bfd_vma addr;
2905 bfd_size_type size;
2906 const char *name;
2907
2908 init_opb ();
2909 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2910 print_space ();
2911
2912 addr = data->output_vma;
2913 if (data->output_section != NULL)
2914 addr += data->output_section->vma;
2915
2916 switch (data->type)
2917 {
2918 default:
2919 abort ();
2920 case BYTE:
2921 size = BYTE_SIZE;
2922 name = "BYTE";
2923 break;
2924 case SHORT:
2925 size = SHORT_SIZE;
2926 name = "SHORT";
2927 break;
2928 case LONG:
2929 size = LONG_SIZE;
2930 name = "LONG";
2931 break;
2932 case QUAD:
2933 size = QUAD_SIZE;
2934 name = "QUAD";
2935 break;
2936 case SQUAD:
2937 size = QUAD_SIZE;
2938 name = "SQUAD";
2939 break;
2940 }
2941
2942 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2943
2944 if (data->exp->type.node_class != etree_value)
2945 {
2946 print_space ();
2947 exp_print_tree (data->exp);
2948 }
2949
2950 print_nl ();
2951
2952 print_dot = addr + TO_ADDR (size);
2953 }
2954
2955 /* Print an address statement. These are generated by options like
2956 -Ttext. */
2957
2958 static void
print_address_statement(lang_address_statement_type * address)2959 print_address_statement (lang_address_statement_type *address)
2960 {
2961 minfo (_("Address of section %s set to "), address->section_name);
2962 exp_print_tree (address->address);
2963 print_nl ();
2964 }
2965
2966 /* Print a reloc statement. */
2967
2968 static void
print_reloc_statement(lang_reloc_statement_type * reloc)2969 print_reloc_statement (lang_reloc_statement_type *reloc)
2970 {
2971 int i;
2972 bfd_vma addr;
2973 bfd_size_type size;
2974
2975 init_opb ();
2976 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2977 print_space ();
2978
2979 addr = reloc->output_vma;
2980 if (reloc->output_section != NULL)
2981 addr += reloc->output_section->vma;
2982
2983 size = bfd_get_reloc_size (reloc->howto);
2984
2985 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2986
2987 if (reloc->name != NULL)
2988 minfo ("%s+", reloc->name);
2989 else
2990 minfo ("%s+", reloc->section->name);
2991
2992 exp_print_tree (reloc->addend_exp);
2993
2994 print_nl ();
2995
2996 print_dot = addr + TO_ADDR (size);
2997 }
2998
2999 static void
print_padding_statement(lang_padding_statement_type * s)3000 print_padding_statement (lang_padding_statement_type *s)
3001 {
3002 int len;
3003 bfd_vma addr;
3004
3005 init_opb ();
3006 minfo (" *fill*");
3007
3008 len = sizeof " *fill*" - 1;
3009 while (len < SECTION_NAME_MAP_LENGTH)
3010 {
3011 print_space ();
3012 ++len;
3013 }
3014
3015 addr = s->output_offset;
3016 if (s->output_section != NULL)
3017 addr += s->output_section->vma;
3018 minfo ("0x%V %W ", addr, (bfd_vma) s->size);
3019
3020 if (s->fill->size != 0)
3021 {
3022 size_t size;
3023 unsigned char *p;
3024 for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
3025 fprintf (config.map_file, "%02x", *p);
3026 }
3027
3028 print_nl ();
3029
3030 print_dot = addr + TO_ADDR (s->size);
3031 }
3032
3033 static void
print_wild_statement(lang_wild_statement_type * w,lang_output_section_statement_type * os)3034 print_wild_statement (lang_wild_statement_type *w,
3035 lang_output_section_statement_type *os)
3036 {
3037 struct wildcard_list *sec;
3038
3039 print_space ();
3040
3041 if (w->filenames_sorted)
3042 minfo ("SORT(");
3043 if (w->filename != NULL)
3044 minfo ("%s", w->filename);
3045 else
3046 minfo ("*");
3047 if (w->filenames_sorted)
3048 minfo (")");
3049
3050 minfo ("(");
3051 for (sec = w->section_list; sec; sec = sec->next)
3052 {
3053 if (sec->spec.sorted)
3054 minfo ("SORT(");
3055 if (sec->spec.exclude_name_list != NULL)
3056 {
3057 name_list *tmp;
3058 minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
3059 for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
3060 minfo (" %s", tmp->name);
3061 minfo (") ");
3062 }
3063 if (sec->spec.name != NULL)
3064 minfo ("%s", sec->spec.name);
3065 else
3066 minfo ("*");
3067 if (sec->spec.sorted)
3068 minfo (")");
3069 if (sec->next)
3070 minfo (" ");
3071 }
3072 minfo (")");
3073
3074 print_nl ();
3075
3076 print_statement_list (w->children.head, os);
3077 }
3078
3079 /* Print a group statement. */
3080
3081 static void
print_group(lang_group_statement_type * s,lang_output_section_statement_type * os)3082 print_group (lang_group_statement_type *s,
3083 lang_output_section_statement_type *os)
3084 {
3085 fprintf (config.map_file, "START GROUP\n");
3086 print_statement_list (s->children.head, os);
3087 fprintf (config.map_file, "END GROUP\n");
3088 }
3089
3090 /* Print the list of statements in S.
3091 This can be called for any statement type. */
3092
3093 static void
print_statement_list(lang_statement_union_type * s,lang_output_section_statement_type * os)3094 print_statement_list (lang_statement_union_type *s,
3095 lang_output_section_statement_type *os)
3096 {
3097 while (s != NULL)
3098 {
3099 print_statement (s, os);
3100 s = s->header.next;
3101 }
3102 }
3103
3104 /* Print the first statement in statement list S.
3105 This can be called for any statement type. */
3106
3107 static void
print_statement(lang_statement_union_type * s,lang_output_section_statement_type * os)3108 print_statement (lang_statement_union_type *s,
3109 lang_output_section_statement_type *os)
3110 {
3111 switch (s->header.type)
3112 {
3113 default:
3114 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
3115 FAIL ();
3116 break;
3117 case lang_constructors_statement_enum:
3118 if (constructor_list.head != NULL)
3119 {
3120 if (constructors_sorted)
3121 minfo (" SORT (CONSTRUCTORS)\n");
3122 else
3123 minfo (" CONSTRUCTORS\n");
3124 print_statement_list (constructor_list.head, os);
3125 }
3126 break;
3127 case lang_wild_statement_enum:
3128 print_wild_statement (&s->wild_statement, os);
3129 break;
3130 case lang_address_statement_enum:
3131 print_address_statement (&s->address_statement);
3132 break;
3133 case lang_object_symbols_statement_enum:
3134 minfo (" CREATE_OBJECT_SYMBOLS\n");
3135 break;
3136 case lang_fill_statement_enum:
3137 print_fill_statement (&s->fill_statement);
3138 break;
3139 case lang_data_statement_enum:
3140 print_data_statement (&s->data_statement);
3141 break;
3142 case lang_reloc_statement_enum:
3143 print_reloc_statement (&s->reloc_statement);
3144 break;
3145 case lang_input_section_enum:
3146 print_input_section (&s->input_section);
3147 break;
3148 case lang_padding_statement_enum:
3149 print_padding_statement (&s->padding_statement);
3150 break;
3151 case lang_output_section_statement_enum:
3152 print_output_section_statement (&s->output_section_statement);
3153 break;
3154 case lang_assignment_statement_enum:
3155 print_assignment (&s->assignment_statement, os);
3156 break;
3157 case lang_target_statement_enum:
3158 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
3159 break;
3160 case lang_output_statement_enum:
3161 minfo ("OUTPUT(%s", s->output_statement.name);
3162 if (output_target != NULL)
3163 minfo (" %s", output_target);
3164 minfo (")\n");
3165 break;
3166 case lang_input_statement_enum:
3167 print_input_statement (&s->input_statement);
3168 break;
3169 case lang_group_statement_enum:
3170 print_group (&s->group_statement, os);
3171 break;
3172 case lang_afile_asection_pair_statement_enum:
3173 FAIL ();
3174 break;
3175 }
3176 }
3177
3178 static void
print_statements(void)3179 print_statements (void)
3180 {
3181 print_statement_list (statement_list.head, abs_output_section);
3182 }
3183
3184 /* Print the first N statements in statement list S to STDERR.
3185 If N == 0, nothing is printed.
3186 If N < 0, the entire list is printed.
3187 Intended to be called from GDB. */
3188
3189 void
dprint_statement(lang_statement_union_type * s,int n)3190 dprint_statement (lang_statement_union_type *s, int n)
3191 {
3192 FILE *map_save = config.map_file;
3193
3194 config.map_file = stderr;
3195
3196 if (n < 0)
3197 print_statement_list (s, abs_output_section);
3198 else
3199 {
3200 while (s && --n >= 0)
3201 {
3202 print_statement (s, abs_output_section);
3203 s = s->header.next;
3204 }
3205 }
3206
3207 config.map_file = map_save;
3208 }
3209
3210 static void
insert_pad(lang_statement_union_type ** ptr,fill_type * fill,unsigned int alignment_needed,asection * output_section,bfd_vma dot)3211 insert_pad (lang_statement_union_type **ptr,
3212 fill_type *fill,
3213 unsigned int alignment_needed,
3214 asection *output_section,
3215 bfd_vma dot)
3216 {
3217 static fill_type zero_fill = { 1, { 0 } };
3218 lang_statement_union_type *pad;
3219
3220 pad = ((lang_statement_union_type *)
3221 ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
3222 if (ptr != &statement_list.head
3223 && pad->header.type == lang_padding_statement_enum
3224 && pad->padding_statement.output_section == output_section)
3225 {
3226 /* Use the existing pad statement. The above test on output
3227 section is probably redundant, but it doesn't hurt to check. */
3228 }
3229 else
3230 {
3231 /* Make a new padding statement, linked into existing chain. */
3232 pad = stat_alloc (sizeof (lang_padding_statement_type));
3233 pad->header.next = *ptr;
3234 *ptr = pad;
3235 pad->header.type = lang_padding_statement_enum;
3236 pad->padding_statement.output_section = output_section;
3237 if (fill == NULL)
3238 fill = &zero_fill;
3239 pad->padding_statement.fill = fill;
3240 }
3241 pad->padding_statement.output_offset = dot - output_section->vma;
3242 pad->padding_statement.size = alignment_needed;
3243 output_section->size += alignment_needed;
3244 }
3245
3246 /* Work out how much this section will move the dot point. */
3247
3248 static bfd_vma
size_input_section(lang_statement_union_type ** this_ptr,lang_output_section_statement_type * output_section_statement,fill_type * fill,bfd_vma dot)3249 size_input_section
3250 (lang_statement_union_type **this_ptr,
3251 lang_output_section_statement_type *output_section_statement,
3252 fill_type *fill,
3253 bfd_vma dot)
3254 {
3255 lang_input_section_type *is = &((*this_ptr)->input_section);
3256 asection *i = is->section;
3257
3258 if (!is->ifile->just_syms_flag && (i->flags & SEC_EXCLUDE) == 0)
3259 {
3260 unsigned int alignment_needed;
3261 asection *o;
3262
3263 /* Align this section first to the input sections requirement,
3264 then to the output section's requirement. If this alignment
3265 is greater than any seen before, then record it too. Perform
3266 the alignment by inserting a magic 'padding' statement. */
3267
3268 if (output_section_statement->subsection_alignment != -1)
3269 i->alignment_power = output_section_statement->subsection_alignment;
3270
3271 o = output_section_statement->bfd_section;
3272 if (o->alignment_power < i->alignment_power)
3273 o->alignment_power = i->alignment_power;
3274
3275 alignment_needed = align_power (dot, i->alignment_power) - dot;
3276
3277 if (alignment_needed != 0)
3278 {
3279 insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
3280 dot += alignment_needed;
3281 }
3282
3283 /* Remember where in the output section this input section goes. */
3284
3285 i->output_offset = dot - o->vma;
3286
3287 /* Mark how big the output section must be to contain this now. */
3288 dot += TO_ADDR (i->size);
3289 o->size = TO_SIZE (dot - o->vma);
3290 }
3291 else
3292 {
3293 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
3294 }
3295
3296 return dot;
3297 }
3298
3299 #define IGNORE_SECTION(s) \
3300 ((s->flags & SEC_NEVER_LOAD) != 0 \
3301 || (s->flags & SEC_ALLOC) == 0 \
3302 || ((s->flags & SEC_THREAD_LOCAL) != 0 \
3303 && (s->flags & SEC_LOAD) == 0))
3304
3305 /* Check to see if any allocated sections overlap with other allocated
3306 sections. This can happen if a linker script specifies the output
3307 section addresses of the two sections. */
3308
3309 static void
lang_check_section_addresses(void)3310 lang_check_section_addresses (void)
3311 {
3312 asection *s;
3313
3314 /* Scan all sections in the output list. */
3315 for (s = output_bfd->sections; s != NULL; s = s->next)
3316 {
3317 asection *os;
3318
3319 /* Ignore sections which are not loaded or which have no contents. */
3320 if (IGNORE_SECTION (s) || s->size == 0)
3321 continue;
3322
3323 /* Once we reach section 's' stop our seach. This prevents two
3324 warning messages from being produced, one for 'section A overlaps
3325 section B' and one for 'section B overlaps section A'. */
3326 for (os = output_bfd->sections; os != s; os = os->next)
3327 {
3328 bfd_vma s_start;
3329 bfd_vma s_end;
3330 bfd_vma os_start;
3331 bfd_vma os_end;
3332
3333 /* Only consider loadable sections with real contents. */
3334 if (IGNORE_SECTION (os) || os->size == 0)
3335 continue;
3336
3337 /* We must check the sections' LMA addresses not their
3338 VMA addresses because overlay sections can have
3339 overlapping VMAs but they must have distinct LMAs. */
3340 s_start = bfd_section_lma (output_bfd, s);
3341 os_start = bfd_section_lma (output_bfd, os);
3342 s_end = s_start + TO_ADDR (s->size) - 1;
3343 os_end = os_start + TO_ADDR (os->size) - 1;
3344
3345 /* Look for an overlap. */
3346 if ((s_end < os_start) || (s_start > os_end))
3347 continue;
3348
3349 einfo (
3350 _("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
3351 s->name, s_start, s_end, os->name, os_start, os_end);
3352
3353 /* Once we have found one overlap for this section,
3354 stop looking for others. */
3355 break;
3356 }
3357 }
3358 }
3359
3360 /* Make sure the new address is within the region. We explicitly permit the
3361 current address to be at the exact end of the region when the address is
3362 non-zero, in case the region is at the end of addressable memory and the
3363 calculation wraps around. */
3364
3365 static void
os_region_check(lang_output_section_statement_type * os,lang_memory_region_type * region,etree_type * tree,bfd_vma base)3366 os_region_check (lang_output_section_statement_type *os,
3367 lang_memory_region_type *region,
3368 etree_type *tree,
3369 bfd_vma base)
3370 {
3371 if ((region->current < region->origin
3372 || (region->current - region->origin > region->length))
3373 && ((region->current != region->origin + region->length)
3374 || base == 0))
3375 {
3376 if (tree != NULL)
3377 {
3378 einfo (_("%X%P: address 0x%v of %B section %s"
3379 " is not within region %s\n"),
3380 region->current,
3381 os->bfd_section->owner,
3382 os->bfd_section->name,
3383 region->name);
3384 }
3385 else
3386 {
3387 einfo (_("%X%P: region %s is full (%B section %s)\n"),
3388 region->name,
3389 os->bfd_section->owner,
3390 os->bfd_section->name);
3391 }
3392 /* Reset the region pointer. */
3393 region->current = region->origin;
3394 }
3395 }
3396
3397 /* Set the sizes for all the output sections. */
3398
3399 static bfd_vma
lang_size_sections_1(lang_statement_union_type * s,lang_output_section_statement_type * output_section_statement,lang_statement_union_type ** prev,fill_type * fill,bfd_vma dot,bfd_boolean * relax,bfd_boolean check_regions)3400 lang_size_sections_1
3401 (lang_statement_union_type *s,
3402 lang_output_section_statement_type *output_section_statement,
3403 lang_statement_union_type **prev,
3404 fill_type *fill,
3405 bfd_vma dot,
3406 bfd_boolean *relax,
3407 bfd_boolean check_regions)
3408 {
3409 /* Size up the sections from their constituent parts. */
3410 for (; s != NULL; s = s->header.next)
3411 {
3412 switch (s->header.type)
3413 {
3414 case lang_output_section_statement_enum:
3415 {
3416 bfd_vma after;
3417 lang_output_section_statement_type *os;
3418
3419 os = &s->output_section_statement;
3420 if (os->bfd_section == NULL)
3421 /* This section was never actually created. */
3422 break;
3423
3424 /* If this is a COFF shared library section, use the size and
3425 address from the input section. FIXME: This is COFF
3426 specific; it would be cleaner if there were some other way
3427 to do this, but nothing simple comes to mind. */
3428 if ((bfd_get_flavour (output_bfd) == bfd_target_ecoff_flavour
3429 || bfd_get_flavour (output_bfd) == bfd_target_coff_flavour)
3430 && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
3431 {
3432 asection *input;
3433
3434 if (os->children.head == NULL
3435 || os->children.head->header.next != NULL
3436 || (os->children.head->header.type
3437 != lang_input_section_enum))
3438 einfo (_("%P%X: Internal error on COFF shared library"
3439 " section %s\n"), os->name);
3440
3441 input = os->children.head->input_section.section;
3442 bfd_set_section_vma (os->bfd_section->owner,
3443 os->bfd_section,
3444 bfd_section_vma (input->owner, input));
3445 os->bfd_section->size = input->size;
3446 break;
3447 }
3448
3449 if (bfd_is_abs_section (os->bfd_section))
3450 {
3451 /* No matter what happens, an abs section starts at zero. */
3452 ASSERT (os->bfd_section->vma == 0);
3453 }
3454 else
3455 {
3456 if (os->addr_tree == NULL)
3457 {
3458 /* No address specified for this section, get one
3459 from the region specification. */
3460 if (os->region == NULL
3461 || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
3462 && os->region->name[0] == '*'
3463 && strcmp (os->region->name,
3464 DEFAULT_MEMORY_REGION) == 0))
3465 {
3466 os->region = lang_memory_default (os->bfd_section);
3467 }
3468
3469 /* If a loadable section is using the default memory
3470 region, and some non default memory regions were
3471 defined, issue an error message. */
3472 if (!IGNORE_SECTION (os->bfd_section)
3473 && ! link_info.relocatable
3474 && check_regions
3475 && strcmp (os->region->name,
3476 DEFAULT_MEMORY_REGION) == 0
3477 && lang_memory_region_list != NULL
3478 && (strcmp (lang_memory_region_list->name,
3479 DEFAULT_MEMORY_REGION) != 0
3480 || lang_memory_region_list->next != NULL))
3481 {
3482 /* By default this is an error rather than just a
3483 warning because if we allocate the section to the
3484 default memory region we can end up creating an
3485 excessively large binary, or even seg faulting when
3486 attempting to perform a negative seek. See
3487 sources.redhat.com/ml/binutils/2003-04/msg00423.html
3488 for an example of this. This behaviour can be
3489 overridden by the using the --no-check-sections
3490 switch. */
3491 if (command_line.check_section_addresses)
3492 einfo (_("%P%F: error: no memory region specified"
3493 " for loadable section `%s'\n"),
3494 bfd_get_section_name (output_bfd,
3495 os->bfd_section));
3496 else
3497 einfo (_("%P: warning: no memory region specified"
3498 " for loadable section `%s'\n"),
3499 bfd_get_section_name (output_bfd,
3500 os->bfd_section));
3501 }
3502
3503 dot = os->region->current;
3504
3505 if (os->section_alignment == -1)
3506 {
3507 bfd_vma olddot;
3508
3509 olddot = dot;
3510 dot = align_power (dot,
3511 os->bfd_section->alignment_power);
3512
3513 if (dot != olddot && config.warn_section_align)
3514 einfo (_("%P: warning: changing start of section"
3515 " %s by %u bytes\n"),
3516 os->name, (unsigned int) (dot - olddot));
3517 }
3518 }
3519 else
3520 {
3521 etree_value_type r;
3522
3523 os->processed = -1;
3524 r = exp_fold_tree (os->addr_tree,
3525 abs_output_section,
3526 lang_allocating_phase_enum,
3527 dot, &dot);
3528 os->processed = 0;
3529
3530 if (!r.valid_p)
3531 einfo (_("%F%S: non constant or forward reference"
3532 " address expression for section %s\n"),
3533 os->name);
3534
3535 dot = r.value + r.section->bfd_section->vma;
3536 }
3537
3538 /* The section starts here.
3539 First, align to what the section needs. */
3540
3541 if (os->section_alignment != -1)
3542 dot = align_power (dot, os->section_alignment);
3543
3544 bfd_set_section_vma (0, os->bfd_section, dot);
3545
3546 os->bfd_section->output_offset = 0;
3547 }
3548
3549 lang_size_sections_1 (os->children.head, os, &os->children.head,
3550 os->fill, dot, relax, check_regions);
3551
3552 /* Put the section within the requested block size, or
3553 align at the block boundary. */
3554 after = ((os->bfd_section->vma
3555 + TO_ADDR (os->bfd_section->size)
3556 + os->block_value - 1)
3557 & - (bfd_vma) os->block_value);
3558
3559 if (bfd_is_abs_section (os->bfd_section))
3560 ASSERT (after == os->bfd_section->vma);
3561 else
3562 os->bfd_section->size
3563 = TO_SIZE (after - os->bfd_section->vma);
3564
3565 dot = os->bfd_section->vma;
3566 /* .tbss sections effectively have zero size. */
3567 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
3568 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
3569 || link_info.relocatable)
3570 dot += TO_ADDR (os->bfd_section->size);
3571
3572 os->processed = 1;
3573
3574 if (os->update_dot_tree != 0)
3575 exp_fold_tree (os->update_dot_tree, abs_output_section,
3576 lang_allocating_phase_enum, dot, &dot);
3577
3578 /* Update dot in the region ?
3579 We only do this if the section is going to be allocated,
3580 since unallocated sections do not contribute to the region's
3581 overall size in memory.
3582
3583 If the SEC_NEVER_LOAD bit is not set, it will affect the
3584 addresses of sections after it. We have to update
3585 dot. */
3586 if (os->region != NULL
3587 && ((os->bfd_section->flags & SEC_NEVER_LOAD) == 0
3588 || (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))))
3589 {
3590 os->region->current = dot;
3591
3592 if (check_regions)
3593 /* Make sure the new address is within the region. */
3594 os_region_check (os, os->region, os->addr_tree,
3595 os->bfd_section->vma);
3596
3597 /* If there's no load address specified, use the run
3598 region as the load region. */
3599 if (os->lma_region == NULL && os->load_base == NULL)
3600 os->lma_region = os->region;
3601
3602 if (os->lma_region != NULL && os->lma_region != os->region)
3603 {
3604 /* Set load_base, which will be handled later. */
3605 os->load_base = exp_intop (os->lma_region->current);
3606 os->lma_region->current +=
3607 TO_ADDR (os->bfd_section->size);
3608 if (check_regions)
3609 os_region_check (os, os->lma_region, NULL,
3610 os->bfd_section->lma);
3611 }
3612 }
3613 }
3614 break;
3615
3616 case lang_constructors_statement_enum:
3617 dot = lang_size_sections_1 (constructor_list.head,
3618 output_section_statement,
3619 &s->wild_statement.children.head,
3620 fill, dot, relax, check_regions);
3621 break;
3622
3623 case lang_data_statement_enum:
3624 {
3625 unsigned int size = 0;
3626
3627 s->data_statement.output_vma =
3628 dot - output_section_statement->bfd_section->vma;
3629 s->data_statement.output_section =
3630 output_section_statement->bfd_section;
3631
3632 /* We might refer to provided symbols in the expression, and
3633 need to mark them as needed. */
3634 exp_fold_tree (s->data_statement.exp, abs_output_section,
3635 lang_allocating_phase_enum, dot, &dot);
3636
3637 switch (s->data_statement.type)
3638 {
3639 default:
3640 abort ();
3641 case QUAD:
3642 case SQUAD:
3643 size = QUAD_SIZE;
3644 break;
3645 case LONG:
3646 size = LONG_SIZE;
3647 break;
3648 case SHORT:
3649 size = SHORT_SIZE;
3650 break;
3651 case BYTE:
3652 size = BYTE_SIZE;
3653 break;
3654 }
3655 if (size < TO_SIZE ((unsigned) 1))
3656 size = TO_SIZE ((unsigned) 1);
3657 dot += TO_ADDR (size);
3658 output_section_statement->bfd_section->size += size;
3659 }
3660 break;
3661
3662 case lang_reloc_statement_enum:
3663 {
3664 int size;
3665
3666 s->reloc_statement.output_vma =
3667 dot - output_section_statement->bfd_section->vma;
3668 s->reloc_statement.output_section =
3669 output_section_statement->bfd_section;
3670 size = bfd_get_reloc_size (s->reloc_statement.howto);
3671 dot += TO_ADDR (size);
3672 output_section_statement->bfd_section->size += size;
3673 }
3674 break;
3675
3676 case lang_wild_statement_enum:
3677
3678 dot = lang_size_sections_1 (s->wild_statement.children.head,
3679 output_section_statement,
3680 &s->wild_statement.children.head,
3681 fill, dot, relax, check_regions);
3682
3683 break;
3684
3685 case lang_object_symbols_statement_enum:
3686 link_info.create_object_symbols_section =
3687 output_section_statement->bfd_section;
3688 break;
3689 case lang_output_statement_enum:
3690 case lang_target_statement_enum:
3691 break;
3692 case lang_input_section_enum:
3693 {
3694 asection *i;
3695
3696 i = (*prev)->input_section.section;
3697 if (relax)
3698 {
3699 bfd_boolean again;
3700
3701 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3702 einfo (_("%P%F: can't relax section: %E\n"));
3703 if (again)
3704 *relax = TRUE;
3705 }
3706 dot = size_input_section (prev, output_section_statement,
3707 output_section_statement->fill, dot);
3708 }
3709 break;
3710 case lang_input_statement_enum:
3711 break;
3712 case lang_fill_statement_enum:
3713 s->fill_statement.output_section =
3714 output_section_statement->bfd_section;
3715
3716 fill = s->fill_statement.fill;
3717 break;
3718 case lang_assignment_statement_enum:
3719 {
3720 bfd_vma newdot = dot;
3721
3722 exp_fold_tree (s->assignment_statement.exp,
3723 output_section_statement,
3724 lang_allocating_phase_enum,
3725 dot,
3726 &newdot);
3727
3728 if (newdot != dot)
3729 {
3730 if (output_section_statement == abs_output_section)
3731 {
3732 /* If we don't have an output section, then just adjust
3733 the default memory address. */
3734 lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
3735 FALSE)->current = newdot;
3736 }
3737 else
3738 {
3739 /* Insert a pad after this statement. We can't
3740 put the pad before when relaxing, in case the
3741 assignment references dot. */
3742 insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
3743 output_section_statement->bfd_section, dot);
3744
3745 /* Don't neuter the pad below when relaxing. */
3746 s = s->header.next;
3747 }
3748
3749 /* If dot is advanced, this implies that the section should
3750 have space allocated to it, unless the user has explicitly
3751 stated that the section should never be loaded. */
3752 if (!(output_section_statement->flags
3753 & (SEC_NEVER_LOAD | SEC_ALLOC)))
3754 output_section_statement->bfd_section->flags |= SEC_ALLOC;
3755
3756 dot = newdot;
3757 }
3758 }
3759 break;
3760
3761 case lang_padding_statement_enum:
3762 /* If this is the first time lang_size_sections is called,
3763 we won't have any padding statements. If this is the
3764 second or later passes when relaxing, we should allow
3765 padding to shrink. If padding is needed on this pass, it
3766 will be added back in. */
3767 s->padding_statement.size = 0;
3768
3769 /* Make sure output_offset is valid. If relaxation shrinks
3770 the section and this pad isn't needed, it's possible to
3771 have output_offset larger than the final size of the
3772 section. bfd_set_section_contents will complain even for
3773 a pad size of zero. */
3774 s->padding_statement.output_offset
3775 = dot - output_section_statement->bfd_section->vma;
3776 break;
3777
3778 case lang_group_statement_enum:
3779 dot = lang_size_sections_1 (s->group_statement.children.head,
3780 output_section_statement,
3781 &s->group_statement.children.head,
3782 fill, dot, relax, check_regions);
3783 break;
3784
3785 default:
3786 FAIL ();
3787 break;
3788
3789 /* We can only get here when relaxing is turned on. */
3790 case lang_address_statement_enum:
3791 break;
3792 }
3793 prev = &s->header.next;
3794 }
3795 return dot;
3796 }
3797
3798 bfd_vma
lang_size_sections(lang_statement_union_type * s,lang_output_section_statement_type * output_section_statement,lang_statement_union_type ** prev,fill_type * fill,bfd_vma dot,bfd_boolean * relax,bfd_boolean check_regions)3799 lang_size_sections
3800 (lang_statement_union_type *s,
3801 lang_output_section_statement_type *output_section_statement,
3802 lang_statement_union_type **prev,
3803 fill_type *fill,
3804 bfd_vma dot,
3805 bfd_boolean *relax,
3806 bfd_boolean check_regions)
3807 {
3808 bfd_vma result;
3809
3810 /* Callers of exp_fold_tree need to increment this. */
3811 lang_statement_iteration++;
3812
3813 exp_data_seg.phase = exp_dataseg_none;
3814 result = lang_size_sections_1 (s, output_section_statement, prev, fill,
3815 dot, relax, check_regions);
3816 if (exp_data_seg.phase == exp_dataseg_end_seen
3817 && link_info.relro && exp_data_seg.relro_end)
3818 {
3819 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
3820 to put exp_data_seg.relro on a (common) page boundary. */
3821 bfd_vma old_min_base, relro_end, maxpage;
3822
3823 exp_data_seg.phase = exp_dataseg_relro_adjust;
3824 old_min_base = exp_data_seg.min_base;
3825 maxpage = exp_data_seg.maxpagesize;
3826 exp_data_seg.base += (-exp_data_seg.relro_end
3827 & (exp_data_seg.pagesize - 1));
3828 /* Compute the expected PT_GNU_RELRO segment end. */
3829 relro_end = (exp_data_seg.relro_end + exp_data_seg.pagesize - 1)
3830 & ~(exp_data_seg.pagesize - 1);
3831 if (old_min_base + maxpage < exp_data_seg.base)
3832 {
3833 exp_data_seg.base -= maxpage;
3834 relro_end -= maxpage;
3835 }
3836 result = lang_size_sections_1 (s, output_section_statement, prev, fill,
3837 dot, relax, check_regions);
3838 if (exp_data_seg.relro_end > relro_end)
3839 {
3840 /* The alignment of sections between DATA_SEGMENT_ALIGN
3841 and DATA_SEGMENT_RELRO_END caused huge padding to be
3842 inserted at DATA_SEGMENT_RELRO_END. Try some other base. */
3843 asection *sec;
3844 unsigned int max_alignment_power = 0;
3845
3846 /* Find maximum alignment power of sections between
3847 DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END. */
3848 for (sec = output_bfd->sections; sec; sec = sec->next)
3849 if (sec->vma >= exp_data_seg.base
3850 && sec->vma < exp_data_seg.relro_end
3851 && sec->alignment_power > max_alignment_power)
3852 max_alignment_power = sec->alignment_power;
3853
3854 if (((bfd_vma) 1 << max_alignment_power) < exp_data_seg.pagesize)
3855 {
3856 if (exp_data_seg.base - (1 << max_alignment_power)
3857 < old_min_base)
3858 exp_data_seg.base += exp_data_seg.pagesize;
3859 exp_data_seg.base -= (1 << max_alignment_power);
3860 result = lang_size_sections_1 (s, output_section_statement,
3861 prev, fill, dot, relax,
3862 check_regions);
3863 }
3864 }
3865 link_info.relro_start = exp_data_seg.base;
3866 link_info.relro_end = exp_data_seg.relro_end;
3867 }
3868 else if (exp_data_seg.phase == exp_dataseg_end_seen)
3869 {
3870 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3871 a page could be saved in the data segment. */
3872 bfd_vma first, last;
3873
3874 first = -exp_data_seg.base & (exp_data_seg.pagesize - 1);
3875 last = exp_data_seg.end & (exp_data_seg.pagesize - 1);
3876 if (first && last
3877 && ((exp_data_seg.base & ~(exp_data_seg.pagesize - 1))
3878 != (exp_data_seg.end & ~(exp_data_seg.pagesize - 1)))
3879 && first + last <= exp_data_seg.pagesize)
3880 {
3881 exp_data_seg.phase = exp_dataseg_adjust;
3882 lang_statement_iteration++;
3883 result = lang_size_sections_1 (s, output_section_statement, prev,
3884 fill, dot, relax, check_regions);
3885 }
3886 }
3887
3888 return result;
3889 }
3890
3891 /* Worker function for lang_do_assignments. Recursiveness goes here. */
3892
3893 static bfd_vma
lang_do_assignments_1(lang_statement_union_type * s,lang_output_section_statement_type * output_section_statement,fill_type * fill,bfd_vma dot)3894 lang_do_assignments_1
3895 (lang_statement_union_type *s,
3896 lang_output_section_statement_type *output_section_statement,
3897 fill_type *fill,
3898 bfd_vma dot)
3899 {
3900 for (; s != NULL; s = s->header.next)
3901 {
3902 switch (s->header.type)
3903 {
3904 case lang_constructors_statement_enum:
3905 dot = lang_do_assignments_1 (constructor_list.head,
3906 output_section_statement,
3907 fill,
3908 dot);
3909 break;
3910
3911 case lang_output_section_statement_enum:
3912 {
3913 lang_output_section_statement_type *os;
3914
3915 os = &(s->output_section_statement);
3916 if (os->bfd_section != NULL)
3917 {
3918 dot = os->bfd_section->vma;
3919 lang_do_assignments_1 (os->children.head, os, os->fill, dot);
3920 /* .tbss sections effectively have zero size. */
3921 if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
3922 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
3923 || link_info.relocatable)
3924 dot += TO_ADDR (os->bfd_section->size);
3925 }
3926 if (os->load_base)
3927 {
3928 /* If nothing has been placed into the output section then
3929 it won't have a bfd_section. */
3930 if (os->bfd_section)
3931 {
3932 os->bfd_section->lma
3933 = exp_get_abs_int (os->load_base, 0, "load base",
3934 lang_final_phase_enum);
3935 }
3936 }
3937 }
3938 break;
3939 case lang_wild_statement_enum:
3940
3941 dot = lang_do_assignments_1 (s->wild_statement.children.head,
3942 output_section_statement,
3943 fill, dot);
3944
3945 break;
3946
3947 case lang_object_symbols_statement_enum:
3948 case lang_output_statement_enum:
3949 case lang_target_statement_enum:
3950 break;
3951 case lang_data_statement_enum:
3952 {
3953 etree_value_type value;
3954
3955 value = exp_fold_tree (s->data_statement.exp,
3956 abs_output_section,
3957 lang_final_phase_enum, dot, &dot);
3958 if (!value.valid_p)
3959 einfo (_("%F%P: invalid data statement\n"));
3960 s->data_statement.value
3961 = value.value + value.section->bfd_section->vma;
3962 }
3963 {
3964 unsigned int size;
3965 switch (s->data_statement.type)
3966 {
3967 default:
3968 abort ();
3969 case QUAD:
3970 case SQUAD:
3971 size = QUAD_SIZE;
3972 break;
3973 case LONG:
3974 size = LONG_SIZE;
3975 break;
3976 case SHORT:
3977 size = SHORT_SIZE;
3978 break;
3979 case BYTE:
3980 size = BYTE_SIZE;
3981 break;
3982 }
3983 if (size < TO_SIZE ((unsigned) 1))
3984 size = TO_SIZE ((unsigned) 1);
3985 dot += TO_ADDR (size);
3986 }
3987 break;
3988
3989 case lang_reloc_statement_enum:
3990 {
3991 etree_value_type value;
3992
3993 value = exp_fold_tree (s->reloc_statement.addend_exp,
3994 abs_output_section,
3995 lang_final_phase_enum, dot, &dot);
3996 s->reloc_statement.addend_value = value.value;
3997 if (!value.valid_p)
3998 einfo (_("%F%P: invalid reloc statement\n"));
3999 }
4000 dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
4001 break;
4002
4003 case lang_input_section_enum:
4004 {
4005 asection *in = s->input_section.section;
4006
4007 if ((in->flags & SEC_EXCLUDE) == 0)
4008 dot += TO_ADDR (in->size);
4009 }
4010 break;
4011
4012 case lang_input_statement_enum:
4013 break;
4014 case lang_fill_statement_enum:
4015 fill = s->fill_statement.fill;
4016 break;
4017 case lang_assignment_statement_enum:
4018 {
4019 exp_fold_tree (s->assignment_statement.exp,
4020 output_section_statement,
4021 lang_final_phase_enum,
4022 dot,
4023 &dot);
4024 }
4025
4026 break;
4027 case lang_padding_statement_enum:
4028 dot += TO_ADDR (s->padding_statement.size);
4029 break;
4030
4031 case lang_group_statement_enum:
4032 dot = lang_do_assignments_1 (s->group_statement.children.head,
4033 output_section_statement,
4034 fill, dot);
4035
4036 break;
4037
4038 default:
4039 FAIL ();
4040 break;
4041 case lang_address_statement_enum:
4042 break;
4043 }
4044
4045 }
4046 return dot;
4047 }
4048
4049 void
lang_do_assignments(lang_statement_union_type * s,lang_output_section_statement_type * output_section_statement,fill_type * fill,bfd_vma dot)4050 lang_do_assignments
4051 (lang_statement_union_type *s,
4052 lang_output_section_statement_type *output_section_statement,
4053 fill_type *fill,
4054 bfd_vma dot)
4055 {
4056 /* Callers of exp_fold_tree need to increment this. */
4057 lang_statement_iteration++;
4058 lang_do_assignments_1 (s, output_section_statement, fill, dot);
4059 }
4060
4061 /* Fix any .startof. or .sizeof. symbols. When the assemblers see the
4062 operator .startof. (section_name), it produces an undefined symbol
4063 .startof.section_name. Similarly, when it sees
4064 .sizeof. (section_name), it produces an undefined symbol
4065 .sizeof.section_name. For all the output sections, we look for
4066 such symbols, and set them to the correct value. */
4067
4068 static void
lang_set_startof(void)4069 lang_set_startof (void)
4070 {
4071 asection *s;
4072
4073 if (link_info.relocatable)
4074 return;
4075
4076 for (s = output_bfd->sections; s != NULL; s = s->next)
4077 {
4078 const char *secname;
4079 char *buf;
4080 struct bfd_link_hash_entry *h;
4081
4082 secname = bfd_get_section_name (output_bfd, s);
4083 buf = xmalloc (10 + strlen (secname));
4084
4085 sprintf (buf, ".startof.%s", secname);
4086 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
4087 if (h != NULL && h->type == bfd_link_hash_undefined)
4088 {
4089 h->type = bfd_link_hash_defined;
4090 h->u.def.value = bfd_get_section_vma (output_bfd, s);
4091 h->u.def.section = bfd_abs_section_ptr;
4092 }
4093
4094 sprintf (buf, ".sizeof.%s", secname);
4095 h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
4096 if (h != NULL && h->type == bfd_link_hash_undefined)
4097 {
4098 h->type = bfd_link_hash_defined;
4099 h->u.def.value = TO_ADDR (s->size);
4100 h->u.def.section = bfd_abs_section_ptr;
4101 }
4102
4103 free (buf);
4104 }
4105 }
4106
4107 static void
lang_finish(void)4108 lang_finish (void)
4109 {
4110 struct bfd_link_hash_entry *h;
4111 bfd_boolean warn;
4112
4113 if (link_info.relocatable || link_info.shared)
4114 warn = FALSE;
4115 else
4116 warn = TRUE;
4117
4118 if (entry_symbol.name == NULL)
4119 {
4120 /* No entry has been specified. Look for start, but don't warn
4121 if we don't find it. */
4122 entry_symbol.name = "start";
4123 warn = FALSE;
4124 }
4125
4126 h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
4127 FALSE, FALSE, TRUE);
4128 if (h != NULL
4129 && (h->type == bfd_link_hash_defined
4130 || h->type == bfd_link_hash_defweak)
4131 && h->u.def.section->output_section != NULL)
4132 {
4133 bfd_vma val;
4134
4135 val = (h->u.def.value
4136 + bfd_get_section_vma (output_bfd,
4137 h->u.def.section->output_section)
4138 + h->u.def.section->output_offset);
4139 if (! bfd_set_start_address (output_bfd, val))
4140 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
4141 }
4142 else
4143 {
4144 bfd_vma val;
4145 const char *send;
4146
4147 /* We couldn't find the entry symbol. Try parsing it as a
4148 number. */
4149 val = bfd_scan_vma (entry_symbol.name, &send, 0);
4150 if (*send == '\0')
4151 {
4152 if (! bfd_set_start_address (output_bfd, val))
4153 einfo (_("%P%F: can't set start address\n"));
4154 }
4155 else
4156 {
4157 asection *ts;
4158
4159 /* Can't find the entry symbol, and it's not a number. Use
4160 the first address in the text section. */
4161 ts = bfd_get_section_by_name (output_bfd, entry_section);
4162 if (ts != NULL)
4163 {
4164 if (warn)
4165 einfo (_("%P: warning: cannot find entry symbol %s;"
4166 " defaulting to %V\n"),
4167 entry_symbol.name,
4168 bfd_get_section_vma (output_bfd, ts));
4169 if (! bfd_set_start_address (output_bfd,
4170 bfd_get_section_vma (output_bfd,
4171 ts)))
4172 einfo (_("%P%F: can't set start address\n"));
4173 }
4174 else
4175 {
4176 if (warn)
4177 einfo (_("%P: warning: cannot find entry symbol %s;"
4178 " not setting start address\n"),
4179 entry_symbol.name);
4180 }
4181 }
4182 }
4183
4184 /* Don't bfd_hash_table_free (&lang_definedness_table);
4185 map file output may result in a call of lang_track_definedness. */
4186 }
4187
4188 /* This is a small function used when we want to ignore errors from
4189 BFD. */
4190
4191 static void
ignore_bfd_errors(const char * s ATTRIBUTE_UNUSED,...)4192 ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
4193 {
4194 /* Don't do anything. */
4195 }
4196
4197 /* Check that the architecture of all the input files is compatible
4198 with the output file. Also call the backend to let it do any
4199 other checking that is needed. */
4200
4201 static void
lang_check(void)4202 lang_check (void)
4203 {
4204 lang_statement_union_type *file;
4205 bfd *input_bfd;
4206 const bfd_arch_info_type *compatible;
4207
4208 for (file = file_chain.head; file != NULL; file = file->input_statement.next)
4209 {
4210 input_bfd = file->input_statement.the_bfd;
4211 compatible
4212 = bfd_arch_get_compatible (input_bfd, output_bfd,
4213 command_line.accept_unknown_input_arch);
4214
4215 /* In general it is not possible to perform a relocatable
4216 link between differing object formats when the input
4217 file has relocations, because the relocations in the
4218 input format may not have equivalent representations in
4219 the output format (and besides BFD does not translate
4220 relocs for other link purposes than a final link). */
4221 if ((link_info.relocatable || link_info.emitrelocations)
4222 && (compatible == NULL
4223 || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
4224 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
4225 {
4226 einfo (_("%P%F: Relocatable linking with relocations from"
4227 " format %s (%B) to format %s (%B) is not supported\n"),
4228 bfd_get_target (input_bfd), input_bfd,
4229 bfd_get_target (output_bfd), output_bfd);
4230 /* einfo with %F exits. */
4231 }
4232
4233 if (compatible == NULL)
4234 {
4235 if (command_line.warn_mismatch)
4236 einfo (_("%P: warning: %s architecture of input file `%B'"
4237 " is incompatible with %s output\n"),
4238 bfd_printable_name (input_bfd), input_bfd,
4239 bfd_printable_name (output_bfd));
4240 }
4241 else if (bfd_count_sections (input_bfd))
4242 {
4243 /* If the input bfd has no contents, it shouldn't set the
4244 private data of the output bfd. */
4245
4246 bfd_error_handler_type pfn = NULL;
4247
4248 /* If we aren't supposed to warn about mismatched input
4249 files, temporarily set the BFD error handler to a
4250 function which will do nothing. We still want to call
4251 bfd_merge_private_bfd_data, since it may set up
4252 information which is needed in the output file. */
4253 if (! command_line.warn_mismatch)
4254 pfn = bfd_set_error_handler (ignore_bfd_errors);
4255 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
4256 {
4257 if (command_line.warn_mismatch)
4258 einfo (_("%P%X: failed to merge target specific data"
4259 " of file %B\n"), input_bfd);
4260 }
4261 if (! command_line.warn_mismatch)
4262 bfd_set_error_handler (pfn);
4263 }
4264 }
4265 }
4266
4267 /* Look through all the global common symbols and attach them to the
4268 correct section. The -sort-common command line switch may be used
4269 to roughly sort the entries by size. */
4270
4271 static void
lang_common(void)4272 lang_common (void)
4273 {
4274 if (command_line.inhibit_common_definition)
4275 return;
4276 if (link_info.relocatable
4277 && ! command_line.force_common_definition)
4278 return;
4279
4280 if (! config.sort_common)
4281 bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
4282 else
4283 {
4284 int power;
4285
4286 for (power = 4; power >= 0; power--)
4287 bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
4288 }
4289 }
4290
4291 /* Place one common symbol in the correct section. */
4292
4293 static bfd_boolean
lang_one_common(struct bfd_link_hash_entry * h,void * info)4294 lang_one_common (struct bfd_link_hash_entry *h, void *info)
4295 {
4296 unsigned int power_of_two;
4297 bfd_vma size;
4298 asection *section;
4299
4300 if (h->type != bfd_link_hash_common)
4301 return TRUE;
4302
4303 size = h->u.c.size;
4304 power_of_two = h->u.c.p->alignment_power;
4305
4306 if (config.sort_common
4307 && power_of_two < (unsigned int) *(int *) info)
4308 return TRUE;
4309
4310 section = h->u.c.p->section;
4311
4312 /* Increase the size of the section to align the common sym. */
4313 section->size += ((bfd_vma) 1 << (power_of_two + opb_shift)) - 1;
4314 section->size &= (- (bfd_vma) 1 << (power_of_two + opb_shift));
4315
4316 /* Adjust the alignment if necessary. */
4317 if (power_of_two > section->alignment_power)
4318 section->alignment_power = power_of_two;
4319
4320 /* Change the symbol from common to defined. */
4321 h->type = bfd_link_hash_defined;
4322 h->u.def.section = section;
4323 h->u.def.value = section->size;
4324
4325 /* Increase the size of the section. */
4326 section->size += size;
4327
4328 /* Make sure the section is allocated in memory, and make sure that
4329 it is no longer a common section. */
4330 section->flags |= SEC_ALLOC;
4331 section->flags &= ~SEC_IS_COMMON;
4332
4333 if (config.map_file != NULL)
4334 {
4335 static bfd_boolean header_printed;
4336 int len;
4337 char *name;
4338 char buf[50];
4339
4340 if (! header_printed)
4341 {
4342 minfo (_("\nAllocating common symbols\n"));
4343 minfo (_("Common symbol size file\n\n"));
4344 header_printed = TRUE;
4345 }
4346
4347 name = demangle (h->root.string);
4348 minfo ("%s", name);
4349 len = strlen (name);
4350 free (name);
4351
4352 if (len >= 19)
4353 {
4354 print_nl ();
4355 len = 0;
4356 }
4357 while (len < 20)
4358 {
4359 print_space ();
4360 ++len;
4361 }
4362
4363 minfo ("0x");
4364 if (size <= 0xffffffff)
4365 sprintf (buf, "%lx", (unsigned long) size);
4366 else
4367 sprintf_vma (buf, size);
4368 minfo ("%s", buf);
4369 len = strlen (buf);
4370
4371 while (len < 16)
4372 {
4373 print_space ();
4374 ++len;
4375 }
4376
4377 minfo ("%B\n", section->owner);
4378 }
4379
4380 return TRUE;
4381 }
4382
4383 /* Run through the input files and ensure that every input section has
4384 somewhere to go. If one is found without a destination then create
4385 an input request and place it into the statement tree. */
4386
4387 static void
lang_place_orphans(void)4388 lang_place_orphans (void)
4389 {
4390 LANG_FOR_EACH_INPUT_STATEMENT (file)
4391 {
4392 asection *s;
4393
4394 for (s = file->the_bfd->sections; s != NULL; s = s->next)
4395 {
4396 if (s->output_section == NULL)
4397 {
4398 /* This section of the file is not attached, root
4399 around for a sensible place for it to go. */
4400
4401 if (file->just_syms_flag)
4402 bfd_link_just_syms (file->the_bfd, s, &link_info);
4403 else if ((s->flags & SEC_EXCLUDE) != 0)
4404 s->output_section = bfd_abs_section_ptr;
4405 else if (strcmp (s->name, "COMMON") == 0)
4406 {
4407 /* This is a lonely common section which must have
4408 come from an archive. We attach to the section
4409 with the wildcard. */
4410 if (! link_info.relocatable
4411 || command_line.force_common_definition)
4412 {
4413 if (default_common_section == NULL)
4414 {
4415 default_common_section =
4416 lang_output_section_statement_lookup (".bss");
4417
4418 }
4419 lang_add_section (&default_common_section->children, s,
4420 default_common_section, file);
4421 }
4422 }
4423 else if (ldemul_place_orphan (file, s))
4424 ;
4425 else
4426 {
4427 lang_output_section_statement_type *os;
4428
4429 os = lang_output_section_statement_lookup (s->name);
4430 lang_add_section (&os->children, s, os, file);
4431 }
4432 }
4433 }
4434 }
4435 }
4436
4437 void
lang_set_flags(lang_memory_region_type * ptr,const char * flags,int invert)4438 lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
4439 {
4440 flagword *ptr_flags;
4441
4442 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
4443 while (*flags)
4444 {
4445 switch (*flags)
4446 {
4447 case 'A': case 'a':
4448 *ptr_flags |= SEC_ALLOC;
4449 break;
4450
4451 case 'R': case 'r':
4452 *ptr_flags |= SEC_READONLY;
4453 break;
4454
4455 case 'W': case 'w':
4456 *ptr_flags |= SEC_DATA;
4457 break;
4458
4459 case 'X': case 'x':
4460 *ptr_flags |= SEC_CODE;
4461 break;
4462
4463 case 'L': case 'l':
4464 case 'I': case 'i':
4465 *ptr_flags |= SEC_LOAD;
4466 break;
4467
4468 default:
4469 einfo (_("%P%F: invalid syntax in flags\n"));
4470 break;
4471 }
4472 flags++;
4473 }
4474 }
4475
4476 /* Call a function on each input file. This function will be called
4477 on an archive, but not on the elements. */
4478
4479 void
lang_for_each_input_file(void (* func)(lang_input_statement_type *))4480 lang_for_each_input_file (void (*func) (lang_input_statement_type *))
4481 {
4482 lang_input_statement_type *f;
4483
4484 for (f = (lang_input_statement_type *) input_file_chain.head;
4485 f != NULL;
4486 f = (lang_input_statement_type *) f->next_real_file)
4487 func (f);
4488 }
4489
4490 /* Call a function on each file. The function will be called on all
4491 the elements of an archive which are included in the link, but will
4492 not be called on the archive file itself. */
4493
4494 void
lang_for_each_file(void (* func)(lang_input_statement_type *))4495 lang_for_each_file (void (*func) (lang_input_statement_type *))
4496 {
4497 LANG_FOR_EACH_INPUT_STATEMENT (f)
4498 {
4499 func (f);
4500 }
4501 }
4502
4503 void
ldlang_add_file(lang_input_statement_type * entry)4504 ldlang_add_file (lang_input_statement_type *entry)
4505 {
4506 bfd **pp;
4507
4508 lang_statement_append (&file_chain,
4509 (lang_statement_union_type *) entry,
4510 &entry->next);
4511
4512 /* The BFD linker needs to have a list of all input BFDs involved in
4513 a link. */
4514 ASSERT (entry->the_bfd->link_next == NULL);
4515 ASSERT (entry->the_bfd != output_bfd);
4516 for (pp = &link_info.input_bfds; *pp != NULL; pp = &(*pp)->link_next)
4517 ;
4518 *pp = entry->the_bfd;
4519 entry->the_bfd->usrdata = entry;
4520 bfd_set_gp_size (entry->the_bfd, g_switch_value);
4521
4522 /* Look through the sections and check for any which should not be
4523 included in the link. We need to do this now, so that we can
4524 notice when the backend linker tries to report multiple
4525 definition errors for symbols which are in sections we aren't
4526 going to link. FIXME: It might be better to entirely ignore
4527 symbols which are defined in sections which are going to be
4528 discarded. This would require modifying the backend linker for
4529 each backend which might set the SEC_LINK_ONCE flag. If we do
4530 this, we should probably handle SEC_EXCLUDE in the same way. */
4531
4532 bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
4533 }
4534
4535 void
lang_add_output(const char * name,int from_script)4536 lang_add_output (const char *name, int from_script)
4537 {
4538 /* Make -o on command line override OUTPUT in script. */
4539 if (!had_output_filename || !from_script)
4540 {
4541 output_filename = name;
4542 had_output_filename = TRUE;
4543 }
4544 }
4545
4546 static lang_output_section_statement_type *current_section;
4547
4548 static int
topower(int x)4549 topower (int x)
4550 {
4551 unsigned int i = 1;
4552 int l;
4553
4554 if (x < 0)
4555 return -1;
4556
4557 for (l = 0; l < 32; l++)
4558 {
4559 if (i >= (unsigned int) x)
4560 return l;
4561 i <<= 1;
4562 }
4563
4564 return 0;
4565 }
4566
4567 lang_output_section_statement_type *
lang_enter_output_section_statement(const char * output_section_statement_name,etree_type * address_exp,enum section_type sectype,etree_type * align,etree_type * subalign,etree_type * ebase,int constraint)4568 lang_enter_output_section_statement (const char *output_section_statement_name,
4569 etree_type *address_exp,
4570 enum section_type sectype,
4571 etree_type *align,
4572 etree_type *subalign,
4573 etree_type *ebase,
4574 int constraint)
4575 {
4576 lang_output_section_statement_type *os;
4577
4578 current_section =
4579 os =
4580 lang_output_section_statement_lookup_1 (output_section_statement_name,
4581 constraint);
4582
4583 /* Make next things chain into subchain of this. */
4584
4585 if (os->addr_tree == NULL)
4586 {
4587 os->addr_tree = address_exp;
4588 }
4589 os->sectype = sectype;
4590 if (sectype != noload_section)
4591 os->flags = SEC_NO_FLAGS;
4592 else
4593 os->flags = SEC_NEVER_LOAD;
4594 os->block_value = 1;
4595 stat_ptr = &os->children;
4596
4597 os->subsection_alignment =
4598 topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
4599 os->section_alignment =
4600 topower (exp_get_value_int (align, -1, "section alignment", 0));
4601
4602 os->load_base = ebase;
4603 return os;
4604 }
4605
4606 void
lang_final(void)4607 lang_final (void)
4608 {
4609 lang_output_statement_type *new =
4610 new_stat (lang_output_statement, stat_ptr);
4611
4612 new->name = output_filename;
4613 }
4614
4615 /* Reset the current counters in the regions. */
4616
4617 void
lang_reset_memory_regions(void)4618 lang_reset_memory_regions (void)
4619 {
4620 lang_memory_region_type *p = lang_memory_region_list;
4621 asection *o;
4622
4623 for (p = lang_memory_region_list; p != NULL; p = p->next)
4624 {
4625 p->old_length = (bfd_size_type) (p->current - p->origin);
4626 p->current = p->origin;
4627 }
4628
4629 for (o = output_bfd->sections; o != NULL; o = o->next)
4630 {
4631 /* Save the last size for possible use by bfd_relax_section. */
4632 o->rawsize = o->size;
4633 o->size = 0;
4634 }
4635 }
4636
4637 /* Worker for lang_gc_sections_1. */
4638
4639 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)4640 gc_section_callback (lang_wild_statement_type *ptr,
4641 struct wildcard_list *sec ATTRIBUTE_UNUSED,
4642 asection *section,
4643 lang_input_statement_type *file ATTRIBUTE_UNUSED,
4644 void *data ATTRIBUTE_UNUSED)
4645 {
4646 /* If the wild pattern was marked KEEP, the member sections
4647 should be as well. */
4648 if (ptr->keep_sections)
4649 section->flags |= SEC_KEEP;
4650 }
4651
4652 /* Iterate over sections marking them against GC. */
4653
4654 static void
lang_gc_sections_1(lang_statement_union_type * s)4655 lang_gc_sections_1 (lang_statement_union_type *s)
4656 {
4657 for (; s != NULL; s = s->header.next)
4658 {
4659 switch (s->header.type)
4660 {
4661 case lang_wild_statement_enum:
4662 walk_wild (&s->wild_statement, gc_section_callback, NULL);
4663 break;
4664 case lang_constructors_statement_enum:
4665 lang_gc_sections_1 (constructor_list.head);
4666 break;
4667 case lang_output_section_statement_enum:
4668 lang_gc_sections_1 (s->output_section_statement.children.head);
4669 break;
4670 case lang_group_statement_enum:
4671 lang_gc_sections_1 (s->group_statement.children.head);
4672 break;
4673 default:
4674 break;
4675 }
4676 }
4677 }
4678
4679 static void
lang_gc_sections(void)4680 lang_gc_sections (void)
4681 {
4682 struct bfd_link_hash_entry *h;
4683 ldlang_undef_chain_list_type *ulist;
4684
4685 /* Keep all sections so marked in the link script. */
4686
4687 lang_gc_sections_1 (statement_list.head);
4688
4689 /* Keep all sections containing symbols undefined on the command-line,
4690 and the section containing the entry symbol. */
4691
4692 for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
4693 {
4694 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
4695 FALSE, FALSE, FALSE);
4696
4697 if (h != NULL
4698 && (h->type == bfd_link_hash_defined
4699 || h->type == bfd_link_hash_defweak)
4700 && ! bfd_is_abs_section (h->u.def.section))
4701 {
4702 h->u.def.section->flags |= SEC_KEEP;
4703 }
4704 }
4705
4706 /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
4707 the special case of debug info. (See bfd/stabs.c)
4708 Twiddle the flag here, to simplify later linker code. */
4709 if (link_info.relocatable)
4710 {
4711 LANG_FOR_EACH_INPUT_STATEMENT (f)
4712 {
4713 asection *sec;
4714 for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
4715 if ((sec->flags & SEC_DEBUGGING) == 0)
4716 sec->flags &= ~SEC_EXCLUDE;
4717 }
4718 }
4719
4720 if (command_line.gc_sections)
4721 bfd_gc_sections (output_bfd, &link_info);
4722 }
4723
4724 void
lang_process(void)4725 lang_process (void)
4726 {
4727 current_target = default_target;
4728
4729 /* Open the output file. */
4730 lang_for_each_statement (ldlang_open_output);
4731 init_opb ();
4732
4733 ldemul_create_output_section_statements ();
4734
4735 /* Add to the hash table all undefineds on the command line. */
4736 lang_place_undefineds ();
4737
4738 if (!bfd_section_already_linked_table_init ())
4739 einfo (_("%P%F: Failed to create hash table\n"));
4740
4741 /* Create a bfd for each input file. */
4742 current_target = default_target;
4743 open_input_bfds (statement_list.head, FALSE);
4744
4745 link_info.gc_sym_list = &entry_symbol;
4746 if (entry_symbol.name == NULL)
4747 link_info.gc_sym_list = ldlang_undef_chain_list_head;
4748
4749 ldemul_after_open ();
4750
4751 bfd_section_already_linked_table_free ();
4752
4753 /* Make sure that we're not mixing architectures. We call this
4754 after all the input files have been opened, but before we do any
4755 other processing, so that any operations merge_private_bfd_data
4756 does on the output file will be known during the rest of the
4757 link. */
4758 lang_check ();
4759
4760 /* Handle .exports instead of a version script if we're told to do so. */
4761 if (command_line.version_exports_section)
4762 lang_do_version_exports_section ();
4763
4764 /* Build all sets based on the information gathered from the input
4765 files. */
4766 ldctor_build_sets ();
4767
4768 /* Remove unreferenced sections if asked to. */
4769 lang_gc_sections ();
4770
4771 /* Size up the common data. */
4772 lang_common ();
4773
4774 /* Update wild statements. */
4775 update_wild_statements (statement_list.head);
4776
4777 /* Run through the contours of the script and attach input sections
4778 to the correct output sections. */
4779 map_input_to_output_sections (statement_list.head, NULL, NULL);
4780
4781 /* Find any sections not attached explicitly and handle them. */
4782 lang_place_orphans ();
4783
4784 if (! link_info.relocatable)
4785 {
4786 asection *found;
4787
4788 /* Merge SEC_MERGE sections. This has to be done after GC of
4789 sections, so that GCed sections are not merged, but before
4790 assigning dynamic symbols, since removing whole input sections
4791 is hard then. */
4792 bfd_merge_sections (output_bfd, &link_info);
4793
4794 /* Look for a text section and set the readonly attribute in it. */
4795 found = bfd_get_section_by_name (output_bfd, ".text");
4796
4797 if (found != NULL)
4798 {
4799 if (config.text_read_only)
4800 found->flags |= SEC_READONLY;
4801 else
4802 found->flags &= ~SEC_READONLY;
4803 }
4804 }
4805
4806 /* Do anything special before sizing sections. This is where ELF
4807 and other back-ends size dynamic sections. */
4808 ldemul_before_allocation ();
4809
4810 if (!link_info.relocatable)
4811 strip_excluded_output_sections ();
4812
4813 /* We must record the program headers before we try to fix the
4814 section positions, since they will affect SIZEOF_HEADERS. */
4815 lang_record_phdrs ();
4816
4817 /* Size up the sections. */
4818 lang_size_sections (statement_list.head, abs_output_section,
4819 &statement_list.head, 0, 0, NULL,
4820 command_line.relax ? FALSE : TRUE);
4821
4822 /* Now run around and relax if we can. */
4823 if (command_line.relax)
4824 {
4825 /* Keep relaxing until bfd_relax_section gives up. */
4826 bfd_boolean relax_again;
4827
4828 do
4829 {
4830 relax_again = FALSE;
4831
4832 /* Note: pe-dll.c does something like this also. If you find
4833 you need to change this code, you probably need to change
4834 pe-dll.c also. DJ */
4835
4836 /* Do all the assignments with our current guesses as to
4837 section sizes. */
4838 lang_do_assignments (statement_list.head, abs_output_section,
4839 NULL, 0);
4840
4841 /* We must do this after lang_do_assignments, because it uses
4842 size. */
4843 lang_reset_memory_regions ();
4844
4845 /* Perform another relax pass - this time we know where the
4846 globals are, so can make a better guess. */
4847 lang_size_sections (statement_list.head, abs_output_section,
4848 &statement_list.head, 0, 0, &relax_again, FALSE);
4849
4850 /* If the normal relax is done and the relax finalize pass
4851 is not performed yet, we perform another relax pass. */
4852 if (!relax_again && link_info.need_relax_finalize)
4853 {
4854 link_info.need_relax_finalize = FALSE;
4855 relax_again = TRUE;
4856 }
4857 }
4858 while (relax_again);
4859
4860 /* Final extra sizing to report errors. */
4861 lang_do_assignments (statement_list.head, abs_output_section, NULL, 0);
4862 lang_reset_memory_regions ();
4863 lang_size_sections (statement_list.head, abs_output_section,
4864 &statement_list.head, 0, 0, NULL, TRUE);
4865 }
4866
4867 /* See if anything special should be done now we know how big
4868 everything is. */
4869 ldemul_after_allocation ();
4870
4871 /* Fix any .startof. or .sizeof. symbols. */
4872 lang_set_startof ();
4873
4874 /* Do all the assignments, now that we know the final resting places
4875 of all the symbols. */
4876
4877 lang_do_assignments (statement_list.head, abs_output_section, NULL, 0);
4878
4879 /* Make sure that the section addresses make sense. */
4880 if (! link_info.relocatable
4881 && command_line.check_section_addresses)
4882 lang_check_section_addresses ();
4883
4884 /* Final stuffs. */
4885
4886 ldemul_finish ();
4887 lang_finish ();
4888 }
4889
4890 /* EXPORTED TO YACC */
4891
4892 void
lang_add_wild(struct wildcard_spec * filespec,struct wildcard_list * section_list,bfd_boolean keep_sections)4893 lang_add_wild (struct wildcard_spec *filespec,
4894 struct wildcard_list *section_list,
4895 bfd_boolean keep_sections)
4896 {
4897 struct wildcard_list *curr, *next;
4898 lang_wild_statement_type *new;
4899
4900 /* Reverse the list as the parser puts it back to front. */
4901 for (curr = section_list, section_list = NULL;
4902 curr != NULL;
4903 section_list = curr, curr = next)
4904 {
4905 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
4906 placed_commons = TRUE;
4907
4908 next = curr->next;
4909 curr->next = section_list;
4910 }
4911
4912 if (filespec != NULL && filespec->name != NULL)
4913 {
4914 if (strcmp (filespec->name, "*") == 0)
4915 filespec->name = NULL;
4916 else if (! wildcardp (filespec->name))
4917 lang_has_input_file = TRUE;
4918 }
4919
4920 new = new_stat (lang_wild_statement, stat_ptr);
4921 new->filename = NULL;
4922 new->filenames_sorted = FALSE;
4923 if (filespec != NULL)
4924 {
4925 new->filename = filespec->name;
4926 new->filenames_sorted = filespec->sorted == by_name;
4927 }
4928 new->section_list = section_list;
4929 new->keep_sections = keep_sections;
4930 lang_list_init (&new->children);
4931 }
4932
4933 void
lang_section_start(const char * name,etree_type * address,const segment_type * segment)4934 lang_section_start (const char *name, etree_type *address,
4935 const segment_type *segment)
4936 {
4937 lang_address_statement_type *ad;
4938
4939 ad = new_stat (lang_address_statement, stat_ptr);
4940 ad->section_name = name;
4941 ad->address = address;
4942 ad->segment = segment;
4943 }
4944
4945 /* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4946 because of a -e argument on the command line, or zero if this is
4947 called by ENTRY in a linker script. Command line arguments take
4948 precedence. */
4949
4950 void
lang_add_entry(const char * name,bfd_boolean cmdline)4951 lang_add_entry (const char *name, bfd_boolean cmdline)
4952 {
4953 if (entry_symbol.name == NULL
4954 || cmdline
4955 || ! entry_from_cmdline)
4956 {
4957 entry_symbol.name = name;
4958 entry_from_cmdline = cmdline;
4959 }
4960 }
4961
4962 void
lang_add_target(const char * name)4963 lang_add_target (const char *name)
4964 {
4965 lang_target_statement_type *new = new_stat (lang_target_statement,
4966 stat_ptr);
4967
4968 new->target = name;
4969
4970 }
4971
4972 void
lang_add_map(const char * name)4973 lang_add_map (const char *name)
4974 {
4975 while (*name)
4976 {
4977 switch (*name)
4978 {
4979 case 'F':
4980 map_option_f = TRUE;
4981 break;
4982 }
4983 name++;
4984 }
4985 }
4986
4987 void
lang_add_fill(fill_type * fill)4988 lang_add_fill (fill_type *fill)
4989 {
4990 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4991 stat_ptr);
4992
4993 new->fill = fill;
4994 }
4995
4996 void
lang_add_data(int type,union etree_union * exp)4997 lang_add_data (int type, union etree_union *exp)
4998 {
4999
5000 lang_data_statement_type *new = new_stat (lang_data_statement,
5001 stat_ptr);
5002
5003 new->exp = exp;
5004 new->type = type;
5005
5006 }
5007
5008 /* Create a new reloc statement. RELOC is the BFD relocation type to
5009 generate. HOWTO is the corresponding howto structure (we could
5010 look this up, but the caller has already done so). SECTION is the
5011 section to generate a reloc against, or NAME is the name of the
5012 symbol to generate a reloc against. Exactly one of SECTION and
5013 NAME must be NULL. ADDEND is an expression for the addend. */
5014
5015 void
lang_add_reloc(bfd_reloc_code_real_type reloc,reloc_howto_type * howto,asection * section,const char * name,union etree_union * addend)5016 lang_add_reloc (bfd_reloc_code_real_type reloc,
5017 reloc_howto_type *howto,
5018 asection *section,
5019 const char *name,
5020 union etree_union *addend)
5021 {
5022 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
5023
5024 p->reloc = reloc;
5025 p->howto = howto;
5026 p->section = section;
5027 p->name = name;
5028 p->addend_exp = addend;
5029
5030 p->addend_value = 0;
5031 p->output_section = NULL;
5032 p->output_vma = 0;
5033 }
5034
5035 lang_assignment_statement_type *
lang_add_assignment(etree_type * exp)5036 lang_add_assignment (etree_type *exp)
5037 {
5038 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
5039 stat_ptr);
5040
5041 new->exp = exp;
5042 return new;
5043 }
5044
5045 void
lang_add_attribute(enum statement_enum attribute)5046 lang_add_attribute (enum statement_enum attribute)
5047 {
5048 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
5049 }
5050
5051 void
lang_startup(const char * name)5052 lang_startup (const char *name)
5053 {
5054 if (startup_file != NULL)
5055 {
5056 einfo (_("%P%Fmultiple STARTUP files\n"));
5057 }
5058 first_file->filename = name;
5059 first_file->local_sym_name = name;
5060 first_file->real = TRUE;
5061
5062 startup_file = name;
5063 }
5064
5065 void
lang_float(bfd_boolean maybe)5066 lang_float (bfd_boolean maybe)
5067 {
5068 lang_float_flag = maybe;
5069 }
5070
5071
5072 /* Work out the load- and run-time regions from a script statement, and
5073 store them in *LMA_REGION and *REGION respectively.
5074
5075 MEMSPEC is the name of the run-time region, or the value of
5076 DEFAULT_MEMORY_REGION if the statement didn't specify one.
5077 LMA_MEMSPEC is the name of the load-time region, or null if the
5078 statement didn't specify one.HAVE_LMA_P is TRUE if the statement
5079 had an explicit load address.
5080
5081 It is an error to specify both a load region and a load address. */
5082
5083 static void
lang_get_regions(lang_memory_region_type ** region,lang_memory_region_type ** lma_region,const char * memspec,const char * lma_memspec,bfd_boolean have_lma,bfd_boolean have_vma)5084 lang_get_regions (lang_memory_region_type **region,
5085 lang_memory_region_type **lma_region,
5086 const char *memspec,
5087 const char *lma_memspec,
5088 bfd_boolean have_lma,
5089 bfd_boolean have_vma)
5090 {
5091 *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
5092
5093 /* If no runtime region or VMA has been specified, but the load region
5094 has been specified, then use the load region for the runtime region
5095 as well. */
5096 if (lma_memspec != NULL
5097 && ! have_vma
5098 && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
5099 *region = *lma_region;
5100 else
5101 *region = lang_memory_region_lookup (memspec, FALSE);
5102
5103 if (have_lma && lma_memspec != 0)
5104 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
5105 }
5106
5107 void
lang_leave_output_section_statement(fill_type * fill,const char * memspec,lang_output_section_phdr_list * phdrs,const char * lma_memspec)5108 lang_leave_output_section_statement (fill_type *fill, const char *memspec,
5109 lang_output_section_phdr_list *phdrs,
5110 const char *lma_memspec)
5111 {
5112 lang_get_regions (¤t_section->region,
5113 ¤t_section->lma_region,
5114 memspec, lma_memspec,
5115 current_section->load_base != NULL,
5116 current_section->addr_tree != NULL);
5117 current_section->fill = fill;
5118 current_section->phdrs = phdrs;
5119 stat_ptr = &statement_list;
5120 }
5121
5122 /* Create an absolute symbol with the given name with the value of the
5123 address of first byte of the section named.
5124
5125 If the symbol already exists, then do nothing. */
5126
5127 void
lang_abs_symbol_at_beginning_of(const char * secname,const char * name)5128 lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
5129 {
5130 struct bfd_link_hash_entry *h;
5131
5132 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
5133 if (h == NULL)
5134 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
5135
5136 if (h->type == bfd_link_hash_new
5137 || h->type == bfd_link_hash_undefined)
5138 {
5139 asection *sec;
5140
5141 h->type = bfd_link_hash_defined;
5142
5143 sec = bfd_get_section_by_name (output_bfd, secname);
5144 if (sec == NULL)
5145 h->u.def.value = 0;
5146 else
5147 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
5148
5149 h->u.def.section = bfd_abs_section_ptr;
5150 }
5151 }
5152
5153 /* Create an absolute symbol with the given name with the value of the
5154 address of the first byte after the end of the section named.
5155
5156 If the symbol already exists, then do nothing. */
5157
5158 void
lang_abs_symbol_at_end_of(const char * secname,const char * name)5159 lang_abs_symbol_at_end_of (const char *secname, const char *name)
5160 {
5161 struct bfd_link_hash_entry *h;
5162
5163 h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
5164 if (h == NULL)
5165 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
5166
5167 if (h->type == bfd_link_hash_new
5168 || h->type == bfd_link_hash_undefined)
5169 {
5170 asection *sec;
5171
5172 h->type = bfd_link_hash_defined;
5173
5174 sec = bfd_get_section_by_name (output_bfd, secname);
5175 if (sec == NULL)
5176 h->u.def.value = 0;
5177 else
5178 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
5179 + TO_ADDR (sec->size));
5180
5181 h->u.def.section = bfd_abs_section_ptr;
5182 }
5183 }
5184
5185 void
lang_statement_append(lang_statement_list_type * list,lang_statement_union_type * element,lang_statement_union_type ** field)5186 lang_statement_append (lang_statement_list_type *list,
5187 lang_statement_union_type *element,
5188 lang_statement_union_type **field)
5189 {
5190 *(list->tail) = element;
5191 list->tail = field;
5192 }
5193
5194 /* Set the output format type. -oformat overrides scripts. */
5195
5196 void
lang_add_output_format(const char * format,const char * big,const char * little,int from_script)5197 lang_add_output_format (const char *format,
5198 const char *big,
5199 const char *little,
5200 int from_script)
5201 {
5202 if (output_target == NULL || !from_script)
5203 {
5204 if (command_line.endian == ENDIAN_BIG
5205 && big != NULL)
5206 format = big;
5207 else if (command_line.endian == ENDIAN_LITTLE
5208 && little != NULL)
5209 format = little;
5210
5211 output_target = format;
5212 }
5213 }
5214
5215 /* Enter a group. This creates a new lang_group_statement, and sets
5216 stat_ptr to build new statements within the group. */
5217
5218 void
lang_enter_group(void)5219 lang_enter_group (void)
5220 {
5221 lang_group_statement_type *g;
5222
5223 g = new_stat (lang_group_statement, stat_ptr);
5224 lang_list_init (&g->children);
5225 stat_ptr = &g->children;
5226 }
5227
5228 /* Leave a group. This just resets stat_ptr to start writing to the
5229 regular list of statements again. Note that this will not work if
5230 groups can occur inside anything else which can adjust stat_ptr,
5231 but currently they can't. */
5232
5233 void
lang_leave_group(void)5234 lang_leave_group (void)
5235 {
5236 stat_ptr = &statement_list;
5237 }
5238
5239 /* Add a new program header. This is called for each entry in a PHDRS
5240 command in a linker script. */
5241
5242 void
lang_new_phdr(const char * name,etree_type * type,bfd_boolean filehdr,bfd_boolean phdrs,etree_type * at,etree_type * flags)5243 lang_new_phdr (const char *name,
5244 etree_type *type,
5245 bfd_boolean filehdr,
5246 bfd_boolean phdrs,
5247 etree_type *at,
5248 etree_type *flags)
5249 {
5250 struct lang_phdr *n, **pp;
5251
5252 n = stat_alloc (sizeof (struct lang_phdr));
5253 n->next = NULL;
5254 n->name = name;
5255 n->type = exp_get_value_int (type, 0, "program header type",
5256 lang_final_phase_enum);
5257 n->filehdr = filehdr;
5258 n->phdrs = phdrs;
5259 n->at = at;
5260 n->flags = flags;
5261
5262 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
5263 ;
5264 *pp = n;
5265 }
5266
5267 /* Record the program header information in the output BFD. FIXME: We
5268 should not be calling an ELF specific function here. */
5269
5270 static void
lang_record_phdrs(void)5271 lang_record_phdrs (void)
5272 {
5273 unsigned int alc;
5274 asection **secs;
5275 lang_output_section_phdr_list *last;
5276 struct lang_phdr *l;
5277 lang_output_section_statement_type *os;
5278
5279 alc = 10;
5280 secs = xmalloc (alc * sizeof (asection *));
5281 last = NULL;
5282 for (l = lang_phdr_list; l != NULL; l = l->next)
5283 {
5284 unsigned int c;
5285 flagword flags;
5286 bfd_vma at;
5287
5288 c = 0;
5289 for (os = &lang_output_section_statement.head->output_section_statement;
5290 os != NULL;
5291 os = os->next)
5292 {
5293 lang_output_section_phdr_list *pl;
5294
5295 if (os->constraint == -1)
5296 continue;
5297
5298 pl = os->phdrs;
5299 if (pl != NULL)
5300 last = pl;
5301 else
5302 {
5303 if (os->sectype == noload_section
5304 || os->bfd_section == NULL
5305 || (os->bfd_section->flags & SEC_ALLOC) == 0)
5306 continue;
5307 pl = last;
5308 }
5309
5310 if (os->bfd_section == NULL)
5311 continue;
5312
5313 for (; pl != NULL; pl = pl->next)
5314 {
5315 if (strcmp (pl->name, l->name) == 0)
5316 {
5317 if (c >= alc)
5318 {
5319 alc *= 2;
5320 secs = xrealloc (secs, alc * sizeof (asection *));
5321 }
5322 secs[c] = os->bfd_section;
5323 ++c;
5324 pl->used = TRUE;
5325 }
5326 }
5327 }
5328
5329 if (l->flags == NULL)
5330 flags = 0;
5331 else
5332 flags = exp_get_vma (l->flags, 0, "phdr flags",
5333 lang_final_phase_enum);
5334
5335 if (l->at == NULL)
5336 at = 0;
5337 else
5338 at = exp_get_vma (l->at, 0, "phdr load address",
5339 lang_final_phase_enum);
5340
5341 if (! bfd_record_phdr (output_bfd, l->type,
5342 l->flags != NULL, flags, l->at != NULL,
5343 at, l->filehdr, l->phdrs, c, secs))
5344 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
5345 }
5346
5347 free (secs);
5348
5349 /* Make sure all the phdr assignments succeeded. */
5350 for (os = &lang_output_section_statement.head->output_section_statement;
5351 os != NULL;
5352 os = os->next)
5353 {
5354 lang_output_section_phdr_list *pl;
5355
5356 if (os->constraint == -1
5357 || os->bfd_section == NULL)
5358 continue;
5359
5360 for (pl = os->phdrs;
5361 pl != NULL;
5362 pl = pl->next)
5363 if (! pl->used && strcmp (pl->name, "NONE") != 0)
5364 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
5365 os->name, pl->name);
5366 }
5367 }
5368
5369 /* Record a list of sections which may not be cross referenced. */
5370
5371 void
lang_add_nocrossref(lang_nocrossref_type * l)5372 lang_add_nocrossref (lang_nocrossref_type *l)
5373 {
5374 struct lang_nocrossrefs *n;
5375
5376 n = xmalloc (sizeof *n);
5377 n->next = nocrossref_list;
5378 n->list = l;
5379 nocrossref_list = n;
5380
5381 /* Set notice_all so that we get informed about all symbols. */
5382 link_info.notice_all = TRUE;
5383 }
5384
5385 /* Overlay handling. We handle overlays with some static variables. */
5386
5387 /* The overlay virtual address. */
5388 static etree_type *overlay_vma;
5389 /* And subsection alignment. */
5390 static etree_type *overlay_subalign;
5391
5392 /* An expression for the maximum section size seen so far. */
5393 static etree_type *overlay_max;
5394
5395 /* A list of all the sections in this overlay. */
5396
5397 struct overlay_list {
5398 struct overlay_list *next;
5399 lang_output_section_statement_type *os;
5400 };
5401
5402 static struct overlay_list *overlay_list;
5403
5404 /* Start handling an overlay. */
5405
5406 void
lang_enter_overlay(etree_type * vma_expr,etree_type * subalign)5407 lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
5408 {
5409 /* The grammar should prevent nested overlays from occurring. */
5410 ASSERT (overlay_vma == NULL
5411 && overlay_subalign == NULL
5412 && overlay_max == NULL);
5413
5414 overlay_vma = vma_expr;
5415 overlay_subalign = subalign;
5416 }
5417
5418 /* Start a section in an overlay. We handle this by calling
5419 lang_enter_output_section_statement with the correct VMA.
5420 lang_leave_overlay sets up the LMA and memory regions. */
5421
5422 void
lang_enter_overlay_section(const char * name)5423 lang_enter_overlay_section (const char *name)
5424 {
5425 struct overlay_list *n;
5426 etree_type *size;
5427
5428 lang_enter_output_section_statement (name, overlay_vma, normal_section,
5429 0, overlay_subalign, 0, 0);
5430
5431 /* If this is the first section, then base the VMA of future
5432 sections on this one. This will work correctly even if `.' is
5433 used in the addresses. */
5434 if (overlay_list == NULL)
5435 overlay_vma = exp_nameop (ADDR, name);
5436
5437 /* Remember the section. */
5438 n = xmalloc (sizeof *n);
5439 n->os = current_section;
5440 n->next = overlay_list;
5441 overlay_list = n;
5442
5443 size = exp_nameop (SIZEOF, name);
5444
5445 /* Arrange to work out the maximum section end address. */
5446 if (overlay_max == NULL)
5447 overlay_max = size;
5448 else
5449 overlay_max = exp_binop (MAX_K, overlay_max, size);
5450 }
5451
5452 /* Finish a section in an overlay. There isn't any special to do
5453 here. */
5454
5455 void
lang_leave_overlay_section(fill_type * fill,lang_output_section_phdr_list * phdrs)5456 lang_leave_overlay_section (fill_type *fill,
5457 lang_output_section_phdr_list *phdrs)
5458 {
5459 const char *name;
5460 char *clean, *s2;
5461 const char *s1;
5462 char *buf;
5463
5464 name = current_section->name;
5465
5466 /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
5467 region and that no load-time region has been specified. It doesn't
5468 really matter what we say here, since lang_leave_overlay will
5469 override it. */
5470 lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
5471
5472 /* Define the magic symbols. */
5473
5474 clean = xmalloc (strlen (name) + 1);
5475 s2 = clean;
5476 for (s1 = name; *s1 != '\0'; s1++)
5477 if (ISALNUM (*s1) || *s1 == '_')
5478 *s2++ = *s1;
5479 *s2 = '\0';
5480
5481 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
5482 sprintf (buf, "__load_start_%s", clean);
5483 lang_add_assignment (exp_assop ('=', buf,
5484 exp_nameop (LOADADDR, name)));
5485
5486 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
5487 sprintf (buf, "__load_stop_%s", clean);
5488 lang_add_assignment (exp_assop ('=', buf,
5489 exp_binop ('+',
5490 exp_nameop (LOADADDR, name),
5491 exp_nameop (SIZEOF, name))));
5492
5493 free (clean);
5494 }
5495
5496 /* Finish an overlay. If there are any overlay wide settings, this
5497 looks through all the sections in the overlay and sets them. */
5498
5499 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)5500 lang_leave_overlay (etree_type *lma_expr,
5501 int nocrossrefs,
5502 fill_type *fill,
5503 const char *memspec,
5504 lang_output_section_phdr_list *phdrs,
5505 const char *lma_memspec)
5506 {
5507 lang_memory_region_type *region;
5508 lang_memory_region_type *lma_region;
5509 struct overlay_list *l;
5510 lang_nocrossref_type *nocrossref;
5511
5512 lang_get_regions (®ion, &lma_region,
5513 memspec, lma_memspec,
5514 lma_expr != NULL, FALSE);
5515
5516 nocrossref = NULL;
5517
5518 /* After setting the size of the last section, set '.' to end of the
5519 overlay region. */
5520 if (overlay_list != NULL)
5521 overlay_list->os->update_dot_tree
5522 = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
5523
5524 l = overlay_list;
5525 while (l != NULL)
5526 {
5527 struct overlay_list *next;
5528
5529 if (fill != NULL && l->os->fill == NULL)
5530 l->os->fill = fill;
5531
5532 l->os->region = region;
5533 l->os->lma_region = lma_region;
5534
5535 /* The first section has the load address specified in the
5536 OVERLAY statement. The rest are worked out from that.
5537 The base address is not needed (and should be null) if
5538 an LMA region was specified. */
5539 if (l->next == 0)
5540 l->os->load_base = lma_expr;
5541 else if (lma_region == 0)
5542 l->os->load_base = exp_binop ('+',
5543 exp_nameop (LOADADDR, l->next->os->name),
5544 exp_nameop (SIZEOF, l->next->os->name));
5545
5546 if (phdrs != NULL && l->os->phdrs == NULL)
5547 l->os->phdrs = phdrs;
5548
5549 if (nocrossrefs)
5550 {
5551 lang_nocrossref_type *nc;
5552
5553 nc = xmalloc (sizeof *nc);
5554 nc->name = l->os->name;
5555 nc->next = nocrossref;
5556 nocrossref = nc;
5557 }
5558
5559 next = l->next;
5560 free (l);
5561 l = next;
5562 }
5563
5564 if (nocrossref != NULL)
5565 lang_add_nocrossref (nocrossref);
5566
5567 overlay_vma = NULL;
5568 overlay_list = NULL;
5569 overlay_max = NULL;
5570 }
5571
5572 /* Version handling. This is only useful for ELF. */
5573
5574 /* This global variable holds the version tree that we build. */
5575
5576 struct bfd_elf_version_tree *lang_elf_version_info;
5577
5578 /* If PREV is NULL, return first version pattern matching particular symbol.
5579 If PREV is non-NULL, return first version pattern matching particular
5580 symbol after PREV (previously returned by lang_vers_match). */
5581
5582 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)5583 lang_vers_match (struct bfd_elf_version_expr_head *head,
5584 struct bfd_elf_version_expr *prev,
5585 const char *sym)
5586 {
5587 const char *cxx_sym = sym;
5588 const char *java_sym = sym;
5589 struct bfd_elf_version_expr *expr = NULL;
5590
5591 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
5592 {
5593 cxx_sym = cplus_demangle (sym, DMGL_PARAMS | DMGL_ANSI);
5594 if (!cxx_sym)
5595 cxx_sym = sym;
5596 }
5597 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
5598 {
5599 java_sym = cplus_demangle (sym, DMGL_JAVA);
5600 if (!java_sym)
5601 java_sym = sym;
5602 }
5603
5604 if (head->htab && (prev == NULL || prev->symbol))
5605 {
5606 struct bfd_elf_version_expr e;
5607
5608 switch (prev ? prev->mask : 0)
5609 {
5610 case 0:
5611 if (head->mask & BFD_ELF_VERSION_C_TYPE)
5612 {
5613 e.symbol = sym;
5614 expr = htab_find (head->htab, &e);
5615 while (expr && strcmp (expr->symbol, sym) == 0)
5616 if (expr->mask == BFD_ELF_VERSION_C_TYPE)
5617 goto out_ret;
5618 else
5619 expr = expr->next;
5620 }
5621 /* Fallthrough */
5622 case BFD_ELF_VERSION_C_TYPE:
5623 if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
5624 {
5625 e.symbol = cxx_sym;
5626 expr = htab_find (head->htab, &e);
5627 while (expr && strcmp (expr->symbol, cxx_sym) == 0)
5628 if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
5629 goto out_ret;
5630 else
5631 expr = expr->next;
5632 }
5633 /* Fallthrough */
5634 case BFD_ELF_VERSION_CXX_TYPE:
5635 if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
5636 {
5637 e.symbol = java_sym;
5638 expr = htab_find (head->htab, &e);
5639 while (expr && strcmp (expr->symbol, java_sym) == 0)
5640 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
5641 goto out_ret;
5642 else
5643 expr = expr->next;
5644 }
5645 /* Fallthrough */
5646 default:
5647 break;
5648 }
5649 }
5650
5651 /* Finally, try the wildcards. */
5652 if (prev == NULL || prev->symbol)
5653 expr = head->remaining;
5654 else
5655 expr = prev->next;
5656 while (expr)
5657 {
5658 const char *s;
5659
5660 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5661 break;
5662
5663 if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
5664 s = java_sym;
5665 else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
5666 s = cxx_sym;
5667 else
5668 s = sym;
5669 if (fnmatch (expr->pattern, s, 0) == 0)
5670 break;
5671 expr = expr->next;
5672 }
5673
5674 out_ret:
5675 if (cxx_sym != sym)
5676 free ((char *) cxx_sym);
5677 if (java_sym != sym)
5678 free ((char *) java_sym);
5679 return expr;
5680 }
5681
5682 /* Return NULL if the PATTERN argument is a glob pattern, otherwise,
5683 return a string pointing to the symbol name. */
5684
5685 static const char *
realsymbol(const char * pattern)5686 realsymbol (const char *pattern)
5687 {
5688 const char *p;
5689 bfd_boolean changed = FALSE, backslash = FALSE;
5690 char *s, *symbol = xmalloc (strlen (pattern) + 1);
5691
5692 for (p = pattern, s = symbol; *p != '\0'; ++p)
5693 {
5694 /* It is a glob pattern only if there is no preceding
5695 backslash. */
5696 if (! backslash && (*p == '?' || *p == '*' || *p == '['))
5697 {
5698 free (symbol);
5699 return NULL;
5700 }
5701
5702 if (backslash)
5703 {
5704 /* Remove the preceding backslash. */
5705 *(s - 1) = *p;
5706 changed = TRUE;
5707 }
5708 else
5709 *s++ = *p;
5710
5711 backslash = *p == '\\';
5712 }
5713
5714 if (changed)
5715 {
5716 *s = '\0';
5717 return symbol;
5718 }
5719 else
5720 {
5721 free (symbol);
5722 return pattern;
5723 }
5724 }
5725
5726 /* This is called for each variable name or match expression. */
5727
5728 struct bfd_elf_version_expr *
lang_new_vers_pattern(struct bfd_elf_version_expr * orig,const char * new,const char * lang)5729 lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
5730 const char *new,
5731 const char *lang)
5732 {
5733 struct bfd_elf_version_expr *ret;
5734
5735 ret = xmalloc (sizeof *ret);
5736 ret->next = orig;
5737 ret->pattern = new;
5738 ret->symver = 0;
5739 ret->script = 0;
5740 ret->symbol = realsymbol (new);
5741
5742 if (lang == NULL || strcasecmp (lang, "C") == 0)
5743 ret->mask = BFD_ELF_VERSION_C_TYPE;
5744 else if (strcasecmp (lang, "C++") == 0)
5745 ret->mask = BFD_ELF_VERSION_CXX_TYPE;
5746 else if (strcasecmp (lang, "Java") == 0)
5747 ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
5748 else
5749 {
5750 einfo (_("%X%P: unknown language `%s' in version information\n"),
5751 lang);
5752 ret->mask = BFD_ELF_VERSION_C_TYPE;
5753 }
5754
5755 return ldemul_new_vers_pattern (ret);
5756 }
5757
5758 /* This is called for each set of variable names and match
5759 expressions. */
5760
5761 struct bfd_elf_version_tree *
lang_new_vers_node(struct bfd_elf_version_expr * globals,struct bfd_elf_version_expr * locals)5762 lang_new_vers_node (struct bfd_elf_version_expr *globals,
5763 struct bfd_elf_version_expr *locals)
5764 {
5765 struct bfd_elf_version_tree *ret;
5766
5767 ret = xcalloc (1, sizeof *ret);
5768 ret->globals.list = globals;
5769 ret->locals.list = locals;
5770 ret->match = lang_vers_match;
5771 ret->name_indx = (unsigned int) -1;
5772 return ret;
5773 }
5774
5775 /* This static variable keeps track of version indices. */
5776
5777 static int version_index;
5778
5779 static hashval_t
version_expr_head_hash(const void * p)5780 version_expr_head_hash (const void *p)
5781 {
5782 const struct bfd_elf_version_expr *e = p;
5783
5784 return htab_hash_string (e->symbol);
5785 }
5786
5787 static int
version_expr_head_eq(const void * p1,const void * p2)5788 version_expr_head_eq (const void *p1, const void *p2)
5789 {
5790 const struct bfd_elf_version_expr *e1 = p1;
5791 const struct bfd_elf_version_expr *e2 = p2;
5792
5793 return strcmp (e1->symbol, e2->symbol) == 0;
5794 }
5795
5796 static void
lang_finalize_version_expr_head(struct bfd_elf_version_expr_head * head)5797 lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
5798 {
5799 size_t count = 0;
5800 struct bfd_elf_version_expr *e, *next;
5801 struct bfd_elf_version_expr **list_loc, **remaining_loc;
5802
5803 for (e = head->list; e; e = e->next)
5804 {
5805 if (e->symbol)
5806 count++;
5807 head->mask |= e->mask;
5808 }
5809
5810 if (count)
5811 {
5812 head->htab = htab_create (count * 2, version_expr_head_hash,
5813 version_expr_head_eq, NULL);
5814 list_loc = &head->list;
5815 remaining_loc = &head->remaining;
5816 for (e = head->list; e; e = next)
5817 {
5818 next = e->next;
5819 if (!e->symbol)
5820 {
5821 *remaining_loc = e;
5822 remaining_loc = &e->next;
5823 }
5824 else
5825 {
5826 void **loc = htab_find_slot (head->htab, e, INSERT);
5827
5828 if (*loc)
5829 {
5830 struct bfd_elf_version_expr *e1, *last;
5831
5832 e1 = *loc;
5833 last = NULL;
5834 do
5835 {
5836 if (e1->mask == e->mask)
5837 {
5838 last = NULL;
5839 break;
5840 }
5841 last = e1;
5842 e1 = e1->next;
5843 }
5844 while (e1 && strcmp (e1->symbol, e->symbol) == 0);
5845
5846 if (last == NULL)
5847 {
5848 /* This is a duplicate. */
5849 /* FIXME: Memory leak. Sometimes pattern is not
5850 xmalloced alone, but in larger chunk of memory. */
5851 /* free (e->symbol); */
5852 free (e);
5853 }
5854 else
5855 {
5856 e->next = last->next;
5857 last->next = e;
5858 }
5859 }
5860 else
5861 {
5862 *loc = e;
5863 *list_loc = e;
5864 list_loc = &e->next;
5865 }
5866 }
5867 }
5868 *remaining_loc = NULL;
5869 *list_loc = head->remaining;
5870 }
5871 else
5872 head->remaining = head->list;
5873 }
5874
5875 /* This is called when we know the name and dependencies of the
5876 version. */
5877
5878 void
lang_register_vers_node(const char * name,struct bfd_elf_version_tree * version,struct bfd_elf_version_deps * deps)5879 lang_register_vers_node (const char *name,
5880 struct bfd_elf_version_tree *version,
5881 struct bfd_elf_version_deps *deps)
5882 {
5883 struct bfd_elf_version_tree *t, **pp;
5884 struct bfd_elf_version_expr *e1;
5885
5886 if (name == NULL)
5887 name = "";
5888
5889 if ((name[0] == '\0' && lang_elf_version_info != NULL)
5890 || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
5891 {
5892 einfo (_("%X%P: anonymous version tag cannot be combined"
5893 " with other version tags\n"));
5894 free (version);
5895 return;
5896 }
5897
5898 /* Make sure this node has a unique name. */
5899 for (t = lang_elf_version_info; t != NULL; t = t->next)
5900 if (strcmp (t->name, name) == 0)
5901 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5902
5903 lang_finalize_version_expr_head (&version->globals);
5904 lang_finalize_version_expr_head (&version->locals);
5905
5906 /* Check the global and local match names, and make sure there
5907 aren't any duplicates. */
5908
5909 for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
5910 {
5911 for (t = lang_elf_version_info; t != NULL; t = t->next)
5912 {
5913 struct bfd_elf_version_expr *e2;
5914
5915 if (t->locals.htab && e1->symbol)
5916 {
5917 e2 = htab_find (t->locals.htab, e1);
5918 while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
5919 {
5920 if (e1->mask == e2->mask)
5921 einfo (_("%X%P: duplicate expression `%s'"
5922 " in version information\n"), e1->symbol);
5923 e2 = e2->next;
5924 }
5925 }
5926 else if (!e1->symbol)
5927 for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
5928 if (strcmp (e1->pattern, e2->pattern) == 0
5929 && e1->mask == e2->mask)
5930 einfo (_("%X%P: duplicate expression `%s'"
5931 " in version information\n"), e1->pattern);
5932 }
5933 }
5934
5935 for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
5936 {
5937 for (t = lang_elf_version_info; t != NULL; t = t->next)
5938 {
5939 struct bfd_elf_version_expr *e2;
5940
5941 if (t->globals.htab && e1->symbol)
5942 {
5943 e2 = htab_find (t->globals.htab, e1);
5944 while (e2 && strcmp (e1->symbol, e2->symbol) == 0)
5945 {
5946 if (e1->mask == e2->mask)
5947 einfo (_("%X%P: duplicate expression `%s'"
5948 " in version information\n"),
5949 e1->symbol);
5950 e2 = e2->next;
5951 }
5952 }
5953 else if (!e1->symbol)
5954 for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
5955 if (strcmp (e1->pattern, e2->pattern) == 0
5956 && e1->mask == e2->mask)
5957 einfo (_("%X%P: duplicate expression `%s'"
5958 " in version information\n"), e1->pattern);
5959 }
5960 }
5961
5962 version->deps = deps;
5963 version->name = name;
5964 if (name[0] != '\0')
5965 {
5966 ++version_index;
5967 version->vernum = version_index;
5968 }
5969 else
5970 version->vernum = 0;
5971
5972 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5973 ;
5974 *pp = version;
5975 }
5976
5977 /* This is called when we see a version dependency. */
5978
5979 struct bfd_elf_version_deps *
lang_add_vers_depend(struct bfd_elf_version_deps * list,const char * name)5980 lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
5981 {
5982 struct bfd_elf_version_deps *ret;
5983 struct bfd_elf_version_tree *t;
5984
5985 ret = xmalloc (sizeof *ret);
5986 ret->next = list;
5987
5988 for (t = lang_elf_version_info; t != NULL; t = t->next)
5989 {
5990 if (strcmp (t->name, name) == 0)
5991 {
5992 ret->version_needed = t;
5993 return ret;
5994 }
5995 }
5996
5997 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5998
5999 return ret;
6000 }
6001
6002 static void
lang_do_version_exports_section(void)6003 lang_do_version_exports_section (void)
6004 {
6005 struct bfd_elf_version_expr *greg = NULL, *lreg;
6006
6007 LANG_FOR_EACH_INPUT_STATEMENT (is)
6008 {
6009 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
6010 char *contents, *p;
6011 bfd_size_type len;
6012
6013 if (sec == NULL)
6014 continue;
6015
6016 len = sec->size;
6017 contents = xmalloc (len);
6018 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
6019 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
6020
6021 p = contents;
6022 while (p < contents + len)
6023 {
6024 greg = lang_new_vers_pattern (greg, p, NULL);
6025 p = strchr (p, '\0') + 1;
6026 }
6027
6028 /* Do not free the contents, as we used them creating the regex. */
6029
6030 /* Do not include this section in the link. */
6031 sec->flags |= SEC_EXCLUDE;
6032 }
6033
6034 lreg = lang_new_vers_pattern (NULL, "*", NULL);
6035 lang_register_vers_node (command_line.version_exports_section,
6036 lang_new_vers_node (greg, lreg), NULL);
6037 }
6038
6039 void
lang_add_unique(const char * name)6040 lang_add_unique (const char *name)
6041 {
6042 struct unique_sections *ent;
6043
6044 for (ent = unique_section_list; ent; ent = ent->next)
6045 if (strcmp (ent->name, name) == 0)
6046 return;
6047
6048 ent = xmalloc (sizeof *ent);
6049 ent->name = xstrdup (name);
6050 ent->next = unique_section_list;
6051 unique_section_list = ent;
6052 }
6053