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