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