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