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