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