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