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