projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* ldlang.c (wild_doit): Update for renaming of SEC_SHORT to
[deliverable/binutils-gdb.git] / ld / ldlang.c
CommitLineData
252b5132
RH		 1/* Linker command language support.
2 Copyright (C) 1991, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
4
5This file is part of GLD, the Gnu Linker.
6
7GLD is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2, or (at your option)
10any later version.
11
12GLD is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GLD; see the file COPYING. If not, write to the Free
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2002111-1307, USA. */
21
22#include "bfd.h"
23#include "sysdep.h"
24#include "libiberty.h"
25#include "obstack.h"
26#include "bfdlink.h"
27
28#include "ld.h"
29#include "ldmain.h"
30#include "ldgram.h"
31#include "ldexp.h"
32#include "ldlang.h"
33#include "ldemul.h"
34#include "ldlex.h"
35#include "ldmisc.h"
36#include "ldctor.h"
37#include "ldfile.h"
38#include "fnmatch.h"
39#include "demangle.h"
40
41#include <ctype.h>
42
43/* FORWARDS */
44static lang_statement_union_type *new_statement PARAMS ((enum statement_enum,
45 size_t,
46 lang_statement_list_type*));
47
48
49/* LOCALS */
50static struct obstack stat_obstack;
51
52#define obstack_chunk_alloc xmalloc
53#define obstack_chunk_free free
54static CONST char *startup_file;
55static lang_statement_list_type input_file_chain;
56static boolean placed_commons = false;
57static lang_output_section_statement_type *default_common_section;
58static boolean map_option_f;
59static bfd_vma print_dot;
60static lang_input_statement_type *first_file;
61static lang_statement_list_type lang_output_section_statement;
62static CONST char *current_target;
63static CONST char *output_target;
64static lang_statement_list_type statement_list;
65static struct lang_phdr *lang_phdr_list;
66
67static void lang_for_each_statement_worker
68 PARAMS ((void (*func) (lang_statement_union_type *),
69 lang_statement_union_type *s));
70static lang_input_statement_type *new_afile
71 PARAMS ((const char *name, lang_input_file_enum_type file_type,
72 const char *target, boolean add_to_list));
73static void init_os PARAMS ((lang_output_section_statement_type *s));
74static void exp_init_os PARAMS ((etree_type *));
75static void section_already_linked PARAMS ((bfd *, asection *, PTR));
76static boolean wildcardp PARAMS ((const char *));
77static lang_statement_union_type *wild_sort
78 PARAMS ((lang_wild_statement_type *, lang_input_statement_type *,
79 asection *));
252b5132
RH		 80static lang_input_statement_type *lookup_name PARAMS ((const char *name));
81static void load_symbols PARAMS ((lang_input_statement_type *entry,
82 lang_statement_list_type *));
252b5132
RH		 83static void wild PARAMS ((lang_wild_statement_type *s,
84 const char *section, const char *file,
85 const char *target,
86 lang_output_section_statement_type *output));
87static bfd *open_output PARAMS ((const char *name));
88static void ldlang_open_output PARAMS ((lang_statement_union_type *statement));
89static void open_input_bfds
90 PARAMS ((lang_statement_union_type *statement, boolean));
91static void lang_reasonable_defaults PARAMS ((void));
92static void lang_place_undefineds PARAMS ((void));
93static void map_input_to_output_sections
94 PARAMS ((lang_statement_union_type *s,
95 const char *target,
96 lang_output_section_statement_type *output_section_statement));
97static void print_output_section_statement
98 PARAMS ((lang_output_section_statement_type *output_section_statement));
99static void print_assignment
100 PARAMS ((lang_assignment_statement_type *assignment,
101 lang_output_section_statement_type *output_section));
102static void print_input_statement PARAMS ((lang_input_statement_type *statm));
103static boolean print_one_symbol PARAMS ((struct bfd_link_hash_entry *, PTR));
104static void print_input_section PARAMS ((lang_input_section_type *in));
105static void print_fill_statement PARAMS ((lang_fill_statement_type *fill));
106static void print_data_statement PARAMS ((lang_data_statement_type *data));
107static void print_address_statement PARAMS ((lang_address_statement_type *));
108static void print_reloc_statement PARAMS ((lang_reloc_statement_type *reloc));
109static void print_padding_statement PARAMS ((lang_padding_statement_type *s));
110static void print_wild_statement
111 PARAMS ((lang_wild_statement_type *w,
112 lang_output_section_statement_type *os));
113static void print_group
114 PARAMS ((lang_group_statement_type *, lang_output_section_statement_type *));
115static void print_statement PARAMS ((lang_statement_union_type *s,
116 lang_output_section_statement_type *os));
117static void print_statement_list PARAMS ((lang_statement_union_type *s,
118 lang_output_section_statement_type *os));
119static void print_statements PARAMS ((void));
120static bfd_vma insert_pad PARAMS ((lang_statement_union_type **this_ptr,
121 fill_type fill, unsigned int power,
122 asection *output_section_statement,
123 bfd_vma dot));
124static bfd_vma size_input_section
125 PARAMS ((lang_statement_union_type **this_ptr,
126 lang_output_section_statement_type *output_section_statement,
127 fill_type fill, bfd_vma dot, boolean relax));
128static void lang_finish PARAMS ((void));
129static void ignore_bfd_errors PARAMS ((const char *, ...));
130static void lang_check PARAMS ((void));
131static void lang_common PARAMS ((void));
132static boolean lang_one_common PARAMS ((struct bfd_link_hash_entry *, PTR));
133static void lang_place_orphans PARAMS ((void));
134static int topower PARAMS ((int));
135static void lang_set_startof PARAMS ((void));
136static void reset_memory_regions PARAMS ((void));
137static void lang_record_phdrs PARAMS ((void));
252b5132
RH		 138static void lang_gc_wild
139 PARAMS ((lang_wild_statement_type *, const char *, const char *));
140static void lang_gc_sections_1 PARAMS ((lang_statement_union_type *));
141static void lang_gc_sections PARAMS ((void));
142static void lang_do_version_exports_section PARAMS ((void));
143static void lang_check_section_addresses PARAMS ((void));
252b5132 144
4dec4d4e
RH		 145typedef void (*callback_t) PARAMS ((lang_wild_statement_type *,
146 asection *, lang_input_statement_type *,
147 void *));
148static void walk_wild_section
149 PARAMS ((lang_wild_statement_type *, const char *,
150 lang_input_statement_type *, callback_t, void *));
151static void walk_wild_file
152 PARAMS ((lang_wild_statement_type *, const char *,
153 lang_input_statement_type *, callback_t, void *));
e50d8076
NC		 154
155static int get_target PARAMS ((const bfd_target *, void *));
156static void stricpy PARAMS ((char *, char *));
157static void strcut PARAMS ((char *, char *));
158static int name_compare PARAMS ((char *, char *));
159static int closest_target_match PARAMS ((const bfd_target *, void *));
160static char * get_first_input_target PARAMS ((void));
4dec4d4e 161
252b5132
RH		 162/* EXPORTS */
163lang_output_section_statement_type *abs_output_section;
164lang_statement_list_type *stat_ptr = &statement_list;
87f2a346 165lang_statement_list_type file_chain = { NULL, NULL };
252b5132
RH		 166const char *entry_symbol = NULL;
167boolean entry_from_cmdline;
168boolean lang_has_input_file = false;
169boolean had_output_filename = false;
170boolean lang_float_flag = false;
171boolean delete_output_file_on_failure = false;
172struct lang_nocrossrefs *nocrossref_list;
173
174etree_type *base; /* Relocation base - or null */
175
176
177#if defined(__STDC__) || defined(ALMOST_STDC)
178#define cat(a,b) a##b
179#else
180#define cat(a,b) a/**/b
181#endif
182
183#define new_stat(x,y) (cat(x,_type)*) new_statement(cat(x,_enum), sizeof(cat(x,_type)),y)
184
185#define outside_section_address(q) ( (q)->output_offset + (q)->output_section->vma)
186
187#define outside_symbol_address(q) ((q)->value + outside_section_address(q->section))
188
189#define SECTION_NAME_MAP_LENGTH (16)
190
191PTR
192stat_alloc (size)
193 size_t size;
194{
195 return obstack_alloc (&stat_obstack, size);
196}
197
4dec4d4e
RH		 198/*----------------------------------------------------------------------
199 Generic traversal routines for finding matching sections.
200*/
201
202static void
203walk_wild_section (ptr, section, file, callback, data)
204 lang_wild_statement_type *ptr;
205 const char *section;
206 lang_input_statement_type *file;
207 callback_t callback;
208 void *data;
209{
210 /* Don't process sections from files which were excluded. */
211 if (ptr->exclude_filename != NULL)
212 {
213 boolean match;
214
215 if (wildcardp (ptr->exclude_filename))
216 match = fnmatch (ptr->exclude_filename, file->filename, 0) == 0 ? true : false;
217 else
218 match = strcmp (ptr->exclude_filename, file->filename) == 0 ? true : false;
219
220 if (match)
221 return;
222 }
223
224 if (file->just_syms_flag == false)
225 {
226 register asection *s;
227 boolean wildcard;
228
229 if (section == NULL)
230 wildcard = false;
231 else
232 wildcard = wildcardp (section);
233
234 for (s = file->the_bfd->sections; s != NULL; s = s->next)
235 {
236 boolean match;
237
238 if (section == NULL)
239 match = true;
240 else
241 {
242 const char *name;
243
244 name = bfd_get_section_name (file->the_bfd, s);
245 if (wildcard)
246 match = fnmatch (section, name, 0) == 0 ? true : false;
247 else
248 match = strcmp (section, name) == 0 ? true : false;
249 }
250
251 if (match)
252 (*callback) (ptr, s, file, data);
253 }
254 }
255}
256
257/* Handle a wild statement for a single file F. */
258
259static void
260walk_wild_file (s, section, f, callback, data)
261 lang_wild_statement_type *s;
262 const char *section;
263 lang_input_statement_type *f;
264 callback_t callback;
265 void *data;
266{
267 if (f->the_bfd == NULL
268 || ! bfd_check_format (f->the_bfd, bfd_archive))
269 walk_wild_section (s, section, f, callback, data);
270 else
271 {
272 bfd *member;
273
274 /* This is an archive file. We must map each member of the
275 archive separately. */
276 member = bfd_openr_next_archived_file (f->the_bfd, (bfd *) NULL);
277 while (member != NULL)
278 {
279 /* When lookup_name is called, it will call the add_symbols
280 entry point for the archive. For each element of the
281 archive which is included, BFD will call ldlang_add_file,
282 which will set the usrdata field of the member to the
283 lang_input_statement. */
284 if (member->usrdata != NULL)
285 {
286 walk_wild_section (s, section,
287 (lang_input_statement_type *) member->usrdata,
288 callback, data);
289 }
290
291 member = bfd_openr_next_archived_file (f->the_bfd, member);
292 }
293 }
294}
295
296static void
297walk_wild (s, section, file, callback, data)
298 lang_wild_statement_type *s;
299 const char *section;
300 const char *file;
301 callback_t callback;
302 void *data;
303{
4dec4d4e
RH		 304 if (file == (char *) NULL)
305 {
306 /* Perform the iteration over all files in the list. */
e50d8076 307 LANG_FOR_EACH_INPUT_STATEMENT (f)
4dec4d4e
RH		 308 {
309 walk_wild_file (s, section, f, callback, data);
310 }
311 }
312 else if (wildcardp (file))
313 {
e50d8076 314 LANG_FOR_EACH_INPUT_STATEMENT (f)
4dec4d4e
RH		 315 {
316 if (fnmatch (file, f->filename, FNM_FILE_NAME) == 0)
317 walk_wild_file (s, section, f, callback, data);
318 }
319 }
320 else
321 {
e50d8076
NC		 322 lang_input_statement_type *f;
323
4dec4d4e
RH		 324 /* Perform the iteration over a single file. */
325 f = lookup_name (file);
326 walk_wild_file (s, section, f, callback, data);
327 }
328}
329
252b5132
RH		 330/*----------------------------------------------------------------------
331 lang_for_each_statement walks the parse tree and calls the provided
332 function for each node
333*/
334
335static void
336lang_for_each_statement_worker (func, s)
337 void (*func) PARAMS ((lang_statement_union_type *));
338 lang_statement_union_type *s;
339{
340 for (; s != (lang_statement_union_type *) NULL; s = s->next)
341 {
342 func (s);
343
344 switch (s->header.type)
345 {
346 case lang_constructors_statement_enum:
347 lang_for_each_statement_worker (func, constructor_list.head);
348 break;
349 case lang_output_section_statement_enum:
350 lang_for_each_statement_worker
351 (func,
352 s->output_section_statement.children.head);
353 break;
354 case lang_wild_statement_enum:
355 lang_for_each_statement_worker
356 (func,
357 s->wild_statement.children.head);
358 break;
359 case lang_group_statement_enum:
360 lang_for_each_statement_worker (func,
361 s->group_statement.children.head);
362 break;
363 case lang_data_statement_enum:
364 case lang_reloc_statement_enum:
365 case lang_object_symbols_statement_enum:
366 case lang_output_statement_enum:
367 case lang_target_statement_enum:
368 case lang_input_section_enum:
369 case lang_input_statement_enum:
370 case lang_assignment_statement_enum:
371 case lang_padding_statement_enum:
372 case lang_address_statement_enum:
373 case lang_fill_statement_enum:
374 break;
375 default:
376 FAIL ();
377 break;
378 }
379 }
380}
381
382void
383lang_for_each_statement (func)
384 void (*func) PARAMS ((lang_statement_union_type *));
385{
386 lang_for_each_statement_worker (func,
387 statement_list.head);
388}
389
390/*----------------------------------------------------------------------*/
391void
392lang_list_init (list)
393 lang_statement_list_type *list;
394{
395 list->head = (lang_statement_union_type *) NULL;
396 list->tail = &list->head;
397}
398
399/*----------------------------------------------------------------------
400
401 build a new statement node for the parse tree
402
403 */
404
405static
406lang_statement_union_type *
407new_statement (type, size, list)
408 enum statement_enum type;
409 size_t size;
410 lang_statement_list_type * list;
411{
412 lang_statement_union_type *new = (lang_statement_union_type *)
413 stat_alloc (size);
414
415 new->header.type = type;
416 new->header.next = (lang_statement_union_type *) NULL;
417 lang_statement_append (list, new, &new->header.next);
418 return new;
419}
420
421/*
422 Build a new input file node for the language. There are several ways
423 in which we treat an input file, eg, we only look at symbols, or
424 prefix it with a -l etc.
425
426 We can be supplied with requests for input files more than once;
427 they may, for example be split over serveral lines like foo.o(.text)
428 foo.o(.data) etc, so when asked for a file we check that we havn't
429 got it already so we don't duplicate the bfd.
430
431 */
432static lang_input_statement_type *
433new_afile (name, file_type, target, add_to_list)
434 CONST char *name;
435 lang_input_file_enum_type file_type;
436 CONST char *target;
437 boolean add_to_list;
438{
439 lang_input_statement_type *p;
440
441 if (add_to_list)
442 p = new_stat (lang_input_statement, stat_ptr);
443 else
444 {
445 p = ((lang_input_statement_type *)
446 stat_alloc (sizeof (lang_input_statement_type)));
447 p->header.next = NULL;
448 }
449
450 lang_has_input_file = true;
451 p->target = target;
452 switch (file_type)
453 {
454 case lang_input_file_is_symbols_only_enum:
455 p->filename = name;
456 p->is_archive = false;
457 p->real = true;
458 p->local_sym_name = name;
459 p->just_syms_flag = true;
460 p->search_dirs_flag = false;
461 break;
462 case lang_input_file_is_fake_enum:
463 p->filename = name;
464 p->is_archive = false;
465 p->real = false;
466 p->local_sym_name = name;
467 p->just_syms_flag = false;
468 p->search_dirs_flag = false;
469 break;
470 case lang_input_file_is_l_enum:
471 p->is_archive = true;
472 p->filename = name;
473 p->real = true;
474 p->local_sym_name = concat ("-l", name, (const char *) NULL);
475 p->just_syms_flag = false;
476 p->search_dirs_flag = true;
477 break;
478 case lang_input_file_is_marker_enum:
479 p->filename = name;
480 p->is_archive = false;
481 p->real = false;
482 p->local_sym_name = name;
483 p->just_syms_flag = false;
484 p->search_dirs_flag = true;
485 break;
486 case lang_input_file_is_search_file_enum:
487 p->filename = name;
488 p->is_archive = false;
489 p->real = true;
490 p->local_sym_name = name;
491 p->just_syms_flag = false;
492 p->search_dirs_flag = true;
493 break;
494 case lang_input_file_is_file_enum:
495 p->filename = name;
496 p->is_archive = false;
497 p->real = true;
498 p->local_sym_name = name;
499 p->just_syms_flag = false;
500 p->search_dirs_flag = false;
501 break;
502 default:
503 FAIL ();
504 }
505 p->the_bfd = (bfd *) NULL;
506 p->asymbols = (asymbol **) NULL;
507 p->next_real_file = (lang_statement_union_type *) NULL;
508 p->next = (lang_statement_union_type *) NULL;
509 p->symbol_count = 0;
510 p->dynamic = config.dynamic_link;
511 p->whole_archive = whole_archive;
512 p->loaded = false;
513 lang_statement_append (&input_file_chain,
514 (lang_statement_union_type *) p,
515 &p->next_real_file);
516 return p;
517}
518
519lang_input_statement_type *
520lang_add_input_file (name, file_type, target)
521 CONST char *name;
522 lang_input_file_enum_type file_type;
523 CONST char *target;
524{
525 lang_has_input_file = true;
526 return new_afile (name, file_type, target, true);
527}
528
529/* Build enough state so that the parser can build its tree */
530void
531lang_init ()
532{
533 obstack_begin (&stat_obstack, 1000);
534
535 stat_ptr = &statement_list;
536
537 lang_list_init (stat_ptr);
538
539 lang_list_init (&input_file_chain);
540 lang_list_init (&lang_output_section_statement);
541 lang_list_init (&file_chain);
542 first_file = lang_add_input_file ((char *) NULL,
543 lang_input_file_is_marker_enum,
544 (char *) NULL);
545 abs_output_section = lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME);
546
547 abs_output_section->bfd_section = bfd_abs_section_ptr;
548
549}
550
551/*----------------------------------------------------------------------
552 A region is an area of memory declared with the
553 MEMORY { name:org=exp, len=exp ... }
554 syntax.
555
556 We maintain a list of all the regions here
557
558 If no regions are specified in the script, then the default is used
559 which is created when looked up to be the entire data space
560*/
561
562static lang_memory_region_type *lang_memory_region_list;
563static lang_memory_region_type **lang_memory_region_list_tail = &lang_memory_region_list;
564
565lang_memory_region_type *
566lang_memory_region_lookup (name)
567 CONST char *CONST name;
568{
569 lang_memory_region_type *p;
570
571 for (p = lang_memory_region_list;
572 p != (lang_memory_region_type *) NULL;
573 p = p->next)
574 {
575 if (strcmp (p->name, name) == 0)
576 {
577 return p;
578 }
579 }
580
581#if 0
582 /* This code used to always use the first region in the list as the
583 default region. I changed it to instead use a region
584 encompassing all of memory as the default region. This permits
585 NOLOAD sections to work reasonably without requiring a region.
586 People should specify what region they mean, if they really want
587 a region. */
588 if (strcmp (name, "*default*") == 0)
589 {
590 if (lang_memory_region_list != (lang_memory_region_type *) NULL)
591 {
592 return lang_memory_region_list;
593 }
594 }
595#endif
596
597 {
598 lang_memory_region_type *new =
599 (lang_memory_region_type *) stat_alloc (sizeof (lang_memory_region_type));
600
601 new->name = buystring (name);
602 new->next = (lang_memory_region_type *) NULL;
603
604 *lang_memory_region_list_tail = new;
605 lang_memory_region_list_tail = &new->next;
606 new->origin = 0;
607 new->flags = 0;
608 new->not_flags = 0;
609 new->length = ~(bfd_size_type)0;
610 new->current = 0;
611 new->had_full_message = false;
612
613 return new;
614 }
615}
616
617
618lang_memory_region_type *
619lang_memory_default (section)
620 asection *section;
621{
622 lang_memory_region_type *p;
623
624 flagword sec_flags = section->flags;
625
626 /* Override SEC_DATA to mean a writable section. */
627 if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
628 sec_flags |= SEC_DATA;
629
630 for (p = lang_memory_region_list;
631 p != (lang_memory_region_type *) NULL;
632 p = p->next)
633 {
634 if ((p->flags & sec_flags) != 0
635 && (p->not_flags & sec_flags) == 0)
636 {
637 return p;
638 }
639 }
640 return lang_memory_region_lookup ("*default*");
641}
642
643lang_output_section_statement_type *
644lang_output_section_find (name)
645 CONST char *CONST name;
646{
647 lang_statement_union_type *u;
648 lang_output_section_statement_type *lookup;
649
650 for (u = lang_output_section_statement.head;
651 u != (lang_statement_union_type *) NULL;
652 u = lookup->next)
653 {
654 lookup = &u->output_section_statement;
655 if (strcmp (name, lookup->name) == 0)
656 {
657 return lookup;
658 }
659 }
660 return (lang_output_section_statement_type *) NULL;
661}
662
663lang_output_section_statement_type *
664lang_output_section_statement_lookup (name)
665 CONST char *CONST name;
666{
667 lang_output_section_statement_type *lookup;
668
669 lookup = lang_output_section_find (name);
670 if (lookup == (lang_output_section_statement_type *) NULL)
671 {
672
673 lookup = (lang_output_section_statement_type *)
674 new_stat (lang_output_section_statement, stat_ptr);
675 lookup->region = (lang_memory_region_type *) NULL;
676 lookup->fill = 0;
677 lookup->block_value = 1;
678 lookup->name = name;
679
680 lookup->next = (lang_statement_union_type *) NULL;
681 lookup->bfd_section = (asection *) NULL;
682 lookup->processed = false;
683 lookup->sectype = normal_section;
684 lookup->addr_tree = (etree_type *) NULL;
685 lang_list_init (&lookup->children);
686
687 lookup->memspec = (CONST char *) NULL;
688 lookup->flags = 0;
689 lookup->subsection_alignment = -1;
690 lookup->section_alignment = -1;
691 lookup->load_base = (union etree_union *) NULL;
692 lookup->phdrs = NULL;
693
694 lang_statement_append (&lang_output_section_statement,
695 (lang_statement_union_type *) lookup,
696 &lookup->next);
697 }
698 return lookup;
699}
700
701static void
702lang_map_flags (flag)
703 flagword flag;
704{
705 if (flag & SEC_ALLOC)
706 minfo ("a");
707
708 if (flag & SEC_CODE)
709 minfo ("x");
710
711 if (flag & SEC_READONLY)
712 minfo ("r");
713
714 if (flag & SEC_DATA)
715 minfo ("w");
716
717 if (flag & SEC_LOAD)
718 minfo ("l");
719}
720
721void
722lang_map ()
723{
724 lang_memory_region_type *m;
725
726 minfo (_("\nMemory Configuration\n\n"));
727 fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
728 _("Name"), _("Origin"), _("Length"), _("Attributes"));
729
730 for (m = lang_memory_region_list;
731 m != (lang_memory_region_type *) NULL;
732 m = m->next)
733 {
734 char buf[100];
735 int len;
736
737 fprintf (config.map_file, "%-16s ", m->name);
738
739 sprintf_vma (buf, m->origin);
740 minfo ("0x%s ", buf);
741 len = strlen (buf);
742 while (len < 16)
743 {
744 print_space ();
745 ++len;
746 }
747
748 minfo ("0x%V", m->length);
749 if (m->flags || m->not_flags)
750 {
751#ifndef BFD64
752 minfo (" ");
753#endif
754 if (m->flags)
755 {
756 print_space ();
757 lang_map_flags (m->flags);
758 }
759
760 if (m->not_flags)
761 {
762 minfo (" !");
763 lang_map_flags (m->not_flags);
764 }
765 }
766
767 print_nl ();
768 }
769
770 fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
771
772 print_statements ();
773}
774
775/* Initialize an output section. */
776
777static void
778init_os (s)
779 lang_output_section_statement_type *s;
780{
781 section_userdata_type *new;
782
783 if (s->bfd_section != NULL)
784 return;
785
786 if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
787 einfo (_("%P%F: Illegal use of `%s' section"), DISCARD_SECTION_NAME);
788
789 new = ((section_userdata_type *)
790 stat_alloc (sizeof (section_userdata_type)));
791
792 s->bfd_section = bfd_get_section_by_name (output_bfd, s->name);
793 if (s->bfd_section == (asection *) NULL)
794 s->bfd_section = bfd_make_section (output_bfd, s->name);
795 if (s->bfd_section == (asection *) NULL)
796 {
797 einfo (_("%P%F: output format %s cannot represent section called %s\n"),
798 output_bfd->xvec->name, s->name);
799 }
800 s->bfd_section->output_section = s->bfd_section;
801
802 /* We initialize an output sections output offset to minus its own */
803 /* vma to allow us to output a section through itself */
804 s->bfd_section->output_offset = 0;
805 get_userdata (s->bfd_section) = (PTR) new;
806
807 /* If there is a base address, make sure that any sections it might
808 mention are initialized. */
809 if (s->addr_tree != NULL)
810 exp_init_os (s->addr_tree);
811}
812
813/* Make sure that all output sections mentioned in an expression are
814 initialized. */
815
816static void
817exp_init_os (exp)
818 etree_type *exp;
819{
820 switch (exp->type.node_class)
821 {
822 case etree_assign:
823 exp_init_os (exp->assign.src);
824 break;
825
826 case etree_binary:
827 exp_init_os (exp->binary.lhs);
828 exp_init_os (exp->binary.rhs);
829 break;
830
831 case etree_trinary:
832 exp_init_os (exp->trinary.cond);
833 exp_init_os (exp->trinary.lhs);
834 exp_init_os (exp->trinary.rhs);
835 break;
836
837 case etree_unary:
838 exp_init_os (exp->unary.child);
839 break;
840
841 case etree_name:
842 switch (exp->type.node_code)
843 {
844 case ADDR:
845 case LOADADDR:
846 case SIZEOF:
847 {
848 lang_output_section_statement_type *os;
849
850 os = lang_output_section_find (exp->name.name);
851 if (os != NULL && os->bfd_section == NULL)
852 init_os (os);
853 }
854 }
855 break;
856
857 default:
858 break;
859 }
860}
861
862/* Sections marked with the SEC_LINK_ONCE flag should only be linked
863 once into the output. This routine checks each sections, and
864 arranges to discard it if a section of the same name has already
865 been linked. This code assumes that all relevant sections have the
866 SEC_LINK_ONCE flag set; that is, it does not depend solely upon the
867 section name. This is called via bfd_map_over_sections. */
868
869/*ARGSUSED*/
870static void
871section_already_linked (abfd, sec, data)
872 bfd *abfd;
873 asection *sec;
874 PTR data;
875{
876 lang_input_statement_type *entry = (lang_input_statement_type *) data;
877 struct sec_link_once
878 {
879 struct sec_link_once *next;
880 asection *sec;
881 };
882 static struct sec_link_once *sec_link_once_list;
883 flagword flags;
884 const char *name;
885 struct sec_link_once *l;
886
887 /* If we are only reading symbols from this object, then we want to
888 discard all sections. */
889 if (entry->just_syms_flag)
890 {
891 sec->output_section = bfd_abs_section_ptr;
892 sec->output_offset = sec->vma;
893 return;
894 }
895
896 flags = bfd_get_section_flags (abfd, sec);
897
898 if ((flags & SEC_LINK_ONCE) == 0)
899 return;
900
e361c369
ILT		 901 /* FIXME: When doing a relocateable link, we may have trouble
902 copying relocations in other sections that refer to local symbols
903 in the section being discarded. Those relocations will have to
904 be converted somehow; as of this writing I'm not sure that any of
905 the backends handle that correctly.
906
907 It is tempting to instead not discard link once sections when
908 doing a relocateable link (technically, they should be discarded
909 whenever we are building constructors). However, that fails,
910 because the linker winds up combining all the link once sections
911 into a single large link once section, which defeats the purpose
912 of having link once sections in the first place.
913
914 Also, not merging link once sections in a relocateable link
915 causes trouble for MIPS ELF, which relies in link once semantics
916 to handle the .reginfo section correctly. */
917
252b5132
RH		 918 name = bfd_get_section_name (abfd, sec);
919
920 for (l = sec_link_once_list; l != NULL; l = l->next)
921 {
922 if (strcmp (name, bfd_get_section_name (l->sec->owner, l->sec)) == 0)
923 {
924 /* The section has already been linked. See if we should
925 issue a warning. */
926 switch (flags & SEC_LINK_DUPLICATES)
927 {
928 default:
929 abort ();
930
931 case SEC_LINK_DUPLICATES_DISCARD:
932 break;
933
934 case SEC_LINK_DUPLICATES_ONE_ONLY:
935 einfo (_("%P: %B: warning: ignoring duplicate section `%s'\n"),
936 abfd, name);
937 break;
938
939 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
940 /* FIXME: We should really dig out the contents of both
941 sections and memcmp them. The COFF/PE spec says that
942 the Microsoft linker does not implement this
943 correctly, so I'm not going to bother doing it
944 either. */
945 /* Fall through. */
946 case SEC_LINK_DUPLICATES_SAME_SIZE:
947 if (bfd_section_size (abfd, sec)
948 != bfd_section_size (l->sec->owner, l->sec))
949 einfo (_("%P: %B: warning: duplicate section `%s' has different size\n"),
950 abfd, name);
951 break;
952 }
953
954 /* Set the output_section field so that wild_doit does not
955 create a lang_input_section structure for this section. */
956 sec->output_section = bfd_abs_section_ptr;
957
958 return;
959 }
960 }
961
962 /* This is the first section with this name. Record it. */
963
964 l = (struct sec_link_once *) xmalloc (sizeof *l);
965 l->sec = sec;
966 l->next = sec_link_once_list;
967 sec_link_once_list = l;
968}
969\f
970/* The wild routines.
971
972 These expand statements like *(.text) and foo.o to a list of
973 explicit actions, like foo.o(.text), bar.o(.text) and
974 foo.o(.text, .data). */
975
976/* Return true if the PATTERN argument is a wildcard pattern.
977 Although backslashes are treated specially if a pattern contains
978 wildcards, we do not consider the mere presence of a backslash to
979 be enough to cause the the pattern to be treated as a wildcard.
980 That lets us handle DOS filenames more naturally. */
981
982static boolean
983wildcardp (pattern)
984 const char *pattern;
985{
986 const char *s;
987
988 for (s = pattern; *s != '\0'; ++s)
989 if (*s == '?'
990 || *s == '*'
991 || *s == '[')
992 return true;
993 return false;
994}
995
996/* Add SECTION to the output section OUTPUT. Do this by creating a
997 lang_input_section statement which is placed at PTR. FILE is the
998 input file which holds SECTION. */
999
1000void
1001wild_doit (ptr, section, output, file)
1002 lang_statement_list_type *ptr;
1003 asection *section;
1004 lang_output_section_statement_type *output;
1005 lang_input_statement_type *file;
1006{
1007 flagword flags;
1008 boolean discard;
1009
1010 flags = bfd_get_section_flags (section->owner, section);
1011
1012 discard = false;
1013
1014 /* If we are doing a final link, discard sections marked with
1015 SEC_EXCLUDE. */
1016 if (! link_info.relocateable
1017 && (flags & SEC_EXCLUDE) != 0)
1018 discard = true;
1019
1020 /* Discard input sections which are assigned to a section named
1021 DISCARD_SECTION_NAME. */
1022 if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
1023 discard = true;
1024
1025 /* Discard debugging sections if we are stripping debugging
1026 information. */
1027 if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
1028 && (flags & SEC_DEBUGGING) != 0)
1029 discard = true;
1030
1031 if (discard)
1032 {
1033 if (section->output_section == NULL)
1034 {
1035 /* This prevents future calls from assigning this section. */
1036 section->output_section = bfd_abs_section_ptr;
1037 }
1038 return;
1039 }
1040
1041 if (section->output_section == NULL)
1042 {
1043 boolean first;
1044 lang_input_section_type *new;
1045 flagword flags;
1046
1047 if (output->bfd_section == NULL)
1048 {
1049 init_os (output);
1050 first = true;
1051 }
1052 else
1053 first = false;
1054
1055 /* Add a section reference to the list */
1056 new = new_stat (lang_input_section, ptr);
1057
1058 new->section = section;
1059 new->ifile = file;
1060 section->output_section = output->bfd_section;
1061
1062 flags = section->flags;
1063
1064 /* We don't copy the SEC_NEVER_LOAD flag from an input section
1065 to an output section, because we want to be able to include a
1066 SEC_NEVER_LOAD section in the middle of an otherwise loaded
1067 section (I don't know why we want to do this, but we do).
1068 build_link_order in ldwrite.c handles this case by turning
1069 the embedded SEC_NEVER_LOAD section into a fill. */
1070
1071 flags &= ~ SEC_NEVER_LOAD;
1072
1073 /* If final link, don't copy the SEC_LINK_ONCE flags, they've
1074 already been processed. One reason to do this is that on pe
1075 format targets, .text$foo sections go into .text and it's odd
1076 to see .text with SEC_LINK_ONCE set. */
1077
1078 if (! link_info.relocateable)
1079 flags &= ~ (SEC_LINK_ONCE | SEC_LINK_DUPLICATES);
1080
1081 /* If this is not the first input section, and the SEC_READONLY
1082 flag is not currently set, then don't set it just because the
1083 input section has it set. */
1084
1085 if (! first && (section->output_section->flags & SEC_READONLY) == 0)
1086 flags &= ~ SEC_READONLY;
1087
1088 section->output_section->flags |= flags;
1089
1090 /* If SEC_READONLY is not set in the input section, then clear
1091 it from the output section. */
1092 if ((section->flags & SEC_READONLY) == 0)
1093 section->output_section->flags &= ~SEC_READONLY;
1094
1095 switch (output->sectype)
1096 {
1097 case normal_section:
1098 break;
1099 case dsect_section:
1100 case copy_section:
1101 case info_section:
1102 case overlay_section:
1103 output->bfd_section->flags &= ~SEC_ALLOC;
1104 break;
1105 case noload_section:
1106 output->bfd_section->flags &= ~SEC_LOAD;
1107 output->bfd_section->flags |= SEC_NEVER_LOAD;
1108 break;
1109 }
1110
667f5177
ILT		 1111 /* Copy over SEC_SMALL_DATA. */
1112 if (section->flags & SEC_SMALL_DATA)
1113 section->output_section->flags |= SEC_SMALL_DATA;
9e41f973 1114
252b5132
RH		 1115 if (section->alignment_power > output->bfd_section->alignment_power)
1116 output->bfd_section->alignment_power = section->alignment_power;
1117
1118 /* If supplied an aligment, then force it. */
1119 if (output->section_alignment != -1)
1120 output->bfd_section->alignment_power = output->section_alignment;
1121 }
1122}
1123
1124/* Handle wildcard sorting. This returns the lang_input_section which
1125 should follow the one we are going to create for SECTION and FILE,
1126 based on the sorting requirements of WILD. It returns NULL if the
1127 new section should just go at the end of the current list. */
1128
1129static lang_statement_union_type *
1130wild_sort (wild, file, section)
1131 lang_wild_statement_type *wild;
1132 lang_input_statement_type *file;
1133 asection *section;
1134{
1135 const char *section_name;
1136 lang_statement_union_type *l;
1137
1138 if (! wild->filenames_sorted && ! wild->sections_sorted)
1139 return NULL;
1140
1141 section_name = bfd_get_section_name (file->the_bfd, section);
1142 for (l = wild->children.head; l != NULL; l = l->next)
1143 {
1144 lang_input_section_type *ls;
1145
1146 if (l->header.type != lang_input_section_enum)
1147 continue;
1148 ls = &l->input_section;
1149
1150 /* Sorting by filename takes precedence over sorting by section
1151 name. */
1152
1153 if (wild->filenames_sorted)
1154 {
1155 const char *fn, *ln;
1156 boolean fa, la;
1157 int i;
1158
1159 /* The PE support for the .idata section as generated by
1160 dlltool assumes that files will be sorted by the name of
1161 the archive and then the name of the file within the
1162 archive. */
1163
1164 if (file->the_bfd != NULL
1165 && bfd_my_archive (file->the_bfd) != NULL)
1166 {
1167 fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
1168 fa = true;
1169 }
1170 else
1171 {
1172 fn = file->filename;
1173 fa = false;
1174 }
1175
1176 if (ls->ifile->the_bfd != NULL
1177 && bfd_my_archive (ls->ifile->the_bfd) != NULL)
1178 {
1179 ln = bfd_get_filename (bfd_my_archive (ls->ifile->the_bfd));
1180 la = true;
1181 }
1182 else
1183 {
1184 ln = ls->ifile->filename;
1185 la = false;
1186 }
1187
1188 i = strcmp (fn, ln);
1189 if (i > 0)
1190 continue;
1191 else if (i < 0)
1192 break;
1193
1194 if (fa || la)
1195 {
1196 if (fa)
1197 fn = file->filename;
1198 if (la)
1199 ln = ls->ifile->filename;
1200
1201 i = strcmp (fn, ln);
1202 if (i > 0)
1203 continue;
1204 else if (i < 0)
1205 break;
1206 }
1207 }
1208
1209 /* Here either the files are not sorted by name, or we are
1210 looking at the sections for this file. */
1211
1212 if (wild->sections_sorted)
1213 {
1214 if (strcmp (section_name,
1215 bfd_get_section_name (ls->ifile->the_bfd,
1216 ls->section))
1217 < 0)
1218 break;
1219 }
1220 }
1221
1222 return l;
1223}
1224
1225/* Expand a wild statement for a particular FILE. SECTION may be
1226 NULL, in which case it is a wild card. */
1227
1228static void
4dec4d4e 1229output_section_callback (ptr, section, file, output)
252b5132 1230 lang_wild_statement_type *ptr;
4dec4d4e 1231 asection *section;
252b5132 1232 lang_input_statement_type *file;
4dec4d4e
RH		 1233 void *output;
1234{
1235 lang_statement_union_type *before;
1236
1237 /* If the wild pattern was marked KEEP, the member sections
1238 should be as well. */
1239 if (ptr->keep_sections)
1240 section->flags |= SEC_KEEP;
1241
1242 before = wild_sort (ptr, file, section);
1243
1244 /* Here BEFORE points to the lang_input_section which
1245 should follow the one we are about to add. If BEFORE
1246 is NULL, then the section should just go at the end
1247 of the current list. */
1248
1249 if (before == NULL)
1250 wild_doit (&ptr->children, section,
1251 (lang_output_section_statement_type *) output,
1252 file);
1253 else
252b5132 1254 {
4dec4d4e
RH		 1255 lang_statement_list_type list;
1256 lang_statement_union_type **pp;
1257
1258 lang_list_init (&list);
1259 wild_doit (&list, section,
1260 (lang_output_section_statement_type *) output,
1261 file);
1262
1263 /* If we are discarding the section, LIST.HEAD will
1264 be NULL. */
1265 if (list.head != NULL)
252b5132 1266 {
4dec4d4e
RH		 1267 ASSERT (list.head->next == NULL);
1268
1269 for (pp = &ptr->children.head;
1270 *pp != before;
1271 pp = &(*pp)->next)
1272 ASSERT (*pp != NULL);
1273
1274 list.head->next = *pp;
1275 *pp = list.head;
252b5132
RH		 1276 }
1277 }
1278}
1279
1280/* This is passed a file name which must have been seen already and
1281 added to the statement tree. We will see if it has been opened
1282 already and had its symbols read. If not then we'll read it. */
1283
1284static lang_input_statement_type *
1285lookup_name (name)
1286 const char *name;
1287{
1288 lang_input_statement_type *search;
1289
1290 for (search = (lang_input_statement_type *) input_file_chain.head;
1291 search != (lang_input_statement_type *) NULL;
1292 search = (lang_input_statement_type *) search->next_real_file)
1293 {
1294 if (search->filename == (char *) NULL && name == (char *) NULL)
1295 return search;
1296 if (search->filename != (char *) NULL
1297 && name != (char *) NULL
1298 && strcmp (search->filename, name) == 0)
1299 break;
1300 }
1301
1302 if (search == (lang_input_statement_type *) NULL)
1303 search = new_afile (name, lang_input_file_is_file_enum, default_target,
1304 false);
1305
1306 /* If we have already added this file, or this file is not real
1307 (FIXME: can that ever actually happen?) or the name is NULL
1308 (FIXME: can that ever actually happen?) don't add this file. */
1309 if (search->loaded
1310 || ! search->real
1311 || search->filename == (const char *) NULL)
1312 return search;
1313
1314 load_symbols (search, (lang_statement_list_type *) NULL);
1315
1316 return search;
1317}
1318
1319/* Get the symbols for an input file. */
1320
1321static void
1322load_symbols (entry, place)
1323 lang_input_statement_type *entry;
1324 lang_statement_list_type *place;
1325{
1326 char **matching;
1327
1328 if (entry->loaded)
1329 return;
1330
1331 ldfile_open_file (entry);
1332
1333 if (! bfd_check_format (entry->the_bfd, bfd_archive)
1334 && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
1335 {
1336 bfd_error_type err;
1337 lang_statement_list_type *hold;
1338
1339 err = bfd_get_error ();
1340 if (err == bfd_error_file_ambiguously_recognized)
1341 {
1342 char **p;
1343
1344 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1345 einfo (_("%B: matching formats:"), entry->the_bfd);
1346 for (p = matching; *p != NULL; p++)
1347 einfo (" %s", *p);
1348 einfo ("%F\n");
1349 }
1350 else if (err != bfd_error_file_not_recognized
1351 || place == NULL)
1352 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1353
1354 bfd_close (entry->the_bfd);
1355 entry->the_bfd = NULL;
1356
1357 /* See if the emulation has some special knowledge. */
1358
1359 if (ldemul_unrecognized_file (entry))
1360 return;
1361
1362 /* Try to interpret the file as a linker script. */
1363
1364 ldfile_open_command_file (entry->filename);
1365
1366 hold = stat_ptr;
1367 stat_ptr = place;
1368
1369 ldfile_assumed_script = true;
1370 parser_input = input_script;
1371 yyparse ();
1372 ldfile_assumed_script = false;
1373
1374 stat_ptr = hold;
1375
1376 return;
1377 }
1378
1379 if (ldemul_recognized_file (entry))
1380 return;
1381
1382 /* We don't call ldlang_add_file for an archive. Instead, the
1383 add_symbols entry point will call ldlang_add_file, via the
1384 add_archive_element callback, for each element of the archive
1385 which is used. */
1386 switch (bfd_get_format (entry->the_bfd))
1387 {
1388 default:
1389 break;
1390
1391 case bfd_object:
1392 ldlang_add_file (entry);
1393 if (trace_files || trace_file_tries)
1394 info_msg ("%I\n", entry);
1395 break;
1396
1397 case bfd_archive:
1398 if (entry->whole_archive)
1399 {
1400 bfd *member = bfd_openr_next_archived_file (entry->the_bfd,
1401 (bfd *) NULL);
1402 while (member != NULL)
1403 {
1404 if (! bfd_check_format (member, bfd_object))
1405 einfo (_("%F%B: object %B in archive is not object\n"),
1406 entry->the_bfd, member);
1407 if (! ((*link_info.callbacks->add_archive_element)
1408 (&link_info, member, "--whole-archive")))
1409 abort ();
1410 if (! bfd_link_add_symbols (member, &link_info))
1411 einfo (_("%F%B: could not read symbols: %E\n"), member);
1412 member = bfd_openr_next_archived_file (entry->the_bfd,
1413 member);
1414 }
1415
1416 entry->loaded = true;
1417
1418 return;
1419 }
1420 }
1421
1422 if (! bfd_link_add_symbols (entry->the_bfd, &link_info))
1423 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1424
1425 entry->loaded = true;
1426}
1427
4dec4d4e 1428
252b5132
RH		 1429
1430/* Handle a wild statement. SECTION or FILE or both may be NULL,
1431 indicating that it is a wildcard. Separate lang_input_section
1432 statements are created for each part of the expansion; they are
1433 added after the wild statement S. OUTPUT is the output section. */
1434
1435static void
1436wild (s, section, file, target, output)
1437 lang_wild_statement_type *s;
1438 const char *section;
1439 const char *file;
87f2a346 1440 const char *target ATTRIBUTE_UNUSED;
252b5132
RH		 1441 lang_output_section_statement_type *output;
1442{
4dec4d4e 1443 walk_wild (s, section, file, output_section_callback, (void *) output);
252b5132
RH		 1444
1445 if (section != (char *) NULL
1446 && strcmp (section, "COMMON") == 0
1447 && default_common_section == NULL)
1448 {
1449 /* Remember the section that common is going to in case we later
1450 get something which doesn't know where to put it. */
1451 default_common_section = output;
1452 }
1453}
1454
e50d8076
NC		 1455/* Return true iff target is the sought target. */
1456static int
1457get_target (target, data)
1458 const bfd_target * target;
1459 void * data;
1460{
1461 const char * sought = (const char *) data;
1462
1463 return strcmp (target->name, sought) == 0;
1464}
1465
1466/* Like strcpy() but convert to lower case as well. */
1467static void
1468stricpy (dest, src)
1469 char * dest;
1470 char * src;
1471{
1472 char c;
1473
1474 while ((c = * src ++) != 0)
1475 {
1476 if (isupper ((unsigned char) c))
1477 c = tolower (c);
1478
1479 * dest ++ = c;
1480 }
1481
1482 * dest = 0;
1483}
1484
1485/* Remove the first occurance of needle (if any) in haystack
1486 from haystack. */
1487static void
1488strcut (haystack, needle)
1489 char * haystack;
1490 char * needle;
1491{
1492 haystack = strstr (haystack, needle);
1493
1494 if (haystack)
1495 {
1496 char * src;
1497
1498 for (src = haystack + strlen (needle); * src;)
1499 * haystack ++ = * src ++;
1500
1501 * haystack = 0;
1502 }
1503}
1504
1505/* Compare two target format name strings.
1506 Return a value indicating how "similar" they are. */
1507static int
1508name_compare (first, second)
1509 char * first;
1510 char * second;
1511{
1512 char * copy1;
1513 char * copy2;
1514 int result;
1515
1516 copy1 = xmalloc (strlen (first) + 1);
1517 copy2 = xmalloc (strlen (second) + 1);
1518
1519 /* Convert the names to lower case. */
1520 stricpy (copy1, first);
1521 stricpy (copy2, second);
1522
1523 /* Remove and endian strings from the name. */
1524 strcut (copy1, "big");
1525 strcut (copy1, "little");
1526 strcut (copy2, "big");
1527 strcut (copy2, "little");
1528
1529 /* Return a value based on how many characters match,
1530 starting from the beginning. If both strings are
1531 the same then return 10 * their length. */
1532 for (result = 0; copy1 [result] == copy2 [result]; result ++)
1533 if (copy1 [result] == 0)
1534 {
1535 result *= 10;
1536 break;
1537 }
1538
1539 free (copy1);
1540 free (copy2);
1541
1542 return result;
1543}
1544
1545/* Set by closest_target_match() below. */
1546static const bfd_target * winner;
1547
1548/* Scan all the valid bfd targets looking for one that has the endianness
1549 requirement that was specified on the command line, and is the nearest
1550 match to the original output target. */
1551static int
1552closest_target_match (target, data)
1553 const bfd_target * target;
1554 void * data;
1555{
1556 const bfd_target * original = (const bfd_target *) data;
1557
1558 if (command_line.endian == ENDIAN_BIG && target->byteorder != BFD_ENDIAN_BIG)
1559 return 0;
1560
1561 if (command_line.endian == ENDIAN_LITTLE && target->byteorder != BFD_ENDIAN_LITTLE)
1562 return 0;
1563
1564 /* Must be the same flavour. */
1565 if (target->flavour != original->flavour)
1566 return 0;
1567
1568 /* If we have not found a potential winner yet, then record this one. */
1569 if (winner == NULL)
1570 {
1571 winner = target;
1572 return 0;
1573 }
1574
1575 /* Oh dear, we now have two potential candidates for a successful match.
1576 Compare their names and choose the better one. */
1577 if (name_compare (target->name, original->name) > name_compare (winner->name, original->name))
1578 winner = target;
1579
1580 /* Keep on searching until wqe have checked them all. */
1581 return 0;
1582}
1583
1584/* Return the BFD target format of the first input file. */
1585static char *
1586get_first_input_target ()
1587{
1588 char * target = NULL;
1589
1590 LANG_FOR_EACH_INPUT_STATEMENT (s)
1591 {
1592 if (s->header.type == lang_input_statement_enum
1593 && s->real)
1594 {
1595 ldfile_open_file (s);
1596
1597 if (s->the_bfd != NULL
1598 && bfd_check_format (s->the_bfd, bfd_object))
1599 {
1600 target = bfd_get_target (s->the_bfd);
1601
1602 if (target != NULL)
1603 break;
1604 }
1605 }
1606 }
1607
1608 return target;
1609}
1610
252b5132
RH		 1611/* Open the output file. */
1612
1613static bfd *
1614open_output (name)
e50d8076 1615 const char * name;
252b5132 1616{
e50d8076 1617 bfd * output;
252b5132 1618
e50d8076 1619 /* Has the user told us which output format to use ? */
252b5132
RH		 1620 if (output_target == (char *) NULL)
1621 {
e50d8076
NC		 1622 /* No - has the current target been set to something other than the default ? */
1623 if (current_target != default_target)
252b5132 1624 output_target = current_target;
e50d8076
NC		 1625
1626 /* No - can we determine the format of the first input file ? */
1627 else
1628 {
1629 output_target = get_first_input_target ();
1630
1631 /* Failed - use the default output target. */
1632 if (output_target == NULL)
1633 output_target = default_target;
1634 }
1635 }
1636
1637 /* Has the user requested a particular endianness on the command line ? */
1638 if (command_line.endian != ENDIAN_UNSET)
1639 {
1640 const bfd_target * target;
1641 int desired_endian;
1642
1643 /* Get the chosen target. */
1644 target = bfd_search_for_target (get_target, (void *) output_target);
1645
1646 if (command_line.endian == ENDIAN_BIG)
1647 desired_endian = BFD_ENDIAN_BIG;
252b5132 1648 else
e50d8076
NC		 1649 desired_endian = BFD_ENDIAN_LITTLE;
1650
1651 /* See if the target has the wrong endianness. This should not happen
1652 if the linker script has provided big and little endian alternatives,
1653 but some scrips don't do this. */
1654 if (target->byteorder != desired_endian)
1655 {
1656 /* If it does, then see if the target provides
1657 an alternative with the correct endianness. */
1658 if (target->alternative_target != NULL
1659 && (target->alternative_target->byteorder == desired_endian))
1660 output_target = target->alternative_target->name;
1661 else
1662 {
1663 /* Try to find a target as similar as possible to the default
1664 target, but which has the desired endian characteristic. */
1665 (void) bfd_search_for_target (closest_target_match, (void *) target);
1666
1667 /* Oh dear - we could not find any targets that satisfy our requirements. */
1668 if (winner == NULL)
1669 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1670 else
1671 output_target = winner->name;
1672 }
1673 }
252b5132 1674 }
e50d8076 1675
252b5132
RH		 1676 output = bfd_openw (name, output_target);
1677
1678 if (output == (bfd *) NULL)
1679 {
1680 if (bfd_get_error () == bfd_error_invalid_target)
e50d8076
NC		 1681 einfo (_("%P%F: target %s not found\n"), output_target);
1682
252b5132
RH		 1683 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1684 }
1685
1686 delete_output_file_on_failure = true;
1687
1688 /* output->flags |= D_PAGED;*/
1689
1690 if (! bfd_set_format (output, bfd_object))
1691 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1692 if (! bfd_set_arch_mach (output,
1693 ldfile_output_architecture,
1694 ldfile_output_machine))
1695 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1696
1697 link_info.hash = bfd_link_hash_table_create (output);
1698 if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1699 einfo (_("%P%F: can not create link hash table: %E\n"));
1700
1701 bfd_set_gp_size (output, g_switch_value);
1702 return output;
1703}
1704
252b5132
RH		 1705static void
1706ldlang_open_output (statement)
1707 lang_statement_union_type * statement;
1708{
1709 switch (statement->header.type)
1710 {
1711 case lang_output_statement_enum:
1712 ASSERT (output_bfd == (bfd *) NULL);
1713 output_bfd = open_output (statement->output_statement.name);
1714 ldemul_set_output_arch ();
1715 if (config.magic_demand_paged && !link_info.relocateable)
1716 output_bfd->flags |= D_PAGED;
1717 else
1718 output_bfd->flags &= ~D_PAGED;
1719 if (config.text_read_only)
1720 output_bfd->flags |= WP_TEXT;
1721 else
1722 output_bfd->flags &= ~WP_TEXT;
1723 if (link_info.traditional_format)
1724 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1725 else
1726 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1727 break;
1728
1729 case lang_target_statement_enum:
1730 current_target = statement->target_statement.target;
1731 break;
1732 default:
1733 break;
1734 }
1735}
1736
1737/* Open all the input files. */
1738
1739static void
1740open_input_bfds (s, force)
1741 lang_statement_union_type *s;
1742 boolean force;
1743{
1744 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1745 {
1746 switch (s->header.type)
1747 {
1748 case lang_constructors_statement_enum:
1749 open_input_bfds (constructor_list.head, force);
1750 break;
1751 case lang_output_section_statement_enum:
1752 open_input_bfds (s->output_section_statement.children.head, force);
1753 break;
1754 case lang_wild_statement_enum:
1755 /* Maybe we should load the file's symbols */
1756 if (s->wild_statement.filename
1757 && ! wildcardp (s->wild_statement.filename))
1758 (void) lookup_name (s->wild_statement.filename);
1759 open_input_bfds (s->wild_statement.children.head, force);
1760 break;
1761 case lang_group_statement_enum:
1762 {
1763 struct bfd_link_hash_entry *undefs;
1764
1765 /* We must continually search the entries in the group
1766 until no new symbols are added to the list of undefined
1767 symbols. */
1768
1769 do
1770 {
1771 undefs = link_info.hash->undefs_tail;
1772 open_input_bfds (s->group_statement.children.head, true);
1773 }
1774 while (undefs != link_info.hash->undefs_tail);
1775 }
1776 break;
1777 case lang_target_statement_enum:
1778 current_target = s->target_statement.target;
1779 break;
1780 case lang_input_statement_enum:
e50d8076 1781 if (s->input_statement.real)
252b5132
RH		 1782 {
1783 lang_statement_list_type add;
1784
1785 s->input_statement.target = current_target;
1786
1787 /* If we are being called from within a group, and this
1788 is an archive which has already been searched, then
1789 force it to be researched. */
1790 if (force
1791 && s->input_statement.loaded
1792 && bfd_check_format (s->input_statement.the_bfd,
1793 bfd_archive))
1794 s->input_statement.loaded = false;
1795
1796 lang_list_init (&add);
1797
1798 load_symbols (&s->input_statement, &add);
1799
1800 if (add.head != NULL)
1801 {
1802 *add.tail = s->next;
1803 s->next = add.head;
1804 }
1805 }
1806 break;
1807 default:
1808 break;
1809 }
1810 }
1811}
1812
1813/* If there are [COMMONS] statements, put a wild one into the bss section */
1814
1815static void
1816lang_reasonable_defaults ()
1817{
1818#if 0
1819 lang_output_section_statement_lookup (".text");
1820 lang_output_section_statement_lookup (".data");
1821
1822 default_common_section =
1823 lang_output_section_statement_lookup (".bss");
1824
1825
1826 if (placed_commons == false)
1827 {
1828 lang_wild_statement_type *new =
1829 new_stat (lang_wild_statement,
1830 &default_common_section->children);
1831
1832 new->section_name = "COMMON";
1833 new->filename = (char *) NULL;
1834 lang_list_init (&new->children);
1835 }
1836#endif
1837
1838}
1839
1840/*
1841 Add the supplied name to the symbol table as an undefined reference.
1842 Remove items from the chain as we open input bfds
1843 */
1844typedef struct ldlang_undef_chain_list
1845{
1846 struct ldlang_undef_chain_list *next;
1847 char *name;
1848} ldlang_undef_chain_list_type;
1849
1850static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
1851
1852void
1853ldlang_add_undef (name)
1854 CONST char *CONST name;
1855{
1856 ldlang_undef_chain_list_type *new =
1857 ((ldlang_undef_chain_list_type *)
1858 stat_alloc (sizeof (ldlang_undef_chain_list_type)));
1859
1860 new->next = ldlang_undef_chain_list_head;
1861 ldlang_undef_chain_list_head = new;
1862
1863 new->name = buystring (name);
1864}
1865
1866/* Run through the list of undefineds created above and place them
1867 into the linker hash table as undefined symbols belonging to the
1868 script file.
1869*/
1870static void
1871lang_place_undefineds ()
1872{
1873 ldlang_undef_chain_list_type *ptr;
1874
1875 for (ptr = ldlang_undef_chain_list_head;
1876 ptr != (ldlang_undef_chain_list_type *) NULL;
1877 ptr = ptr->next)
1878 {
1879 struct bfd_link_hash_entry *h;
1880
1881 h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
1882 if (h == (struct bfd_link_hash_entry *) NULL)
1883 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
1884 if (h->type == bfd_link_hash_new)
1885 {
1886 h->type = bfd_link_hash_undefined;
1887 h->u.undef.abfd = NULL;
1888 bfd_link_add_undef (link_info.hash, h);
1889 }
1890 }
1891}
1892
1893/* Open input files and attatch to output sections */
1894static void
1895map_input_to_output_sections (s, target, output_section_statement)
1896 lang_statement_union_type * s;
1897 CONST char *target;
1898 lang_output_section_statement_type * output_section_statement;
1899{
1900 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1901 {
1902 switch (s->header.type)
1903 {
1904
1905
1906 case lang_wild_statement_enum:
1907 wild (&s->wild_statement, s->wild_statement.section_name,
1908 s->wild_statement.filename, target,
1909 output_section_statement);
1910
1911 break;
1912 case lang_constructors_statement_enum:
1913 map_input_to_output_sections (constructor_list.head,
1914 target,
1915 output_section_statement);
1916 break;
1917 case lang_output_section_statement_enum:
1918 map_input_to_output_sections (s->output_section_statement.children.head,
1919 target,
1920 &s->output_section_statement);
1921 break;
1922 case lang_output_statement_enum:
1923 break;
1924 case lang_target_statement_enum:
1925 target = s->target_statement.target;
1926 break;
1927 case lang_group_statement_enum:
1928 map_input_to_output_sections (s->group_statement.children.head,
1929 target,
1930 output_section_statement);
1931 break;
1932 case lang_fill_statement_enum:
1933 case lang_input_section_enum:
1934 case lang_object_symbols_statement_enum:
1935 case lang_data_statement_enum:
1936 case lang_reloc_statement_enum:
1937 case lang_padding_statement_enum:
1938 case lang_input_statement_enum:
1939 if (output_section_statement != NULL
1940 && output_section_statement->bfd_section == NULL)
1941 init_os (output_section_statement);
1942 break;
1943 case lang_assignment_statement_enum:
1944 if (output_section_statement != NULL
1945 && output_section_statement->bfd_section == NULL)
1946 init_os (output_section_statement);
1947
1948 /* Make sure that any sections mentioned in the assignment
1949 are initialized. */
1950 exp_init_os (s->assignment_statement.exp);
1951 break;
1952 case lang_afile_asection_pair_statement_enum:
1953 FAIL ();
1954 break;
1955 case lang_address_statement_enum:
1956 /* Mark the specified section with the supplied address */
1957 {
1958 lang_output_section_statement_type *os =
1959 lang_output_section_statement_lookup
1960 (s->address_statement.section_name);
1961
1962 if (os->bfd_section == NULL)
1963 init_os (os);
1964 os->addr_tree = s->address_statement.address;
1965 }
1966 break;
1967 }
1968 }
1969}
1970
1971static void
1972print_output_section_statement (output_section_statement)
1973 lang_output_section_statement_type * output_section_statement;
1974{
1975 asection *section = output_section_statement->bfd_section;
1976 int len;
1977
1978 if (output_section_statement != abs_output_section)
1979 {
1980 minfo ("\n%s", output_section_statement->name);
1981
1982 if (section != NULL)
1983 {
1984 print_dot = section->vma;
1985
1986 len = strlen (output_section_statement->name);
1987 if (len >= SECTION_NAME_MAP_LENGTH - 1)
1988 {
1989 print_nl ();
1990 len = 0;
1991 }
1992 while (len < SECTION_NAME_MAP_LENGTH)
1993 {
1994 print_space ();
1995 ++len;
1996 }
1997
1998 minfo ("0x%V %W", section->vma, section->_raw_size);
1999
2000 if (output_section_statement->load_base != NULL)
2001 {
2002 bfd_vma addr;
2003
2004 addr = exp_get_abs_int (output_section_statement->load_base, 0,
2005 "load base", lang_final_phase_enum);
2006 minfo (_(" load address 0x%V"), addr);
2007 }
2008 }
2009
2010 print_nl ();
2011 }
2012
2013 print_statement_list (output_section_statement->children.head,
2014 output_section_statement);
2015}
2016
2017static void
2018print_assignment (assignment, output_section)
2019 lang_assignment_statement_type * assignment;
2020 lang_output_section_statement_type * output_section;
2021{
2022 int i;
2023 etree_value_type result;
2024
2025 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2026 print_space ();
2027
2028 result = exp_fold_tree (assignment->exp->assign.src, output_section,
2029 lang_final_phase_enum, print_dot, &print_dot);
2030 if (result.valid_p)
2031 minfo ("0x%V", result.value + result.section->bfd_section->vma);
2032 else
2033 {
2034 minfo ("*undef* ");
2035#ifdef BFD64
2036 minfo (" ");
2037#endif
2038 }
2039
2040 minfo (" ");
2041
2042 exp_print_tree (assignment->exp);
2043
2044 print_nl ();
2045}
2046
2047static void
2048print_input_statement (statm)
2049 lang_input_statement_type * statm;
2050{
2051 if (statm->filename != (char *) NULL)
2052 {
2053 fprintf (config.map_file, "LOAD %s\n", statm->filename);
2054 }
2055}
2056
2057/* Print all symbols defined in a particular section. This is called
2058 via bfd_link_hash_traverse. */
2059
2060static boolean
2061print_one_symbol (hash_entry, ptr)
2062 struct bfd_link_hash_entry *hash_entry;
2063 PTR ptr;
2064{
2065 asection *sec = (asection *) ptr;
2066
2067 if ((hash_entry->type == bfd_link_hash_defined
2068 || hash_entry->type == bfd_link_hash_defweak)
2069 && sec == hash_entry->u.def.section)
2070 {
2071 int i;
2072
2073 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2074 print_space ();
2075 minfo ("0x%V ",
2076 (hash_entry->u.def.value
2077 + hash_entry->u.def.section->output_offset
2078 + hash_entry->u.def.section->output_section->vma));
2079
2080 minfo (" %T\n", hash_entry->root.string);
2081 }
2082
2083 return true;
2084}
2085
2086/* Print information about an input section to the map file. */
2087
2088static void
2089print_input_section (in)
2090 lang_input_section_type * in;
2091{
2092 asection *i = in->section;
2093 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
2094
2095 if (size != 0)
2096 {
2097 print_space ();
2098
2099 minfo ("%s", i->name);
2100
2101 if (i->output_section != NULL)
2102 {
2103 int len;
2104
2105 len = 1 + strlen (i->name);
2106 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2107 {
2108 print_nl ();
2109 len = 0;
2110 }
2111 while (len < SECTION_NAME_MAP_LENGTH)
2112 {
2113 print_space ();
2114 ++len;
2115 }
2116
2117 minfo ("0x%V %W %B\n",
2118 i->output_section->vma + i->output_offset, size,
2119 i->owner);
2120
2121 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2122 {
2123 len = SECTION_NAME_MAP_LENGTH + 3;
2124#ifdef BFD64
2125 len += 16;
2126#else
2127 len += 8;
2128#endif
2129 while (len > 0)
2130 {
2131 print_space ();
2132 --len;
2133 }
2134
2135 minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2136 }
2137
2138 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
2139
2140 print_dot = i->output_section->vma + i->output_offset + size;
2141 }
2142 }
2143}
2144
2145static void
2146print_fill_statement (fill)
2147 lang_fill_statement_type * fill;
2148{
2149 fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill);
2150}
2151
2152static void
2153print_data_statement (data)
2154 lang_data_statement_type * data;
2155{
2156 int i;
2157 bfd_vma addr;
2158 bfd_size_type size;
2159 const char *name;
2160
2161 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2162 print_space ();
2163
2164 addr = data->output_vma;
2165 if (data->output_section != NULL)
2166 addr += data->output_section->vma;
2167
2168 switch (data->type)
2169 {
2170 default:
2171 abort ();
2172 case BYTE:
2173 size = BYTE_SIZE;
2174 name = "BYTE";
2175 break;
2176 case SHORT:
2177 size = SHORT_SIZE;
2178 name = "SHORT";
2179 break;
2180 case LONG:
2181 size = LONG_SIZE;
2182 name = "LONG";
2183 break;
2184 case QUAD:
2185 size = QUAD_SIZE;
2186 name = "QUAD";
2187 break;
2188 case SQUAD:
2189 size = QUAD_SIZE;
2190 name = "SQUAD";
2191 break;
2192 }
2193
2194 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2195
2196 if (data->exp->type.node_class != etree_value)
2197 {
2198 print_space ();
2199 exp_print_tree (data->exp);
2200 }
2201
2202 print_nl ();
2203
2204 print_dot = addr + size;
2205}
2206
2207/* Print an address statement. These are generated by options like
2208 -Ttext. */
2209
2210static void
2211print_address_statement (address)
2212 lang_address_statement_type *address;
2213{
2214 minfo (_("Address of section %s set to "), address->section_name);
2215 exp_print_tree (address->address);
2216 print_nl ();
2217}
2218
2219/* Print a reloc statement. */
2220
2221static void
2222print_reloc_statement (reloc)
2223 lang_reloc_statement_type *reloc;
2224{
2225 int i;
2226 bfd_vma addr;
2227 bfd_size_type size;
2228
2229 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2230 print_space ();
2231
2232 addr = reloc->output_vma;
2233 if (reloc->output_section != NULL)
2234 addr += reloc->output_section->vma;
2235
2236 size = bfd_get_reloc_size (reloc->howto);
2237
2238 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2239
2240 if (reloc->name != NULL)
2241 minfo ("%s+", reloc->name);
2242 else
2243 minfo ("%s+", reloc->section->name);
2244
2245 exp_print_tree (reloc->addend_exp);
2246
2247 print_nl ();
2248
2249 print_dot = addr + size;
2250}
2251
2252static void
2253print_padding_statement (s)
2254 lang_padding_statement_type *s;
2255{
2256 int len;
2257 bfd_vma addr;
2258
2259 minfo (" *fill*");
2260
2261 len = sizeof " *fill*" - 1;
2262 while (len < SECTION_NAME_MAP_LENGTH)
2263 {
2264 print_space ();
2265 ++len;
2266 }
2267
2268 addr = s->output_offset;
2269 if (s->output_section != NULL)
2270 addr += s->output_section->vma;
2271 minfo ("0x%V %W", addr, s->size);
2272
2273 if (s->fill != 0)
2274 minfo (" %u", s->fill);
2275
2276 print_nl ();
2277
2278 print_dot = addr + s->size;
2279}
2280
2281static void
2282print_wild_statement (w, os)
2283 lang_wild_statement_type * w;
2284 lang_output_section_statement_type * os;
2285{
2286 print_space ();
2287
2288 if (w->filenames_sorted)
2289 minfo ("SORT(");
2290 if (w->exclude_filename != NULL)
2291 minfo ("EXCLUDE_FILE ( %s )", w->exclude_filename);
2292 if (w->filename != NULL)
2293 minfo ("%s", w->filename);
2294 else
2295 minfo ("*");
2296 if (w->filenames_sorted)
2297 minfo (")");
2298
2299 minfo ("(");
2300 if (w->sections_sorted)
2301 minfo ("SORT(");
2302 if (w->section_name != NULL)
2303 minfo ("%s", w->section_name);
2304 else
2305 minfo ("*");
2306 if (w->sections_sorted)
2307 minfo (")");
2308 minfo (")");
2309
2310 print_nl ();
2311
2312 print_statement_list (w->children.head, os);
2313}
2314
2315/* Print a group statement. */
2316
2317static void
2318print_group (s, os)
2319 lang_group_statement_type *s;
2320 lang_output_section_statement_type *os;
2321{
2322 fprintf (config.map_file, "START GROUP\n");
2323 print_statement_list (s->children.head, os);
2324 fprintf (config.map_file, "END GROUP\n");
2325}
2326
2327/* Print the list of statements in S.
2328 This can be called for any statement type. */
2329
2330static void
2331print_statement_list (s, os)
2332 lang_statement_union_type *s;
2333 lang_output_section_statement_type *os;
2334{
2335 while (s != NULL)
2336 {
2337 print_statement (s, os);
2338 s = s->next;
2339 }
2340}
2341
2342/* Print the first statement in statement list S.
2343 This can be called for any statement type. */
2344
2345static void
2346print_statement (s, os)
2347 lang_statement_union_type *s;
2348 lang_output_section_statement_type *os;
2349{
2350 switch (s->header.type)
2351 {
2352 default:
2353 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2354 FAIL ();
2355 break;
2356 case lang_constructors_statement_enum:
2357 if (constructor_list.head != NULL)
2358 {
2359 if (constructors_sorted)
2360 minfo (" SORT (CONSTRUCTORS)\n");
2361 else
2362 minfo (" CONSTRUCTORS\n");
2363 print_statement_list (constructor_list.head, os);
2364 }
2365 break;
2366 case lang_wild_statement_enum:
2367 print_wild_statement (&s->wild_statement, os);
2368 break;
2369 case lang_address_statement_enum:
2370 print_address_statement (&s->address_statement);
2371 break;
2372 case lang_object_symbols_statement_enum:
2373 minfo (" CREATE_OBJECT_SYMBOLS\n");
2374 break;
2375 case lang_fill_statement_enum:
2376 print_fill_statement (&s->fill_statement);
2377 break;
2378 case lang_data_statement_enum:
2379 print_data_statement (&s->data_statement);
2380 break;
2381 case lang_reloc_statement_enum:
2382 print_reloc_statement (&s->reloc_statement);
2383 break;
2384 case lang_input_section_enum:
2385 print_input_section (&s->input_section);
2386 break;
2387 case lang_padding_statement_enum:
2388 print_padding_statement (&s->padding_statement);
2389 break;
2390 case lang_output_section_statement_enum:
2391 print_output_section_statement (&s->output_section_statement);
2392 break;
2393 case lang_assignment_statement_enum:
2394 print_assignment (&s->assignment_statement, os);
2395 break;
2396 case lang_target_statement_enum:
2397 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2398 break;
2399 case lang_output_statement_enum:
2400 minfo ("OUTPUT(%s", s->output_statement.name);
2401 if (output_target != NULL)
2402 minfo (" %s", output_target);
2403 minfo (")\n");
2404 break;
2405 case lang_input_statement_enum:
2406 print_input_statement (&s->input_statement);
2407 break;
2408 case lang_group_statement_enum:
2409 print_group (&s->group_statement, os);
2410 break;
2411 case lang_afile_asection_pair_statement_enum:
2412 FAIL ();
2413 break;
2414 }
2415}
2416
2417static void
2418print_statements ()
2419{
2420 print_statement_list (statement_list.head, abs_output_section);
2421}
2422
2423/* Print the first N statements in statement list S to STDERR.
2424 If N == 0, nothing is printed.
2425 If N < 0, the entire list is printed.
2426 Intended to be called from GDB. */
2427
2428void
2429dprint_statement (s, n)
2430 lang_statement_union_type * s;
2431 int n;
2432{
2433 FILE *map_save = config.map_file;
2434
2435 config.map_file = stderr;
2436
2437 if (n < 0)
2438 print_statement_list (s, abs_output_section);
2439 else
2440 {
2441 while (s && --n >= 0)
2442 {
2443 print_statement (s, abs_output_section);
2444 s = s->next;
2445 }
2446 }
2447
2448 config.map_file = map_save;
2449}
2450
2451static bfd_vma
2452insert_pad (this_ptr, fill, power, output_section_statement, dot)
2453 lang_statement_union_type ** this_ptr;
2454 fill_type fill;
2455 unsigned int power;
2456 asection * output_section_statement;
2457 bfd_vma dot;
2458{
2459 /* Align this section first to the
2460 input sections requirement, then
2461 to the output section's requirement.
2462 If this alignment is > than any seen before,
2463 then record it too. Perform the alignment by
2464 inserting a magic 'padding' statement.
2465 */
2466
2467 unsigned int alignment_needed = align_power (dot, power) - dot;
2468
2469 if (alignment_needed != 0)
2470 {
2471 lang_statement_union_type *new =
2472 ((lang_statement_union_type *)
2473 stat_alloc (sizeof (lang_padding_statement_type)));
2474
2475 /* Link into existing chain */
2476 new->header.next = *this_ptr;
2477 *this_ptr = new;
2478 new->header.type = lang_padding_statement_enum;
2479 new->padding_statement.output_section = output_section_statement;
2480 new->padding_statement.output_offset =
2481 dot - output_section_statement->vma;
2482 new->padding_statement.fill = fill;
2483 new->padding_statement.size = alignment_needed;
2484 }
2485
2486
2487 /* Remember the most restrictive alignment */
2488 if (power > output_section_statement->alignment_power)
2489 {
2490 output_section_statement->alignment_power = power;
2491 }
2492 output_section_statement->_raw_size += alignment_needed;
2493 return alignment_needed + dot;
2494
2495}
2496
2497/* Work out how much this section will move the dot point */
2498static bfd_vma
2499size_input_section (this_ptr, output_section_statement, fill, dot, relax)
2500 lang_statement_union_type ** this_ptr;
2501 lang_output_section_statement_type * output_section_statement;
2502 fill_type fill;
2503 bfd_vma dot;
87f2a346 2504 boolean relax ATTRIBUTE_UNUSED;
252b5132
RH		 2505{
2506 lang_input_section_type *is = &((*this_ptr)->input_section);
2507 asection *i = is->section;
2508
2509 if (is->ifile->just_syms_flag == false)
2510 {
2511 if (output_section_statement->subsection_alignment != -1)
2512 i->alignment_power =
2513 output_section_statement->subsection_alignment;
2514
2515 dot = insert_pad (this_ptr, fill, i->alignment_power,
2516 output_section_statement->bfd_section, dot);
2517
2518 /* Remember where in the output section this input section goes */
2519
2520 i->output_offset = dot - output_section_statement->bfd_section->vma;
2521
2522 /* Mark how big the output section must be to contain this now
2523 */
2524 if (i->_cooked_size != 0)
2525 dot += i->_cooked_size;
2526 else
2527 dot += i->_raw_size;
2528 output_section_statement->bfd_section->_raw_size = dot - output_section_statement->bfd_section->vma;
2529 }
2530 else
2531 {
2532 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2533 }
2534
2535 return dot;
2536}
2537
2538/* Check to see if any allocated sections overlap with other allocated
2539 sections. This can happen when the linker script specifically specifies
2540 the output section addresses of the two sections. */
2541static void
2542lang_check_section_addresses ()
2543{
2544 asection * s;
2545
2546 /* Scan all sections in the output list. */
2547 for (s = output_bfd->sections; s != NULL; s = s->next)
2548 /* Ignore sections which are not loaded or which have no contents. */
2549 if ((bfd_get_section_flags (output_bfd, s) & (SEC_ALLOC | SEC_LOAD))
2550 && bfd_section_size (output_bfd, s) != 0)
2551 {
2552 asection * os;
2553
2554 /* Once we reach section 's' stop our seach. This prevents two
2555 warning messages from being produced, one for 'section A overlaps
2556 section B' and one for 'section B overlaps section A'. */
2557 for (os = output_bfd->sections; os != s; os = os->next)
2558 {
2559 bfd_vma s_start;
2560 bfd_vma s_end;
2561 bfd_vma os_start;
2562 bfd_vma os_end;
2563
2564 /* Only consider loadable sections with real contents. */
2565 if (((bfd_get_section_flags (output_bfd, os)
2566 & (SEC_ALLOC | SEC_LOAD)) == 0)
2567 || bfd_section_size (output_bfd, os) == 0)
2568 continue;
2569
2570 /* We must check the sections' LMA addresses not their
2571 VMA addresses because overlay sections can have
2572 overlapping VMAs but they must have distinct LMAs. */
2573 s_start = bfd_section_lma (output_bfd, s);
2574 os_start = bfd_section_lma (output_bfd, os);
2575 s_end = s_start + bfd_section_size (output_bfd, s) - 1;
2576 os_end = os_start + bfd_section_size (output_bfd, os) - 1;
2577
2578 /* Look for an overlap. */
2579 if ((s_end < os_start) || (s_start > os_end))
2580 continue;
2581
2582 einfo (
2583_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
2584 s->name, s_start, s_end, os->name, os_start, os_end);
2585
2586 /* Once we have found one overlap for this section,
2587 stop looking for others. */
2588 break;
2589 }
2590 }
2591}
2592
2593/* This variable indicates whether bfd_relax_section should be called
2594 again. */
2595
2596static boolean relax_again;
2597
2598/* Set the sizes for all the output sections. */
2599
2600bfd_vma
2601lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
2602 lang_statement_union_type * s;
2603 lang_output_section_statement_type * output_section_statement;
2604 lang_statement_union_type ** prev;
2605 fill_type fill;
2606 bfd_vma dot;
2607 boolean relax;
2608{
2609 /* Size up the sections from their constituent parts. */
2610 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2611 {
2612 switch (s->header.type)
2613 {
2614 case lang_output_section_statement_enum:
2615 {
2616 bfd_vma after;
2617 lang_output_section_statement_type *os = &s->output_section_statement;
2618
2619 if (os->bfd_section == NULL)
2620 /* This section was never actually created. */
2621 break;
2622
2623 /* If this is a COFF shared library section, use the size and
2624 address from the input section. FIXME: This is COFF
2625 specific; it would be cleaner if there were some other way
2626 to do this, but nothing simple comes to mind. */
2627 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2628 {
2629 asection * input;
2630
2631 if (os->children.head == NULL
2632 || os->children.head->next != NULL
2633 || os->children.head->header.type != lang_input_section_enum)
2634 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2635 os->name);
2636
2637 input = os->children.head->input_section.section;
2638 bfd_set_section_vma (os->bfd_section->owner,
2639 os->bfd_section,
2640 bfd_section_vma (input->owner, input));
2641 os->bfd_section->_raw_size = input->_raw_size;
2642 break;
2643 }
2644
2645 if (bfd_is_abs_section (os->bfd_section))
2646 {
2647 /* No matter what happens, an abs section starts at zero. */
2648 ASSERT (os->bfd_section->vma == 0);
2649 }
2650 else
2651 {
2652 if (os->addr_tree == (etree_type *) NULL)
2653 {
2654 /* No address specified for this section, get one
2655 from the region specification. */
2656 if (os->region == (lang_memory_region_type *) NULL
2657 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2658 & (SEC_ALLOC | SEC_LOAD)) != 0)
2659 && os->region->name[0] == '*'
2660 && strcmp (os->region->name, "*default*") == 0))
2661 {
2662 os->region = lang_memory_default (os->bfd_section);
2663 }
2664
2665 /* If a loadable section is using the default memory
2666 region, and some non default memory regions were
2667 defined, issue a warning. */
2668 if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2669 & (SEC_ALLOC | SEC_LOAD)) != 0
2670 && ! link_info.relocateable
2671 && strcmp (os->region->name, "*default*") == 0
2672 && lang_memory_region_list != NULL
2673 && (strcmp (lang_memory_region_list->name, "*default*") != 0
2674 || lang_memory_region_list->next != NULL))
2675 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2676 bfd_get_section_name (output_bfd, os->bfd_section));
2677
2678 dot = os->region->current;
2679
2680 if (os->section_alignment == -1)
2681 {
2682 bfd_vma olddot;
2683
2684 olddot = dot;
2685 dot = align_power (dot, os->bfd_section->alignment_power);
2686
2687 if (dot != olddot && config.warn_section_align)
2688 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2689 os->name, (unsigned int) (dot - olddot));
2690 }
2691 }
2692 else
2693 {
2694 etree_value_type r;
2695
2696 r = exp_fold_tree (os->addr_tree,
2697 abs_output_section,
2698 lang_allocating_phase_enum,
2699 dot, &dot);
2700 if (r.valid_p == false)
2701 {
2702 einfo (_("%F%S: non constant address expression for section %s\n"),
2703 os->name);
2704 }
2705 dot = r.value + r.section->bfd_section->vma;
2706 }
2707
2708 /* The section starts here.
2709 First, align to what the section needs. */
2710
2711 if (os->section_alignment != -1)
2712 dot = align_power (dot, os->section_alignment);
2713
2714 bfd_set_section_vma (0, os->bfd_section, dot);
2715
2716 os->bfd_section->output_offset = 0;
2717 }
2718
2719 (void) lang_size_sections (os->children.head, os, &os->children.head,
2720 os->fill, dot, relax);
2721
2722 /* Ignore the size of the input sections, use the vma and size to
2723 align against. */
2724
2725 after = ALIGN_N (os->bfd_section->vma +
2726 os->bfd_section->_raw_size,
2727 /* The coercion here is important, see ld.h. */
2728 (bfd_vma) os->block_value);
2729
2730 if (bfd_is_abs_section (os->bfd_section))
2731 ASSERT (after == os->bfd_section->vma);
2732 else
2733 os->bfd_section->_raw_size = after - os->bfd_section->vma;
2734 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
2735 os->processed = true;
2736
2737 /* Update dot in the region ?
2738 We only do this if the section is going to be allocated,
2739 since unallocated sections do not contribute to the region's
2740 overall size in memory. */
2741 if (os->region != (lang_memory_region_type *) NULL
2742 && (bfd_get_section_flags (output_bfd, os->bfd_section)
2743 & (SEC_ALLOC | SEC_LOAD)))
2744 {
2745 os->region->current = dot;
2746
2747 /* Make sure this isn't silly. */
2748 if (os->region->current < os->region->origin
2749 || (os->region->current - os->region->origin
2750 > os->region->length))
2751 {
2752 if (os->addr_tree != (etree_type *) NULL)
2753 {
2754 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2755 os->region->current,
2756 os->bfd_section->owner,
2757 os->bfd_section->name,
2758 os->region->name);
2759 }
2760 else
2761 {
2762 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2763 os->region->name,
2764 os->bfd_section->owner,
2765 os->bfd_section->name);
2766 }
2767 /* Reset the region pointer. */
2768 os->region->current = os->region->origin;
2769 }
2770 }
2771 }
2772 break;
2773
2774 case lang_constructors_statement_enum:
2775 dot = lang_size_sections (constructor_list.head,
2776 output_section_statement,
2777 &s->wild_statement.children.head,
2778 fill,
2779 dot, relax);
2780 break;
2781
2782 case lang_data_statement_enum:
2783 {
2784 unsigned int size = 0;
2785
2786 s->data_statement.output_vma = dot - output_section_statement->bfd_section->vma;
2787 s->data_statement.output_section =
2788 output_section_statement->bfd_section;
2789
2790 switch (s->data_statement.type)
2791 {
2792 case QUAD:
2793 case SQUAD:
2794 size = QUAD_SIZE;
2795 break;
2796 case LONG:
2797 size = LONG_SIZE;
2798 break;
2799 case SHORT:
2800 size = SHORT_SIZE;
2801 break;
2802 case BYTE:
2803 size = BYTE_SIZE;
2804 break;
2805 }
2806
2807 dot += size;
2808 output_section_statement->bfd_section->_raw_size += size;
2809 /* The output section gets contents, and then we inspect for
2810 any flags set in the input script which override any ALLOC. */
2811 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
2812 if (!(output_section_statement->flags & SEC_NEVER_LOAD)) {
2813 output_section_statement->bfd_section->flags |= SEC_ALLOC | SEC_LOAD;
2814 }
2815 }
2816 break;
2817
2818 case lang_reloc_statement_enum:
2819 {
2820 int size;
2821
2822 s->reloc_statement.output_vma =
2823 dot - output_section_statement->bfd_section->vma;
2824 s->reloc_statement.output_section =
2825 output_section_statement->bfd_section;
2826 size = bfd_get_reloc_size (s->reloc_statement.howto);
2827 dot += size;
2828 output_section_statement->bfd_section->_raw_size += size;
2829 }
2830 break;
2831
2832 case lang_wild_statement_enum:
2833
2834 dot = lang_size_sections (s->wild_statement.children.head,
2835 output_section_statement,
2836 &s->wild_statement.children.head,
2837
2838 fill, dot, relax);
2839
2840 break;
2841
2842 case lang_object_symbols_statement_enum:
2843 link_info.create_object_symbols_section =
2844 output_section_statement->bfd_section;
2845 break;
2846 case lang_output_statement_enum:
2847 case lang_target_statement_enum:
2848 break;
2849 case lang_input_section_enum:
2850 {
2851 asection *i;
2852
2853 i = (*prev)->input_section.section;
2854 if (! relax)
2855 {
2856 if (i->_cooked_size == 0)
2857 i->_cooked_size = i->_raw_size;
2858 }
2859 else
2860 {
2861 boolean again;
2862
2863 if (! bfd_relax_section (i->owner, i, &link_info, &again))
2864 einfo (_("%P%F: can't relax section: %E\n"));
2865 if (again)
2866 relax_again = true;
2867 }
2868 dot = size_input_section (prev,
2869 output_section_statement,
2870 output_section_statement->fill,
2871 dot, relax);
2872 }
2873 break;
2874 case lang_input_statement_enum:
2875 break;
2876 case lang_fill_statement_enum:
2877 s->fill_statement.output_section = output_section_statement->bfd_section;
2878
2879 fill = s->fill_statement.fill;
2880 break;
2881 case lang_assignment_statement_enum:
2882 {
2883 bfd_vma newdot = dot;
2884
2885 exp_fold_tree (s->assignment_statement.exp,
2886 output_section_statement,
2887 lang_allocating_phase_enum,
2888 dot,
2889 &newdot);
2890
2891 if (newdot != dot)
2892 {
2893 /* The assignment changed dot. Insert a pad. */
2894 if (output_section_statement == abs_output_section)
2895 {
2896 /* If we don't have an output section, then just adjust
2897 the default memory address. */
2898 lang_memory_region_lookup ("*default*")->current = newdot;
2899 }
2900 else if (!relax)
2901 {
2902 lang_statement_union_type *new =
2903 ((lang_statement_union_type *)
2904 stat_alloc (sizeof (lang_padding_statement_type)));
2905
2906 /* Link into existing chain. */
2907 new->header.next = *prev;
2908 *prev = new;
2909 new->header.type = lang_padding_statement_enum;
2910 new->padding_statement.output_section =
2911 output_section_statement->bfd_section;
2912 new->padding_statement.output_offset =
2913 dot - output_section_statement->bfd_section->vma;
2914 new->padding_statement.fill = fill;
2915 new->padding_statement.size = newdot - dot;
2916 output_section_statement->bfd_section->_raw_size +=
2917 new->padding_statement.size;
2918 }
2919
2920 dot = newdot;
2921 }
2922 }
2923 break;
2924
2925 case lang_padding_statement_enum:
2926 /* If we are relaxing, and this is not the first pass, some
2927 padding statements may have been inserted during previous
2928 passes. We may have to move the padding statement to a new
2929 location if dot has a different value at this point in this
2930 pass than it did at this point in the previous pass. */
2931 s->padding_statement.output_offset =
2932 dot - output_section_statement->bfd_section->vma;
2933 dot += s->padding_statement.size;
2934 output_section_statement->bfd_section->_raw_size +=
2935 s->padding_statement.size;
2936 break;
2937
2938 case lang_group_statement_enum:
2939 dot = lang_size_sections (s->group_statement.children.head,
2940 output_section_statement,
2941 &s->group_statement.children.head,
2942 fill, dot, relax);
2943 break;
2944
2945 default:
2946 FAIL ();
2947 break;
2948
2949 /* This can only get here when relaxing is turned on. */
2950
2951 case lang_address_statement_enum:
2952 break;
2953 }
2954 prev = &s->header.next;
2955 }
2956 return dot;
2957}
2958
2959bfd_vma
2960lang_do_assignments (s, output_section_statement, fill, dot)
2961 lang_statement_union_type * s;
2962 lang_output_section_statement_type * output_section_statement;
2963 fill_type fill;
2964 bfd_vma dot;
2965{
2966 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2967 {
2968 switch (s->header.type)
2969 {
2970 case lang_constructors_statement_enum:
2971 dot = lang_do_assignments (constructor_list.head,
2972 output_section_statement,
2973 fill,
2974 dot);
2975 break;
2976
2977 case lang_output_section_statement_enum:
2978 {
2979 lang_output_section_statement_type *os =
2980 &(s->output_section_statement);
2981
2982 if (os->bfd_section != NULL)
2983 {
2984 dot = os->bfd_section->vma;
2985 (void) lang_do_assignments (os->children.head, os,
2986 os->fill, dot);
2987 dot = os->bfd_section->vma + os->bfd_section->_raw_size;
2988 }
2989 if (os->load_base)
2990 {
2991 /* If nothing has been placed into the output section then
2992 it won't have a bfd_section. */
2993 if (os->bfd_section)
2994 {
2995 os->bfd_section->lma
2996 = exp_get_abs_int(os->load_base, 0,"load base", lang_final_phase_enum);
2997 }
2998 }
2999 }
3000 break;
3001 case lang_wild_statement_enum:
3002
3003 dot = lang_do_assignments (s->wild_statement.children.head,
3004 output_section_statement,
3005 fill, dot);
3006
3007 break;
3008
3009 case lang_object_symbols_statement_enum:
3010 case lang_output_statement_enum:
3011 case lang_target_statement_enum:
3012#if 0
3013 case lang_common_statement_enum:
3014#endif
3015 break;
3016 case lang_data_statement_enum:
3017 {
3018 etree_value_type value;
3019
3020 value = exp_fold_tree (s->data_statement.exp,
3021 abs_output_section,
3022 lang_final_phase_enum, dot, &dot);
3023 s->data_statement.value = value.value;
3024 if (value.valid_p == false)
3025 einfo (_("%F%P: invalid data statement\n"));
3026 }
3027 switch (s->data_statement.type)
3028 {
3029 case QUAD:
3030 case SQUAD:
3031 dot += QUAD_SIZE;
3032 break;
3033 case LONG:
3034 dot += LONG_SIZE;
3035 break;
3036 case SHORT:
3037 dot += SHORT_SIZE;
3038 break;
3039 case BYTE:
3040 dot += BYTE_SIZE;
3041 break;
3042 }
3043 break;
3044
3045 case lang_reloc_statement_enum:
3046 {
3047 etree_value_type value;
3048
3049 value = exp_fold_tree (s->reloc_statement.addend_exp,
3050 abs_output_section,
3051 lang_final_phase_enum, dot, &dot);
3052 s->reloc_statement.addend_value = value.value;
3053 if (value.valid_p == false)
3054 einfo (_("%F%P: invalid reloc statement\n"));
3055 }
3056 dot += bfd_get_reloc_size (s->reloc_statement.howto);
3057 break;
3058
3059 case lang_input_section_enum:
3060 {
3061 asection *in = s->input_section.section;
3062
3063 if (in->_cooked_size != 0)
3064 dot += in->_cooked_size;
3065 else
3066 dot += in->_raw_size;
3067 }
3068 break;
3069
3070 case lang_input_statement_enum:
3071 break;
3072 case lang_fill_statement_enum:
3073 fill = s->fill_statement.fill;
3074 break;
3075 case lang_assignment_statement_enum:
3076 {
3077 exp_fold_tree (s->assignment_statement.exp,
3078 output_section_statement,
3079 lang_final_phase_enum,
3080 dot,
3081 &dot);
3082 }
3083
3084 break;
3085 case lang_padding_statement_enum:
3086 dot += s->padding_statement.size;
3087 break;
3088
3089 case lang_group_statement_enum:
3090 dot = lang_do_assignments (s->group_statement.children.head,
3091 output_section_statement,
3092 fill, dot);
3093
3094 break;
3095
3096 default:
3097 FAIL ();
3098 break;
3099 case lang_address_statement_enum:
3100 break;
3101 }
3102
3103 }
3104 return dot;
3105}
3106
3107/* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3108 operator .startof. (section_name), it produces an undefined symbol
3109 .startof.section_name. Similarly, when it sees
3110 .sizeof. (section_name), it produces an undefined symbol
3111 .sizeof.section_name. For all the output sections, we look for
3112 such symbols, and set them to the correct value. */
3113
3114static void
3115lang_set_startof ()
3116{
3117 asection *s;
3118
3119 if (link_info.relocateable)
3120 return;
3121
3122 for (s = output_bfd->sections; s != NULL; s = s->next)
3123 {
3124 const char *secname;
3125 char *buf;
3126 struct bfd_link_hash_entry *h;
3127
3128 secname = bfd_get_section_name (output_bfd, s);
3129 buf = xmalloc (10 + strlen (secname));
3130
3131 sprintf (buf, ".startof.%s", secname);
3132 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3133 if (h != NULL && h->type == bfd_link_hash_undefined)
3134 {
3135 h->type = bfd_link_hash_defined;
3136 h->u.def.value = bfd_get_section_vma (output_bfd, s);
3137 h->u.def.section = bfd_abs_section_ptr;
3138 }
3139
3140 sprintf (buf, ".sizeof.%s", secname);
3141 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3142 if (h != NULL && h->type == bfd_link_hash_undefined)
3143 {
3144 h->type = bfd_link_hash_defined;
3145 if (s->_cooked_size != 0)
3146 h->u.def.value = s->_cooked_size;
3147 else
3148 h->u.def.value = s->_raw_size;
3149 h->u.def.section = bfd_abs_section_ptr;
3150 }
3151
3152 free (buf);
3153 }
3154}
3155
3156static void
3157lang_finish ()
3158{
3159 struct bfd_link_hash_entry *h;
3160 boolean warn;
3161
3162 if (link_info.relocateable || link_info.shared)
3163 warn = false;
3164 else
3165 warn = true;
3166
3167 if (entry_symbol == (char *) NULL)
3168 {
3169 /* No entry has been specified. Look for start, but don't warn
3170 if we don't find it. */
3171 entry_symbol = "start";
3172 warn = false;
3173 }
3174
3175 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
3176 if (h != (struct bfd_link_hash_entry *) NULL
3177 && (h->type == bfd_link_hash_defined
3178 || h->type == bfd_link_hash_defweak)
3179 && h->u.def.section->output_section != NULL)
3180 {
3181 bfd_vma val;
3182
3183 val = (h->u.def.value
3184 + bfd_get_section_vma (output_bfd,
3185 h->u.def.section->output_section)
3186 + h->u.def.section->output_offset);
3187 if (! bfd_set_start_address (output_bfd, val))
3188 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
3189 }
3190 else
3191 {
3192 bfd_vma val;
3193 CONST char *send;
3194
3195 /* We couldn't find the entry symbol. Try parsing it as a
3196 number. */
3197 val = bfd_scan_vma (entry_symbol, &send, 0);
3198 if (*send == '\0')
3199 {
3200 if (! bfd_set_start_address (output_bfd, val))
3201 einfo (_("%P%F: can't set start address\n"));
3202 }
3203 else
3204 {
3205 asection *ts;
3206
3207 /* Can't find the entry symbol, and it's not a number. Use
3208 the first address in the text section. */
3209 ts = bfd_get_section_by_name (output_bfd, ".text");
3210 if (ts != (asection *) NULL)
3211 {
3212 if (warn)
3213 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3214 entry_symbol, bfd_get_section_vma (output_bfd, ts));
3215 if (! bfd_set_start_address (output_bfd,
3216 bfd_get_section_vma (output_bfd,
3217 ts)))
3218 einfo (_("%P%F: can't set start address\n"));
3219 }
3220 else
3221 {
3222 if (warn)
3223 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3224 entry_symbol);
3225 }
3226 }
3227 }
3228}
3229
3230/* This is a small function used when we want to ignore errors from
3231 BFD. */
3232
3233static void
3234#ifdef ANSI_PROTOTYPES
87f2a346 3235ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
252b5132
RH		 3236#else
3237ignore_bfd_errors (s)
87f2a346 3238 const char *s ATTRIBUTE_UNUSED;
252b5132
RH		 3239#endif
3240{
3241 /* Don't do anything. */
3242}
3243
3244/* Check that the architecture of all the input files is compatible
3245 with the output file. Also call the backend to let it do any
3246 other checking that is needed. */
3247
3248static void
3249lang_check ()
3250{
3251 lang_statement_union_type *file;
3252 bfd *input_bfd;
3253 CONST bfd_arch_info_type *compatible;
3254
3255 for (file = file_chain.head;
3256 file != (lang_statement_union_type *) NULL;
3257 file = file->input_statement.next)
3258 {
3259 input_bfd = file->input_statement.the_bfd;
3260 compatible = bfd_arch_get_compatible (input_bfd,
3261 output_bfd);
3262 if (compatible == NULL)
3263 {
3264 if (command_line.warn_mismatch)
3265 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3266 bfd_printable_name (input_bfd), input_bfd,
3267 bfd_printable_name (output_bfd));
3268 }
3269 else
3270 {
3271 bfd_error_handler_type pfn = NULL;
3272
3273 /* If we aren't supposed to warn about mismatched input
3274 files, temporarily set the BFD error handler to a
3275 function which will do nothing. We still want to call
3276 bfd_merge_private_bfd_data, since it may set up
3277 information which is needed in the output file. */
3278 if (! command_line.warn_mismatch)
3279 pfn = bfd_set_error_handler (ignore_bfd_errors);
3280 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3281 {
3282 if (command_line.warn_mismatch)
3283 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3284 input_bfd);
3285 }
3286 if (! command_line.warn_mismatch)
3287 bfd_set_error_handler (pfn);
3288 }
3289 }
3290}
3291
3292/* Look through all the global common symbols and attach them to the
3293 correct section. The -sort-common command line switch may be used
3294 to roughly sort the entries by size. */
3295
3296static void
3297lang_common ()
3298{
3299 if (link_info.relocateable
3300 && ! command_line.force_common_definition)
3301 return;
3302
3303 if (! config.sort_common)
3304 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3305 else
3306 {
3307 int power;
3308
3309 for (power = 4; power >= 0; power--)
3310 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3311 (PTR) &power);
3312 }
3313}
3314
3315/* Place one common symbol in the correct section. */
3316
3317static boolean
3318lang_one_common (h, info)
3319 struct bfd_link_hash_entry *h;
3320 PTR info;
3321{
3322 unsigned int power_of_two;
3323 bfd_vma size;
3324 asection *section;
3325
3326 if (h->type != bfd_link_hash_common)
3327 return true;
3328
3329 size = h->u.c.size;
3330 power_of_two = h->u.c.p->alignment_power;
3331
3332 if (config.sort_common
3333 && power_of_two < (unsigned int) *(int *) info)
3334 return true;
3335
3336 section = h->u.c.p->section;
3337
3338 /* Increase the size of the section. */
3339 section->_cooked_size = ALIGN_N (section->_cooked_size,
3340 (bfd_size_type) (1 << power_of_two));
3341
3342 /* Adjust the alignment if necessary. */
3343 if (power_of_two > section->alignment_power)
3344 section->alignment_power = power_of_two;
3345
3346 /* Change the symbol from common to defined. */
3347 h->type = bfd_link_hash_defined;
3348 h->u.def.section = section;
3349 h->u.def.value = section->_cooked_size;
3350
3351 /* Increase the size of the section. */
3352 section->_cooked_size += size;
3353
3354 /* Make sure the section is allocated in memory, and make sure that
3355 it is no longer a common section. */
3356 section->flags |= SEC_ALLOC;
3357 section->flags &= ~ SEC_IS_COMMON;
3358
3359 if (config.map_file != NULL)
3360 {
3361 static boolean header_printed;
3362 int len;
3363 char *name;
3364 char buf[50];
3365
3366 if (! header_printed)
3367 {
3368 minfo (_("\nAllocating common symbols\n"));
3369 minfo (_("Common symbol size file\n\n"));
3370 header_printed = true;
3371 }
3372
3373 name = demangle (h->root.string);
3374 minfo ("%s", name);
3375 len = strlen (name);
3376 free (name);
3377
3378 if (len >= 19)
3379 {
3380 print_nl ();
3381 len = 0;
3382 }
3383 while (len < 20)
3384 {
3385 print_space ();
3386 ++len;
3387 }
3388
3389 minfo ("0x");
3390 if (size <= 0xffffffff)
3391 sprintf (buf, "%lx", (unsigned long) size);
3392 else
3393 sprintf_vma (buf, size);
3394 minfo ("%s", buf);
3395 len = strlen (buf);
3396
3397 while (len < 16)
3398 {
3399 print_space ();
3400 ++len;
3401 }
3402
3403 minfo ("%B\n", section->owner);
3404 }
3405
3406 return true;
3407}
3408
3409/*
3410run through the input files and ensure that every input
3411section has somewhere to go. If one is found without
3412a destination then create an input request and place it
3413into the statement tree.
3414*/
3415
3416static void
3417lang_place_orphans ()
3418{
e50d8076 3419 LANG_FOR_EACH_INPUT_STATEMENT (file)
252b5132
RH		 3420 {
3421 asection *s;
3422
3423 for (s = file->the_bfd->sections;
3424 s != (asection *) NULL;
3425 s = s->next)
3426 {
3427 if (s->output_section == (asection *) NULL)
3428 {
3429 /* This section of the file is not attatched, root
3430 around for a sensible place for it to go */
3431
3432 if (file->just_syms_flag)
3433 {
3434 /* We are only retrieving symbol values from this
3435 file. We want the symbols to act as though the
3436 values in the file are absolute. */
3437 s->output_section = bfd_abs_section_ptr;
3438 s->output_offset = s->vma;
3439 }
3440 else if (strcmp (s->name, "COMMON") == 0)
3441 {
3442 /* This is a lonely common section which must have
3443 come from an archive. We attach to the section
3444 with the wildcard. */
3445 if (! link_info.relocateable
3446 || command_line.force_common_definition)
3447 {
3448 if (default_common_section == NULL)
3449 {
3450#if 0
3451 /* This message happens when using the
3452 svr3.ifile linker script, so I have
3453 disabled it. */
3454 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3455#endif
3456 default_common_section =
3457 lang_output_section_statement_lookup (".bss");
3458
3459 }
3460 wild_doit (&default_common_section->children, s,
3461 default_common_section, file);
3462 }
3463 }
3464 else if (ldemul_place_orphan (file, s))
3465 ;
3466 else
3467 {
3468 lang_output_section_statement_type *os =
3469 lang_output_section_statement_lookup (s->name);
3470
3471 wild_doit (&os->children, s, os, file);
3472 }
3473 }
3474 }
3475 }
3476}
3477
3478
3479void
aa8804e4 3480lang_set_flags (ptr, flags, invert)
252b5132
RH		 3481 lang_memory_region_type *ptr;
3482 CONST char *flags;
aa8804e4 3483 int invert;
252b5132 3484{
aa8804e4 3485 flagword *ptr_flags;
252b5132 3486
aa8804e4 3487 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
252b5132
RH		 3488 while (*flags)
3489 {
3490 switch (*flags)
3491 {
252b5132
RH		 3492 case 'A': case 'a':
3493 *ptr_flags |= SEC_ALLOC;
3494 break;
3495
3496 case 'R': case 'r':
3497 *ptr_flags |= SEC_READONLY;
3498 break;
3499
3500 case 'W': case 'w':
3501 *ptr_flags |= SEC_DATA;
3502 break;
3503
3504 case 'X': case 'x':
3505 *ptr_flags |= SEC_CODE;
3506 break;
3507
3508 case 'L': case 'l':
3509 case 'I': case 'i':
3510 *ptr_flags |= SEC_LOAD;
3511 break;
3512
3513 default:
3514 einfo (_("%P%F: invalid syntax in flags\n"));
3515 break;
3516 }
3517 flags++;
3518 }
3519}
3520
3521/* Call a function on each input file. This function will be called
3522 on an archive, but not on the elements. */
3523
3524void
3525lang_for_each_input_file (func)
3526 void (*func) PARAMS ((lang_input_statement_type *));
3527{
3528 lang_input_statement_type *f;
3529
3530 for (f = (lang_input_statement_type *) input_file_chain.head;
3531 f != NULL;
3532 f = (lang_input_statement_type *) f->next_real_file)
3533 func (f);
3534}
3535
3536/* Call a function on each file. The function will be called on all
3537 the elements of an archive which are included in the link, but will
3538 not be called on the archive file itself. */
3539
3540void
3541lang_for_each_file (func)
3542 void (*func) PARAMS ((lang_input_statement_type *));
3543{
e50d8076 3544 LANG_FOR_EACH_INPUT_STATEMENT (f)
252b5132
RH		 3545 {
3546 func (f);
3547 }
3548}
3549
3550#if 0
3551
3552/* Not used. */
3553
3554void
3555lang_for_each_input_section (func)
3556 void (*func) PARAMS ((bfd * ab, asection * as));
3557{
e50d8076 3558 LANG_FOR_EACH_INPUT_STATEMENT (f)
252b5132 3559 {
e50d8076 3560 asection * s;
252b5132
RH		 3561
3562 for (s = f->the_bfd->sections;
3563 s != (asection *) NULL;
3564 s = s->next)
3565 {
3566 func (f->the_bfd, s);
3567 }
3568 }
3569}
3570
3571#endif
3572
3573void
3574ldlang_add_file (entry)
3575 lang_input_statement_type * entry;
3576{
3577 bfd **pp;
3578
3579 lang_statement_append (&file_chain,
3580 (lang_statement_union_type *) entry,
3581 &entry->next);
3582
3583 /* The BFD linker needs to have a list of all input BFDs involved in
3584 a link. */
3585 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3586 ASSERT (entry->the_bfd != output_bfd);
3587 for (pp = &link_info.input_bfds;
3588 *pp != (bfd *) NULL;
3589 pp = &(*pp)->link_next)
3590 ;
3591 *pp = entry->the_bfd;
3592 entry->the_bfd->usrdata = (PTR) entry;
3593 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3594
3595 /* Look through the sections and check for any which should not be
3596 included in the link. We need to do this now, so that we can
3597 notice when the backend linker tries to report multiple
3598 definition errors for symbols which are in sections we aren't
3599 going to link. FIXME: It might be better to entirely ignore
3600 symbols which are defined in sections which are going to be
3601 discarded. This would require modifying the backend linker for
3602 each backend which might set the SEC_LINK_ONCE flag. If we do
3603 this, we should probably handle SEC_EXCLUDE in the same way. */
3604
3605 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3606}
3607
3608void
3609lang_add_output (name, from_script)
3610 CONST char *name;
3611 int from_script;
3612{
3613 /* Make -o on command line override OUTPUT in script. */
3614 if (had_output_filename == false || !from_script)
3615 {
3616 output_filename = name;
3617 had_output_filename = true;
3618 }
3619}
3620
3621
3622static lang_output_section_statement_type *current_section;
3623
3624static int
3625topower (x)
3626 int x;
3627{
3628 unsigned int i = 1;
3629 int l;
3630
3631 if (x < 0)
3632 return -1;
3633
3634 for (l = 0; l < 32; l++)
3635 {
3636 if (i >= (unsigned int) x)
3637 return l;
3638 i <<= 1;
3639 }
3640
3641 return 0;
3642}
3643
3644void
3645lang_enter_output_section_statement (output_section_statement_name,
3646 address_exp, sectype, block_value,
3647 align, subalign, ebase)
3648 const char *output_section_statement_name;
3649 etree_type * address_exp;
3650 enum section_type sectype;
3651 bfd_vma block_value;
3652 etree_type *align;
3653 etree_type *subalign;
3654 etree_type *ebase;
3655{
3656 lang_output_section_statement_type *os;
3657
3658 current_section =
3659 os =
3660 lang_output_section_statement_lookup (output_section_statement_name);
3661
3662
3663
3664 /* Add this statement to tree */
3665 /* add_statement(lang_output_section_statement_enum,
3666 output_section_statement);*/
3667 /* Make next things chain into subchain of this */
3668
3669 if (os->addr_tree ==
3670 (etree_type *) NULL)
3671 {
3672 os->addr_tree =
3673 address_exp;
3674 }
3675 os->sectype = sectype;
3676 if (sectype != noload_section)
3677 os->flags = SEC_NO_FLAGS;
3678 else
3679 os->flags = SEC_NEVER_LOAD;
3680 os->block_value = block_value ? block_value : 1;
3681 stat_ptr = &os->children;
3682
3683 os->subsection_alignment = topower(
3684 exp_get_value_int(subalign, -1,
3685 "subsection alignment",
3686 0));
3687 os->section_alignment = topower(
3688 exp_get_value_int(align, -1,
3689 "section alignment", 0));
3690
3691 os->load_base = ebase;
3692}
3693
3694
3695void
3696lang_final ()
3697{
3698 lang_output_statement_type *new =
3699 new_stat (lang_output_statement, stat_ptr);
3700
3701 new->name = output_filename;
3702}
3703
3704/* Reset the current counters in the regions */
3705static void
3706reset_memory_regions ()
3707{
3708 lang_memory_region_type *p = lang_memory_region_list;
3709
3710 for (p = lang_memory_region_list;
3711 p != (lang_memory_region_type *) NULL;
3712 p = p->next)
3713 {
3714 p->old_length = (bfd_size_type) (p->current - p->origin);
3715 p->current = p->origin;
3716 }
3717}
3718
252b5132
RH		 3719/* Expand a wild statement for a particular FILE, marking its sections KEEP
3720 as needed. SECTION may be NULL, in which case it is a wild card. */
3721
3722static void
4dec4d4e 3723gc_section_callback (ptr, section, file, data)
252b5132 3724 lang_wild_statement_type *ptr;
4dec4d4e 3725 asection *section;
87f2a346
ILT		 3726 lang_input_statement_type *file ATTRIBUTE_UNUSED;
3727 void *data ATTRIBUTE_UNUSED;
252b5132 3728{
4dec4d4e
RH		 3729 /* If the wild pattern was marked KEEP, the member sections
3730 should be as well. */
3731 if (ptr->keep_sections)
3732 section->flags |= SEC_KEEP;
252b5132
RH		 3733}
3734
3735/* Handle a wild statement, marking it against GC. SECTION or FILE or both
3736 may be NULL, indicating that it is a wildcard. */
3737
3738static void
3739lang_gc_wild (s, section, file)
3740 lang_wild_statement_type *s;
3741 const char *section;
3742 const char *file;
3743{
4dec4d4e 3744 walk_wild (s, section, file, gc_section_callback, NULL);
252b5132
RH		 3745}
3746
3747/* Iterate over sections marking them against GC. */
3748
3749static void
3750lang_gc_sections_1 (s)
3751 lang_statement_union_type * s;
3752{
3753 for (; s != (lang_statement_union_type *) NULL; s = s->next)
3754 {
3755 switch (s->header.type)
3756 {
3757 case lang_wild_statement_enum:
3758 lang_gc_wild (&s->wild_statement,
3759 s->wild_statement.section_name,
3760 s->wild_statement.filename);
3761 break;
3762 case lang_constructors_statement_enum:
3763 lang_gc_sections_1 (constructor_list.head);
3764 break;
3765 case lang_output_section_statement_enum:
3766 lang_gc_sections_1 (s->output_section_statement.children.head);
3767 break;
3768 case lang_group_statement_enum:
3769 lang_gc_sections_1 (s->group_statement.children.head);
3770 break;
3771 default:
3772 break;
3773 }
3774 }
3775}
3776
3777static void
3778lang_gc_sections ()
3779{
3780 struct bfd_link_hash_entry *h;
3781 ldlang_undef_chain_list_type *ulist, fake_list_start;
3782
3783 /* Keep all sections so marked in the link script. */
3784
3785 lang_gc_sections_1 (statement_list.head);
3786
3787 /* Keep all sections containing symbols undefined on the command-line.
3788 Handle the entry symbol at the same time. */
7c83b342
DE		 3789
3790 if (entry_symbol != NULL)
3791 {
3792 fake_list_start.next = ldlang_undef_chain_list_head;
3793 fake_list_start.name = (char *) entry_symbol;
3794 ulist = &fake_list_start;
3795 }
252b5132 3796 else
7c83b342 3797 ulist = ldlang_undef_chain_list_head;
252b5132 3798
7c83b342 3799 for (; ulist; ulist = ulist->next)
252b5132
RH		 3800 {
3801 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
3802 false, false, false);
3803
3804 if (h != (struct bfd_link_hash_entry *) NULL
3805 && (h->type == bfd_link_hash_defined
3806 || h->type == bfd_link_hash_defweak)
3807 && ! bfd_is_abs_section (h->u.def.section))
3808 {
3809 h->u.def.section->flags |= SEC_KEEP;
3810 }
3811 }
3812
3813 bfd_gc_sections (output_bfd, &link_info);
3814}
3815
3816void
3817lang_process ()
3818{
3819 lang_reasonable_defaults ();
3820 current_target = default_target;
3821
3822 lang_for_each_statement (ldlang_open_output); /* Open the output file */
3823
3824 ldemul_create_output_section_statements ();
3825
3826 /* Add to the hash table all undefineds on the command line */
3827 lang_place_undefineds ();
3828
3829 /* Create a bfd for each input file */
3830 current_target = default_target;
3831 open_input_bfds (statement_list.head, false);
3832
3833 ldemul_after_open ();
3834
3835 /* Make sure that we're not mixing architectures. We call this
3836 after all the input files have been opened, but before we do any
3837 other processing, so that any operations merge_private_bfd_data
3838 does on the output file will be known during the rest of the
3839 link. */
3840 lang_check ();
3841
3842 /* Handle .exports instead of a version script if we're told to do so. */
3843 if (command_line.version_exports_section)
3844 lang_do_version_exports_section ();
3845
3846 /* Build all sets based on the information gathered from the input
3847 files. */
3848 ldctor_build_sets ();
3849
3850 /* Remove unreferenced sections if asked to. */
3851 if (command_line.gc_sections)
3852 lang_gc_sections ();
3853
3854 /* Size up the common data */
3855 lang_common ();
3856
3857 /* Run through the contours of the script and attach input sections
3858 to the correct output sections
3859 */
3860 map_input_to_output_sections (statement_list.head, (char *) NULL,
3861 (lang_output_section_statement_type *) NULL);
3862
3863
3864 /* Find any sections not attached explicitly and handle them */
3865 lang_place_orphans ();
3866
3867 ldemul_before_allocation ();
3868
3869 /* We must record the program headers before we try to fix the
3870 section positions, since they will affect SIZEOF_HEADERS. */
3871 lang_record_phdrs ();
3872
3873 /* Now run around and relax if we can */
3874 if (command_line.relax)
3875 {
3876 /* First time round is a trial run to get the 'worst case'
3877 addresses of the objects if there was no relaxing. */
3878 lang_size_sections (statement_list.head,
3879 abs_output_section,
3880 &(statement_list.head), 0, (bfd_vma) 0, false);
3881
3882 /* Keep relaxing until bfd_relax_section gives up. */
3883 do
3884 {
3885 reset_memory_regions ();
3886
3887 relax_again = false;
3888
3889 /* Note: pe-dll.c does something like this also. If you find
3890 you need to change this code, you probably need to change
3891 pe-dll.c also. DJ */
3892
3893 /* Do all the assignments with our current guesses as to
3894 section sizes. */
3895 lang_do_assignments (statement_list.head,
3896 abs_output_section,
3897 (fill_type) 0, (bfd_vma) 0);
3898
3899 /* Perform another relax pass - this time we know where the
3900 globals are, so can make better guess. */
3901 lang_size_sections (statement_list.head,
3902 abs_output_section,
3903 &(statement_list.head), 0, (bfd_vma) 0, true);
3904 }
3905 while (relax_again);
3906 }
3907 else
3908 {
3909 /* Size up the sections. */
3910 lang_size_sections (statement_list.head,
3911 abs_output_section,
3912 &(statement_list.head), 0, (bfd_vma) 0, false);
3913 }
3914
3915 /* See if anything special should be done now we know how big
3916 everything is. */
3917 ldemul_after_allocation ();
3918
3919 /* Fix any .startof. or .sizeof. symbols. */
3920 lang_set_startof ();
3921
3922 /* Do all the assignments, now that we know the final restingplaces
3923 of all the symbols */
3924
3925 lang_do_assignments (statement_list.head,
3926 abs_output_section,
3927 (fill_type) 0, (bfd_vma) 0);
3928
3929 /* Make sure that the section addresses make sense. */
3930 if (! link_info.relocateable
3931 && command_line.check_section_addresses)
3932 lang_check_section_addresses ();
3933
3934 /* Final stuffs */
3935
3936 ldemul_finish ();
3937 lang_finish ();
3938}
3939
3940/* EXPORTED TO YACC */
3941
3942void
3943lang_add_wild (section_name, sections_sorted, filename, filenames_sorted,
3944 keep_sections, exclude_filename)
3945 const char *const section_name;
3946 boolean sections_sorted;
3947 const char *const filename;
3948 boolean filenames_sorted;
3949 boolean keep_sections;
3950 const char *exclude_filename;
3951{
3952 lang_wild_statement_type *new = new_stat (lang_wild_statement,
3953 stat_ptr);
3954
3955 if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
3956 {
3957 placed_commons = true;
3958 }
3959 if (filename != NULL && ! wildcardp (filename))
3960 {
3961 lang_has_input_file = true;
3962 }
3963 new->section_name = section_name;
3964 new->sections_sorted = sections_sorted;
3965 new->filename = filename;
3966 new->filenames_sorted = filenames_sorted;
3967 new->keep_sections = keep_sections;
3968 new->exclude_filename = exclude_filename;
3969 lang_list_init (&new->children);
3970}
3971
3972void
3973lang_section_start (name, address)
3974 CONST char *name;
3975 etree_type * address;
3976{
3977 lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
3978
3979 ad->section_name = name;
3980 ad->address = address;
3981}
3982
3983/* Set the start symbol to NAME. CMDLINE is nonzero if this is called
3984 because of a -e argument on the command line, or zero if this is
3985 called by ENTRY in a linker script. Command line arguments take
3986 precedence. */
3987
3988void
3989lang_add_entry (name, cmdline)
3990 CONST char *name;
3991 boolean cmdline;
3992{
3993 if (entry_symbol == NULL
3994 || cmdline
3995 || ! entry_from_cmdline)
3996 {
3997 entry_symbol = name;
3998 entry_from_cmdline = cmdline;
3999 }
4000}
4001
4002void
4003lang_add_target (name)
4004 CONST char *name;
4005{
4006 lang_target_statement_type *new = new_stat (lang_target_statement,
4007 stat_ptr);
4008
4009 new->target = name;
4010
4011}
4012
4013void
4014lang_add_map (name)
4015 CONST char *name;
4016{
4017 while (*name)
4018 {
4019 switch (*name)
4020 {
4021 case 'F':
4022 map_option_f = true;
4023 break;
4024 }
4025 name++;
4026 }
4027}
4028
4029void
4030lang_add_fill (exp)
4031 int exp;
4032{
4033 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4034 stat_ptr);
4035
4036 new->fill = exp;
4037}
4038
4039void
4040lang_add_data (type, exp)
4041 int type;
4042 union etree_union *exp;
4043{
4044
4045 lang_data_statement_type *new = new_stat (lang_data_statement,
4046 stat_ptr);
4047
4048 new->exp = exp;
4049 new->type = type;
4050
4051}
4052
4053/* Create a new reloc statement. RELOC is the BFD relocation type to
4054 generate. HOWTO is the corresponding howto structure (we could
4055 look this up, but the caller has already done so). SECTION is the
4056 section to generate a reloc against, or NAME is the name of the
4057 symbol to generate a reloc against. Exactly one of SECTION and
4058 NAME must be NULL. ADDEND is an expression for the addend. */
4059
4060void
4061lang_add_reloc (reloc, howto, section, name, addend)
4062 bfd_reloc_code_real_type reloc;
4063 reloc_howto_type *howto;
4064 asection *section;
4065 const char *name;
4066 union etree_union *addend;
4067{
4068 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
4069
4070 p->reloc = reloc;
4071 p->howto = howto;
4072 p->section = section;
4073 p->name = name;
4074 p->addend_exp = addend;
4075
4076 p->addend_value = 0;
4077 p->output_section = NULL;
4078 p->output_vma = 0;
4079}
4080
4081lang_assignment_statement_type *
4082lang_add_assignment (exp)
4083 etree_type * exp;
4084{
4085 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4086 stat_ptr);
4087
4088 new->exp = exp;
4089 return new;
4090}
4091
4092void
4093lang_add_attribute (attribute)
4094 enum statement_enum attribute;
4095{
4096 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4097}
4098
4099void
4100lang_startup (name)
4101 CONST char *name;
4102{
4103 if (startup_file != (char *) NULL)
4104 {
4105 einfo (_("%P%Fmultiple STARTUP files\n"));
4106 }
4107 first_file->filename = name;
4108 first_file->local_sym_name = name;
4109 first_file->real = true;
4110
4111 startup_file = name;
4112}
4113
4114void
4115lang_float (maybe)
4116 boolean maybe;
4117{
4118 lang_float_flag = maybe;
4119}
4120
4121void
4122lang_leave_output_section_statement (fill, memspec, phdrs)
4123 bfd_vma fill;
4124 const char *memspec;
4125 struct lang_output_section_phdr_list *phdrs;
4126{
4127 current_section->fill = fill;
4128 current_section->region = lang_memory_region_lookup (memspec);
4129 current_section->phdrs = phdrs;
4130 stat_ptr = &statement_list;
4131}
4132
4133/*
4134 Create an absolute symbol with the given name with the value of the
4135 address of first byte of the section named.
4136
4137 If the symbol already exists, then do nothing.
4138*/
4139void
4140lang_abs_symbol_at_beginning_of (secname, name)
4141 const char *secname;
4142 const char *name;
4143{
4144 struct bfd_link_hash_entry *h;
4145
4146 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4147 if (h == (struct bfd_link_hash_entry *) NULL)
4148 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4149
4150 if (h->type == bfd_link_hash_new
4151 || h->type == bfd_link_hash_undefined)
4152 {
4153 asection *sec;
4154
4155 h->type = bfd_link_hash_defined;
4156
4157 sec = bfd_get_section_by_name (output_bfd, secname);
4158 if (sec == (asection *) NULL)
4159 h->u.def.value = 0;
4160 else
4161 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4162
4163 h->u.def.section = bfd_abs_section_ptr;
4164 }
4165}
4166
4167/*
4168 Create an absolute symbol with the given name with the value of the
4169 address of the first byte after the end of the section named.
4170
4171 If the symbol already exists, then do nothing.
4172*/
4173void
4174lang_abs_symbol_at_end_of (secname, name)
4175 const char *secname;
4176 const char *name;
4177{
4178 struct bfd_link_hash_entry *h;
4179
4180 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4181 if (h == (struct bfd_link_hash_entry *) NULL)
4182 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4183
4184 if (h->type == bfd_link_hash_new
4185 || h->type == bfd_link_hash_undefined)
4186 {
4187 asection *sec;
4188
4189 h->type = bfd_link_hash_defined;
4190
4191 sec = bfd_get_section_by_name (output_bfd, secname);
4192 if (sec == (asection *) NULL)
4193 h->u.def.value = 0;
4194 else
4195 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4196 + bfd_section_size (output_bfd, sec));
4197
4198 h->u.def.section = bfd_abs_section_ptr;
4199 }
4200}
4201
4202void
4203lang_statement_append (list, element, field)
4204 lang_statement_list_type * list;
4205 lang_statement_union_type * element;
4206 lang_statement_union_type ** field;
4207{
4208 *(list->tail) = element;
4209 list->tail = field;
4210}
4211
4212/* Set the output format type. -oformat overrides scripts. */
4213
4214void
4215lang_add_output_format (format, big, little, from_script)
4216 const char *format;
4217 const char *big;
4218 const char *little;
4219 int from_script;
4220{
4221 if (output_target == NULL || !from_script)
4222 {
4223 if (command_line.endian == ENDIAN_BIG
4224 && big != NULL)
4225 format = big;
4226 else if (command_line.endian == ENDIAN_LITTLE
4227 && little != NULL)
4228 format = little;
4229
4230 output_target = format;
4231 }
4232}
4233
4234/* Enter a group. This creates a new lang_group_statement, and sets
4235 stat_ptr to build new statements within the group. */
4236
4237void
4238lang_enter_group ()
4239{
4240 lang_group_statement_type *g;
4241
4242 g = new_stat (lang_group_statement, stat_ptr);
4243 lang_list_init (&g->children);
4244 stat_ptr = &g->children;
4245}
4246
4247/* Leave a group. This just resets stat_ptr to start writing to the
4248 regular list of statements again. Note that this will not work if
4249 groups can occur inside anything else which can adjust stat_ptr,
4250 but currently they can't. */
4251
4252void
4253lang_leave_group ()
4254{
4255 stat_ptr = &statement_list;
4256}
4257
4258/* Add a new program header. This is called for each entry in a PHDRS
4259 command in a linker script. */
4260
4261void
4262lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4263 const char *name;
4264 etree_type *type;
4265 boolean filehdr;
4266 boolean phdrs;
4267 etree_type *at;
4268 etree_type *flags;
4269{
4270 struct lang_phdr *n, **pp;
4271
4272 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4273 n->next = NULL;
4274 n->name = name;
4275 n->type = exp_get_value_int (type, 0, "program header type",
4276 lang_final_phase_enum);
4277 n->filehdr = filehdr;
4278 n->phdrs = phdrs;
4279 n->at = at;
4280 n->flags = flags;
4281
4282 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4283 ;
4284 *pp = n;
4285}
4286
4287/* Record the program header information in the output BFD. FIXME: We
4288 should not be calling an ELF specific function here. */
4289
4290static void
4291lang_record_phdrs ()
4292{
4293 unsigned int alc;
4294 asection **secs;
4295 struct lang_output_section_phdr_list *last;
4296 struct lang_phdr *l;
4297 lang_statement_union_type *u;
4298
4299 alc = 10;
4300 secs = (asection **) xmalloc (alc * sizeof (asection *));
4301 last = NULL;
4302 for (l = lang_phdr_list; l != NULL; l = l->next)
4303 {
4304 unsigned int c;
4305 flagword flags;
4306 bfd_vma at;
4307
4308 c = 0;
4309 for (u = lang_output_section_statement.head;
4310 u != NULL;
4311 u = u->output_section_statement.next)
4312 {
4313 lang_output_section_statement_type *os;
4314 struct lang_output_section_phdr_list *pl;
4315
4316 os = &u->output_section_statement;
4317
4318 pl = os->phdrs;
4319 if (pl != NULL)
4320 last = pl;
4321 else
4322 {
4323 if (os->sectype == noload_section
4324 || os->bfd_section == NULL
4325 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4326 continue;
4327 pl = last;
4328 }
4329
4330 if (os->bfd_section == NULL)
4331 continue;
4332
4333 for (; pl != NULL; pl = pl->next)
4334 {
4335 if (strcmp (pl->name, l->name) == 0)
4336 {
4337 if (c >= alc)
4338 {
4339 alc *= 2;
4340 secs = ((asection **)
4341 xrealloc (secs, alc * sizeof (asection *)));
4342 }
4343 secs[c] = os->bfd_section;
4344 ++c;
4345 pl->used = true;
4346 }
4347 }
4348 }
4349
4350 if (l->flags == NULL)
4351 flags = 0;
4352 else
4353 flags = exp_get_vma (l->flags, 0, "phdr flags",
4354 lang_final_phase_enum);
4355
4356 if (l->at == NULL)
4357 at = 0;
4358 else
4359 at = exp_get_vma (l->at, 0, "phdr load address",
4360 lang_final_phase_enum);
4361
4362 if (! bfd_record_phdr (output_bfd, l->type,
4363 l->flags == NULL ? false : true,
4364 flags,
4365 l->at == NULL ? false : true,
4366 at, l->filehdr, l->phdrs, c, secs))
4367 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4368 }
4369
4370 free (secs);
4371
4372 /* Make sure all the phdr assignments succeeded. */
4373 for (u = lang_output_section_statement.head;
4374 u != NULL;
4375 u = u->output_section_statement.next)
4376 {
4377 struct lang_output_section_phdr_list *pl;
4378
4379 if (u->output_section_statement.bfd_section == NULL)
4380 continue;
4381
4382 for (pl = u->output_section_statement.phdrs;
4383 pl != NULL;
4384 pl = pl->next)
4385 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4386 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4387 u->output_section_statement.name, pl->name);
4388 }
4389}
4390
4391/* Record a list of sections which may not be cross referenced. */
4392
4393void
4394lang_add_nocrossref (l)
4395 struct lang_nocrossref *l;
4396{
4397 struct lang_nocrossrefs *n;
4398
4399 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4400 n->next = nocrossref_list;
4401 n->list = l;
4402 nocrossref_list = n;
4403
4404 /* Set notice_all so that we get informed about all symbols. */
4405 link_info.notice_all = true;
4406}
4407\f
4408/* Overlay handling. We handle overlays with some static variables. */
4409
4410/* The overlay virtual address. */
4411static etree_type *overlay_vma;
4412
4413/* The overlay load address. */
4414static etree_type *overlay_lma;
4415
4416/* Whether nocrossrefs is set for this overlay. */
4417static int overlay_nocrossrefs;
4418
4419/* An expression for the maximum section size seen so far. */
4420static etree_type *overlay_max;
4421
4422/* A list of all the sections in this overlay. */
4423
4424struct overlay_list
4425{
4426 struct overlay_list *next;
4427 lang_output_section_statement_type *os;
4428};
4429
4430static struct overlay_list *overlay_list;
4431
4432/* Start handling an overlay. */
4433
4434void
4435lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
4436 etree_type *vma_expr;
4437 etree_type *lma_expr;
4438 int nocrossrefs;
4439{
4440 /* The grammar should prevent nested overlays from occurring. */
4441 ASSERT (overlay_vma == NULL
4442 && overlay_lma == NULL
4443 && overlay_list == NULL
4444 && overlay_max == NULL);
4445
4446 overlay_vma = vma_expr;
4447 overlay_lma = lma_expr;
4448 overlay_nocrossrefs = nocrossrefs;
4449}
4450
4451/* Start a section in an overlay. We handle this by calling
4452 lang_enter_output_section_statement with the correct VMA and LMA. */
4453
4454void
4455lang_enter_overlay_section (name)
4456 const char *name;
4457{
4458 struct overlay_list *n;
4459 etree_type *size;
4460
4461 lang_enter_output_section_statement (name, overlay_vma, normal_section,
4462 0, 0, 0, overlay_lma);
4463
4464 /* If this is the first section, then base the VMA and LMA of future
4465 sections on this one. This will work correctly even if `.' is
4466 used in the addresses. */
4467 if (overlay_list == NULL)
4468 {
4469 overlay_vma = exp_nameop (ADDR, name);
4470 overlay_lma = exp_nameop (LOADADDR, name);
4471 }
4472
4473 /* Remember the section. */
4474 n = (struct overlay_list *) xmalloc (sizeof *n);
4475 n->os = current_section;
4476 n->next = overlay_list;
4477 overlay_list = n;
4478
4479 size = exp_nameop (SIZEOF, name);
4480
4481 /* Adjust the LMA for the next section. */
4482 overlay_lma = exp_binop ('+', overlay_lma, size);
4483
4484 /* Arrange to work out the maximum section end address. */
4485 if (overlay_max == NULL)
4486 overlay_max = size;
4487 else
4488 overlay_max = exp_binop (MAX_K, overlay_max, size);
4489}
4490
4491/* Finish a section in an overlay. There isn't any special to do
4492 here. */
4493
4494void
4495lang_leave_overlay_section (fill, phdrs)
4496 bfd_vma fill;
4497 struct lang_output_section_phdr_list *phdrs;
4498{
4499 const char *name;
4500 char *clean, *s2;
4501 const char *s1;
4502 char *buf;
4503
4504 name = current_section->name;
4505
4506 lang_leave_output_section_statement (fill, "*default*", phdrs);
4507
4508 /* Define the magic symbols. */
4509
4510 clean = xmalloc (strlen (name) + 1);
4511 s2 = clean;
4512 for (s1 = name; *s1 != '\0'; s1++)
4513 if (isalnum ((unsigned char) *s1) || *s1 == '_')
4514 *s2++ = *s1;
4515 *s2 = '\0';
4516
4517 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4518 sprintf (buf, "__load_start_%s", clean);
4519 lang_add_assignment (exp_assop ('=', buf,
4520 exp_nameop (LOADADDR, name)));
4521
4522 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4523 sprintf (buf, "__load_stop_%s", clean);
4524 lang_add_assignment (exp_assop ('=', buf,
4525 exp_binop ('+',
4526 exp_nameop (LOADADDR, name),
4527 exp_nameop (SIZEOF, name))));
4528
4529 free (clean);
4530}
4531
4532/* Finish an overlay. If there are any overlay wide settings, this
4533 looks through all the sections in the overlay and sets them. */
4534
4535void
4536lang_leave_overlay (fill, memspec, phdrs)
4537 bfd_vma fill;
4538 const char *memspec;
4539 struct lang_output_section_phdr_list *phdrs;
4540{
4541 lang_memory_region_type *region;
4542 struct overlay_list *l;
4543 struct lang_nocrossref *nocrossref;
4544
4545 if (memspec == NULL)
4546 region = NULL;
4547 else
4548 region = lang_memory_region_lookup (memspec);
4549
4550 nocrossref = NULL;
4551
4552 l = overlay_list;
4553 while (l != NULL)
4554 {
4555 struct overlay_list *next;
4556
4557 if (fill != 0 && l->os->fill == 0)
4558 l->os->fill = fill;
4559 if (region != NULL && l->os->region == NULL)
4560 l->os->region = region;
4561 if (phdrs != NULL && l->os->phdrs == NULL)
4562 l->os->phdrs = phdrs;
4563
4564 if (overlay_nocrossrefs)
4565 {
4566 struct lang_nocrossref *nc;
4567
4568 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4569 nc->name = l->os->name;
4570 nc->next = nocrossref;
4571 nocrossref = nc;
4572 }
4573
4574 next = l->next;
4575 free (l);
4576 l = next;
4577 }
4578
4579 if (nocrossref != NULL)
4580 lang_add_nocrossref (nocrossref);
4581
4582 /* Update . for the end of the overlay. */
4583 lang_add_assignment (exp_assop ('=', ".",
4584 exp_binop ('+', overlay_vma, overlay_max)));
4585
4586 overlay_vma = NULL;
4587 overlay_lma = NULL;
4588 overlay_nocrossrefs = 0;
4589 overlay_list = NULL;
4590 overlay_max = NULL;
4591}
4592\f
4593/* Version handling. This is only useful for ELF. */
4594
4595/* This global variable holds the version tree that we build. */
4596
4597struct bfd_elf_version_tree *lang_elf_version_info;
4598
4599static int
4600lang_vers_match_lang_c (expr, sym)
4601 struct bfd_elf_version_expr *expr;
4602 const char *sym;
4603{
4604 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4605 return 1;
4606 return fnmatch (expr->pattern, sym, 0) == 0;
4607}
4608
4609static int
4610lang_vers_match_lang_cplusplus (expr, sym)
4611 struct bfd_elf_version_expr *expr;
4612 const char *sym;
4613{
4614 char *alt_sym;
4615 int result;
4616
4617 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4618 return 1;
4619
4620 alt_sym = cplus_demangle(sym, /* DMGL_NO_TPARAMS */ 0);
4621 if (!alt_sym)
4622 {
4623 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4624 Should we early out false in this case? */
4625 result = fnmatch (expr->pattern, sym, 0) == 0;
4626 }
4627 else
4628 {
4629 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4630 free (alt_sym);
4631 }
4632
4633 return result;
4634}
4635
4636static int
4637lang_vers_match_lang_java (expr, sym)
4638 struct bfd_elf_version_expr *expr;
4639 const char *sym;
4640{
4641 char *alt_sym;
4642 int result;
4643
4644 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4645 return 1;
4646
4647 alt_sym = cplus_demangle(sym, DMGL_JAVA);
4648 if (!alt_sym)
4649 {
4650 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4651 Should we early out false in this case? */
4652 result = fnmatch (expr->pattern, sym, 0) == 0;
4653 }
4654 else
4655 {
4656 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4657 free (alt_sym);
4658 }
4659
4660 return result;
4661}
4662
4663/* This is called for each variable name or match expression. */
4664
4665struct bfd_elf_version_expr *
4666lang_new_vers_regex (orig, new, lang)
4667 struct bfd_elf_version_expr *orig;
4668 const char *new;
4669 const char *lang;
4670{
4671 struct bfd_elf_version_expr *ret;
4672
4673 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
4674 ret->next = orig;
4675 ret->pattern = new;
4676
4677 if (lang == NULL || strcasecmp (lang, "C") == 0)
4678 ret->match = lang_vers_match_lang_c;
4679 else if (strcasecmp (lang, "C++") == 0)
4680 ret->match = lang_vers_match_lang_cplusplus;
4681 else if (strcasecmp (lang, "Java") == 0)
4682 ret->match = lang_vers_match_lang_java;
4683 else
4684 {
4685 einfo (_("%X%P: unknown language `%s' in version information\n"),
4686 lang);
4687 ret->match = lang_vers_match_lang_c;
4688 }
4689
4690 return ret;
4691}
4692
4693/* This is called for each set of variable names and match
4694 expressions. */
4695
4696struct bfd_elf_version_tree *
4697lang_new_vers_node (globals, locals)
4698 struct bfd_elf_version_expr *globals;
4699 struct bfd_elf_version_expr *locals;
4700{
4701 struct bfd_elf_version_tree *ret;
4702
4703 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
4704 ret->next = NULL;
4705 ret->name = NULL;
4706 ret->vernum = 0;
4707 ret->globals = globals;
4708 ret->locals = locals;
4709 ret->deps = NULL;
4710 ret->name_indx = (unsigned int) -1;
4711 ret->used = 0;
4712 return ret;
4713}
4714
4715/* This static variable keeps track of version indices. */
4716
4717static int version_index;
4718
4719/* This is called when we know the name and dependencies of the
4720 version. */
4721
4722void
4723lang_register_vers_node (name, version, deps)
4724 const char *name;
4725 struct bfd_elf_version_tree *version;
4726 struct bfd_elf_version_deps *deps;
4727{
4728 struct bfd_elf_version_tree *t, **pp;
4729 struct bfd_elf_version_expr *e1;
4730
4731 /* Make sure this node has a unique name. */
4732 for (t = lang_elf_version_info; t != NULL; t = t->next)
4733 if (strcmp (t->name, name) == 0)
4734 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
4735
4736 /* Check the global and local match names, and make sure there
4737 aren't any duplicates. */
4738
4739 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
4740 {
4741 for (t = lang_elf_version_info; t != NULL; t = t->next)
4742 {
4743 struct bfd_elf_version_expr *e2;
4744
4745 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
4746 if (strcmp (e1->pattern, e2->pattern) == 0)
4747 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4748 e1->pattern);
4749 }
4750 }
4751
4752 for (e1 = version->locals; e1 != NULL; e1 = e1->next)
4753 {
4754 for (t = lang_elf_version_info; t != NULL; t = t->next)
4755 {
4756 struct bfd_elf_version_expr *e2;
4757
4758 for (e2 = t->globals; e2 != NULL; e2 = e2->next)
4759 if (strcmp (e1->pattern, e2->pattern) == 0)
4760 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
4761 e1->pattern);
4762 }
4763 }
4764
4765 version->deps = deps;
4766 version->name = name;
4767 ++version_index;
4768 version->vernum = version_index;
4769
4770 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
4771 ;
4772 *pp = version;
4773}
4774
4775/* This is called when we see a version dependency. */
4776
4777struct bfd_elf_version_deps *
4778lang_add_vers_depend (list, name)
4779 struct bfd_elf_version_deps *list;
4780 const char *name;
4781{
4782 struct bfd_elf_version_deps *ret;
4783 struct bfd_elf_version_tree *t;
4784
4785 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
4786 ret->next = list;
4787
4788 for (t = lang_elf_version_info; t != NULL; t = t->next)
4789 {
4790 if (strcmp (t->name, name) == 0)
4791 {
4792 ret->version_needed = t;
4793 return ret;
4794 }
4795 }
4796
4797 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
4798
4799 return ret;
4800}
4801
4802static void
4803lang_do_version_exports_section ()
4804{
4805 struct bfd_elf_version_expr *greg = NULL, *lreg;
4806
4807 LANG_FOR_EACH_INPUT_STATEMENT (is)
4808 {
4809 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
4810 char *contents, *p;
4811 bfd_size_type len;
4812
4813 if (sec == NULL)
4814 continue;
4815
4816 len = bfd_section_size (is->the_bfd, sec);
4817 contents = xmalloc (len);
4818 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
4819 einfo (_("%X%P: unable to read .exports section contents"), sec);
4820
4821 p = contents;
4822 while (p < contents+len)
4823 {
4824 greg = lang_new_vers_regex (greg, p, NULL);
4825 p = strchr (p, '\0') + 1;
4826 }
4827
4828 /* Do not free the contents, as we used them creating the regex. */
4829
4830 /* Do not include this section in the link. */
4831 bfd_set_section_flags (is->the_bfd, sec,
4832 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
4833 }
4834
4835 lreg = lang_new_vers_regex (NULL, "*", NULL);
4836 lang_register_vers_node (command_line.version_exports_section,
4837 lang_new_vers_node (greg, lreg), NULL);
4838}
GDB Binutils - Deliverables
This page took 0.207024 seconds and 4 git commands to generate.