projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
When truncating an aligned block, ensure that the low order bits of the
[deliverable/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
d1b2b2dc 626 new->name = xstrdup (name);
252b5132
RH		 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 ();
884fb58e
NC		 1452
1453 /* See if the emulation has some special knowledge. */
1454 if (ldemul_unrecognized_file (entry))
1455 return;
1456
252b5132
RH		 1457 if (err == bfd_error_file_ambiguously_recognized)
1458 {
1459 char **p;
1460
1461 einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
1462 einfo (_("%B: matching formats:"), entry->the_bfd);
1463 for (p = matching; *p != NULL; p++)
1464 einfo (" %s", *p);
1465 einfo ("%F\n");
1466 }
1467 else if (err != bfd_error_file_not_recognized
1468 || place == NULL)
1469 einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
1470
1471 bfd_close (entry->the_bfd);
1472 entry->the_bfd = NULL;
1473
252b5132 1474 /* Try to interpret the file as a linker script. */
252b5132
RH		 1475 ldfile_open_command_file (entry->filename);
1476
1477 hold = stat_ptr;
1478 stat_ptr = place;
1479
1480 ldfile_assumed_script = true;
1481 parser_input = input_script;
1482 yyparse ();
1483 ldfile_assumed_script = false;
1484
1485 stat_ptr = hold;
1486
1487 return;
1488 }
1489
1490 if (ldemul_recognized_file (entry))
1491 return;
1492
1493 /* We don't call ldlang_add_file for an archive. Instead, the
1494 add_symbols entry point will call ldlang_add_file, via the
1495 add_archive_element callback, for each element of the archive
1496 which is used. */
1497 switch (bfd_get_format (entry->the_bfd))
1498 {
1499 default:
1500 break;
1501
1502 case bfd_object:
1503 ldlang_add_file (entry);
1504 if (trace_files || trace_file_tries)
1505 info_msg ("%I\n", entry);
1506 break;
1507
1508 case bfd_archive:
1509 if (entry->whole_archive)
1510 {
1511 bfd *member = bfd_openr_next_archived_file (entry->the_bfd,
1512 (bfd *) NULL);
1513 while (member != NULL)
1514 {
1515 if (! bfd_check_format (member, bfd_object))
1516 einfo (_("%F%B: object %B in archive is not object\n"),
1517 entry->the_bfd, member);
1518 if (! ((*link_info.callbacks->add_archive_element)
1519 (&link_info, member, "--whole-archive")))
1520 abort ();
1521 if (! bfd_link_add_symbols (member, &link_info))
1522 einfo (_("%F%B: could not read symbols: %E\n"), member);
1523 member = bfd_openr_next_archived_file (entry->the_bfd,
1524 member);
1525 }
1526
1527 entry->loaded = true;
1528
1529 return;
1530 }
1531 }
1532
1533 if (! bfd_link_add_symbols (entry->the_bfd, &link_info))
1534 einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
1535
1536 entry->loaded = true;
1537}
1538
252b5132
RH		 1539/* Handle a wild statement. SECTION or FILE or both may be NULL,
1540 indicating that it is a wildcard. Separate lang_input_section
1541 statements are created for each part of the expansion; they are
1542 added after the wild statement S. OUTPUT is the output section. */
1543
1544static void
1545wild (s, section, file, target, output)
1546 lang_wild_statement_type *s;
1547 const char *section;
1548 const char *file;
87f2a346 1549 const char *target ATTRIBUTE_UNUSED;
252b5132
RH		 1550 lang_output_section_statement_type *output;
1551{
5f992e62 1552 walk_wild (s, section, file, output_section_callback, (PTR) output);
252b5132
RH		 1553
1554 if (section != (char *) NULL
1555 && strcmp (section, "COMMON") == 0
1556 && default_common_section == NULL)
1557 {
1558 /* Remember the section that common is going to in case we later
1559 get something which doesn't know where to put it. */
1560 default_common_section = output;
1561 }
1562}
1563
e50d8076 1564/* Return true iff target is the sought target. */
08da4cac 1565
e50d8076
NC		 1566static int
1567get_target (target, data)
08da4cac 1568 const bfd_target *target;
5f992e62 1569 PTR data;
e50d8076 1570{
08da4cac 1571 const char *sought = (const char *) data;
5f992e62 1572
e50d8076
NC		 1573 return strcmp (target->name, sought) == 0;
1574}
1575
1576/* Like strcpy() but convert to lower case as well. */
08da4cac 1577
e50d8076
NC		 1578static void
1579stricpy (dest, src)
08da4cac
KH		 1580 char *dest;
1581 char *src;
e50d8076
NC		 1582{
1583 char c;
5f992e62 1584
08da4cac 1585 while ((c = *src++) != 0)
e50d8076
NC		 1586 {
1587 if (isupper ((unsigned char) c))
1588 c = tolower (c);
1589
08da4cac 1590 *dest++ = c;
e50d8076
NC		 1591 }
1592
08da4cac 1593 *dest = 0;
e50d8076
NC		 1594}
1595
1596/* Remove the first occurance of needle (if any) in haystack
1597 from haystack. */
08da4cac 1598
e50d8076
NC		 1599static void
1600strcut (haystack, needle)
08da4cac
KH		 1601 char *haystack;
1602 char *needle;
e50d8076
NC		 1603{
1604 haystack = strstr (haystack, needle);
5f992e62 1605
e50d8076
NC		 1606 if (haystack)
1607 {
08da4cac 1608 char *src;
e50d8076 1609
08da4cac
KH		 1610 for (src = haystack + strlen (needle); *src;)
1611 *haystack++ = *src++;
5f992e62 1612
08da4cac 1613 *haystack = 0;
e50d8076
NC		 1614 }
1615}
1616
1617/* Compare two target format name strings.
1618 Return a value indicating how "similar" they are. */
08da4cac 1619
e50d8076
NC		 1620static int
1621name_compare (first, second)
08da4cac
KH		 1622 char *first;
1623 char *second;
e50d8076 1624{
08da4cac
KH		 1625 char *copy1;
1626 char *copy2;
1627 int result;
5f992e62 1628
e50d8076
NC		 1629 copy1 = xmalloc (strlen (first) + 1);
1630 copy2 = xmalloc (strlen (second) + 1);
1631
1632 /* Convert the names to lower case. */
1633 stricpy (copy1, first);
1634 stricpy (copy2, second);
1635
1636 /* Remove and endian strings from the name. */
1637 strcut (copy1, "big");
1638 strcut (copy1, "little");
1639 strcut (copy2, "big");
1640 strcut (copy2, "little");
1641
1642 /* Return a value based on how many characters match,
1643 starting from the beginning. If both strings are
1644 the same then return 10 * their length. */
08da4cac
KH		 1645 for (result = 0; copy1[result] == copy2[result]; result++)
1646 if (copy1[result] == 0)
e50d8076
NC		 1647 {
1648 result *= 10;
1649 break;
1650 }
5f992e62 1651
e50d8076
NC		 1652 free (copy1);
1653 free (copy2);
1654
1655 return result;
1656}
1657
1658/* Set by closest_target_match() below. */
08da4cac 1659static const bfd_target *winner;
e50d8076
NC		 1660
1661/* Scan all the valid bfd targets looking for one that has the endianness
1662 requirement that was specified on the command line, and is the nearest
1663 match to the original output target. */
08da4cac 1664
e50d8076
NC		 1665static int
1666closest_target_match (target, data)
08da4cac 1667 const bfd_target *target;
5f992e62 1668 PTR data;
e50d8076 1669{
08da4cac 1670 const bfd_target *original = (const bfd_target *) data;
5f992e62 1671
08da4cac
KH		 1672 if (command_line.endian == ENDIAN_BIG
1673 && target->byteorder != BFD_ENDIAN_BIG)
e50d8076 1674 return 0;
5f992e62 1675
08da4cac
KH		 1676 if (command_line.endian == ENDIAN_LITTLE
1677 && target->byteorder != BFD_ENDIAN_LITTLE)
e50d8076
NC		 1678 return 0;
1679
1680 /* Must be the same flavour. */
1681 if (target->flavour != original->flavour)
1682 return 0;
1683
1684 /* If we have not found a potential winner yet, then record this one. */
1685 if (winner == NULL)
1686 {
1687 winner = target;
1688 return 0;
1689 }
1690
1691 /* Oh dear, we now have two potential candidates for a successful match.
4de2d33d 1692 Compare their names and choose the better one. */
e50d8076
NC		 1693 if (name_compare (target->name, original->name) > name_compare (winner->name, original->name))
1694 winner = target;
1695
1696 /* Keep on searching until wqe have checked them all. */
1697 return 0;
1698}
1699
1700/* Return the BFD target format of the first input file. */
08da4cac 1701
e50d8076
NC		 1702static char *
1703get_first_input_target ()
1704{
08da4cac 1705 char *target = NULL;
e50d8076
NC		 1706
1707 LANG_FOR_EACH_INPUT_STATEMENT (s)
1708 {
1709 if (s->header.type == lang_input_statement_enum
1710 && s->real)
1711 {
1712 ldfile_open_file (s);
5f992e62 1713
e50d8076
NC		 1714 if (s->the_bfd != NULL
1715 && bfd_check_format (s->the_bfd, bfd_object))
1716 {
1717 target = bfd_get_target (s->the_bfd);
5f992e62 1718
e50d8076
NC		 1719 if (target != NULL)
1720 break;
1721 }
1722 }
1723 }
5f992e62 1724
e50d8076
NC		 1725 return target;
1726}
1727
252b5132
RH		 1728/* Open the output file. */
1729
1730static bfd *
1731open_output (name)
08da4cac 1732 const char *name;
252b5132 1733{
08da4cac 1734 bfd *output;
252b5132 1735
08da4cac 1736 /* Has the user told us which output format to use? */
252b5132
RH		 1737 if (output_target == (char *) NULL)
1738 {
08da4cac
KH		 1739 /* No - has the current target been set to something other than
1740 the default? */
e50d8076 1741 if (current_target != default_target)
252b5132 1742 output_target = current_target;
e50d8076 1743
08da4cac 1744 /* No - can we determine the format of the first input file? */
e50d8076
NC		 1745 else
1746 {
1747 output_target = get_first_input_target ();
1748
1749 /* Failed - use the default output target. */
1750 if (output_target == NULL)
1751 output_target = default_target;
1752 }
1753 }
5f992e62 1754
08da4cac
KH		 1755 /* Has the user requested a particular endianness on the command
1756 line? */
e50d8076
NC		 1757 if (command_line.endian != ENDIAN_UNSET)
1758 {
08da4cac 1759 const bfd_target *target;
1b69a0bf 1760 enum bfd_endian desired_endian;
e50d8076
NC		 1761
1762 /* Get the chosen target. */
5f992e62 1763 target = bfd_search_for_target (get_target, (PTR) output_target);
e50d8076 1764
c13b1b77
NC		 1765 /* If the target is not supported, we cannot do anything. */
1766 if (target != NULL)
e50d8076 1767 {
c13b1b77
NC		 1768 if (command_line.endian == ENDIAN_BIG)
1769 desired_endian = BFD_ENDIAN_BIG;
e50d8076 1770 else
c13b1b77 1771 desired_endian = BFD_ENDIAN_LITTLE;
5f992e62
AM		 1772
1773 /* See if the target has the wrong endianness. This should
1774 not happen if the linker script has provided big and
1775 little endian alternatives, but some scrips don't do
1776 this. */
c13b1b77 1777 if (target->byteorder != desired_endian)
e50d8076 1778 {
c13b1b77
NC		 1779 /* If it does, then see if the target provides
1780 an alternative with the correct endianness. */
1781 if (target->alternative_target != NULL
1782 && (target->alternative_target->byteorder == desired_endian))
1783 output_target = target->alternative_target->name;
e50d8076 1784 else
c13b1b77 1785 {
5f992e62
AM		 1786 /* Try to find a target as similar as possible to
1787 the default target, but which has the desired
1788 endian characteristic. */
1789 (void) bfd_search_for_target (closest_target_match, (PTR) target);
1790
1791 /* Oh dear - we could not find any targets that
1792 satisfy our requirements. */
c13b1b77
NC		 1793 if (winner == NULL)
1794 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1795 else
1796 output_target = winner->name;
1797 }
e50d8076
NC		 1798 }
1799 }
252b5132 1800 }
5f992e62 1801
252b5132
RH		 1802 output = bfd_openw (name, output_target);
1803
1804 if (output == (bfd *) NULL)
1805 {
1806 if (bfd_get_error () == bfd_error_invalid_target)
e50d8076
NC		 1807 einfo (_("%P%F: target %s not found\n"), output_target);
1808
252b5132
RH		 1809 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1810 }
1811
1812 delete_output_file_on_failure = true;
1813
08da4cac
KH		 1814#if 0
1815 output->flags |= D_PAGED;
1816#endif
252b5132
RH		 1817
1818 if (! bfd_set_format (output, bfd_object))
1819 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1820 if (! bfd_set_arch_mach (output,
1821 ldfile_output_architecture,
1822 ldfile_output_machine))
1823 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1824
1825 link_info.hash = bfd_link_hash_table_create (output);
1826 if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1827 einfo (_("%P%F: can not create link hash table: %E\n"));
1828
1829 bfd_set_gp_size (output, g_switch_value);
1830 return output;
1831}
1832
252b5132
RH		 1833static void
1834ldlang_open_output (statement)
08da4cac 1835 lang_statement_union_type *statement;
252b5132
RH		 1836{
1837 switch (statement->header.type)
1838 {
1839 case lang_output_statement_enum:
1840 ASSERT (output_bfd == (bfd *) NULL);
1841 output_bfd = open_output (statement->output_statement.name);
1842 ldemul_set_output_arch ();
1843 if (config.magic_demand_paged && !link_info.relocateable)
1844 output_bfd->flags |= D_PAGED;
1845 else
1846 output_bfd->flags &= ~D_PAGED;
1847 if (config.text_read_only)
1848 output_bfd->flags |= WP_TEXT;
1849 else
1850 output_bfd->flags &= ~WP_TEXT;
1851 if (link_info.traditional_format)
1852 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1853 else
1854 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1855 break;
1856
1857 case lang_target_statement_enum:
1858 current_target = statement->target_statement.target;
1859 break;
1860 default:
1861 break;
1862 }
1863}
1864
1865/* Open all the input files. */
1866
1867static void
1868open_input_bfds (s, force)
1869 lang_statement_union_type *s;
1870 boolean force;
1871{
1872 for (; s != (lang_statement_union_type *) NULL; s = s->next)
1873 {
1874 switch (s->header.type)
1875 {
1876 case lang_constructors_statement_enum:
1877 open_input_bfds (constructor_list.head, force);
1878 break;
1879 case lang_output_section_statement_enum:
1880 open_input_bfds (s->output_section_statement.children.head, force);
1881 break;
1882 case lang_wild_statement_enum:
08da4cac 1883 /* Maybe we should load the file's symbols. */
252b5132
RH		 1884 if (s->wild_statement.filename
1885 && ! wildcardp (s->wild_statement.filename))
1886 (void) lookup_name (s->wild_statement.filename);
1887 open_input_bfds (s->wild_statement.children.head, force);
1888 break;
1889 case lang_group_statement_enum:
1890 {
1891 struct bfd_link_hash_entry *undefs;
1892
1893 /* We must continually search the entries in the group
08da4cac
KH		 1894 until no new symbols are added to the list of undefined
1895 symbols. */
252b5132
RH		 1896
1897 do
1898 {
1899 undefs = link_info.hash->undefs_tail;
1900 open_input_bfds (s->group_statement.children.head, true);
1901 }
1902 while (undefs != link_info.hash->undefs_tail);
1903 }
1904 break;
1905 case lang_target_statement_enum:
1906 current_target = s->target_statement.target;
1907 break;
1908 case lang_input_statement_enum:
e50d8076 1909 if (s->input_statement.real)
252b5132
RH		 1910 {
1911 lang_statement_list_type add;
1276aefa 1912 bfd_error_handler_type pfn;
252b5132
RH		 1913
1914 s->input_statement.target = current_target;
1915
1916 /* If we are being called from within a group, and this
1917 is an archive which has already been searched, then
cd4c806a
L		 1918 force it to be researched unless the whole archive
1919 has been loaded already. */
252b5132 1920 if (force
cd4c806a 1921 && !s->input_statement.whole_archive
252b5132
RH		 1922 && s->input_statement.loaded
1923 && bfd_check_format (s->input_statement.the_bfd,
1924 bfd_archive))
1925 s->input_statement.loaded = false;
1926
1276aefa
NC		 1927 lang_list_init (& add);
1928
1929 /* We need to know if an error occurs whilst loading the
1930 symbols, since this means that a valid executable can
1931 not be produced. */
1932 pfn = bfd_set_error_handler (record_bfd_errors);
252b5132
RH		 1933
1934 load_symbols (&s->input_statement, &add);
1935
1276aefa
NC		 1936 bfd_set_error_handler (pfn);
1937
252b5132
RH		 1938 if (add.head != NULL)
1939 {
1940 *add.tail = s->next;
1941 s->next = add.head;
1942 }
1943 }
1944 break;
1945 default:
1946 break;
1947 }
1948 }
1949}
1950
08da4cac
KH		 1951/* If there are [COMMONS] statements, put a wild one into the bss
1952 section. */
252b5132
RH		 1953
1954static void
1955lang_reasonable_defaults ()
1956{
1957#if 0
1958 lang_output_section_statement_lookup (".text");
1959 lang_output_section_statement_lookup (".data");
1960
08da4cac 1961 default_common_section = lang_output_section_statement_lookup (".bss");
252b5132 1962
252b5132
RH		 1963 if (placed_commons == false)
1964 {
1965 lang_wild_statement_type *new =
1966 new_stat (lang_wild_statement,
1967 &default_common_section->children);
1968
1969 new->section_name = "COMMON";
1970 new->filename = (char *) NULL;
1971 lang_list_init (&new->children);
1972 }
1973#endif
252b5132
RH		 1974}
1975
08da4cac
KH		 1976/* Add the supplied name to the symbol table as an undefined reference.
1977 Remove items from the chain as we open input bfds. */
252b5132
RH		 1978typedef struct ldlang_undef_chain_list
1979{
1980 struct ldlang_undef_chain_list *next;
1981 char *name;
1982} ldlang_undef_chain_list_type;
1983
1984static ldlang_undef_chain_list_type *ldlang_undef_chain_list_head;
1985
1986void
1987ldlang_add_undef (name)
5f992e62 1988 const char *const name;
252b5132
RH		 1989{
1990 ldlang_undef_chain_list_type *new =
1991 ((ldlang_undef_chain_list_type *)
1992 stat_alloc (sizeof (ldlang_undef_chain_list_type)));
1993
1994 new->next = ldlang_undef_chain_list_head;
1995 ldlang_undef_chain_list_head = new;
1996
d1b2b2dc 1997 new->name = xstrdup (name);
252b5132
RH		 1998}
1999
2000/* Run through the list of undefineds created above and place them
2001 into the linker hash table as undefined symbols belonging to the
08da4cac
KH		 2002 script file. */
2003
252b5132
RH		 2004static void
2005lang_place_undefineds ()
2006{
2007 ldlang_undef_chain_list_type *ptr;
2008
2009 for (ptr = ldlang_undef_chain_list_head;
2010 ptr != (ldlang_undef_chain_list_type *) NULL;
2011 ptr = ptr->next)
2012 {
2013 struct bfd_link_hash_entry *h;
2014
2015 h = bfd_link_hash_lookup (link_info.hash, ptr->name, true, false, true);
2016 if (h == (struct bfd_link_hash_entry *) NULL)
2017 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2018 if (h->type == bfd_link_hash_new)
2019 {
2020 h->type = bfd_link_hash_undefined;
2021 h->u.undef.abfd = NULL;
2022 bfd_link_add_undef (link_info.hash, h);
2023 }
2024 }
2025}
2026
08da4cac
KH		 2027/* Open input files and attatch to output sections. */
2028
252b5132
RH		 2029static void
2030map_input_to_output_sections (s, target, output_section_statement)
08da4cac 2031 lang_statement_union_type *s;
5f992e62 2032 const char *target;
08da4cac 2033 lang_output_section_statement_type *output_section_statement;
252b5132
RH		 2034{
2035 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2036 {
2037 switch (s->header.type)
2038 {
2039
252b5132
RH		 2040 case lang_wild_statement_enum:
2041 wild (&s->wild_statement, s->wild_statement.section_name,
2042 s->wild_statement.filename, target,
2043 output_section_statement);
2044
2045 break;
2046 case lang_constructors_statement_enum:
2047 map_input_to_output_sections (constructor_list.head,
2048 target,
2049 output_section_statement);
2050 break;
2051 case lang_output_section_statement_enum:
2052 map_input_to_output_sections (s->output_section_statement.children.head,
2053 target,
2054 &s->output_section_statement);
2055 break;
2056 case lang_output_statement_enum:
2057 break;
2058 case lang_target_statement_enum:
2059 target = s->target_statement.target;
2060 break;
2061 case lang_group_statement_enum:
2062 map_input_to_output_sections (s->group_statement.children.head,
2063 target,
2064 output_section_statement);
2065 break;
2066 case lang_fill_statement_enum:
2067 case lang_input_section_enum:
2068 case lang_object_symbols_statement_enum:
2069 case lang_data_statement_enum:
2070 case lang_reloc_statement_enum:
2071 case lang_padding_statement_enum:
2072 case lang_input_statement_enum:
2073 if (output_section_statement != NULL
2074 && output_section_statement->bfd_section == NULL)
2075 init_os (output_section_statement);
2076 break;
2077 case lang_assignment_statement_enum:
2078 if (output_section_statement != NULL
2079 && output_section_statement->bfd_section == NULL)
2080 init_os (output_section_statement);
2081
2082 /* Make sure that any sections mentioned in the assignment
08da4cac 2083 are initialized. */
252b5132
RH		 2084 exp_init_os (s->assignment_statement.exp);
2085 break;
2086 case lang_afile_asection_pair_statement_enum:
2087 FAIL ();
2088 break;
2089 case lang_address_statement_enum:
08da4cac 2090 /* Mark the specified section with the supplied address. */
252b5132
RH		 2091 {
2092 lang_output_section_statement_type *os =
2093 lang_output_section_statement_lookup
2094 (s->address_statement.section_name);
2095
2096 if (os->bfd_section == NULL)
2097 init_os (os);
2098 os->addr_tree = s->address_statement.address;
2099 }
2100 break;
2101 }
2102 }
2103}
2104
2105static void
2106print_output_section_statement (output_section_statement)
08da4cac 2107 lang_output_section_statement_type *output_section_statement;
252b5132
RH		 2108{
2109 asection *section = output_section_statement->bfd_section;
2110 int len;
2111
2112 if (output_section_statement != abs_output_section)
2113 {
2114 minfo ("\n%s", output_section_statement->name);
2115
2116 if (section != NULL)
2117 {
2118 print_dot = section->vma;
2119
2120 len = strlen (output_section_statement->name);
2121 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2122 {
2123 print_nl ();
2124 len = 0;
2125 }
2126 while (len < SECTION_NAME_MAP_LENGTH)
2127 {
2128 print_space ();
2129 ++len;
2130 }
2131
2132 minfo ("0x%V %W", section->vma, section->_raw_size);
2133
2134 if (output_section_statement->load_base != NULL)
2135 {
2136 bfd_vma addr;
2137
2138 addr = exp_get_abs_int (output_section_statement->load_base, 0,
2139 "load base", lang_final_phase_enum);
2140 minfo (_(" load address 0x%V"), addr);
2141 }
2142 }
2143
2144 print_nl ();
2145 }
2146
2147 print_statement_list (output_section_statement->children.head,
2148 output_section_statement);
2149}
2150
2151static void
2152print_assignment (assignment, output_section)
08da4cac
KH		 2153 lang_assignment_statement_type *assignment;
2154 lang_output_section_statement_type *output_section;
252b5132
RH		 2155{
2156 int i;
2157 etree_value_type result;
2158
2159 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2160 print_space ();
2161
2162 result = exp_fold_tree (assignment->exp->assign.src, output_section,
2163 lang_final_phase_enum, print_dot, &print_dot);
2164 if (result.valid_p)
2165 minfo ("0x%V", result.value + result.section->bfd_section->vma);
2166 else
2167 {
2168 minfo ("*undef* ");
2169#ifdef BFD64
2170 minfo (" ");
2171#endif
2172 }
2173
2174 minfo (" ");
2175
2176 exp_print_tree (assignment->exp);
2177
2178 print_nl ();
2179}
2180
2181static void
2182print_input_statement (statm)
08da4cac 2183 lang_input_statement_type *statm;
252b5132
RH		 2184{
2185 if (statm->filename != (char *) NULL)
2186 {
2187 fprintf (config.map_file, "LOAD %s\n", statm->filename);
2188 }
2189}
2190
2191/* Print all symbols defined in a particular section. This is called
2192 via bfd_link_hash_traverse. */
2193
5f992e62 2194static boolean
252b5132
RH		 2195print_one_symbol (hash_entry, ptr)
2196 struct bfd_link_hash_entry *hash_entry;
2197 PTR ptr;
2198{
2199 asection *sec = (asection *) ptr;
2200
2201 if ((hash_entry->type == bfd_link_hash_defined
2202 || hash_entry->type == bfd_link_hash_defweak)
2203 && sec == hash_entry->u.def.section)
2204 {
2205 int i;
2206
2207 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2208 print_space ();
2209 minfo ("0x%V ",
2210 (hash_entry->u.def.value
2211 + hash_entry->u.def.section->output_offset
2212 + hash_entry->u.def.section->output_section->vma));
2213
2214 minfo (" %T\n", hash_entry->root.string);
2215 }
2216
2217 return true;
2218}
2219
2220/* Print information about an input section to the map file. */
2221
2222static void
2223print_input_section (in)
08da4cac 2224 lang_input_section_type *in;
252b5132
RH		 2225{
2226 asection *i = in->section;
2227 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
5f992e62 2228 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
f6af82bd 2229 ldfile_output_machine);
252b5132
RH		 2230 if (size != 0)
2231 {
2232 print_space ();
2233
2234 minfo ("%s", i->name);
2235
2236 if (i->output_section != NULL)
2237 {
2238 int len;
2239
2240 len = 1 + strlen (i->name);
2241 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2242 {
2243 print_nl ();
2244 len = 0;
2245 }
2246 while (len < SECTION_NAME_MAP_LENGTH)
2247 {
2248 print_space ();
2249 ++len;
2250 }
2251
2252 minfo ("0x%V %W %B\n",
4cbfc3ac 2253 i->output_section->vma + i->output_offset, size / opb,
252b5132
RH		 2254 i->owner);
2255
2256 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2257 {
2258 len = SECTION_NAME_MAP_LENGTH + 3;
2259#ifdef BFD64
2260 len += 16;
2261#else
2262 len += 8;
2263#endif
2264 while (len > 0)
2265 {
2266 print_space ();
2267 --len;
2268 }
2269
2270 minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2271 }
2272
2273 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
2274
4cbfc3ac 2275 print_dot = i->output_section->vma + i->output_offset + size / opb;
252b5132
RH		 2276 }
2277 }
2278}
2279
2280static void
2281print_fill_statement (fill)
08da4cac 2282 lang_fill_statement_type *fill;
252b5132
RH		 2283{
2284 fprintf (config.map_file, " FILL mask 0x%x\n", fill->fill);
2285}
2286
2287static void
2288print_data_statement (data)
08da4cac 2289 lang_data_statement_type *data;
252b5132
RH		 2290{
2291 int i;
2292 bfd_vma addr;
2293 bfd_size_type size;
2294 const char *name;
5f992e62 2295 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
f6af82bd 2296 ldfile_output_machine);
252b5132
RH		 2297
2298 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2299 print_space ();
2300
2301 addr = data->output_vma;
2302 if (data->output_section != NULL)
2303 addr += data->output_section->vma;
2304
2305 switch (data->type)
2306 {
2307 default:
2308 abort ();
2309 case BYTE:
2310 size = BYTE_SIZE;
2311 name = "BYTE";
2312 break;
2313 case SHORT:
2314 size = SHORT_SIZE;
2315 name = "SHORT";
2316 break;
2317 case LONG:
2318 size = LONG_SIZE;
2319 name = "LONG";
2320 break;
2321 case QUAD:
2322 size = QUAD_SIZE;
2323 name = "QUAD";
2324 break;
2325 case SQUAD:
2326 size = QUAD_SIZE;
2327 name = "SQUAD";
2328 break;
2329 }
2330
2331 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2332
2333 if (data->exp->type.node_class != etree_value)
2334 {
2335 print_space ();
2336 exp_print_tree (data->exp);
2337 }
2338
2339 print_nl ();
2340
4cbfc3ac
TW		 2341 print_dot = addr + size / opb;
2342
252b5132
RH		 2343}
2344
2345/* Print an address statement. These are generated by options like
2346 -Ttext. */
2347
2348static void
2349print_address_statement (address)
2350 lang_address_statement_type *address;
2351{
2352 minfo (_("Address of section %s set to "), address->section_name);
2353 exp_print_tree (address->address);
2354 print_nl ();
2355}
2356
2357/* Print a reloc statement. */
2358
2359static void
2360print_reloc_statement (reloc)
2361 lang_reloc_statement_type *reloc;
2362{
2363 int i;
2364 bfd_vma addr;
2365 bfd_size_type size;
5f992e62
AM		 2366 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2367 ldfile_output_machine);
252b5132
RH		 2368
2369 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2370 print_space ();
2371
2372 addr = reloc->output_vma;
2373 if (reloc->output_section != NULL)
2374 addr += reloc->output_section->vma;
2375
2376 size = bfd_get_reloc_size (reloc->howto);
2377
2378 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2379
2380 if (reloc->name != NULL)
2381 minfo ("%s+", reloc->name);
2382 else
2383 minfo ("%s+", reloc->section->name);
2384
2385 exp_print_tree (reloc->addend_exp);
2386
2387 print_nl ();
2388
4cbfc3ac 2389 print_dot = addr + size / opb;
5f992e62 2390}
252b5132
RH		 2391
2392static void
2393print_padding_statement (s)
2394 lang_padding_statement_type *s;
2395{
2396 int len;
2397 bfd_vma addr;
5f992e62
AM		 2398 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2399 ldfile_output_machine);
252b5132
RH		 2400
2401 minfo (" *fill*");
2402
2403 len = sizeof " *fill*" - 1;
2404 while (len < SECTION_NAME_MAP_LENGTH)
2405 {
2406 print_space ();
2407 ++len;
2408 }
2409
2410 addr = s->output_offset;
2411 if (s->output_section != NULL)
2412 addr += s->output_section->vma;
2413 minfo ("0x%V %W", addr, s->size);
2414
2415 if (s->fill != 0)
2416 minfo (" %u", s->fill);
2417
2418 print_nl ();
2419
4cbfc3ac 2420 print_dot = addr + s->size / opb;
252b5132
RH		 2421}
2422
2423static void
2424print_wild_statement (w, os)
08da4cac
KH		 2425 lang_wild_statement_type *w;
2426 lang_output_section_statement_type *os;
252b5132
RH		 2427{
2428 print_space ();
2429
2430 if (w->filenames_sorted)
2431 minfo ("SORT(");
18625d54
CM		 2432 if (w->exclude_filename_list != NULL)
2433 {
2434 name_list *tmp;
2435 minfo ("EXCLUDE_FILE ( %s", w->exclude_filename_list->name);
08da4cac
KH		 2436 for (tmp = w->exclude_filename_list->next; tmp; tmp = tmp->next)
2437 minfo (", %s", tmp->name);
18625d54 2438 minfo (")");
08da4cac
KH		 2439 }
2440 if (w->filename != NULL)
252b5132
RH		 2441 minfo ("%s", w->filename);
2442 else
2443 minfo ("*");
2444 if (w->filenames_sorted)
2445 minfo (")");
2446
2447 minfo ("(");
2448 if (w->sections_sorted)
2449 minfo ("SORT(");
2450 if (w->section_name != NULL)
2451 minfo ("%s", w->section_name);
2452 else
2453 minfo ("*");
2454 if (w->sections_sorted)
2455 minfo (")");
2456 minfo (")");
2457
2458 print_nl ();
2459
2460 print_statement_list (w->children.head, os);
2461}
2462
2463/* Print a group statement. */
2464
2465static void
2466print_group (s, os)
2467 lang_group_statement_type *s;
2468 lang_output_section_statement_type *os;
2469{
2470 fprintf (config.map_file, "START GROUP\n");
2471 print_statement_list (s->children.head, os);
2472 fprintf (config.map_file, "END GROUP\n");
2473}
2474
2475/* Print the list of statements in S.
2476 This can be called for any statement type. */
2477
2478static void
2479print_statement_list (s, os)
2480 lang_statement_union_type *s;
2481 lang_output_section_statement_type *os;
2482{
2483 while (s != NULL)
2484 {
2485 print_statement (s, os);
2486 s = s->next;
2487 }
2488}
2489
2490/* Print the first statement in statement list S.
2491 This can be called for any statement type. */
2492
2493static void
2494print_statement (s, os)
2495 lang_statement_union_type *s;
2496 lang_output_section_statement_type *os;
2497{
2498 switch (s->header.type)
2499 {
2500 default:
2501 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2502 FAIL ();
2503 break;
2504 case lang_constructors_statement_enum:
2505 if (constructor_list.head != NULL)
2506 {
2507 if (constructors_sorted)
2508 minfo (" SORT (CONSTRUCTORS)\n");
2509 else
2510 minfo (" CONSTRUCTORS\n");
2511 print_statement_list (constructor_list.head, os);
2512 }
2513 break;
2514 case lang_wild_statement_enum:
2515 print_wild_statement (&s->wild_statement, os);
2516 break;
2517 case lang_address_statement_enum:
2518 print_address_statement (&s->address_statement);
2519 break;
2520 case lang_object_symbols_statement_enum:
2521 minfo (" CREATE_OBJECT_SYMBOLS\n");
2522 break;
2523 case lang_fill_statement_enum:
2524 print_fill_statement (&s->fill_statement);
2525 break;
2526 case lang_data_statement_enum:
2527 print_data_statement (&s->data_statement);
2528 break;
2529 case lang_reloc_statement_enum:
2530 print_reloc_statement (&s->reloc_statement);
2531 break;
2532 case lang_input_section_enum:
2533 print_input_section (&s->input_section);
2534 break;
2535 case lang_padding_statement_enum:
2536 print_padding_statement (&s->padding_statement);
2537 break;
2538 case lang_output_section_statement_enum:
2539 print_output_section_statement (&s->output_section_statement);
2540 break;
2541 case lang_assignment_statement_enum:
2542 print_assignment (&s->assignment_statement, os);
2543 break;
2544 case lang_target_statement_enum:
2545 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2546 break;
2547 case lang_output_statement_enum:
2548 minfo ("OUTPUT(%s", s->output_statement.name);
2549 if (output_target != NULL)
2550 minfo (" %s", output_target);
2551 minfo (")\n");
2552 break;
2553 case lang_input_statement_enum:
2554 print_input_statement (&s->input_statement);
2555 break;
2556 case lang_group_statement_enum:
2557 print_group (&s->group_statement, os);
2558 break;
2559 case lang_afile_asection_pair_statement_enum:
2560 FAIL ();
2561 break;
2562 }
2563}
2564
2565static void
2566print_statements ()
2567{
2568 print_statement_list (statement_list.head, abs_output_section);
2569}
2570
2571/* Print the first N statements in statement list S to STDERR.
2572 If N == 0, nothing is printed.
2573 If N < 0, the entire list is printed.
2574 Intended to be called from GDB. */
2575
2576void
2577dprint_statement (s, n)
08da4cac 2578 lang_statement_union_type *s;
252b5132
RH		 2579 int n;
2580{
2581 FILE *map_save = config.map_file;
2582
2583 config.map_file = stderr;
2584
2585 if (n < 0)
2586 print_statement_list (s, abs_output_section);
2587 else
2588 {
2589 while (s && --n >= 0)
2590 {
2591 print_statement (s, abs_output_section);
2592 s = s->next;
2593 }
2594 }
2595
2596 config.map_file = map_save;
2597}
2598
2599static bfd_vma
2600insert_pad (this_ptr, fill, power, output_section_statement, dot)
08da4cac 2601 lang_statement_union_type **this_ptr;
252b5132
RH		 2602 fill_type fill;
2603 unsigned int power;
08da4cac 2604 asection *output_section_statement;
252b5132
RH		 2605 bfd_vma dot;
2606{
2607 /* Align this section first to the
2608 input sections requirement, then
2609 to the output section's requirement.
2610 If this alignment is > than any seen before,
2611 then record it too. Perform the alignment by
08da4cac 2612 inserting a magic 'padding' statement. */
252b5132 2613
5f992e62
AM		 2614 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2615 ldfile_output_machine);
252b5132
RH		 2616 unsigned int alignment_needed = align_power (dot, power) - dot;
2617
2618 if (alignment_needed != 0)
2619 {
2620 lang_statement_union_type *new =
2621 ((lang_statement_union_type *)
2622 stat_alloc (sizeof (lang_padding_statement_type)));
2623
08da4cac 2624 /* Link into existing chain. */
252b5132
RH		 2625 new->header.next = *this_ptr;
2626 *this_ptr = new;
2627 new->header.type = lang_padding_statement_enum;
2628 new->padding_statement.output_section = output_section_statement;
2629 new->padding_statement.output_offset =
2630 dot - output_section_statement->vma;
2631 new->padding_statement.fill = fill;
4cbfc3ac 2632 new->padding_statement.size = alignment_needed * opb;
252b5132
RH		 2633 }
2634
08da4cac 2635 /* Remember the most restrictive alignment. */
252b5132
RH		 2636 if (power > output_section_statement->alignment_power)
2637 {
2638 output_section_statement->alignment_power = power;
2639 }
4cbfc3ac 2640 output_section_statement->_raw_size += alignment_needed * opb;
252b5132 2641
4cbfc3ac 2642 return dot + alignment_needed;
252b5132
RH		 2643}
2644
08da4cac
KH		 2645/* Work out how much this section will move the dot point. */
2646
252b5132
RH		 2647static bfd_vma
2648size_input_section (this_ptr, output_section_statement, fill, dot, relax)
08da4cac
KH		 2649 lang_statement_union_type **this_ptr;
2650 lang_output_section_statement_type *output_section_statement;
252b5132
RH		 2651 fill_type fill;
2652 bfd_vma dot;
87f2a346 2653 boolean relax ATTRIBUTE_UNUSED;
252b5132
RH		 2654{
2655 lang_input_section_type *is = &((*this_ptr)->input_section);
2656 asection *i = is->section;
5f992e62
AM		 2657 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2658 ldfile_output_machine);
252b5132
RH		 2659
2660 if (is->ifile->just_syms_flag == false)
2661 {
2662 if (output_section_statement->subsection_alignment != -1)
2663 i->alignment_power =
2664 output_section_statement->subsection_alignment;
2665
2666 dot = insert_pad (this_ptr, fill, i->alignment_power,
2667 output_section_statement->bfd_section, dot);
2668
08da4cac 2669 /* Remember where in the output section this input section goes. */
252b5132
RH		 2670
2671 i->output_offset = dot - output_section_statement->bfd_section->vma;
2672
08da4cac 2673 /* Mark how big the output section must be to contain this now. */
252b5132 2674 if (i->_cooked_size != 0)
4cbfc3ac 2675 dot += i->_cooked_size / opb;
252b5132 2676 else
4cbfc3ac 2677 dot += i->_raw_size / opb;
5f992e62 2678 output_section_statement->bfd_section->_raw_size =
08da4cac 2679 (dot - output_section_statement->bfd_section->vma) * opb;
252b5132
RH		 2680 }
2681 else
2682 {
2683 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2684 }
2685
2686 return dot;
2687}
2688
33275c22 2689#define IGNORE_SECTION(bfd, s) \
50e05050 2690 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) != (SEC_ALLOC | SEC_LOAD)) \
33275c22 2691 || bfd_section_size (bfd, s) == 0)
252b5132
RH		 2692/* Check to see if any allocated sections overlap with other allocated
2693 sections. This can happen when the linker script specifically specifies
2694 the output section addresses of the two sections. */
08da4cac 2695
252b5132
RH		 2696static void
2697lang_check_section_addresses ()
2698{
08da4cac 2699 asection *s;
f6af82bd 2700 unsigned opb = bfd_octets_per_byte (output_bfd);
252b5132 2701
a2b64bed 2702
252b5132
RH		 2703 /* Scan all sections in the output list. */
2704 for (s = output_bfd->sections; s != NULL; s = s->next)
33275c22 2705 {
08da4cac 2706 asection *os;
5f992e62 2707
33275c22
NC		 2708 /* Ignore sections which are not loaded or which have no contents. */
2709 if (IGNORE_SECTION (output_bfd, s))
2710 continue;
5f992e62 2711
33275c22
NC		 2712 /* Once we reach section 's' stop our seach. This prevents two
2713 warning messages from being produced, one for 'section A overlaps
2714 section B' and one for 'section B overlaps section A'. */
2715 for (os = output_bfd->sections; os != s; os = os->next)
2716 {
2717 bfd_vma s_start;
2718 bfd_vma s_end;
2719 bfd_vma os_start;
2720 bfd_vma os_end;
5f992e62 2721
33275c22
NC		 2722 /* Only consider loadable sections with real contents. */
2723 if (IGNORE_SECTION (output_bfd, os))
2724 continue;
252b5132 2725
33275c22
NC		 2726 /* We must check the sections' LMA addresses not their
2727 VMA addresses because overlay sections can have
2728 overlapping VMAs but they must have distinct LMAs. */
2729 s_start = bfd_section_lma (output_bfd, s);
2730 os_start = bfd_section_lma (output_bfd, os);
9e4ed18c
TW		 2731 s_end = s_start + bfd_section_size (output_bfd, s) / opb - 1;
2732 os_end = os_start + bfd_section_size (output_bfd, os) / opb - 1;
5f992e62 2733
33275c22
NC		 2734 /* Look for an overlap. */
2735 if ((s_end < os_start) || (s_start > os_end))
2736 continue;
5f992e62 2737
33275c22 2738 einfo (
252b5132 2739_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
33275c22 2740 s->name, s_start, s_end, os->name, os_start, os_end);
5f992e62 2741
33275c22
NC		 2742 /* Once we have found one overlap for this section,
2743 stop looking for others. */
2744 break;
2745 }
2746 }
252b5132
RH		 2747}
2748
2749/* This variable indicates whether bfd_relax_section should be called
2750 again. */
2751
2752static boolean relax_again;
2753
562d3460
TW		 2754/* Make sure the new address is within the region. We explicitly permit the
2755 current address to be at the exact end of the region when the address is
2756 non-zero, in case the region is at the end of addressable memory and the
5f992e62 2757 calculation wraps around. */
562d3460
TW		 2758
2759static void
2760os_region_check (os, region, tree, base)
08da4cac
KH		 2761 lang_output_section_statement_type *os;
2762 struct memory_region_struct *region;
2763 etree_type *tree;
2764 bfd_vma base;
562d3460
TW		 2765{
2766 if ((region->current < region->origin
2767 || (region->current - region->origin > region->length))
2768 && ((region->current != region->origin + region->length)
2769 || base == 0))
2770 {
2771 if (tree != (etree_type *) NULL)
2772 {
2773 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2774 region->current,
2775 os->bfd_section->owner,
2776 os->bfd_section->name,
2777 region->name);
2778 }
2779 else
2780 {
2781 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2782 region->name,
2783 os->bfd_section->owner,
2784 os->bfd_section->name);
2785 }
2786 /* Reset the region pointer. */
2787 region->current = region->origin;
2788 }
2789}
2790
252b5132
RH		 2791/* Set the sizes for all the output sections. */
2792
2793bfd_vma
2794lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
08da4cac
KH		 2795 lang_statement_union_type *s;
2796 lang_output_section_statement_type *output_section_statement;
2797 lang_statement_union_type **prev;
252b5132
RH		 2798 fill_type fill;
2799 bfd_vma dot;
2800 boolean relax;
2801{
5f992e62 2802 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
f6af82bd 2803 ldfile_output_machine);
4cbfc3ac 2804
252b5132
RH		 2805 /* Size up the sections from their constituent parts. */
2806 for (; s != (lang_statement_union_type *) NULL; s = s->next)
2807 {
2808 switch (s->header.type)
2809 {
2810 case lang_output_section_statement_enum:
2811 {
2812 bfd_vma after;
2813 lang_output_section_statement_type *os = &s->output_section_statement;
2814
2815 if (os->bfd_section == NULL)
2816 /* This section was never actually created. */
2817 break;
2818
2819 /* If this is a COFF shared library section, use the size and
2820 address from the input section. FIXME: This is COFF
2821 specific; it would be cleaner if there were some other way
2822 to do this, but nothing simple comes to mind. */
2823 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2824 {
08da4cac 2825 asection *input;
252b5132
RH		 2826
2827 if (os->children.head == NULL
2828 || os->children.head->next != NULL
2829 || os->children.head->header.type != lang_input_section_enum)
2830 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2831 os->name);
2832
2833 input = os->children.head->input_section.section;
2834 bfd_set_section_vma (os->bfd_section->owner,
2835 os->bfd_section,
2836 bfd_section_vma (input->owner, input));
2837 os->bfd_section->_raw_size = input->_raw_size;
2838 break;
2839 }
2840
2841 if (bfd_is_abs_section (os->bfd_section))
2842 {
2843 /* No matter what happens, an abs section starts at zero. */
2844 ASSERT (os->bfd_section->vma == 0);
2845 }
2846 else
2847 {
2848 if (os->addr_tree == (etree_type *) NULL)
2849 {
2850 /* No address specified for this section, get one
2851 from the region specification. */
2852 if (os->region == (lang_memory_region_type *) NULL
2853 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2854 & (SEC_ALLOC | SEC_LOAD)) != 0)
2855 && os->region->name[0] == '*'
2856 && strcmp (os->region->name, "*default*") == 0))
2857 {
2858 os->region = lang_memory_default (os->bfd_section);
2859 }
2860
2861 /* If a loadable section is using the default memory
2862 region, and some non default memory regions were
2863 defined, issue a warning. */
2864 if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2865 & (SEC_ALLOC | SEC_LOAD)) != 0
2866 && ! link_info.relocateable
2867 && strcmp (os->region->name, "*default*") == 0
2868 && lang_memory_region_list != NULL
2869 && (strcmp (lang_memory_region_list->name, "*default*") != 0
2870 || lang_memory_region_list->next != NULL))
2871 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
2872 bfd_get_section_name (output_bfd, os->bfd_section));
2873
2874 dot = os->region->current;
5f992e62 2875
252b5132
RH		 2876 if (os->section_alignment == -1)
2877 {
2878 bfd_vma olddot;
2879
2880 olddot = dot;
2881 dot = align_power (dot, os->bfd_section->alignment_power);
2882
2883 if (dot != olddot && config.warn_section_align)
2884 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2885 os->name, (unsigned int) (dot - olddot));
2886 }
2887 }
2888 else
2889 {
2890 etree_value_type r;
2891
2892 r = exp_fold_tree (os->addr_tree,
2893 abs_output_section,
2894 lang_allocating_phase_enum,
2895 dot, &dot);
2896 if (r.valid_p == false)
2897 {
2898 einfo (_("%F%S: non constant address expression for section %s\n"),
2899 os->name);
2900 }
2901 dot = r.value + r.section->bfd_section->vma;
2902 }
5f992e62 2903
252b5132
RH		 2904 /* The section starts here.
2905 First, align to what the section needs. */
2906
2907 if (os->section_alignment != -1)
2908 dot = align_power (dot, os->section_alignment);
2909
2910 bfd_set_section_vma (0, os->bfd_section, dot);
5f992e62 2911
252b5132
RH		 2912 os->bfd_section->output_offset = 0;
2913 }
2914
08da4cac
KH		 2915 (void) lang_size_sections (os->children.head, os,
2916 &os->children.head,
252b5132 2917 os->fill, dot, relax);
5f992e62 2918
08da4cac
KH		 2919 /* Put the section within the requested block size, or
2920 align at the block boundary. */
32edc927
TW		 2921 after = ALIGN_N (os->bfd_section->vma
2922 + os->bfd_section->_raw_size / opb,
252b5132
RH		 2923 /* The coercion here is important, see ld.h. */
2924 (bfd_vma) os->block_value);
2925
2926 if (bfd_is_abs_section (os->bfd_section))
2927 ASSERT (after == os->bfd_section->vma);
2928 else
5f992e62 2929 os->bfd_section->_raw_size =
08da4cac 2930 (after - os->bfd_section->vma) * opb;
4cbfc3ac 2931 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
252b5132
RH		 2932 os->processed = true;
2933
2934 /* Update dot in the region ?
2935 We only do this if the section is going to be allocated,
2936 since unallocated sections do not contribute to the region's
13392b77 2937 overall size in memory.
5f992e62 2938
cce4c4c5
NC		 2939 If the SEC_NEVER_LOAD bit is not set, it will affect the
2940 addresses of sections after it. We have to update
2941 dot. */
252b5132 2942 if (os->region != (lang_memory_region_type *) NULL
cce4c4c5
NC		 2943 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
2944 & SEC_NEVER_LOAD) == 0
2945 || (bfd_get_section_flags (output_bfd, os->bfd_section)
2946 & (SEC_ALLOC | SEC_LOAD))))
252b5132
RH		 2947 {
2948 os->region->current = dot;
5f992e62 2949
562d3460 2950 /* Make sure the new address is within the region. */
08da4cac
KH		 2951 os_region_check (os, os->region, os->addr_tree,
2952 os->bfd_section->vma);
2953
2954 /* If there's no load address specified, use the run
2955 region as the load region. */
2956 if (os->lma_region == NULL && os->load_base == NULL)
2957 os->lma_region = os->region;
2958
2959 if (os->lma_region != NULL)
2960 {
2961 if (os->load_base != NULL)
2962 {
2963 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
2964 }
2965 else
2966 {
2967 /* Don't allocate twice. */
2968 if (os->lma_region != os->region)
2969 {
2970 /* Set load_base, which will be handled later. */
2971 os->load_base =
2972 exp_intop (os->lma_region->current);
2973 os->lma_region->current +=
2974 os->bfd_section->_raw_size / opb;
2975 os_region_check (os, os->lma_region, NULL,
2976 os->bfd_section->lma);
2977 }
2978 }
2979 }
252b5132
RH		 2980 }
2981 }
2982 break;
2983
2984 case lang_constructors_statement_enum:
2985 dot = lang_size_sections (constructor_list.head,
2986 output_section_statement,
2987 &s->wild_statement.children.head,
2988 fill,
2989 dot, relax);
2990 break;
2991
2992 case lang_data_statement_enum:
2993 {
2994 unsigned int size = 0;
2995
08da4cac
KH		 2996 s->data_statement.output_vma =
2997 dot - output_section_statement->bfd_section->vma;
252b5132
RH		 2998 s->data_statement.output_section =
2999 output_section_statement->bfd_section;
3000
3001 switch (s->data_statement.type)
3002 {
08da4cac
KH		 3003 default:
3004 abort ();
252b5132
RH		 3005 case QUAD:
3006 case SQUAD:
3007 size = QUAD_SIZE;
3008 break;
3009 case LONG:
3010 size = LONG_SIZE;
3011 break;
3012 case SHORT:
3013 size = SHORT_SIZE;
3014 break;
3015 case BYTE:
3016 size = BYTE_SIZE;
3017 break;
3018 }
08da4cac
KH		 3019 if (size < opb)
3020 size = opb;
4cbfc3ac 3021 dot += size / opb;
252b5132
RH		 3022 output_section_statement->bfd_section->_raw_size += size;
3023 /* The output section gets contents, and then we inspect for
3024 any flags set in the input script which override any ALLOC. */
3025 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
08da4cac
KH		 3026 if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3027 {
3028 output_section_statement->bfd_section->flags |=
3029 SEC_ALLOC | SEC_LOAD;
3030 }
252b5132
RH		 3031 }
3032 break;
3033
3034 case lang_reloc_statement_enum:
3035 {
3036 int size;
3037
3038 s->reloc_statement.output_vma =
3039 dot - output_section_statement->bfd_section->vma;
3040 s->reloc_statement.output_section =
3041 output_section_statement->bfd_section;
3042 size = bfd_get_reloc_size (s->reloc_statement.howto);
4cbfc3ac 3043 dot += size / opb;
252b5132
RH		 3044 output_section_statement->bfd_section->_raw_size += size;
3045 }
3046 break;
5f992e62 3047
252b5132
RH		 3048 case lang_wild_statement_enum:
3049
3050 dot = lang_size_sections (s->wild_statement.children.head,
3051 output_section_statement,
3052 &s->wild_statement.children.head,
252b5132
RH		 3053 fill, dot, relax);
3054
3055 break;
3056
3057 case lang_object_symbols_statement_enum:
3058 link_info.create_object_symbols_section =
3059 output_section_statement->bfd_section;
3060 break;
3061 case lang_output_statement_enum:
3062 case lang_target_statement_enum:
3063 break;
3064 case lang_input_section_enum:
3065 {
3066 asection *i;
3067
3068 i = (*prev)->input_section.section;
3069 if (! relax)
3070 {
3071 if (i->_cooked_size == 0)
3072 i->_cooked_size = i->_raw_size;
3073 }
3074 else
3075 {
3076 boolean again;
3077
3078 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3079 einfo (_("%P%F: can't relax section: %E\n"));
3080 if (again)
3081 relax_again = true;
3082 }
3083 dot = size_input_section (prev,
3084 output_section_statement,
3085 output_section_statement->fill,
3086 dot, relax);
3087 }
3088 break;
3089 case lang_input_statement_enum:
3090 break;
3091 case lang_fill_statement_enum:
08da4cac
KH		 3092 s->fill_statement.output_section =
3093 output_section_statement->bfd_section;
252b5132
RH		 3094
3095 fill = s->fill_statement.fill;
3096 break;
3097 case lang_assignment_statement_enum:
3098 {
3099 bfd_vma newdot = dot;
3100
3101 exp_fold_tree (s->assignment_statement.exp,
3102 output_section_statement,
3103 lang_allocating_phase_enum,
3104 dot,
3105 &newdot);
3106
3107 if (newdot != dot)
3108 {
3109 /* The assignment changed dot. Insert a pad. */
3110 if (output_section_statement == abs_output_section)
3111 {
3112 /* If we don't have an output section, then just adjust
3113 the default memory address. */
3114 lang_memory_region_lookup ("*default*")->current = newdot;
3115 }
3116 else if (!relax)
3117 {
3118 lang_statement_union_type *new =
3119 ((lang_statement_union_type *)
3120 stat_alloc (sizeof (lang_padding_statement_type)));
3121
3122 /* Link into existing chain. */
3123 new->header.next = *prev;
3124 *prev = new;
3125 new->header.type = lang_padding_statement_enum;
3126 new->padding_statement.output_section =
3127 output_section_statement->bfd_section;
3128 new->padding_statement.output_offset =
3129 dot - output_section_statement->bfd_section->vma;
3130 new->padding_statement.fill = fill;
4cbfc3ac 3131 new->padding_statement.size = (newdot - dot) * opb;
252b5132
RH		 3132 output_section_statement->bfd_section->_raw_size +=
3133 new->padding_statement.size;
3134 }
3135
3136 dot = newdot;
3137 }
3138 }
3139 break;
3140
3141 case lang_padding_statement_enum:
3142 /* If we are relaxing, and this is not the first pass, some
3143 padding statements may have been inserted during previous
3144 passes. We may have to move the padding statement to a new
3145 location if dot has a different value at this point in this
3146 pass than it did at this point in the previous pass. */
3147 s->padding_statement.output_offset =
3148 dot - output_section_statement->bfd_section->vma;
4cbfc3ac 3149 dot += s->padding_statement.size / opb;
252b5132
RH		 3150 output_section_statement->bfd_section->_raw_size +=
3151 s->padding_statement.size;
3152 break;
3153
3154 case lang_group_statement_enum:
3155 dot = lang_size_sections (s->group_statement.children.head,
3156 output_section_statement,
3157 &s->group_statement.children.head,
3158 fill, dot, relax);
3159 break;
3160
3161 default:
3162 FAIL ();
3163 break;
3164
3165 /* This can only get here when relaxing is turned on. */
3166
3167 case lang_address_statement_enum:
3168 break;
3169 }
3170 prev = &s->header.next;
3171 }
3172 return dot;
3173}
3174
3175bfd_vma
3176lang_do_assignments (s, output_section_statement, fill, dot)
08da4cac
KH		 3177 lang_statement_union_type *s;
3178 lang_output_section_statement_type *output_section_statement;
252b5132
RH		 3179 fill_type fill;
3180 bfd_vma dot;
3181{
5f992e62
AM		 3182 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3183 ldfile_output_machine);
4cbfc3ac 3184
252b5132
RH		 3185 for (; s != (lang_statement_union_type *) NULL; s = s->next)
3186 {
3187 switch (s->header.type)
3188 {
3189 case lang_constructors_statement_enum:
3190 dot = lang_do_assignments (constructor_list.head,
3191 output_section_statement,
3192 fill,
3193 dot);
3194 break;
3195
3196 case lang_output_section_statement_enum:
3197 {
3198 lang_output_section_statement_type *os =
3199 &(s->output_section_statement);
3200
3201 if (os->bfd_section != NULL)
3202 {
3203 dot = os->bfd_section->vma;
3204 (void) lang_do_assignments (os->children.head, os,
3205 os->fill, dot);
4cbfc3ac
TW		 3206 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3207
252b5132 3208 }
c13b1b77 3209 if (os->load_base)
252b5132
RH		 3210 {
3211 /* If nothing has been placed into the output section then
4de2d33d 3212 it won't have a bfd_section. */
5f992e62 3213 if (os->bfd_section)
252b5132 3214 {
5f992e62 3215 os->bfd_section->lma
08da4cac
KH		 3216 = exp_get_abs_int (os->load_base, 0, "load base",
3217 lang_final_phase_enum);
252b5132
RH		 3218 }
3219 }
3220 }
3221 break;
3222 case lang_wild_statement_enum:
3223
3224 dot = lang_do_assignments (s->wild_statement.children.head,
3225 output_section_statement,
3226 fill, dot);
3227
3228 break;
3229
3230 case lang_object_symbols_statement_enum:
3231 case lang_output_statement_enum:
3232 case lang_target_statement_enum:
3233#if 0
3234 case lang_common_statement_enum:
3235#endif
3236 break;
3237 case lang_data_statement_enum:
3238 {
3239 etree_value_type value;
3240
3241 value = exp_fold_tree (s->data_statement.exp,
3242 abs_output_section,
3243 lang_final_phase_enum, dot, &dot);
3244 s->data_statement.value = value.value;
3245 if (value.valid_p == false)
3246 einfo (_("%F%P: invalid data statement\n"));
3247 }
4cbfc3ac 3248 {
f6af82bd 3249 unsigned int size;
08da4cac
KH		 3250 switch (s->data_statement.type)
3251 {
3252 default:
3253 abort ();
3254 case QUAD:
3255 case SQUAD:
3256 size = QUAD_SIZE;
3257 break;
3258 case LONG:
3259 size = LONG_SIZE;
3260 break;
3261 case SHORT:
3262 size = SHORT_SIZE;
3263 break;
3264 case BYTE:
3265 size = BYTE_SIZE;
3266 break;
3267 }
3268 if (size < opb)
3269 size = opb;
3270 dot += size / opb;
3271 }
252b5132
RH		 3272 break;
3273
3274 case lang_reloc_statement_enum:
3275 {
3276 etree_value_type value;
3277
3278 value = exp_fold_tree (s->reloc_statement.addend_exp,
3279 abs_output_section,
3280 lang_final_phase_enum, dot, &dot);
3281 s->reloc_statement.addend_value = value.value;
3282 if (value.valid_p == false)
3283 einfo (_("%F%P: invalid reloc statement\n"));
3284 }
4cbfc3ac 3285 dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
252b5132
RH		 3286 break;
3287
3288 case lang_input_section_enum:
3289 {
3290 asection *in = s->input_section.section;
3291
3292 if (in->_cooked_size != 0)
4cbfc3ac 3293 dot += in->_cooked_size / opb;
252b5132 3294 else
4cbfc3ac 3295 dot += in->_raw_size / opb;
252b5132
RH		 3296 }
3297 break;
3298
3299 case lang_input_statement_enum:
3300 break;
3301 case lang_fill_statement_enum:
3302 fill = s->fill_statement.fill;
3303 break;
3304 case lang_assignment_statement_enum:
3305 {
3306 exp_fold_tree (s->assignment_statement.exp,
3307 output_section_statement,
3308 lang_final_phase_enum,
3309 dot,
3310 &dot);
3311 }
3312
3313 break;
3314 case lang_padding_statement_enum:
4cbfc3ac 3315 dot += s->padding_statement.size / opb;
252b5132
RH		 3316 break;
3317
3318 case lang_group_statement_enum:
3319 dot = lang_do_assignments (s->group_statement.children.head,
3320 output_section_statement,
3321 fill, dot);
3322
3323 break;
3324
3325 default:
3326 FAIL ();
3327 break;
3328 case lang_address_statement_enum:
3329 break;
3330 }
3331
3332 }
3333 return dot;
3334}
3335
3336/* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3337 operator .startof. (section_name), it produces an undefined symbol
3338 .startof.section_name. Similarly, when it sees
3339 .sizeof. (section_name), it produces an undefined symbol
3340 .sizeof.section_name. For all the output sections, we look for
3341 such symbols, and set them to the correct value. */
3342
3343static void
3344lang_set_startof ()
3345{
3346 asection *s;
3347
3348 if (link_info.relocateable)
3349 return;
3350
3351 for (s = output_bfd->sections; s != NULL; s = s->next)
3352 {
3353 const char *secname;
3354 char *buf;
3355 struct bfd_link_hash_entry *h;
3356
3357 secname = bfd_get_section_name (output_bfd, s);
3358 buf = xmalloc (10 + strlen (secname));
3359
3360 sprintf (buf, ".startof.%s", secname);
3361 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3362 if (h != NULL && h->type == bfd_link_hash_undefined)
3363 {
3364 h->type = bfd_link_hash_defined;
3365 h->u.def.value = bfd_get_section_vma (output_bfd, s);
3366 h->u.def.section = bfd_abs_section_ptr;
3367 }
3368
3369 sprintf (buf, ".sizeof.%s", secname);
3370 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3371 if (h != NULL && h->type == bfd_link_hash_undefined)
3372 {
5f992e62 3373 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
f6af82bd 3374 ldfile_output_machine);
252b5132
RH		 3375 h->type = bfd_link_hash_defined;
3376 if (s->_cooked_size != 0)
4cbfc3ac 3377 h->u.def.value = s->_cooked_size / opb;
252b5132 3378 else
4cbfc3ac 3379 h->u.def.value = s->_raw_size / opb;
252b5132
RH		 3380 h->u.def.section = bfd_abs_section_ptr;
3381 }
3382
3383 free (buf);
3384 }
3385}
3386
3387static void
3388lang_finish ()
3389{
3390 struct bfd_link_hash_entry *h;
3391 boolean warn;
3392
3393 if (link_info.relocateable || link_info.shared)
3394 warn = false;
3395 else
3396 warn = true;
3397
3398 if (entry_symbol == (char *) NULL)
3399 {
3400 /* No entry has been specified. Look for start, but don't warn
3401 if we don't find it. */
3402 entry_symbol = "start";
3403 warn = false;
3404 }
3405
3406 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
3407 if (h != (struct bfd_link_hash_entry *) NULL
3408 && (h->type == bfd_link_hash_defined
3409 || h->type == bfd_link_hash_defweak)
3410 && h->u.def.section->output_section != NULL)
3411 {
3412 bfd_vma val;
3413
3414 val = (h->u.def.value
3415 + bfd_get_section_vma (output_bfd,
3416 h->u.def.section->output_section)
3417 + h->u.def.section->output_offset);
3418 if (! bfd_set_start_address (output_bfd, val))
3419 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
3420 }
3421 else
3422 {
3423 bfd_vma val;
5f992e62 3424 const char *send;
252b5132
RH		 3425
3426 /* We couldn't find the entry symbol. Try parsing it as a
3427 number. */
3428 val = bfd_scan_vma (entry_symbol, &send, 0);
3429 if (*send == '\0')
3430 {
3431 if (! bfd_set_start_address (output_bfd, val))
3432 einfo (_("%P%F: can't set start address\n"));
3433 }
3434 else
3435 {
3436 asection *ts;
3437
3438 /* Can't find the entry symbol, and it's not a number. Use
3439 the first address in the text section. */
3440 ts = bfd_get_section_by_name (output_bfd, ".text");
3441 if (ts != (asection *) NULL)
3442 {
3443 if (warn)
3444 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3445 entry_symbol, bfd_get_section_vma (output_bfd, ts));
3446 if (! bfd_set_start_address (output_bfd,
3447 bfd_get_section_vma (output_bfd,
3448 ts)))
3449 einfo (_("%P%F: can't set start address\n"));
3450 }
3451 else
3452 {
3453 if (warn)
3454 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3455 entry_symbol);
3456 }
3457 }
3458 }
3459}
3460
1276aefa
NC		 3461
3462/* This is the routine to handle BFD error messages. */
3463
3464#ifdef ANSI_PROTOTYPES
3465
3466static void
3467record_bfd_errors (const char *s, ...)
3468{
3469 va_list p;
3470
3471 einfo ("%P: ");
3472
3473 va_start (p, s);
3474
3475 vfprintf (stderr, s, p);
3476
3477 va_end (p);
3478
3479 fprintf (stderr, "\n");
3480
3481 einfo ("%X");
3482}
3483
3484#else /* ! defined (ANSI_PROTOTYPES) */
3485
3486static void
3487record_bfd_errors (va_alist)
3488 va_dcl
3489{
3490 va_list p;
3491 const char *s;
3492
3493 einfo ("%P: ");
3494
3495 va_start (p);
3496
3497 s = va_arg (p, const char *);
3498 vfprintf (stderr, s, p);
3499
3500 va_end (p);
3501
3502 fprintf (stderr, "\n");
3503
3504 einfo ("%X");
3505}
3506
3507#endif /* ! defined (ANSI_PROTOTYPES) */
252b5132
RH		 3508/* This is a small function used when we want to ignore errors from
3509 BFD. */
3510
3511static void
3512#ifdef ANSI_PROTOTYPES
87f2a346 3513ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
252b5132
RH		 3514#else
3515ignore_bfd_errors (s)
87f2a346 3516 const char *s ATTRIBUTE_UNUSED;
252b5132
RH		 3517#endif
3518{
3519 /* Don't do anything. */
3520}
3521
3522/* Check that the architecture of all the input files is compatible
3523 with the output file. Also call the backend to let it do any
3524 other checking that is needed. */
3525
3526static void
3527lang_check ()
3528{
3529 lang_statement_union_type *file;
3530 bfd *input_bfd;
5f992e62 3531 const bfd_arch_info_type *compatible;
252b5132
RH		 3532
3533 for (file = file_chain.head;
3534 file != (lang_statement_union_type *) NULL;
3535 file = file->input_statement.next)
3536 {
3537 input_bfd = file->input_statement.the_bfd;
3538 compatible = bfd_arch_get_compatible (input_bfd,
3539 output_bfd);
3540 if (compatible == NULL)
3541 {
3542 if (command_line.warn_mismatch)
3543 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3544 bfd_printable_name (input_bfd), input_bfd,
3545 bfd_printable_name (output_bfd));
3546 }
b9247304 3547 else if (bfd_count_sections (input_bfd))
252b5132 3548 {
b9247304
L		 3549 /* If the input bfd has no contents, it shouldn't set the
3550 private data of the output bfd. */
3551
252b5132
RH		 3552 bfd_error_handler_type pfn = NULL;
3553
3554 /* If we aren't supposed to warn about mismatched input
3555 files, temporarily set the BFD error handler to a
3556 function which will do nothing. We still want to call
3557 bfd_merge_private_bfd_data, since it may set up
3558 information which is needed in the output file. */
3559 if (! command_line.warn_mismatch)
3560 pfn = bfd_set_error_handler (ignore_bfd_errors);
3561 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3562 {
3563 if (command_line.warn_mismatch)
3564 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3565 input_bfd);
3566 }
3567 if (! command_line.warn_mismatch)
3568 bfd_set_error_handler (pfn);
3569 }
3570 }
3571}
3572
3573/* Look through all the global common symbols and attach them to the
3574 correct section. The -sort-common command line switch may be used
3575 to roughly sort the entries by size. */
3576
3577static void
3578lang_common ()
3579{
3580 if (link_info.relocateable
3581 && ! command_line.force_common_definition)
3582 return;
3583
3584 if (! config.sort_common)
3585 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3586 else
3587 {
3588 int power;
3589
3590 for (power = 4; power >= 0; power--)
3591 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3592 (PTR) &power);
3593 }
3594}
3595
3596/* Place one common symbol in the correct section. */
3597
3598static boolean
3599lang_one_common (h, info)
3600 struct bfd_link_hash_entry *h;
3601 PTR info;
3602{
3603 unsigned int power_of_two;
3604 bfd_vma size;
3605 asection *section;
5f992e62
AM		 3606 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3607 ldfile_output_machine);
252b5132
RH		 3608
3609 if (h->type != bfd_link_hash_common)
3610 return true;
3611
3612 size = h->u.c.size;
3613 power_of_two = h->u.c.p->alignment_power;
3614
3615 if (config.sort_common
3616 && power_of_two < (unsigned int) *(int *) info)
3617 return true;
3618
3619 section = h->u.c.p->section;
3620
3621 /* Increase the size of the section. */
4cbfc3ac
TW		 3622 section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb,
3623 (bfd_size_type) (1 << power_of_two)) * opb;
252b5132
RH		 3624
3625 /* Adjust the alignment if necessary. */
3626 if (power_of_two > section->alignment_power)
3627 section->alignment_power = power_of_two;
3628
3629 /* Change the symbol from common to defined. */
3630 h->type = bfd_link_hash_defined;
3631 h->u.def.section = section;
3632 h->u.def.value = section->_cooked_size;
3633
3634 /* Increase the size of the section. */
3635 section->_cooked_size += size;
3636
3637 /* Make sure the section is allocated in memory, and make sure that
3638 it is no longer a common section. */
3639 section->flags |= SEC_ALLOC;
08da4cac 3640 section->flags &= ~SEC_IS_COMMON;
252b5132
RH		 3641
3642 if (config.map_file != NULL)
3643 {
3644 static boolean header_printed;
3645 int len;
3646 char *name;
3647 char buf[50];
3648
3649 if (! header_printed)
3650 {
3651 minfo (_("\nAllocating common symbols\n"));
3652 minfo (_("Common symbol size file\n\n"));
3653 header_printed = true;
3654 }
3655
3656 name = demangle (h->root.string);
3657 minfo ("%s", name);
3658 len = strlen (name);
3659 free (name);
3660
3661 if (len >= 19)
3662 {
3663 print_nl ();
3664 len = 0;
3665 }
3666 while (len < 20)
3667 {
3668 print_space ();
3669 ++len;
3670 }
3671
3672 minfo ("0x");
3673 if (size <= 0xffffffff)
3674 sprintf (buf, "%lx", (unsigned long) size);
3675 else
3676 sprintf_vma (buf, size);
3677 minfo ("%s", buf);
3678 len = strlen (buf);
3679
3680 while (len < 16)
3681 {
3682 print_space ();
3683 ++len;
3684 }
3685
3686 minfo ("%B\n", section->owner);
3687 }
3688
3689 return true;
3690}
3691
08da4cac
KH		 3692/* Run through the input files and ensure that every input section has
3693 somewhere to go. If one is found without a destination then create
3694 an input request and place it into the statement tree. */
252b5132
RH		 3695
3696static void
3697lang_place_orphans ()
3698{
e50d8076 3699 LANG_FOR_EACH_INPUT_STATEMENT (file)
252b5132
RH		 3700 {
3701 asection *s;
3702
3703 for (s = file->the_bfd->sections;
3704 s != (asection *) NULL;
3705 s = s->next)
3706 {
3707 if (s->output_section == (asection *) NULL)
3708 {
3709 /* This section of the file is not attatched, root
08da4cac 3710 around for a sensible place for it to go. */
252b5132
RH		 3711
3712 if (file->just_syms_flag)
3713 {
3714 /* We are only retrieving symbol values from this
3715 file. We want the symbols to act as though the
3716 values in the file are absolute. */
3717 s->output_section = bfd_abs_section_ptr;
3718 s->output_offset = s->vma;
3719 }
3720 else if (strcmp (s->name, "COMMON") == 0)
3721 {
3722 /* This is a lonely common section which must have
3723 come from an archive. We attach to the section
3724 with the wildcard. */
3725 if (! link_info.relocateable
3726 || command_line.force_common_definition)
3727 {
3728 if (default_common_section == NULL)
3729 {
3730#if 0
3731 /* This message happens when using the
3732 svr3.ifile linker script, so I have
3733 disabled it. */
3734 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3735#endif
3736 default_common_section =
3737 lang_output_section_statement_lookup (".bss");
3738
3739 }
3740 wild_doit (&default_common_section->children, s,
3741 default_common_section, file);
3742 }
3743 }
3744 else if (ldemul_place_orphan (file, s))
3745 ;
3746 else
3747 {
3748 lang_output_section_statement_type *os =
3749 lang_output_section_statement_lookup (s->name);
3750
3751 wild_doit (&os->children, s, os, file);
3752 }
3753 }
3754 }
3755 }
3756}
3757
252b5132 3758void
aa8804e4 3759lang_set_flags (ptr, flags, invert)
252b5132 3760 lang_memory_region_type *ptr;
5f992e62 3761 const char *flags;
aa8804e4 3762 int invert;
252b5132 3763{
aa8804e4 3764 flagword *ptr_flags;
252b5132 3765
aa8804e4 3766 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
252b5132
RH		 3767 while (*flags)
3768 {
3769 switch (*flags)
3770 {
252b5132
RH		 3771 case 'A': case 'a':
3772 *ptr_flags |= SEC_ALLOC;
3773 break;
3774
3775 case 'R': case 'r':
3776 *ptr_flags |= SEC_READONLY;
3777 break;
3778
3779 case 'W': case 'w':
3780 *ptr_flags |= SEC_DATA;
3781 break;
3782
3783 case 'X': case 'x':
3784 *ptr_flags |= SEC_CODE;
3785 break;
3786
3787 case 'L': case 'l':
3788 case 'I': case 'i':
3789 *ptr_flags |= SEC_LOAD;
3790 break;
3791
3792 default:
3793 einfo (_("%P%F: invalid syntax in flags\n"));
3794 break;
3795 }
3796 flags++;
3797 }
3798}
3799
3800/* Call a function on each input file. This function will be called
3801 on an archive, but not on the elements. */
3802
3803void
3804lang_for_each_input_file (func)
3805 void (*func) PARAMS ((lang_input_statement_type *));
3806{
3807 lang_input_statement_type *f;
3808
3809 for (f = (lang_input_statement_type *) input_file_chain.head;
3810 f != NULL;
3811 f = (lang_input_statement_type *) f->next_real_file)
3812 func (f);
3813}
3814
3815/* Call a function on each file. The function will be called on all
3816 the elements of an archive which are included in the link, but will
3817 not be called on the archive file itself. */
3818
3819void
3820lang_for_each_file (func)
3821 void (*func) PARAMS ((lang_input_statement_type *));
3822{
e50d8076 3823 LANG_FOR_EACH_INPUT_STATEMENT (f)
252b5132
RH		 3824 {
3825 func (f);
3826 }
3827}
3828
3829#if 0
3830
3831/* Not used. */
3832
3833void
3834lang_for_each_input_section (func)
08da4cac 3835 void (*func) PARAMS ((bfd *ab, asection *as));
252b5132 3836{
e50d8076 3837 LANG_FOR_EACH_INPUT_STATEMENT (f)
252b5132 3838 {
08da4cac 3839 asection *s;
252b5132
RH		 3840
3841 for (s = f->the_bfd->sections;
3842 s != (asection *) NULL;
3843 s = s->next)
3844 {
3845 func (f->the_bfd, s);
3846 }
3847 }
3848}
3849
3850#endif
3851
3852void
3853ldlang_add_file (entry)
08da4cac 3854 lang_input_statement_type *entry;
252b5132
RH		 3855{
3856 bfd **pp;
3857
3858 lang_statement_append (&file_chain,
3859 (lang_statement_union_type *) entry,
3860 &entry->next);
3861
3862 /* The BFD linker needs to have a list of all input BFDs involved in
3863 a link. */
3864 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3865 ASSERT (entry->the_bfd != output_bfd);
3866 for (pp = &link_info.input_bfds;
3867 *pp != (bfd *) NULL;
3868 pp = &(*pp)->link_next)
3869 ;
3870 *pp = entry->the_bfd;
3871 entry->the_bfd->usrdata = (PTR) entry;
3872 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3873
3874 /* Look through the sections and check for any which should not be
3875 included in the link. We need to do this now, so that we can
3876 notice when the backend linker tries to report multiple
3877 definition errors for symbols which are in sections we aren't
3878 going to link. FIXME: It might be better to entirely ignore
3879 symbols which are defined in sections which are going to be
3880 discarded. This would require modifying the backend linker for
3881 each backend which might set the SEC_LINK_ONCE flag. If we do
3882 this, we should probably handle SEC_EXCLUDE in the same way. */
3883
3884 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3885}
3886
3887void
3888lang_add_output (name, from_script)
5f992e62 3889 const char *name;
252b5132
RH		 3890 int from_script;
3891{
3892 /* Make -o on command line override OUTPUT in script. */
3893 if (had_output_filename == false || !from_script)
3894 {
3895 output_filename = name;
3896 had_output_filename = true;
3897 }
3898}
3899
252b5132
RH		 3900static lang_output_section_statement_type *current_section;
3901
3902static int
3903topower (x)
3904 int x;
3905{
3906 unsigned int i = 1;
3907 int l;
3908
3909 if (x < 0)
3910 return -1;
3911
5f992e62 3912 for (l = 0; l < 32; l++)
252b5132
RH		 3913 {
3914 if (i >= (unsigned int) x)
3915 return l;
3916 i <<= 1;
3917 }
3918
3919 return 0;
3920}
3921
aea4bd9d 3922lang_output_section_statement_type *
252b5132
RH		 3923lang_enter_output_section_statement (output_section_statement_name,
3924 address_exp, sectype, block_value,
3925 align, subalign, ebase)
3926 const char *output_section_statement_name;
08da4cac 3927 etree_type *address_exp;
252b5132
RH		 3928 enum section_type sectype;
3929 bfd_vma block_value;
3930 etree_type *align;
3931 etree_type *subalign;
3932 etree_type *ebase;
3933{
3934 lang_output_section_statement_type *os;
3935
3936 current_section =
3937 os =
3938 lang_output_section_statement_lookup (output_section_statement_name);
3939
08da4cac
KH		 3940 /* Add this statement to tree. */
3941#if 0
3942 add_statement (lang_output_section_statement_enum,
3943 output_section_statement);
3944#endif
3945 /* Make next things chain into subchain of this. */
252b5132 3946
08da4cac
KH		 3947 if (os->addr_tree == (etree_type *) NULL)
3948 {
3949 os->addr_tree = address_exp;
3950 }
252b5132
RH		 3951 os->sectype = sectype;
3952 if (sectype != noload_section)
3953 os->flags = SEC_NO_FLAGS;
3954 else
3955 os->flags = SEC_NEVER_LOAD;
3956 os->block_value = block_value ? block_value : 1;
3957 stat_ptr = &os->children;
3958
08da4cac
KH		 3959 os->subsection_alignment =
3960 topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
3961 os->section_alignment =
3962 topower (exp_get_value_int (align, -1, "section alignment", 0));
252b5132
RH		 3963
3964 os->load_base = ebase;
aea4bd9d 3965 return os;
252b5132
RH		 3966}
3967
252b5132
RH		 3968void
3969lang_final ()
3970{
3971 lang_output_statement_type *new =
3972 new_stat (lang_output_statement, stat_ptr);
3973
3974 new->name = output_filename;
3975}
3976
08da4cac
KH		 3977/* Reset the current counters in the regions. */
3978
252b5132
RH		 3979static void
3980reset_memory_regions ()
3981{
3982 lang_memory_region_type *p = lang_memory_region_list;
3983
3984 for (p = lang_memory_region_list;
3985 p != (lang_memory_region_type *) NULL;
3986 p = p->next)
3987 {
3988 p->old_length = (bfd_size_type) (p->current - p->origin);
3989 p->current = p->origin;
3990 }
3991}
3992
252b5132
RH		 3993/* Expand a wild statement for a particular FILE, marking its sections KEEP
3994 as needed. SECTION may be NULL, in which case it is a wild card. */
3995
3996static void
4dec4d4e 3997gc_section_callback (ptr, section, file, data)
252b5132 3998 lang_wild_statement_type *ptr;
4dec4d4e 3999 asection *section;
87f2a346 4000 lang_input_statement_type *file ATTRIBUTE_UNUSED;
5f992e62 4001 PTR data ATTRIBUTE_UNUSED;
252b5132 4002{
4dec4d4e
RH		 4003 /* If the wild pattern was marked KEEP, the member sections
4004 should be as well. */
4005 if (ptr->keep_sections)
4006 section->flags |= SEC_KEEP;
252b5132
RH		 4007}
4008
4009/* Handle a wild statement, marking it against GC. SECTION or FILE or both
4010 may be NULL, indicating that it is a wildcard. */
4011
4012static void
4013lang_gc_wild (s, section, file)
4014 lang_wild_statement_type *s;
4015 const char *section;
4016 const char *file;
4017{
4dec4d4e 4018 walk_wild (s, section, file, gc_section_callback, NULL);
252b5132
RH		 4019}
4020
4021/* Iterate over sections marking them against GC. */
4022
4023static void
4024lang_gc_sections_1 (s)
08da4cac 4025 lang_statement_union_type *s;
252b5132
RH		 4026{
4027 for (; s != (lang_statement_union_type *) NULL; s = s->next)
4028 {
4029 switch (s->header.type)
4030 {
4031 case lang_wild_statement_enum:
4032 lang_gc_wild (&s->wild_statement,
4033 s->wild_statement.section_name,
4034 s->wild_statement.filename);
4035 break;
4036 case lang_constructors_statement_enum:
4037 lang_gc_sections_1 (constructor_list.head);
4038 break;
4039 case lang_output_section_statement_enum:
4040 lang_gc_sections_1 (s->output_section_statement.children.head);
4041 break;
4042 case lang_group_statement_enum:
4043 lang_gc_sections_1 (s->group_statement.children.head);
4044 break;
4045 default:
4046 break;
4047 }
4048 }
4049}
4050
4051static void
4052lang_gc_sections ()
4053{
4054 struct bfd_link_hash_entry *h;
4055 ldlang_undef_chain_list_type *ulist, fake_list_start;
4056
4057 /* Keep all sections so marked in the link script. */
4058
4059 lang_gc_sections_1 (statement_list.head);
4060
4061 /* Keep all sections containing symbols undefined on the command-line.
4062 Handle the entry symbol at the same time. */
5f992e62 4063
7c83b342
DE		 4064 if (entry_symbol != NULL)
4065 {
4066 fake_list_start.next = ldlang_undef_chain_list_head;
4067 fake_list_start.name = (char *) entry_symbol;
4068 ulist = &fake_list_start;
4069 }
252b5132 4070 else
7c83b342 4071 ulist = ldlang_undef_chain_list_head;
252b5132 4072
7c83b342 4073 for (; ulist; ulist = ulist->next)
252b5132 4074 {
5f992e62 4075 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
252b5132
RH		 4076 false, false, false);
4077
4078 if (h != (struct bfd_link_hash_entry *) NULL
08da4cac
KH		 4079 && (h->type == bfd_link_hash_defined
4080 || h->type == bfd_link_hash_defweak)
252b5132
RH		 4081 && ! bfd_is_abs_section (h->u.def.section))
4082 {
4083 h->u.def.section->flags |= SEC_KEEP;
4084 }
4085 }
4086
4087 bfd_gc_sections (output_bfd, &link_info);
4088}
4089
4090void
4091lang_process ()
4092{
4093 lang_reasonable_defaults ();
4094 current_target = default_target;
4095
08da4cac
KH		 4096 /* Open the output file. */
4097 lang_for_each_statement (ldlang_open_output);
252b5132
RH		 4098
4099 ldemul_create_output_section_statements ();
4100
08da4cac 4101 /* Add to the hash table all undefineds on the command line. */
252b5132
RH		 4102 lang_place_undefineds ();
4103
9503fd87
ILT		 4104 already_linked_table_init ();
4105
08da4cac 4106 /* Create a bfd for each input file. */
252b5132
RH		 4107 current_target = default_target;
4108 open_input_bfds (statement_list.head, false);
4109
4110 ldemul_after_open ();
4111
9503fd87
ILT		 4112 already_linked_table_free ();
4113
252b5132
RH		 4114 /* Make sure that we're not mixing architectures. We call this
4115 after all the input files have been opened, but before we do any
4116 other processing, so that any operations merge_private_bfd_data
4117 does on the output file will be known during the rest of the
4118 link. */
4119 lang_check ();
4120
4121 /* Handle .exports instead of a version script if we're told to do so. */
4122 if (command_line.version_exports_section)
4123 lang_do_version_exports_section ();
4124
4125 /* Build all sets based on the information gathered from the input
4126 files. */
4127 ldctor_build_sets ();
4128
4129 /* Remove unreferenced sections if asked to. */
4130 if (command_line.gc_sections)
4131 lang_gc_sections ();
4132
08da4cac 4133 /* Size up the common data. */
252b5132
RH		 4134 lang_common ();
4135
4136 /* Run through the contours of the script and attach input sections
08da4cac 4137 to the correct output sections. */
252b5132
RH		 4138 map_input_to_output_sections (statement_list.head, (char *) NULL,
4139 (lang_output_section_statement_type *) NULL);
4140
08da4cac 4141 /* Find any sections not attached explicitly and handle them. */
252b5132
RH		 4142 lang_place_orphans ();
4143
4144 ldemul_before_allocation ();
4145
4146 /* We must record the program headers before we try to fix the
4147 section positions, since they will affect SIZEOF_HEADERS. */
4148 lang_record_phdrs ();
4149
08da4cac 4150 /* Now run around and relax if we can. */
252b5132
RH		 4151 if (command_line.relax)
4152 {
4153 /* First time round is a trial run to get the 'worst case'
4154 addresses of the objects if there was no relaxing. */
4155 lang_size_sections (statement_list.head,
4156 abs_output_section,
4157 &(statement_list.head), 0, (bfd_vma) 0, false);
4158
4159 /* Keep relaxing until bfd_relax_section gives up. */
4160 do
4161 {
4162 reset_memory_regions ();
4163
4164 relax_again = false;
4165
4166 /* Note: pe-dll.c does something like this also. If you find
4167 you need to change this code, you probably need to change
08da4cac 4168 pe-dll.c also. DJ */
252b5132
RH		 4169
4170 /* Do all the assignments with our current guesses as to
4171 section sizes. */
4172 lang_do_assignments (statement_list.head,
4173 abs_output_section,
4174 (fill_type) 0, (bfd_vma) 0);
4175
4176 /* Perform another relax pass - this time we know where the
4177 globals are, so can make better guess. */
4178 lang_size_sections (statement_list.head,
4179 abs_output_section,
4180 &(statement_list.head), 0, (bfd_vma) 0, true);
4181 }
4182 while (relax_again);
4183 }
4184 else
4185 {
4186 /* Size up the sections. */
4187 lang_size_sections (statement_list.head,
4188 abs_output_section,
4189 &(statement_list.head), 0, (bfd_vma) 0, false);
4190 }
4191
4192 /* See if anything special should be done now we know how big
4193 everything is. */
4194 ldemul_after_allocation ();
4195
4196 /* Fix any .startof. or .sizeof. symbols. */
4197 lang_set_startof ();
4198
08da4cac
KH		 4199 /* Do all the assignments, now that we know the final resting places
4200 of all the symbols. */
252b5132
RH		 4201
4202 lang_do_assignments (statement_list.head,
4203 abs_output_section,
4204 (fill_type) 0, (bfd_vma) 0);
4205
4206 /* Make sure that the section addresses make sense. */
4207 if (! link_info.relocateable
4208 && command_line.check_section_addresses)
4209 lang_check_section_addresses ();
5f992e62 4210
08da4cac 4211 /* Final stuffs. */
252b5132
RH		 4212
4213 ldemul_finish ();
4214 lang_finish ();
4215}
4216
4217/* EXPORTED TO YACC */
4218
4219void
4220lang_add_wild (section_name, sections_sorted, filename, filenames_sorted,
18625d54 4221 keep_sections, exclude_filename_list)
252b5132
RH		 4222 const char *const section_name;
4223 boolean sections_sorted;
4224 const char *const filename;
4225 boolean filenames_sorted;
4226 boolean keep_sections;
18625d54 4227 struct name_list *exclude_filename_list;
252b5132
RH		 4228{
4229 lang_wild_statement_type *new = new_stat (lang_wild_statement,
4230 stat_ptr);
4231
4232 if (section_name != (char *) NULL && strcmp (section_name, "COMMON") == 0)
4233 {
4234 placed_commons = true;
4235 }
4236 if (filename != NULL && ! wildcardp (filename))
4237 {
4238 lang_has_input_file = true;
4239 }
4240 new->section_name = section_name;
4241 new->sections_sorted = sections_sorted;
4242 new->filename = filename;
4243 new->filenames_sorted = filenames_sorted;
4244 new->keep_sections = keep_sections;
18625d54 4245 new->exclude_filename_list = exclude_filename_list;
252b5132
RH		 4246 lang_list_init (&new->children);
4247}
4248
4249void
4250lang_section_start (name, address)
5f992e62 4251 const char *name;
08da4cac 4252 etree_type *address;
252b5132
RH		 4253{
4254 lang_address_statement_type *ad = new_stat (lang_address_statement, stat_ptr);
4255
4256 ad->section_name = name;
4257 ad->address = address;
4258}
4259
4260/* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4261 because of a -e argument on the command line, or zero if this is
4262 called by ENTRY in a linker script. Command line arguments take
4263 precedence. */
4264
4265void
4266lang_add_entry (name, cmdline)
5f992e62 4267 const char *name;
252b5132
RH		 4268 boolean cmdline;
4269{
4270 if (entry_symbol == NULL
4271 || cmdline
4272 || ! entry_from_cmdline)
4273 {
4274 entry_symbol = name;
4275 entry_from_cmdline = cmdline;
4276 }
4277}
4278
4279void
4280lang_add_target (name)
5f992e62 4281 const char *name;
252b5132
RH		 4282{
4283 lang_target_statement_type *new = new_stat (lang_target_statement,
4284 stat_ptr);
4285
4286 new->target = name;
4287
4288}
4289
4290void
4291lang_add_map (name)
5f992e62 4292 const char *name;
252b5132
RH		 4293{
4294 while (*name)
4295 {
4296 switch (*name)
4297 {
08da4cac 4298 case 'F':
252b5132
RH		 4299 map_option_f = true;
4300 break;
4301 }
4302 name++;
4303 }
4304}
4305
4306void
4307lang_add_fill (exp)
4308 int exp;
4309{
4310 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4311 stat_ptr);
4312
4313 new->fill = exp;
4314}
4315
4316void
4317lang_add_data (type, exp)
4318 int type;
4319 union etree_union *exp;
4320{
4321
4322 lang_data_statement_type *new = new_stat (lang_data_statement,
4323 stat_ptr);
4324
4325 new->exp = exp;
4326 new->type = type;
4327
4328}
4329
4330/* Create a new reloc statement. RELOC is the BFD relocation type to
4331 generate. HOWTO is the corresponding howto structure (we could
4332 look this up, but the caller has already done so). SECTION is the
4333 section to generate a reloc against, or NAME is the name of the
4334 symbol to generate a reloc against. Exactly one of SECTION and
4335 NAME must be NULL. ADDEND is an expression for the addend. */
4336
4337void
4338lang_add_reloc (reloc, howto, section, name, addend)
4339 bfd_reloc_code_real_type reloc;
4340 reloc_howto_type *howto;
4341 asection *section;
4342 const char *name;
4343 union etree_union *addend;
4344{
4345 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
5f992e62 4346
252b5132
RH		 4347 p->reloc = reloc;
4348 p->howto = howto;
4349 p->section = section;
4350 p->name = name;
4351 p->addend_exp = addend;
4352
4353 p->addend_value = 0;
4354 p->output_section = NULL;
4355 p->output_vma = 0;
4356}
4357
4358lang_assignment_statement_type *
4359lang_add_assignment (exp)
08da4cac 4360 etree_type *exp;
252b5132
RH		 4361{
4362 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4363 stat_ptr);
4364
4365 new->exp = exp;
4366 return new;
4367}
4368
4369void
4370lang_add_attribute (attribute)
4371 enum statement_enum attribute;
4372{
4373 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4374}
4375
4376void
4377lang_startup (name)
5f992e62 4378 const char *name;
252b5132
RH		 4379{
4380 if (startup_file != (char *) NULL)
4381 {
4382 einfo (_("%P%Fmultiple STARTUP files\n"));
4383 }
4384 first_file->filename = name;
4385 first_file->local_sym_name = name;
4386 first_file->real = true;
4387
4388 startup_file = name;
4389}
4390
4391void
4392lang_float (maybe)
4393 boolean maybe;
4394{
4395 lang_float_flag = maybe;
4396}
4397
4398void
562d3460 4399lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
252b5132
RH		 4400 bfd_vma fill;
4401 const char *memspec;
4402 struct lang_output_section_phdr_list *phdrs;
562d3460 4403 const char *lma_memspec;
252b5132
RH		 4404{
4405 current_section->fill = fill;
4406 current_section->region = lang_memory_region_lookup (memspec);
562d3460
TW		 4407 if (strcmp (lma_memspec, "*default*") != 0)
4408 {
4409 current_section->lma_region = lang_memory_region_lookup (lma_memspec);
08da4cac
KH		 4410 /* If no runtime region has been given, but the load region has
4411 been, use the load region. */
562d3460
TW		 4412 if (strcmp (memspec, "*default*") == 0)
4413 current_section->region = lang_memory_region_lookup (lma_memspec);
4414 }
252b5132
RH		 4415 current_section->phdrs = phdrs;
4416 stat_ptr = &statement_list;
4417}
4418
08da4cac
KH		 4419/* Create an absolute symbol with the given name with the value of the
4420 address of first byte of the section named.
4421
4422 If the symbol already exists, then do nothing. */
252b5132 4423
252b5132
RH		 4424void
4425lang_abs_symbol_at_beginning_of (secname, name)
4426 const char *secname;
4427 const char *name;
4428{
4429 struct bfd_link_hash_entry *h;
4430
4431 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4432 if (h == (struct bfd_link_hash_entry *) NULL)
4433 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4434
4435 if (h->type == bfd_link_hash_new
4436 || h->type == bfd_link_hash_undefined)
4437 {
4438 asection *sec;
4439
4440 h->type = bfd_link_hash_defined;
4441
4442 sec = bfd_get_section_by_name (output_bfd, secname);
4443 if (sec == (asection *) NULL)
4444 h->u.def.value = 0;
4445 else
4446 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4447
4448 h->u.def.section = bfd_abs_section_ptr;
4449 }
4450}
4451
08da4cac
KH		 4452/* Create an absolute symbol with the given name with the value of the
4453 address of the first byte after the end of the section named.
4454
4455 If the symbol already exists, then do nothing. */
252b5132 4456
252b5132
RH		 4457void
4458lang_abs_symbol_at_end_of (secname, name)
4459 const char *secname;
4460 const char *name;
4461{
4462 struct bfd_link_hash_entry *h;
4463
4464 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4465 if (h == (struct bfd_link_hash_entry *) NULL)
4466 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4467
4468 if (h->type == bfd_link_hash_new
4469 || h->type == bfd_link_hash_undefined)
4470 {
4471 asection *sec;
4472
4473 h->type = bfd_link_hash_defined;
4474
4475 sec = bfd_get_section_by_name (output_bfd, secname);
4476 if (sec == (asection *) NULL)
4477 h->u.def.value = 0;
4478 else
4479 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4cbfc3ac
TW		 4480 + bfd_section_size (output_bfd, sec) /
4481 bfd_octets_per_byte (output_bfd));
252b5132
RH		 4482
4483 h->u.def.section = bfd_abs_section_ptr;
4484 }
4485}
4486
4487void
4488lang_statement_append (list, element, field)
08da4cac
KH		 4489 lang_statement_list_type *list;
4490 lang_statement_union_type *element;
4491 lang_statement_union_type **field;
252b5132
RH		 4492{
4493 *(list->tail) = element;
4494 list->tail = field;
4495}
4496
4497/* Set the output format type. -oformat overrides scripts. */
4498
4499void
4500lang_add_output_format (format, big, little, from_script)
4501 const char *format;
4502 const char *big;
4503 const char *little;
4504 int from_script;
4505{
4506 if (output_target == NULL || !from_script)
4507 {
4508 if (command_line.endian == ENDIAN_BIG
4509 && big != NULL)
4510 format = big;
4511 else if (command_line.endian == ENDIAN_LITTLE
4512 && little != NULL)
4513 format = little;
4514
4515 output_target = format;
4516 }
4517}
4518
4519/* Enter a group. This creates a new lang_group_statement, and sets
4520 stat_ptr to build new statements within the group. */
4521
4522void
4523lang_enter_group ()
4524{
4525 lang_group_statement_type *g;
4526
4527 g = new_stat (lang_group_statement, stat_ptr);
4528 lang_list_init (&g->children);
4529 stat_ptr = &g->children;
4530}
4531
4532/* Leave a group. This just resets stat_ptr to start writing to the
4533 regular list of statements again. Note that this will not work if
4534 groups can occur inside anything else which can adjust stat_ptr,
4535 but currently they can't. */
4536
4537void
4538lang_leave_group ()
4539{
4540 stat_ptr = &statement_list;
4541}
4542
4543/* Add a new program header. This is called for each entry in a PHDRS
4544 command in a linker script. */
4545
4546void
4547lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4548 const char *name;
4549 etree_type *type;
4550 boolean filehdr;
4551 boolean phdrs;
4552 etree_type *at;
4553 etree_type *flags;
4554{
4555 struct lang_phdr *n, **pp;
4556
4557 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4558 n->next = NULL;
4559 n->name = name;
4560 n->type = exp_get_value_int (type, 0, "program header type",
4561 lang_final_phase_enum);
4562 n->filehdr = filehdr;
4563 n->phdrs = phdrs;
4564 n->at = at;
4565 n->flags = flags;
4566
4567 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4568 ;
4569 *pp = n;
4570}
4571
4572/* Record the program header information in the output BFD. FIXME: We
4573 should not be calling an ELF specific function here. */
4574
4575static void
4576lang_record_phdrs ()
4577{
4578 unsigned int alc;
4579 asection **secs;
4580 struct lang_output_section_phdr_list *last;
4581 struct lang_phdr *l;
4582 lang_statement_union_type *u;
4583
4584 alc = 10;
4585 secs = (asection **) xmalloc (alc * sizeof (asection *));
4586 last = NULL;
4587 for (l = lang_phdr_list; l != NULL; l = l->next)
4588 {
4589 unsigned int c;
4590 flagword flags;
4591 bfd_vma at;
4592
4593 c = 0;
4594 for (u = lang_output_section_statement.head;
4595 u != NULL;
4596 u = u->output_section_statement.next)
4597 {
4598 lang_output_section_statement_type *os;
4599 struct lang_output_section_phdr_list *pl;
4600
4601 os = &u->output_section_statement;
4602
4603 pl = os->phdrs;
4604 if (pl != NULL)
4605 last = pl;
4606 else
4607 {
4608 if (os->sectype == noload_section
4609 || os->bfd_section == NULL
4610 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4611 continue;
4612 pl = last;
4613 }
4614
4615 if (os->bfd_section == NULL)
4616 continue;
4617
4618 for (; pl != NULL; pl = pl->next)
4619 {
4620 if (strcmp (pl->name, l->name) == 0)
4621 {
4622 if (c >= alc)
4623 {
4624 alc *= 2;
4625 secs = ((asection **)
4626 xrealloc (secs, alc * sizeof (asection *)));
4627 }
4628 secs[c] = os->bfd_section;
4629 ++c;
4630 pl->used = true;
4631 }
4632 }
4633 }
4634
4635 if (l->flags == NULL)
4636 flags = 0;
4637 else
4638 flags = exp_get_vma (l->flags, 0, "phdr flags",
4639 lang_final_phase_enum);
4640
4641 if (l->at == NULL)
4642 at = 0;
4643 else
4644 at = exp_get_vma (l->at, 0, "phdr load address",
4645 lang_final_phase_enum);
4646
4647 if (! bfd_record_phdr (output_bfd, l->type,
4648 l->flags == NULL ? false : true,
4649 flags,
4650 l->at == NULL ? false : true,
4651 at, l->filehdr, l->phdrs, c, secs))
4652 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4653 }
4654
4655 free (secs);
4656
4657 /* Make sure all the phdr assignments succeeded. */
4658 for (u = lang_output_section_statement.head;
4659 u != NULL;
4660 u = u->output_section_statement.next)
4661 {
4662 struct lang_output_section_phdr_list *pl;
4663
4664 if (u->output_section_statement.bfd_section == NULL)
4665 continue;
4666
4667 for (pl = u->output_section_statement.phdrs;
4668 pl != NULL;
4669 pl = pl->next)
4670 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4671 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4672 u->output_section_statement.name, pl->name);
4673 }
4674}
4675
4676/* Record a list of sections which may not be cross referenced. */
4677
4678void
4679lang_add_nocrossref (l)
4680 struct lang_nocrossref *l;
4681{
4682 struct lang_nocrossrefs *n;
4683
4684 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4685 n->next = nocrossref_list;
4686 n->list = l;
4687 nocrossref_list = n;
4688
4689 /* Set notice_all so that we get informed about all symbols. */
4690 link_info.notice_all = true;
4691}
4692\f
4693/* Overlay handling. We handle overlays with some static variables. */
4694
4695/* The overlay virtual address. */
4696static etree_type *overlay_vma;
4697
4698/* The overlay load address. */
4699static etree_type *overlay_lma;
4700
4701/* Whether nocrossrefs is set for this overlay. */
4702static int overlay_nocrossrefs;
4703
4704/* An expression for the maximum section size seen so far. */
4705static etree_type *overlay_max;
4706
4707/* A list of all the sections in this overlay. */
4708
89cdebba 4709struct overlay_list {
252b5132
RH		 4710 struct overlay_list *next;
4711 lang_output_section_statement_type *os;
4712};
4713
4714static struct overlay_list *overlay_list;
4715
4716/* Start handling an overlay. */
4717
4718void
4719lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
4720 etree_type *vma_expr;
4721 etree_type *lma_expr;
4722 int nocrossrefs;
4723{
4724 /* The grammar should prevent nested overlays from occurring. */
4725 ASSERT (overlay_vma == NULL
4726 && overlay_lma == NULL
4727 && overlay_list == NULL
4728 && overlay_max == NULL);
4729
4730 overlay_vma = vma_expr;
4731 overlay_lma = lma_expr;
4732 overlay_nocrossrefs = nocrossrefs;
4733}
4734
4735/* Start a section in an overlay. We handle this by calling
4736 lang_enter_output_section_statement with the correct VMA and LMA. */
4737
4738void
4739lang_enter_overlay_section (name)
4740 const char *name;
4741{
4742 struct overlay_list *n;
4743 etree_type *size;
4744
4745 lang_enter_output_section_statement (name, overlay_vma, normal_section,
4746 0, 0, 0, overlay_lma);
4747
4748 /* If this is the first section, then base the VMA and LMA of future
4749 sections on this one. This will work correctly even if `.' is
4750 used in the addresses. */
4751 if (overlay_list == NULL)
4752 {
4753 overlay_vma = exp_nameop (ADDR, name);
4754 overlay_lma = exp_nameop (LOADADDR, name);
4755 }
4756
4757 /* Remember the section. */
4758 n = (struct overlay_list *) xmalloc (sizeof *n);
4759 n->os = current_section;
4760 n->next = overlay_list;
4761 overlay_list = n;
4762
4763 size = exp_nameop (SIZEOF, name);
4764
4765 /* Adjust the LMA for the next section. */
4766 overlay_lma = exp_binop ('+', overlay_lma, size);
4767
4768 /* Arrange to work out the maximum section end address. */
4769 if (overlay_max == NULL)
4770 overlay_max = size;
4771 else
4772 overlay_max = exp_binop (MAX_K, overlay_max, size);
4773}
4774
4775/* Finish a section in an overlay. There isn't any special to do
4776 here. */
4777
4778void
4779lang_leave_overlay_section (fill, phdrs)
4780 bfd_vma fill;
4781 struct lang_output_section_phdr_list *phdrs;
4782{
4783 const char *name;
4784 char *clean, *s2;
4785 const char *s1;
4786 char *buf;
4787
4788 name = current_section->name;
4789
5f992e62 4790 lang_leave_output_section_statement (fill, "*default*",
562d3460 4791 phdrs, "*default*");
252b5132
RH		 4792
4793 /* Define the magic symbols. */
4794
4795 clean = xmalloc (strlen (name) + 1);
4796 s2 = clean;
4797 for (s1 = name; *s1 != '\0'; s1++)
4798 if (isalnum ((unsigned char) *s1) || *s1 == '_')
4799 *s2++ = *s1;
4800 *s2 = '\0';
4801
4802 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4803 sprintf (buf, "__load_start_%s", clean);
4804 lang_add_assignment (exp_assop ('=', buf,
4805 exp_nameop (LOADADDR, name)));
4806
4807 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4808 sprintf (buf, "__load_stop_%s", clean);
4809 lang_add_assignment (exp_assop ('=', buf,
4810 exp_binop ('+',
4811 exp_nameop (LOADADDR, name),
4812 exp_nameop (SIZEOF, name))));
4813
4814 free (clean);
4815}
4816
4817/* Finish an overlay. If there are any overlay wide settings, this
4818 looks through all the sections in the overlay and sets them. */
4819
4820void
562d3460 4821lang_leave_overlay (fill, memspec, phdrs, lma_memspec)
252b5132
RH		 4822 bfd_vma fill;
4823 const char *memspec;
4824 struct lang_output_section_phdr_list *phdrs;
562d3460 4825 const char *lma_memspec;
252b5132
RH		 4826{
4827 lang_memory_region_type *region;
562d3460 4828 lang_memory_region_type *lma_region;
252b5132
RH		 4829 struct overlay_list *l;
4830 struct lang_nocrossref *nocrossref;
4831
4832 if (memspec == NULL)
4833 region = NULL;
4834 else
4835 region = lang_memory_region_lookup (memspec);
4836
562d3460
TW		 4837 if (lma_memspec == NULL)
4838 lma_region = NULL;
4839 else
4840 lma_region = lang_memory_region_lookup (lma_memspec);
4841
252b5132
RH		 4842 nocrossref = NULL;
4843
4844 l = overlay_list;
4845 while (l != NULL)
4846 {
4847 struct overlay_list *next;
4848
4849 if (fill != 0 && l->os->fill == 0)
4850 l->os->fill = fill;
4851 if (region != NULL && l->os->region == NULL)
4852 l->os->region = region;
c1eb1488
AM		 4853 /* We only set lma_region for the first overlay section, as
4854 subsequent overlay sections will have load_base set relative
02aa14fb
AM		 4855 to the first section. Also, don't set lma_region if
4856 load_base is specified. FIXME: There should really be a test
4857 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4858 rather than letting LDADDR simply override LMA_REGION. */
4859 if (lma_region != NULL && l->os->lma_region == NULL
4860 && l->next == NULL && l->os->load_base == NULL)
08da4cac 4861 l->os->lma_region = lma_region;
252b5132
RH		 4862 if (phdrs != NULL && l->os->phdrs == NULL)
4863 l->os->phdrs = phdrs;
4864
4865 if (overlay_nocrossrefs)
4866 {
4867 struct lang_nocrossref *nc;
4868
4869 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4870 nc->name = l->os->name;
4871 nc->next = nocrossref;
4872 nocrossref = nc;
4873 }
4874
4875 next = l->next;
4876 free (l);
4877 l = next;
4878 }
4879
4880 if (nocrossref != NULL)
4881 lang_add_nocrossref (nocrossref);
4882
4883 /* Update . for the end of the overlay. */
4884 lang_add_assignment (exp_assop ('=', ".",
4885 exp_binop ('+', overlay_vma, overlay_max)));
4886
4887 overlay_vma = NULL;
4888 overlay_lma = NULL;
4889 overlay_nocrossrefs = 0;
4890 overlay_list = NULL;
4891 overlay_max = NULL;
4892}
4893\f
4894/* Version handling. This is only useful for ELF. */
4895
4896/* This global variable holds the version tree that we build. */
4897
4898struct bfd_elf_version_tree *lang_elf_version_info;
4899
4900static int
4901lang_vers_match_lang_c (expr, sym)
4902 struct bfd_elf_version_expr *expr;
4903 const char *sym;
4904{
4905 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4906 return 1;
4907 return fnmatch (expr->pattern, sym, 0) == 0;
4908}
4909
4910static int
4911lang_vers_match_lang_cplusplus (expr, sym)
4912 struct bfd_elf_version_expr *expr;
4913 const char *sym;
4914{
4915 char *alt_sym;
4916 int result;
4917
4918 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4919 return 1;
4920
08da4cac 4921 alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
252b5132
RH		 4922 if (!alt_sym)
4923 {
4924 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
4925 Should we early out false in this case? */
4926 result = fnmatch (expr->pattern, sym, 0) == 0;
4927 }
4928 else
4929 {
4930 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4931 free (alt_sym);
4932 }
4933
4934 return result;
4935}
4936
4937static int
4938lang_vers_match_lang_java (expr, sym)
4939 struct bfd_elf_version_expr *expr;
4940 const char *sym;
4941{
4942 char *alt_sym;
4943 int result;
4944
4945 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
4946 return 1;
4947
08da4cac 4948 alt_sym = cplus_demangle (sym, DMGL_JAVA);
252b5132
RH		 4949 if (!alt_sym)
4950 {
4951 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
4952 Should we early out false in this case? */
4953 result = fnmatch (expr->pattern, sym, 0) == 0;
4954 }
4955 else
4956 {
4957 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
4958 free (alt_sym);
4959 }
4960
4961 return result;
4962}
4963
4964/* This is called for each variable name or match expression. */
4965
4966struct bfd_elf_version_expr *
4967lang_new_vers_regex (orig, new, lang)
4968 struct bfd_elf_version_expr *orig;
4969 const char *new;
4970 const char *lang;
4971{
4972 struct bfd_elf_version_expr *ret;
4973
4974 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
4975 ret->next = orig;
4976 ret->pattern = new;
4977
4978 if (lang == NULL || strcasecmp (lang, "C") == 0)
4979 ret->match = lang_vers_match_lang_c;
4980 else if (strcasecmp (lang, "C++") == 0)
4981 ret->match = lang_vers_match_lang_cplusplus;
4982 else if (strcasecmp (lang, "Java") == 0)
4983 ret->match = lang_vers_match_lang_java;
4984 else
4985 {
4986 einfo (_("%X%P: unknown language `%s' in version information\n"),
4987 lang);
4988 ret->match = lang_vers_match_lang_c;
4989 }
4990
4991 return ret;
4992}
4993
4994/* This is called for each set of variable names and match
4995 expressions. */
4996
4997struct bfd_elf_version_tree *
4998lang_new_vers_node (globals, locals)
4999 struct bfd_elf_version_expr *globals;
5000 struct bfd_elf_version_expr *locals;
5001{
5002 struct bfd_elf_version_tree *ret;
5003
5004 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5005 ret->next = NULL;
5006 ret->name = NULL;
5007 ret->vernum = 0;
5008 ret->globals = globals;
5009 ret->locals = locals;
5010 ret->deps = NULL;
5011 ret->name_indx = (unsigned int) -1;
5012 ret->used = 0;
5013 return ret;
5014}
5015
5016/* This static variable keeps track of version indices. */
5017
5018static int version_index;
5019
5020/* This is called when we know the name and dependencies of the
5021 version. */
5022
5023void
5024lang_register_vers_node (name, version, deps)
5025 const char *name;
5026 struct bfd_elf_version_tree *version;
5027 struct bfd_elf_version_deps *deps;
5028{
5029 struct bfd_elf_version_tree *t, **pp;
5030 struct bfd_elf_version_expr *e1;
5031
5032 /* Make sure this node has a unique name. */
5033 for (t = lang_elf_version_info; t != NULL; t = t->next)
5034 if (strcmp (t->name, name) == 0)
5035 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5036
5037 /* Check the global and local match names, and make sure there
5038 aren't any duplicates. */
5039
5040 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5041 {
5042 for (t = lang_elf_version_info; t != NULL; t = t->next)
5043 {
5044 struct bfd_elf_version_expr *e2;
5045
5046 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5047 if (strcmp (e1->pattern, e2->pattern) == 0)
5048 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5049 e1->pattern);
5050 }
5051 }
5052
5053 for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5054 {
5055 for (t = lang_elf_version_info; t != NULL; t = t->next)
5056 {
5057 struct bfd_elf_version_expr *e2;
5058
5059 for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5060 if (strcmp (e1->pattern, e2->pattern) == 0)
5061 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5062 e1->pattern);
5063 }
5064 }
5065
5066 version->deps = deps;
5067 version->name = name;
5068 ++version_index;
5069 version->vernum = version_index;
5070
5071 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5072 ;
5073 *pp = version;
5074}
5075
5076/* This is called when we see a version dependency. */
5077
5078struct bfd_elf_version_deps *
5079lang_add_vers_depend (list, name)
5080 struct bfd_elf_version_deps *list;
5081 const char *name;
5082{
5083 struct bfd_elf_version_deps *ret;
5084 struct bfd_elf_version_tree *t;
5085
5086 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5087 ret->next = list;
5088
5089 for (t = lang_elf_version_info; t != NULL; t = t->next)
5090 {
5091 if (strcmp (t->name, name) == 0)
5092 {
5093 ret->version_needed = t;
5094 return ret;
5095 }
5096 }
5097
5098 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5099
5100 return ret;
5101}
5102
5103static void
5104lang_do_version_exports_section ()
5105{
5106 struct bfd_elf_version_expr *greg = NULL, *lreg;
5107
5108 LANG_FOR_EACH_INPUT_STATEMENT (is)
5109 {
5110 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5111 char *contents, *p;
5112 bfd_size_type len;
5113
5114 if (sec == NULL)
5115 continue;
5116
5117 len = bfd_section_size (is->the_bfd, sec);
5118 contents = xmalloc (len);
5119 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
5120 einfo (_("%X%P: unable to read .exports section contents"), sec);
5121
5122 p = contents;
89cdebba 5123 while (p < contents + len)
252b5132
RH		 5124 {
5125 greg = lang_new_vers_regex (greg, p, NULL);
5126 p = strchr (p, '\0') + 1;
5127 }
5128
5129 /* Do not free the contents, as we used them creating the regex. */
5130
5131 /* Do not include this section in the link. */
5132 bfd_set_section_flags (is->the_bfd, sec,
5133 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5134 }
5135
5136 lreg = lang_new_vers_regex (NULL, "*", NULL);
5137 lang_register_vers_node (command_line.version_exports_section,
5138 lang_new_vers_node (greg, lreg), NULL);
5139}
577a0623
AM		 5140
5141void
5142lang_add_unique (name)
5143 const char *name;
5144{
5145 struct unique_sections *ent;
5146
5147 for (ent = unique_section_list; ent; ent = ent->next)
5148 if (strcmp (ent->name, name) == 0)
5149 return;
5150
5151 ent = (struct unique_sections *) xmalloc (sizeof *ent);
5152 ent->name = xstrdup (name);
5153 ent->next = unique_section_list;
5154 unique_section_list = ent;
5155}
GDB Binutils - Deliverables
This page took 0.294833 seconds and 4 git commands to generate.