projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
AJ found the problem and created the patch.
[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
e052cfbe
RS		 2910 /* The section might have been removed after its statement was
2911 added. For example, ldemul_before_allocation can remove
2912 dynamic sections if they turn out not to be needed. */
2913 if (!link_info.relocateable
2914 && (bfd_get_section_flags (output_bfd, os->bfd_section)
2915 & SEC_EXCLUDE) != 0)
2916 break;
2917
252b5132
RH		 2918 /* If this is a COFF shared library section, use the size and
2919 address from the input section. FIXME: This is COFF
2920 specific; it would be cleaner if there were some other way
2921 to do this, but nothing simple comes to mind. */
2922 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2923 {
08da4cac 2924 asection *input;
252b5132
RH		 2925
2926 if (os->children.head == NULL
bba1a0c0 2927 || os->children.head->header.next != NULL
252b5132
RH		 2928 || os->children.head->header.type != lang_input_section_enum)
2929 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2930 os->name);
2931
2932 input = os->children.head->input_section.section;
2933 bfd_set_section_vma (os->bfd_section->owner,
2934 os->bfd_section,
2935 bfd_section_vma (input->owner, input));
2936 os->bfd_section->_raw_size = input->_raw_size;
2937 break;
2938 }
2939
2940 if (bfd_is_abs_section (os->bfd_section))
2941 {
2942 /* No matter what happens, an abs section starts at zero. */
2943 ASSERT (os->bfd_section->vma == 0);
2944 }
2945 else
2946 {
2947 if (os->addr_tree == (etree_type *) NULL)
2948 {
2949 /* No address specified for this section, get one
2950 from the region specification. */
2951 if (os->region == (lang_memory_region_type *) NULL
2952 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2953 & (SEC_ALLOC | SEC_LOAD)) != 0)
2954 && os->region->name[0] == '*'
2955 && strcmp (os->region->name, "*default*") == 0))
2956 {
2957 os->region = lang_memory_default (os->bfd_section);
2958 }
2959
2960 /* If a loadable section is using the default memory
2961 region, and some non default memory regions were
2962 defined, issue a warning. */
2963 if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2964 & (SEC_ALLOC | SEC_LOAD)) != 0
d08a14c3
AM		 2965 && (bfd_get_section_flags (output_bfd, os->bfd_section)
2966 & SEC_NEVER_LOAD) == 0
252b5132
RH		 2967 && ! link_info.relocateable
2968 && strcmp (os->region->name, "*default*") == 0
2969 && lang_memory_region_list != NULL
d1778b88
AM		 2970 && (strcmp (lang_memory_region_list->name,
2971 "*default*") != 0
252b5132
RH		 2972 || lang_memory_region_list->next != NULL))
2973 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
d1778b88
AM		 2974 bfd_get_section_name (output_bfd,
2975 os->bfd_section));
252b5132
RH		 2976
2977 dot = os->region->current;
5f992e62 2978
252b5132
RH		 2979 if (os->section_alignment == -1)
2980 {
2981 bfd_vma olddot;
2982
2983 olddot = dot;
d1778b88
AM		 2984 dot = align_power (dot,
2985 os->bfd_section->alignment_power);
252b5132
RH		 2986
2987 if (dot != olddot && config.warn_section_align)
2988 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2989 os->name, (unsigned int) (dot - olddot));
2990 }
2991 }
2992 else
2993 {
2994 etree_value_type r;
2995
2996 r = exp_fold_tree (os->addr_tree,
2997 abs_output_section,
2998 lang_allocating_phase_enum,
2999 dot, &dot);
3000 if (r.valid_p == false)
3001 {
3002 einfo (_("%F%S: non constant address expression for section %s\n"),
3003 os->name);
3004 }
3005 dot = r.value + r.section->bfd_section->vma;
3006 }
5f992e62 3007
252b5132
RH		 3008 /* The section starts here.
3009 First, align to what the section needs. */
3010
3011 if (os->section_alignment != -1)
3012 dot = align_power (dot, os->section_alignment);
3013
3014 bfd_set_section_vma (0, os->bfd_section, dot);
5f992e62 3015
252b5132
RH		 3016 os->bfd_section->output_offset = 0;
3017 }
3018
2d20f7bf
JJ		 3019 lang_size_sections_1 (os->children.head, os, &os->children.head,
3020 os->fill, dot, relax);
5f992e62 3021
08da4cac
KH		 3022 /* Put the section within the requested block size, or
3023 align at the block boundary. */
32edc927
TW		 3024 after = ALIGN_N (os->bfd_section->vma
3025 + os->bfd_section->_raw_size / opb,
252b5132
RH		 3026 /* The coercion here is important, see ld.h. */
3027 (bfd_vma) os->block_value);
3028
3029 if (bfd_is_abs_section (os->bfd_section))
3030 ASSERT (after == os->bfd_section->vma);
13ae64f3
JJ		 3031 else if ((os->bfd_section->flags & SEC_HAS_CONTENTS) == 0
3032 && (os->bfd_section->flags & SEC_THREAD_LOCAL))
3033 os->bfd_section->_raw_size = 0;
252b5132 3034 else
5f992e62 3035 os->bfd_section->_raw_size =
08da4cac 3036 (after - os->bfd_section->vma) * opb;
9f88b410 3037
4cbfc3ac 3038 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
252b5132
RH		 3039 os->processed = true;
3040
9f88b410
RS		 3041 if (os->update_dot_tree != 0)
3042 exp_fold_tree (os->update_dot_tree, abs_output_section,
3043 lang_allocating_phase_enum, dot, &dot);
3044
252b5132
RH		 3045 /* Update dot in the region ?
3046 We only do this if the section is going to be allocated,
3047 since unallocated sections do not contribute to the region's
13392b77 3048 overall size in memory.
5f992e62 3049
cce4c4c5
NC		 3050 If the SEC_NEVER_LOAD bit is not set, it will affect the
3051 addresses of sections after it. We have to update
3052 dot. */
252b5132 3053 if (os->region != (lang_memory_region_type *) NULL
cce4c4c5
NC		 3054 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
3055 & SEC_NEVER_LOAD) == 0
3056 || (bfd_get_section_flags (output_bfd, os->bfd_section)
3057 & (SEC_ALLOC | SEC_LOAD))))
252b5132
RH		 3058 {
3059 os->region->current = dot;
5f992e62 3060
562d3460 3061 /* Make sure the new address is within the region. */
08da4cac
KH		 3062 os_region_check (os, os->region, os->addr_tree,
3063 os->bfd_section->vma);
3064
3065 /* If there's no load address specified, use the run
3066 region as the load region. */
3067 if (os->lma_region == NULL && os->load_base == NULL)
3068 os->lma_region = os->region;
3069
ee3cc2e2 3070 if (os->lma_region != NULL && os->lma_region != os->region)
08da4cac 3071 {
ee3cc2e2
RS		 3072 /* Set load_base, which will be handled later. */
3073 os->load_base = exp_intop (os->lma_region->current);
3074 os->lma_region->current +=
3075 os->bfd_section->_raw_size / opb;
3076 os_region_check (os, os->lma_region, NULL,
3077 os->bfd_section->lma);
08da4cac 3078 }
252b5132
RH		 3079 }
3080 }
3081 break;
3082
3083 case lang_constructors_statement_enum:
2d20f7bf
JJ		 3084 dot = lang_size_sections_1 (constructor_list.head,
3085 output_section_statement,
3086 &s->wild_statement.children.head,
3087 fill, dot, relax);
252b5132
RH		 3088 break;
3089
3090 case lang_data_statement_enum:
3091 {
3092 unsigned int size = 0;
3093
08da4cac
KH		 3094 s->data_statement.output_vma =
3095 dot - output_section_statement->bfd_section->vma;
252b5132
RH		 3096 s->data_statement.output_section =
3097 output_section_statement->bfd_section;
3098
3099 switch (s->data_statement.type)
3100 {
08da4cac
KH		 3101 default:
3102 abort ();
252b5132
RH		 3103 case QUAD:
3104 case SQUAD:
3105 size = QUAD_SIZE;
3106 break;
3107 case LONG:
3108 size = LONG_SIZE;
3109 break;
3110 case SHORT:
3111 size = SHORT_SIZE;
3112 break;
3113 case BYTE:
3114 size = BYTE_SIZE;
3115 break;
3116 }
08da4cac
KH		 3117 if (size < opb)
3118 size = opb;
4cbfc3ac 3119 dot += size / opb;
252b5132
RH		 3120 output_section_statement->bfd_section->_raw_size += size;
3121 /* The output section gets contents, and then we inspect for
3122 any flags set in the input script which override any ALLOC. */
3123 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
08da4cac
KH		 3124 if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3125 {
3126 output_section_statement->bfd_section->flags |=
3127 SEC_ALLOC | SEC_LOAD;
3128 }
252b5132
RH		 3129 }
3130 break;
3131
3132 case lang_reloc_statement_enum:
3133 {
3134 int size;
3135
3136 s->reloc_statement.output_vma =
3137 dot - output_section_statement->bfd_section->vma;
3138 s->reloc_statement.output_section =
3139 output_section_statement->bfd_section;
3140 size = bfd_get_reloc_size (s->reloc_statement.howto);
4cbfc3ac 3141 dot += size / opb;
252b5132
RH		 3142 output_section_statement->bfd_section->_raw_size += size;
3143 }
3144 break;
5f992e62 3145
252b5132
RH		 3146 case lang_wild_statement_enum:
3147
2d20f7bf
JJ		 3148 dot = lang_size_sections_1 (s->wild_statement.children.head,
3149 output_section_statement,
3150 &s->wild_statement.children.head,
3151 fill, dot, relax);
252b5132
RH		 3152
3153 break;
3154
3155 case lang_object_symbols_statement_enum:
3156 link_info.create_object_symbols_section =
3157 output_section_statement->bfd_section;
3158 break;
3159 case lang_output_statement_enum:
3160 case lang_target_statement_enum:
3161 break;
3162 case lang_input_section_enum:
3163 {
3164 asection *i;
3165
3166 i = (*prev)->input_section.section;
3167 if (! relax)
3168 {
3169 if (i->_cooked_size == 0)
3170 i->_cooked_size = i->_raw_size;
3171 }
3172 else
3173 {
3174 boolean again;
3175
3176 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3177 einfo (_("%P%F: can't relax section: %E\n"));
3178 if (again)
b3327aad 3179 *relax = true;
252b5132 3180 }
b3327aad
AM		 3181 dot = size_input_section (prev, output_section_statement,
3182 output_section_statement->fill, dot);
252b5132
RH		 3183 }
3184 break;
3185 case lang_input_statement_enum:
3186 break;
3187 case lang_fill_statement_enum:
08da4cac
KH		 3188 s->fill_statement.output_section =
3189 output_section_statement->bfd_section;
252b5132
RH		 3190
3191 fill = s->fill_statement.fill;
3192 break;
3193 case lang_assignment_statement_enum:
3194 {
3195 bfd_vma newdot = dot;
3196
3197 exp_fold_tree (s->assignment_statement.exp,
3198 output_section_statement,
3199 lang_allocating_phase_enum,
3200 dot,
3201 &newdot);
3202
3203 if (newdot != dot)
3204 {
252b5132
RH		 3205 if (output_section_statement == abs_output_section)
3206 {
3207 /* If we don't have an output section, then just adjust
3208 the default memory address. */
3209 lang_memory_region_lookup ("*default*")->current = newdot;
3210 }
b3327aad 3211 else
252b5132 3212 {
b3327aad
AM		 3213 /* Insert a pad after this statement. We can't
3214 put the pad before when relaxing, in case the
3215 assignment references dot. */
3216 insert_pad (&s->header.next, fill, (newdot - dot) * opb,
3217 output_section_statement->bfd_section, dot);
3218
3219 /* Don't neuter the pad below when relaxing. */
3220 s = s->header.next;
252b5132
RH		 3221 }
3222
3223 dot = newdot;
3224 }
3225 }
3226 break;
3227
3228 case lang_padding_statement_enum:
c0c330a7
AM		 3229 /* If this is the first time lang_size_sections is called,
3230 we won't have any padding statements. If this is the
3231 second or later passes when relaxing, we should allow
3232 padding to shrink. If padding is needed on this pass, it
3233 will be added back in. */
3234 s->padding_statement.size = 0;
6e814ff8
AM		 3235
3236 /* Make sure output_offset is valid. If relaxation shrinks
3237 the section and this pad isn't needed, it's possible to
3238 have output_offset larger than the final size of the
3239 section. bfd_set_section_contents will complain even for
3240 a pad size of zero. */
3241 s->padding_statement.output_offset
3242 = dot - output_section_statement->bfd_section->vma;
252b5132
RH		 3243 break;
3244
3245 case lang_group_statement_enum:
2d20f7bf
JJ		 3246 dot = lang_size_sections_1 (s->group_statement.children.head,
3247 output_section_statement,
3248 &s->group_statement.children.head,
3249 fill, dot, relax);
252b5132
RH		 3250 break;
3251
3252 default:
3253 FAIL ();
3254 break;
3255
c0c330a7 3256 /* We can only get here when relaxing is turned on. */
252b5132
RH		 3257 case lang_address_statement_enum:
3258 break;
3259 }
3260 prev = &s->header.next;
3261 }
3262 return dot;
3263}
3264
2d20f7bf
JJ		 3265bfd_vma
3266lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
3267 lang_statement_union_type *s;
3268 lang_output_section_statement_type *output_section_statement;
3269 lang_statement_union_type **prev;
2c382fb6 3270 fill_type *fill;
2d20f7bf
JJ		 3271 bfd_vma dot;
3272 boolean *relax;
3273{
3274 bfd_vma result;
3275
3276 exp_data_seg.phase = exp_dataseg_none;
3277 result = lang_size_sections_1 (s, output_section_statement, prev, fill,
3278 dot, relax);
3279 if (exp_data_seg.phase == exp_dataseg_end_seen)
3280 {
3281 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3282 a page could be saved in the data segment. */
3283 bfd_vma first, last;
3284
3285 first = -exp_data_seg.base & (exp_data_seg.pagesize - 1);
3286 last = exp_data_seg.end & (exp_data_seg.pagesize - 1);
3287 if (first && last
3288 && ((exp_data_seg.base & ~(exp_data_seg.pagesize - 1))
3289 != (exp_data_seg.end & ~(exp_data_seg.pagesize - 1)))
3290 && first + last <= exp_data_seg.pagesize)
3291 {
3292 exp_data_seg.phase = exp_dataseg_adjust;
3293 result = lang_size_sections_1 (s, output_section_statement, prev,
3294 fill, dot, relax);
3295 }
3296 }
3297
3298 return result;
3299}
3300
252b5132
RH		 3301bfd_vma
3302lang_do_assignments (s, output_section_statement, fill, dot)
08da4cac
KH		 3303 lang_statement_union_type *s;
3304 lang_output_section_statement_type *output_section_statement;
2c382fb6 3305 fill_type *fill;
252b5132
RH		 3306 bfd_vma dot;
3307{
5f992e62
AM		 3308 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3309 ldfile_output_machine);
4cbfc3ac 3310
bba1a0c0 3311 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
252b5132
RH		 3312 {
3313 switch (s->header.type)
3314 {
3315 case lang_constructors_statement_enum:
3316 dot = lang_do_assignments (constructor_list.head,
3317 output_section_statement,
3318 fill,
3319 dot);
3320 break;
3321
3322 case lang_output_section_statement_enum:
3323 {
d1778b88 3324 lang_output_section_statement_type *os;
252b5132 3325
d1778b88 3326 os = &(s->output_section_statement);
252b5132
RH		 3327 if (os->bfd_section != NULL)
3328 {
3329 dot = os->bfd_section->vma;
3330 (void) lang_do_assignments (os->children.head, os,
3331 os->fill, dot);
4cbfc3ac
TW		 3332 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3333
252b5132 3334 }
c13b1b77 3335 if (os->load_base)
252b5132
RH		 3336 {
3337 /* If nothing has been placed into the output section then
4de2d33d 3338 it won't have a bfd_section. */
5f992e62 3339 if (os->bfd_section)
252b5132 3340 {
5f992e62 3341 os->bfd_section->lma
08da4cac
KH		 3342 = exp_get_abs_int (os->load_base, 0, "load base",
3343 lang_final_phase_enum);
252b5132
RH		 3344 }
3345 }
3346 }
3347 break;
3348 case lang_wild_statement_enum:
3349
3350 dot = lang_do_assignments (s->wild_statement.children.head,
3351 output_section_statement,
3352 fill, dot);
3353
3354 break;
3355
3356 case lang_object_symbols_statement_enum:
3357 case lang_output_statement_enum:
3358 case lang_target_statement_enum:
3359#if 0
3360 case lang_common_statement_enum:
3361#endif
3362 break;
3363 case lang_data_statement_enum:
3364 {
3365 etree_value_type value;
3366
3367 value = exp_fold_tree (s->data_statement.exp,
3368 abs_output_section,
3369 lang_final_phase_enum, dot, &dot);
3370 s->data_statement.value = value.value;
3371 if (value.valid_p == false)
3372 einfo (_("%F%P: invalid data statement\n"));
3373 }
b7a26f91
KH		 3374 {
3375 unsigned int size;
08da4cac
KH		 3376 switch (s->data_statement.type)
3377 {
3378 default:
3379 abort ();
3380 case QUAD:
3381 case SQUAD:
3382 size = QUAD_SIZE;
3383 break;
3384 case LONG:
3385 size = LONG_SIZE;
3386 break;
3387 case SHORT:
3388 size = SHORT_SIZE;
3389 break;
3390 case BYTE:
3391 size = BYTE_SIZE;
3392 break;
3393 }
3394 if (size < opb)
3395 size = opb;
3396 dot += size / opb;
3397 }
252b5132
RH		 3398 break;
3399
3400 case lang_reloc_statement_enum:
3401 {
3402 etree_value_type value;
3403
3404 value = exp_fold_tree (s->reloc_statement.addend_exp,
3405 abs_output_section,
3406 lang_final_phase_enum, dot, &dot);
3407 s->reloc_statement.addend_value = value.value;
3408 if (value.valid_p == false)
3409 einfo (_("%F%P: invalid reloc statement\n"));
3410 }
4cbfc3ac 3411 dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
252b5132
RH		 3412 break;
3413
3414 case lang_input_section_enum:
3415 {
3416 asection *in = s->input_section.section;
3417
3418 if (in->_cooked_size != 0)
4cbfc3ac 3419 dot += in->_cooked_size / opb;
252b5132 3420 else
4cbfc3ac 3421 dot += in->_raw_size / opb;
252b5132
RH		 3422 }
3423 break;
3424
3425 case lang_input_statement_enum:
3426 break;
3427 case lang_fill_statement_enum:
3428 fill = s->fill_statement.fill;
3429 break;
3430 case lang_assignment_statement_enum:
3431 {
3432 exp_fold_tree (s->assignment_statement.exp,
3433 output_section_statement,
3434 lang_final_phase_enum,
3435 dot,
3436 &dot);
3437 }
3438
3439 break;
3440 case lang_padding_statement_enum:
4cbfc3ac 3441 dot += s->padding_statement.size / opb;
252b5132
RH		 3442 break;
3443
3444 case lang_group_statement_enum:
3445 dot = lang_do_assignments (s->group_statement.children.head,
3446 output_section_statement,
3447 fill, dot);
3448
3449 break;
3450
3451 default:
3452 FAIL ();
3453 break;
3454 case lang_address_statement_enum:
3455 break;
3456 }
3457
3458 }
3459 return dot;
3460}
3461
3462/* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3463 operator .startof. (section_name), it produces an undefined symbol
3464 .startof.section_name. Similarly, when it sees
3465 .sizeof. (section_name), it produces an undefined symbol
3466 .sizeof.section_name. For all the output sections, we look for
3467 such symbols, and set them to the correct value. */
3468
3469static void
3470lang_set_startof ()
3471{
3472 asection *s;
3473
3474 if (link_info.relocateable)
3475 return;
3476
3477 for (s = output_bfd->sections; s != NULL; s = s->next)
3478 {
3479 const char *secname;
3480 char *buf;
3481 struct bfd_link_hash_entry *h;
3482
3483 secname = bfd_get_section_name (output_bfd, s);
3484 buf = xmalloc (10 + strlen (secname));
3485
3486 sprintf (buf, ".startof.%s", secname);
3487 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3488 if (h != NULL && h->type == bfd_link_hash_undefined)
3489 {
3490 h->type = bfd_link_hash_defined;
3491 h->u.def.value = bfd_get_section_vma (output_bfd, s);
3492 h->u.def.section = bfd_abs_section_ptr;
3493 }
3494
3495 sprintf (buf, ".sizeof.%s", secname);
3496 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3497 if (h != NULL && h->type == bfd_link_hash_undefined)
3498 {
b7a26f91 3499 unsigned opb;
d1778b88 3500
b7a26f91 3501 opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
d1778b88 3502 ldfile_output_machine);
252b5132
RH		 3503 h->type = bfd_link_hash_defined;
3504 if (s->_cooked_size != 0)
4cbfc3ac 3505 h->u.def.value = s->_cooked_size / opb;
252b5132 3506 else
4cbfc3ac 3507 h->u.def.value = s->_raw_size / opb;
252b5132
RH		 3508 h->u.def.section = bfd_abs_section_ptr;
3509 }
3510
3511 free (buf);
3512 }
3513}
3514
3515static void
3516lang_finish ()
3517{
3518 struct bfd_link_hash_entry *h;
3519 boolean warn;
3520
3521 if (link_info.relocateable || link_info.shared)
3522 warn = false;
3523 else
3524 warn = true;
3525
3526 if (entry_symbol == (char *) NULL)
3527 {
3528 /* No entry has been specified. Look for start, but don't warn
3529 if we don't find it. */
3530 entry_symbol = "start";
3531 warn = false;
3532 }
3533
3534 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
3535 if (h != (struct bfd_link_hash_entry *) NULL
3536 && (h->type == bfd_link_hash_defined
3537 || h->type == bfd_link_hash_defweak)
3538 && h->u.def.section->output_section != NULL)
3539 {
3540 bfd_vma val;
3541
3542 val = (h->u.def.value
3543 + bfd_get_section_vma (output_bfd,
3544 h->u.def.section->output_section)
3545 + h->u.def.section->output_offset);
3546 if (! bfd_set_start_address (output_bfd, val))
3547 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
3548 }
3549 else
3550 {
3551 bfd_vma val;
5f992e62 3552 const char *send;
252b5132
RH		 3553
3554 /* We couldn't find the entry symbol. Try parsing it as a
3555 number. */
3556 val = bfd_scan_vma (entry_symbol, &send, 0);
3557 if (*send == '\0')
3558 {
3559 if (! bfd_set_start_address (output_bfd, val))
3560 einfo (_("%P%F: can't set start address\n"));
3561 }
3562 else
3563 {
3564 asection *ts;
3565
3566 /* Can't find the entry symbol, and it's not a number. Use
3567 the first address in the text section. */
1e281515 3568 ts = bfd_get_section_by_name (output_bfd, entry_section);
252b5132
RH		 3569 if (ts != (asection *) NULL)
3570 {
3571 if (warn)
3572 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3573 entry_symbol, bfd_get_section_vma (output_bfd, ts));
3574 if (! bfd_set_start_address (output_bfd,
3575 bfd_get_section_vma (output_bfd,
3576 ts)))
3577 einfo (_("%P%F: can't set start address\n"));
3578 }
3579 else
3580 {
3581 if (warn)
3582 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3583 entry_symbol);
3584 }
3585 }
3586 }
3587}
3588
3589/* This is a small function used when we want to ignore errors from
3590 BFD. */
3591
3592static void
3593#ifdef ANSI_PROTOTYPES
87f2a346 3594ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
252b5132
RH		 3595#else
3596ignore_bfd_errors (s)
87f2a346 3597 const char *s ATTRIBUTE_UNUSED;
252b5132
RH		 3598#endif
3599{
3600 /* Don't do anything. */
3601}
3602
3603/* Check that the architecture of all the input files is compatible
3604 with the output file. Also call the backend to let it do any
3605 other checking that is needed. */
3606
3607static void
3608lang_check ()
3609{
3610 lang_statement_union_type *file;
3611 bfd *input_bfd;
5f992e62 3612 const bfd_arch_info_type *compatible;
252b5132
RH		 3613
3614 for (file = file_chain.head;
3615 file != (lang_statement_union_type *) NULL;
3616 file = file->input_statement.next)
3617 {
3618 input_bfd = file->input_statement.the_bfd;
30cba025
AM		 3619 compatible = bfd_arch_get_compatible (input_bfd, output_bfd);
3620
3621 /* In general it is not possible to perform a relocatable
3622 link between differing object formats when the input
3623 file has relocations, because the relocations in the
3624 input format may not have equivalent representations in
3625 the output format (and besides BFD does not translate
3626 relocs for other link purposes than a final link). */
d35a52e2 3627 if ((link_info.relocateable || link_info.emitrelocations)
30cba025 3628 && (compatible == NULL
d35a52e2 3629 || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
30cba025
AM		 3630 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
3631 {
3632 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3633 bfd_get_target (input_bfd), input_bfd,
3634 bfd_get_target (output_bfd), output_bfd);
3635 /* einfo with %F exits. */
3636 }
3637
252b5132
RH		 3638 if (compatible == NULL)
3639 {
3640 if (command_line.warn_mismatch)
3641 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3642 bfd_printable_name (input_bfd), input_bfd,
3643 bfd_printable_name (output_bfd));
3644 }
b9247304 3645 else if (bfd_count_sections (input_bfd))
252b5132 3646 {
b9247304 3647 /* If the input bfd has no contents, it shouldn't set the
b7a26f91 3648 private data of the output bfd. */
b9247304 3649
252b5132
RH		 3650 bfd_error_handler_type pfn = NULL;
3651
3652 /* If we aren't supposed to warn about mismatched input
3653 files, temporarily set the BFD error handler to a
3654 function which will do nothing. We still want to call
3655 bfd_merge_private_bfd_data, since it may set up
3656 information which is needed in the output file. */
3657 if (! command_line.warn_mismatch)
3658 pfn = bfd_set_error_handler (ignore_bfd_errors);
3659 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3660 {
3661 if (command_line.warn_mismatch)
3662 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3663 input_bfd);
3664 }
3665 if (! command_line.warn_mismatch)
3666 bfd_set_error_handler (pfn);
3667 }
3668 }
3669}
3670
3671/* Look through all the global common symbols and attach them to the
3672 correct section. The -sort-common command line switch may be used
3673 to roughly sort the entries by size. */
3674
3675static void
3676lang_common ()
3677{
4818e05f
AM		 3678 if (command_line.inhibit_common_definition)
3679 return;
252b5132
RH		 3680 if (link_info.relocateable
3681 && ! command_line.force_common_definition)
3682 return;
3683
3684 if (! config.sort_common)
3685 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3686 else
3687 {
3688 int power;
3689
3690 for (power = 4; power >= 0; power--)
3691 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3692 (PTR) &power);
3693 }
3694}
3695
3696/* Place one common symbol in the correct section. */
3697
3698static boolean
3699lang_one_common (h, info)
3700 struct bfd_link_hash_entry *h;
3701 PTR info;
3702{
3703 unsigned int power_of_two;
3704 bfd_vma size;
3705 asection *section;
5f992e62
AM		 3706 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3707 ldfile_output_machine);
252b5132
RH		 3708
3709 if (h->type != bfd_link_hash_common)
3710 return true;
3711
3712 size = h->u.c.size;
3713 power_of_two = h->u.c.p->alignment_power;
3714
3715 if (config.sort_common
3716 && power_of_two < (unsigned int) *(int *) info)
3717 return true;
3718
3719 section = h->u.c.p->section;
3720
3721 /* Increase the size of the section. */
4cbfc3ac
TW		 3722 section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb,
3723 (bfd_size_type) (1 << power_of_two)) * opb;
252b5132
RH		 3724
3725 /* Adjust the alignment if necessary. */
3726 if (power_of_two > section->alignment_power)
3727 section->alignment_power = power_of_two;
3728
3729 /* Change the symbol from common to defined. */
3730 h->type = bfd_link_hash_defined;
3731 h->u.def.section = section;
3732 h->u.def.value = section->_cooked_size;
3733
3734 /* Increase the size of the section. */
3735 section->_cooked_size += size;
3736
3737 /* Make sure the section is allocated in memory, and make sure that
3738 it is no longer a common section. */
3739 section->flags |= SEC_ALLOC;
08da4cac 3740 section->flags &= ~SEC_IS_COMMON;
252b5132
RH		 3741
3742 if (config.map_file != NULL)
3743 {
3744 static boolean header_printed;
3745 int len;
3746 char *name;
3747 char buf[50];
3748
3749 if (! header_printed)
3750 {
3751 minfo (_("\nAllocating common symbols\n"));
3752 minfo (_("Common symbol size file\n\n"));
3753 header_printed = true;
3754 }
3755
3756 name = demangle (h->root.string);
3757 minfo ("%s", name);
3758 len = strlen (name);
3759 free (name);
3760
3761 if (len >= 19)
3762 {
3763 print_nl ();
3764 len = 0;
3765 }
3766 while (len < 20)
3767 {
3768 print_space ();
3769 ++len;
3770 }
3771
3772 minfo ("0x");
3773 if (size <= 0xffffffff)
3774 sprintf (buf, "%lx", (unsigned long) size);
3775 else
3776 sprintf_vma (buf, size);
3777 minfo ("%s", buf);
3778 len = strlen (buf);
3779
3780 while (len < 16)
3781 {
3782 print_space ();
3783 ++len;
3784 }
3785
3786 minfo ("%B\n", section->owner);
3787 }
3788
3789 return true;
3790}
3791
08da4cac
KH		 3792/* Run through the input files and ensure that every input section has
3793 somewhere to go. If one is found without a destination then create
3794 an input request and place it into the statement tree. */
252b5132
RH		 3795
3796static void
3797lang_place_orphans ()
3798{
e50d8076 3799 LANG_FOR_EACH_INPUT_STATEMENT (file)
252b5132
RH		 3800 {
3801 asection *s;
3802
3803 for (s = file->the_bfd->sections;
3804 s != (asection *) NULL;
3805 s = s->next)
3806 {
3807 if (s->output_section == (asection *) NULL)
3808 {
3809 /* This section of the file is not attatched, root
08da4cac 3810 around for a sensible place for it to go. */
252b5132
RH		 3811
3812 if (file->just_syms_flag)
3813 {
c2c01aa7 3814 abort ();
252b5132
RH		 3815 }
3816 else if (strcmp (s->name, "COMMON") == 0)
3817 {
3818 /* This is a lonely common section which must have
3819 come from an archive. We attach to the section
3820 with the wildcard. */
3821 if (! link_info.relocateable
3822 || command_line.force_common_definition)
3823 {
3824 if (default_common_section == NULL)
3825 {
3826#if 0
3827 /* This message happens when using the
3828 svr3.ifile linker script, so I have
3829 disabled it. */
3830 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3831#endif
3832 default_common_section =
3833 lang_output_section_statement_lookup (".bss");
3834
3835 }
39dcfe18
AM		 3836 lang_add_section (&default_common_section->children, s,
3837 default_common_section, file);
252b5132
RH		 3838 }
3839 }
3840 else if (ldemul_place_orphan (file, s))
3841 ;
3842 else
3843 {
39dcfe18 3844 lang_output_section_statement_type *os;
252b5132 3845
39dcfe18
AM		 3846 os = lang_output_section_statement_lookup (s->name);
3847 lang_add_section (&os->children, s, os, file);
252b5132
RH		 3848 }
3849 }
3850 }
3851 }
3852}
3853
252b5132 3854void
aa8804e4 3855lang_set_flags (ptr, flags, invert)
252b5132 3856 lang_memory_region_type *ptr;
5f992e62 3857 const char *flags;
aa8804e4 3858 int invert;
252b5132 3859{
aa8804e4 3860 flagword *ptr_flags;
252b5132 3861
aa8804e4 3862 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
252b5132
RH		 3863 while (*flags)
3864 {
3865 switch (*flags)
3866 {
252b5132
RH		 3867 case 'A': case 'a':
3868 *ptr_flags |= SEC_ALLOC;
3869 break;
3870
3871 case 'R': case 'r':
3872 *ptr_flags |= SEC_READONLY;
3873 break;
3874
3875 case 'W': case 'w':
3876 *ptr_flags |= SEC_DATA;
3877 break;
3878
3879 case 'X': case 'x':
3880 *ptr_flags |= SEC_CODE;
3881 break;
3882
3883 case 'L': case 'l':
3884 case 'I': case 'i':
3885 *ptr_flags |= SEC_LOAD;
3886 break;
3887
3888 default:
3889 einfo (_("%P%F: invalid syntax in flags\n"));
3890 break;
3891 }
3892 flags++;
3893 }
3894}
3895
3896/* Call a function on each input file. This function will be called
3897 on an archive, but not on the elements. */
3898
3899void
3900lang_for_each_input_file (func)
3901 void (*func) PARAMS ((lang_input_statement_type *));
3902{
3903 lang_input_statement_type *f;
3904
3905 for (f = (lang_input_statement_type *) input_file_chain.head;
3906 f != NULL;
3907 f = (lang_input_statement_type *) f->next_real_file)
3908 func (f);
3909}
3910
3911/* Call a function on each file. The function will be called on all
3912 the elements of an archive which are included in the link, but will
3913 not be called on the archive file itself. */
3914
3915void
3916lang_for_each_file (func)
3917 void (*func) PARAMS ((lang_input_statement_type *));
3918{
e50d8076 3919 LANG_FOR_EACH_INPUT_STATEMENT (f)
252b5132
RH		 3920 {
3921 func (f);
3922 }
3923}
3924
3925#if 0
3926
3927/* Not used. */
3928
3929void
3930lang_for_each_input_section (func)
08da4cac 3931 void (*func) PARAMS ((bfd *ab, asection *as));
252b5132 3932{
e50d8076 3933 LANG_FOR_EACH_INPUT_STATEMENT (f)
252b5132 3934 {
08da4cac 3935 asection *s;
252b5132
RH		 3936
3937 for (s = f->the_bfd->sections;
3938 s != (asection *) NULL;
3939 s = s->next)
3940 {
3941 func (f->the_bfd, s);
3942 }
3943 }
3944}
3945
3946#endif
3947
3948void
3949ldlang_add_file (entry)
08da4cac 3950 lang_input_statement_type *entry;
252b5132
RH		 3951{
3952 bfd **pp;
3953
3954 lang_statement_append (&file_chain,
3955 (lang_statement_union_type *) entry,
3956 &entry->next);
3957
3958 /* The BFD linker needs to have a list of all input BFDs involved in
3959 a link. */
3960 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3961 ASSERT (entry->the_bfd != output_bfd);
3962 for (pp = &link_info.input_bfds;
3963 *pp != (bfd *) NULL;
3964 pp = &(*pp)->link_next)
3965 ;
3966 *pp = entry->the_bfd;
3967 entry->the_bfd->usrdata = (PTR) entry;
3968 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3969
3970 /* Look through the sections and check for any which should not be
3971 included in the link. We need to do this now, so that we can
3972 notice when the backend linker tries to report multiple
3973 definition errors for symbols which are in sections we aren't
3974 going to link. FIXME: It might be better to entirely ignore
3975 symbols which are defined in sections which are going to be
3976 discarded. This would require modifying the backend linker for
3977 each backend which might set the SEC_LINK_ONCE flag. If we do
3978 this, we should probably handle SEC_EXCLUDE in the same way. */
3979
3980 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3981}
3982
3983void
3984lang_add_output (name, from_script)
5f992e62 3985 const char *name;
252b5132
RH		 3986 int from_script;
3987{
3988 /* Make -o on command line override OUTPUT in script. */
3989 if (had_output_filename == false || !from_script)
3990 {
3991 output_filename = name;
3992 had_output_filename = true;
3993 }
3994}
3995
252b5132
RH		 3996static lang_output_section_statement_type *current_section;
3997
3998static int
3999topower (x)
4000 int x;
4001{
4002 unsigned int i = 1;
4003 int l;
4004
4005 if (x < 0)
4006 return -1;
4007
5f992e62 4008 for (l = 0; l < 32; l++)
252b5132
RH		 4009 {
4010 if (i >= (unsigned int) x)
4011 return l;
4012 i <<= 1;
4013 }
4014
4015 return 0;
4016}
4017
aea4bd9d 4018lang_output_section_statement_type *
252b5132
RH		 4019lang_enter_output_section_statement (output_section_statement_name,
4020 address_exp, sectype, block_value,
4021 align, subalign, ebase)
4022 const char *output_section_statement_name;
08da4cac 4023 etree_type *address_exp;
252b5132
RH		 4024 enum section_type sectype;
4025 bfd_vma block_value;
4026 etree_type *align;
4027 etree_type *subalign;
4028 etree_type *ebase;
4029{
4030 lang_output_section_statement_type *os;
4031
4032 current_section =
4033 os =
4034 lang_output_section_statement_lookup (output_section_statement_name);
4035
08da4cac
KH		 4036 /* Add this statement to tree. */
4037#if 0
4038 add_statement (lang_output_section_statement_enum,
4039 output_section_statement);
4040#endif
4041 /* Make next things chain into subchain of this. */
252b5132 4042
08da4cac
KH		 4043 if (os->addr_tree == (etree_type *) NULL)
4044 {
4045 os->addr_tree = address_exp;
4046 }
252b5132
RH		 4047 os->sectype = sectype;
4048 if (sectype != noload_section)
4049 os->flags = SEC_NO_FLAGS;
4050 else
4051 os->flags = SEC_NEVER_LOAD;
4052 os->block_value = block_value ? block_value : 1;
4053 stat_ptr = &os->children;
4054
08da4cac
KH		 4055 os->subsection_alignment =
4056 topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
4057 os->section_alignment =
4058 topower (exp_get_value_int (align, -1, "section alignment", 0));
252b5132
RH		 4059
4060 os->load_base = ebase;
aea4bd9d 4061 return os;
252b5132
RH		 4062}
4063
252b5132
RH		 4064void
4065lang_final ()
4066{
4067 lang_output_statement_type *new =
4068 new_stat (lang_output_statement, stat_ptr);
4069
4070 new->name = output_filename;
4071}
4072
08da4cac
KH		 4073/* Reset the current counters in the regions. */
4074
e3dc8847
HPN		 4075void
4076lang_reset_memory_regions ()
252b5132
RH		 4077{
4078 lang_memory_region_type *p = lang_memory_region_list;
b3327aad 4079 asection *o;
252b5132
RH		 4080
4081 for (p = lang_memory_region_list;
4082 p != (lang_memory_region_type *) NULL;
4083 p = p->next)
4084 {
4085 p->old_length = (bfd_size_type) (p->current - p->origin);
4086 p->current = p->origin;
4087 }
b3327aad
AM		 4088
4089 for (o = output_bfd->sections; o != NULL; o = o->next)
4090 o->_raw_size = 0;
252b5132
RH		 4091}
4092
b6bf44ba
AM		 4093/* If the wild pattern was marked KEEP, the member sections
4094 should be as well. */
252b5132
RH		 4095
4096static void
b6bf44ba 4097gc_section_callback (ptr, sec, section, file, data)
252b5132 4098 lang_wild_statement_type *ptr;
b6bf44ba 4099 struct wildcard_list *sec ATTRIBUTE_UNUSED;
4dec4d4e 4100 asection *section;
87f2a346 4101 lang_input_statement_type *file ATTRIBUTE_UNUSED;
5f992e62 4102 PTR data ATTRIBUTE_UNUSED;
252b5132 4103{
4dec4d4e
RH		 4104 if (ptr->keep_sections)
4105 section->flags |= SEC_KEEP;
252b5132
RH		 4106}
4107
b6bf44ba 4108/* Handle a wild statement, marking it against GC. */
252b5132
RH		 4109
4110static void
b6bf44ba 4111lang_gc_wild (s)
252b5132 4112 lang_wild_statement_type *s;
252b5132 4113{
b6bf44ba 4114 walk_wild (s, gc_section_callback, NULL);
252b5132
RH		 4115}
4116
4117/* Iterate over sections marking them against GC. */
4118
4119static void
4120lang_gc_sections_1 (s)
08da4cac 4121 lang_statement_union_type *s;
252b5132 4122{
bba1a0c0 4123 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
252b5132
RH		 4124 {
4125 switch (s->header.type)
4126 {
4127 case lang_wild_statement_enum:
b6bf44ba 4128 lang_gc_wild (&s->wild_statement);
abc6ab0a 4129 break;
252b5132
RH		 4130 case lang_constructors_statement_enum:
4131 lang_gc_sections_1 (constructor_list.head);
4132 break;
4133 case lang_output_section_statement_enum:
4134 lang_gc_sections_1 (s->output_section_statement.children.head);
4135 break;
4136 case lang_group_statement_enum:
4137 lang_gc_sections_1 (s->group_statement.children.head);
4138 break;
4139 default:
4140 break;
4141 }
4142 }
4143}
4144
4145static void
4146lang_gc_sections ()
4147{
4148 struct bfd_link_hash_entry *h;
4149 ldlang_undef_chain_list_type *ulist, fake_list_start;
4150
4151 /* Keep all sections so marked in the link script. */
4152
4153 lang_gc_sections_1 (statement_list.head);
4154
4155 /* Keep all sections containing symbols undefined on the command-line.
4156 Handle the entry symbol at the same time. */
5f992e62 4157
7c83b342
DE		 4158 if (entry_symbol != NULL)
4159 {
4160 fake_list_start.next = ldlang_undef_chain_list_head;
4161 fake_list_start.name = (char *) entry_symbol;
4162 ulist = &fake_list_start;
4163 }
252b5132 4164 else
7c83b342 4165 ulist = ldlang_undef_chain_list_head;
252b5132 4166
7c83b342 4167 for (; ulist; ulist = ulist->next)
252b5132 4168 {
5f992e62 4169 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
252b5132
RH		 4170 false, false, false);
4171
4172 if (h != (struct bfd_link_hash_entry *) NULL
08da4cac
KH		 4173 && (h->type == bfd_link_hash_defined
4174 || h->type == bfd_link_hash_defweak)
252b5132
RH		 4175 && ! bfd_is_abs_section (h->u.def.section))
4176 {
4177 h->u.def.section->flags |= SEC_KEEP;
4178 }
4179 }
4180
4181 bfd_gc_sections (output_bfd, &link_info);
4182}
4183
4184void
4185lang_process ()
4186{
4187 lang_reasonable_defaults ();
4188 current_target = default_target;
4189
08da4cac
KH		 4190 /* Open the output file. */
4191 lang_for_each_statement (ldlang_open_output);
252b5132
RH		 4192
4193 ldemul_create_output_section_statements ();
4194
08da4cac 4195 /* Add to the hash table all undefineds on the command line. */
252b5132
RH		 4196 lang_place_undefineds ();
4197
9503fd87
ILT		 4198 already_linked_table_init ();
4199
08da4cac 4200 /* Create a bfd for each input file. */
252b5132
RH		 4201 current_target = default_target;
4202 open_input_bfds (statement_list.head, false);
4203
4204 ldemul_after_open ();
4205
9503fd87
ILT		 4206 already_linked_table_free ();
4207
252b5132
RH		 4208 /* Make sure that we're not mixing architectures. We call this
4209 after all the input files have been opened, but before we do any
4210 other processing, so that any operations merge_private_bfd_data
4211 does on the output file will be known during the rest of the
4212 link. */
4213 lang_check ();
4214
4215 /* Handle .exports instead of a version script if we're told to do so. */
4216 if (command_line.version_exports_section)
4217 lang_do_version_exports_section ();
4218
4219 /* Build all sets based on the information gathered from the input
4220 files. */
4221 ldctor_build_sets ();
4222
4223 /* Remove unreferenced sections if asked to. */
4224 if (command_line.gc_sections)
4225 lang_gc_sections ();
4226
8550eb6e
JJ		 4227 /* If there were any SEC_MERGE sections, finish their merging, so that
4228 section sizes can be computed. This has to be done after GC of sections,
4229 so that GCed sections are not merged, but before assigning output
4230 sections, since removing whole input sections is hard then. */
4231 bfd_merge_sections (output_bfd, &link_info);
4232
08da4cac 4233 /* Size up the common data. */
252b5132
RH		 4234 lang_common ();
4235
4236 /* Run through the contours of the script and attach input sections
08da4cac 4237 to the correct output sections. */
252b5132
RH		 4238 map_input_to_output_sections (statement_list.head, (char *) NULL,
4239 (lang_output_section_statement_type *) NULL);
4240
08da4cac 4241 /* Find any sections not attached explicitly and handle them. */
252b5132
RH		 4242 lang_place_orphans ();
4243
862120bd
AM		 4244 if (! link_info.relocateable)
4245 {
4246 /* Look for a text section and set the readonly attribute in it. */
4247 asection *found = bfd_get_section_by_name (output_bfd, ".text");
4248
4249 if (found != (asection *) NULL)
4250 {
4251 if (config.text_read_only)
4252 found->flags |= SEC_READONLY;
4253 else
4254 found->flags &= ~SEC_READONLY;
4255 }
4256 }
4257
4258 /* Do anything special before sizing sections. This is where ELF
4259 and other back-ends size dynamic sections. */
252b5132
RH		 4260 ldemul_before_allocation ();
4261
4262 /* We must record the program headers before we try to fix the
4263 section positions, since they will affect SIZEOF_HEADERS. */
4264 lang_record_phdrs ();
4265
b3327aad
AM		 4266 /* Size up the sections. */
4267 lang_size_sections (statement_list.head,
4268 abs_output_section,
4269 &statement_list.head, 0, (bfd_vma) 0, NULL);
4270
08da4cac 4271 /* Now run around and relax if we can. */
252b5132
RH		 4272 if (command_line.relax)
4273 {
252b5132 4274 /* Keep relaxing until bfd_relax_section gives up. */
b3327aad
AM		 4275 boolean relax_again;
4276
252b5132
RH		 4277 do
4278 {
e3dc8847 4279 lang_reset_memory_regions ();
252b5132
RH		 4280
4281 relax_again = false;
4282
4283 /* Note: pe-dll.c does something like this also. If you find
4284 you need to change this code, you probably need to change
08da4cac 4285 pe-dll.c also. DJ */
252b5132
RH		 4286
4287 /* Do all the assignments with our current guesses as to
4288 section sizes. */
4289 lang_do_assignments (statement_list.head,
4290 abs_output_section,
2c382fb6 4291 (fill_type *) 0, (bfd_vma) 0);
252b5132
RH		 4292
4293 /* Perform another relax pass - this time we know where the
0d6d936f 4294 globals are, so can make a better guess. */
252b5132
RH		 4295 lang_size_sections (statement_list.head,
4296 abs_output_section,
0d6d936f 4297 &statement_list.head, 0, (bfd_vma) 0,
b3327aad 4298 &relax_again);
252b5132
RH		 4299 }
4300 while (relax_again);
4301 }
252b5132
RH		 4302
4303 /* See if anything special should be done now we know how big
4304 everything is. */
4305 ldemul_after_allocation ();
4306
4307 /* Fix any .startof. or .sizeof. symbols. */
4308 lang_set_startof ();
4309
08da4cac
KH		 4310 /* Do all the assignments, now that we know the final resting places
4311 of all the symbols. */
252b5132
RH		 4312
4313 lang_do_assignments (statement_list.head,
4314 abs_output_section,
2c382fb6 4315 (fill_type *) 0, (bfd_vma) 0);
252b5132
RH		 4316
4317 /* Make sure that the section addresses make sense. */
4318 if (! link_info.relocateable
4319 && command_line.check_section_addresses)
4320 lang_check_section_addresses ();
5f992e62 4321
08da4cac 4322 /* Final stuffs. */
252b5132
RH		 4323
4324 ldemul_finish ();
4325 lang_finish ();
4326}
4327
4328/* EXPORTED TO YACC */
4329
4330void
b6bf44ba
AM		 4331lang_add_wild (filespec, section_list, keep_sections)
4332 struct wildcard_spec *filespec;
4333 struct wildcard_list *section_list;
252b5132 4334 boolean keep_sections;
252b5132 4335{
b6bf44ba
AM		 4336 struct wildcard_list *curr, *next;
4337 lang_wild_statement_type *new;
4338
4339 /* Reverse the list as the parser puts it back to front. */
4340 for (curr = section_list, section_list = NULL;
4341 curr != NULL;
4342 section_list = curr, curr = next)
4343 {
4344 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
4345 placed_commons = true;
252b5132 4346
b6bf44ba
AM		 4347 next = curr->next;
4348 curr->next = section_list;
4349 }
4350
4351 if (filespec != NULL && filespec->name != NULL)
252b5132 4352 {
b6bf44ba
AM		 4353 if (strcmp (filespec->name, "*") == 0)
4354 filespec->name = NULL;
4355 else if (! wildcardp (filespec->name))
4356 lang_has_input_file = true;
252b5132 4357 }
b6bf44ba
AM		 4358
4359 new = new_stat (lang_wild_statement, stat_ptr);
4360 new->filename = NULL;
4361 new->filenames_sorted = false;
4362 if (filespec != NULL)
252b5132 4363 {
b6bf44ba
AM		 4364 new->filename = filespec->name;
4365 new->filenames_sorted = filespec->sorted;
252b5132 4366 }
b6bf44ba 4367 new->section_list = section_list;
252b5132 4368 new->keep_sections = keep_sections;
252b5132
RH		 4369 lang_list_init (&new->children);
4370}
4371
4372void
4373lang_section_start (name, address)
5f992e62 4374 const char *name;
08da4cac 4375 etree_type *address;
252b5132 4376{
d1778b88 4377 lang_address_statement_type *ad;
252b5132 4378
d1778b88 4379 ad = new_stat (lang_address_statement, stat_ptr);
252b5132
RH		 4380 ad->section_name = name;
4381 ad->address = address;
4382}
4383
4384/* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4385 because of a -e argument on the command line, or zero if this is
4386 called by ENTRY in a linker script. Command line arguments take
4387 precedence. */
4388
4389void
4390lang_add_entry (name, cmdline)
5f992e62 4391 const char *name;
252b5132
RH		 4392 boolean cmdline;
4393{
4394 if (entry_symbol == NULL
4395 || cmdline
4396 || ! entry_from_cmdline)
4397 {
4398 entry_symbol = name;
4399 entry_from_cmdline = cmdline;
4400 }
4401}
4402
4403void
4404lang_add_target (name)
5f992e62 4405 const char *name;
252b5132
RH		 4406{
4407 lang_target_statement_type *new = new_stat (lang_target_statement,
4408 stat_ptr);
4409
4410 new->target = name;
4411
4412}
4413
4414void
4415lang_add_map (name)
5f992e62 4416 const char *name;
252b5132
RH		 4417{
4418 while (*name)
4419 {
4420 switch (*name)
4421 {
08da4cac 4422 case 'F':
252b5132
RH		 4423 map_option_f = true;
4424 break;
4425 }
4426 name++;
4427 }
4428}
4429
4430void
2c382fb6
AM		 4431lang_add_fill (fill)
4432 fill_type *fill;
252b5132
RH		 4433{
4434 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4435 stat_ptr);
4436
2c382fb6 4437 new->fill = fill;
252b5132
RH		 4438}
4439
4440void
4441lang_add_data (type, exp)
4442 int type;
4443 union etree_union *exp;
4444{
4445
4446 lang_data_statement_type *new = new_stat (lang_data_statement,
4447 stat_ptr);
4448
4449 new->exp = exp;
4450 new->type = type;
4451
4452}
4453
4454/* Create a new reloc statement. RELOC is the BFD relocation type to
4455 generate. HOWTO is the corresponding howto structure (we could
4456 look this up, but the caller has already done so). SECTION is the
4457 section to generate a reloc against, or NAME is the name of the
4458 symbol to generate a reloc against. Exactly one of SECTION and
4459 NAME must be NULL. ADDEND is an expression for the addend. */
4460
4461void
4462lang_add_reloc (reloc, howto, section, name, addend)
4463 bfd_reloc_code_real_type reloc;
4464 reloc_howto_type *howto;
4465 asection *section;
4466 const char *name;
4467 union etree_union *addend;
4468{
4469 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
5f992e62 4470
252b5132
RH		 4471 p->reloc = reloc;
4472 p->howto = howto;
4473 p->section = section;
4474 p->name = name;
4475 p->addend_exp = addend;
4476
4477 p->addend_value = 0;
4478 p->output_section = NULL;
4479 p->output_vma = 0;
4480}
4481
4482lang_assignment_statement_type *
4483lang_add_assignment (exp)
08da4cac 4484 etree_type *exp;
252b5132
RH		 4485{
4486 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4487 stat_ptr);
4488
4489 new->exp = exp;
4490 return new;
4491}
4492
4493void
4494lang_add_attribute (attribute)
4495 enum statement_enum attribute;
4496{
4497 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4498}
4499
4500void
4501lang_startup (name)
5f992e62 4502 const char *name;
252b5132
RH		 4503{
4504 if (startup_file != (char *) NULL)
4505 {
4506 einfo (_("%P%Fmultiple STARTUP files\n"));
4507 }
4508 first_file->filename = name;
4509 first_file->local_sym_name = name;
4510 first_file->real = true;
4511
4512 startup_file = name;
4513}
4514
4515void
4516lang_float (maybe)
4517 boolean maybe;
4518{
4519 lang_float_flag = maybe;
4520}
4521
ee3cc2e2
RS		 4522
4523/* Work out the load- and run-time regions from a script statement, and
4524 store them in *LMA_REGION and *REGION respectively.
4525
4526 MEMSPEC is the name of the run-time region, or "*default*" if the
4527 statement didn't specify one. LMA_MEMSPEC is the name of the
4528 load-time region, or null if the statement didn't specify one.
4529 HAVE_LMA_P is true if the statement had an explicit load address.
4530
4531 It is an error to specify both a load region and a load address. */
4532
4533static void
4534lang_get_regions (region, lma_region, memspec, lma_memspec, have_lma_p)
4535 struct memory_region_struct **region, **lma_region;
4536 const char *memspec, *lma_memspec;
4537 int have_lma_p;
4538{
4539 *lma_region = lang_memory_region_lookup (lma_memspec);
4540
4541 /* If no runtime region has been given, but the load region has
4542 been, use the load region. */
4543 if (lma_memspec != 0 && strcmp (memspec, "*default*") == 0)
4544 *region = *lma_region;
4545 else
4546 *region = lang_memory_region_lookup (memspec);
4547
4548 if (have_lma_p && lma_memspec != 0)
4549 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4550}
4551
252b5132 4552void
562d3460 4553lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
2c382fb6 4554 fill_type *fill;
252b5132
RH		 4555 const char *memspec;
4556 struct lang_output_section_phdr_list *phdrs;
562d3460 4557 const char *lma_memspec;
252b5132 4558{
ee3cc2e2
RS		 4559 lang_get_regions (&current_section->region,
4560 &current_section->lma_region,
4561 memspec, lma_memspec,
4562 current_section->load_base != 0);
252b5132 4563 current_section->fill = fill;
252b5132
RH		 4564 current_section->phdrs = phdrs;
4565 stat_ptr = &statement_list;
4566}
4567
08da4cac
KH		 4568/* Create an absolute symbol with the given name with the value of the
4569 address of first byte of the section named.
4570
4571 If the symbol already exists, then do nothing. */
252b5132 4572
252b5132
RH		 4573void
4574lang_abs_symbol_at_beginning_of (secname, name)
4575 const char *secname;
4576 const char *name;
4577{
4578 struct bfd_link_hash_entry *h;
4579
4580 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4581 if (h == (struct bfd_link_hash_entry *) NULL)
4582 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4583
4584 if (h->type == bfd_link_hash_new
4585 || h->type == bfd_link_hash_undefined)
4586 {
4587 asection *sec;
4588
4589 h->type = bfd_link_hash_defined;
4590
4591 sec = bfd_get_section_by_name (output_bfd, secname);
4592 if (sec == (asection *) NULL)
4593 h->u.def.value = 0;
4594 else
4595 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4596
4597 h->u.def.section = bfd_abs_section_ptr;
4598 }
4599}
4600
08da4cac
KH		 4601/* Create an absolute symbol with the given name with the value of the
4602 address of the first byte after the end of the section named.
4603
4604 If the symbol already exists, then do nothing. */
252b5132 4605
252b5132
RH		 4606void
4607lang_abs_symbol_at_end_of (secname, name)
4608 const char *secname;
4609 const char *name;
4610{
4611 struct bfd_link_hash_entry *h;
4612
4613 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4614 if (h == (struct bfd_link_hash_entry *) NULL)
4615 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4616
4617 if (h->type == bfd_link_hash_new
4618 || h->type == bfd_link_hash_undefined)
4619 {
4620 asection *sec;
4621
4622 h->type = bfd_link_hash_defined;
4623
4624 sec = bfd_get_section_by_name (output_bfd, secname);
4625 if (sec == (asection *) NULL)
4626 h->u.def.value = 0;
4627 else
4628 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4cbfc3ac
TW		 4629 + bfd_section_size (output_bfd, sec) /
4630 bfd_octets_per_byte (output_bfd));
252b5132
RH		 4631
4632 h->u.def.section = bfd_abs_section_ptr;
4633 }
4634}
4635
4636void
4637lang_statement_append (list, element, field)
08da4cac
KH		 4638 lang_statement_list_type *list;
4639 lang_statement_union_type *element;
4640 lang_statement_union_type **field;
252b5132
RH		 4641{
4642 *(list->tail) = element;
4643 list->tail = field;
4644}
4645
4646/* Set the output format type. -oformat overrides scripts. */
4647
4648void
4649lang_add_output_format (format, big, little, from_script)
4650 const char *format;
4651 const char *big;
4652 const char *little;
4653 int from_script;
4654{
4655 if (output_target == NULL || !from_script)
4656 {
4657 if (command_line.endian == ENDIAN_BIG
4658 && big != NULL)
4659 format = big;
4660 else if (command_line.endian == ENDIAN_LITTLE
4661 && little != NULL)
4662 format = little;
4663
4664 output_target = format;
4665 }
4666}
4667
4668/* Enter a group. This creates a new lang_group_statement, and sets
4669 stat_ptr to build new statements within the group. */
4670
4671void
4672lang_enter_group ()
4673{
4674 lang_group_statement_type *g;
4675
4676 g = new_stat (lang_group_statement, stat_ptr);
4677 lang_list_init (&g->children);
4678 stat_ptr = &g->children;
4679}
4680
4681/* Leave a group. This just resets stat_ptr to start writing to the
4682 regular list of statements again. Note that this will not work if
4683 groups can occur inside anything else which can adjust stat_ptr,
4684 but currently they can't. */
4685
4686void
4687lang_leave_group ()
4688{
4689 stat_ptr = &statement_list;
4690}
4691
4692/* Add a new program header. This is called for each entry in a PHDRS
4693 command in a linker script. */
4694
4695void
4696lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4697 const char *name;
4698 etree_type *type;
4699 boolean filehdr;
4700 boolean phdrs;
4701 etree_type *at;
4702 etree_type *flags;
4703{
4704 struct lang_phdr *n, **pp;
4705
4706 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4707 n->next = NULL;
4708 n->name = name;
4709 n->type = exp_get_value_int (type, 0, "program header type",
4710 lang_final_phase_enum);
4711 n->filehdr = filehdr;
4712 n->phdrs = phdrs;
4713 n->at = at;
4714 n->flags = flags;
4715
4716 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4717 ;
4718 *pp = n;
4719}
4720
4721/* Record the program header information in the output BFD. FIXME: We
4722 should not be calling an ELF specific function here. */
4723
4724static void
4725lang_record_phdrs ()
4726{
4727 unsigned int alc;
4728 asection **secs;
4729 struct lang_output_section_phdr_list *last;
4730 struct lang_phdr *l;
4731 lang_statement_union_type *u;
4732
4733 alc = 10;
4734 secs = (asection **) xmalloc (alc * sizeof (asection *));
4735 last = NULL;
4736 for (l = lang_phdr_list; l != NULL; l = l->next)
4737 {
4738 unsigned int c;
4739 flagword flags;
4740 bfd_vma at;
4741
4742 c = 0;
4743 for (u = lang_output_section_statement.head;
4744 u != NULL;
4745 u = u->output_section_statement.next)
4746 {
4747 lang_output_section_statement_type *os;
4748 struct lang_output_section_phdr_list *pl;
4749
4750 os = &u->output_section_statement;
4751
4752 pl = os->phdrs;
4753 if (pl != NULL)
4754 last = pl;
4755 else
4756 {
4757 if (os->sectype == noload_section
4758 || os->bfd_section == NULL
4759 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4760 continue;
4761 pl = last;
4762 }
4763
4764 if (os->bfd_section == NULL)
4765 continue;
4766
4767 for (; pl != NULL; pl = pl->next)
4768 {
4769 if (strcmp (pl->name, l->name) == 0)
4770 {
4771 if (c >= alc)
4772 {
4773 alc *= 2;
4774 secs = ((asection **)
4775 xrealloc (secs, alc * sizeof (asection *)));
4776 }
4777 secs[c] = os->bfd_section;
4778 ++c;
4779 pl->used = true;
4780 }
4781 }
4782 }
4783
4784 if (l->flags == NULL)
4785 flags = 0;
4786 else
4787 flags = exp_get_vma (l->flags, 0, "phdr flags",
4788 lang_final_phase_enum);
4789
4790 if (l->at == NULL)
4791 at = 0;
4792 else
4793 at = exp_get_vma (l->at, 0, "phdr load address",
4794 lang_final_phase_enum);
4795
4796 if (! bfd_record_phdr (output_bfd, l->type,
d1778b88 4797 l->flags != NULL, flags, l->at != NULL,
252b5132
RH		 4798 at, l->filehdr, l->phdrs, c, secs))
4799 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4800 }
4801
4802 free (secs);
4803
4804 /* Make sure all the phdr assignments succeeded. */
4805 for (u = lang_output_section_statement.head;
4806 u != NULL;
4807 u = u->output_section_statement.next)
4808 {
4809 struct lang_output_section_phdr_list *pl;
4810
4811 if (u->output_section_statement.bfd_section == NULL)
4812 continue;
4813
4814 for (pl = u->output_section_statement.phdrs;
4815 pl != NULL;
4816 pl = pl->next)
4817 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4818 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4819 u->output_section_statement.name, pl->name);
4820 }
4821}
4822
4823/* Record a list of sections which may not be cross referenced. */
4824
4825void
4826lang_add_nocrossref (l)
4827 struct lang_nocrossref *l;
4828{
4829 struct lang_nocrossrefs *n;
4830
4831 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4832 n->next = nocrossref_list;
4833 n->list = l;
4834 nocrossref_list = n;
4835
4836 /* Set notice_all so that we get informed about all symbols. */
4837 link_info.notice_all = true;
4838}
4839\f
4840/* Overlay handling. We handle overlays with some static variables. */
4841
4842/* The overlay virtual address. */
4843static etree_type *overlay_vma;
4844
252b5132
RH		 4845/* An expression for the maximum section size seen so far. */
4846static etree_type *overlay_max;
4847
4848/* A list of all the sections in this overlay. */
4849
89cdebba 4850struct overlay_list {
252b5132
RH		 4851 struct overlay_list *next;
4852 lang_output_section_statement_type *os;
4853};
4854
4855static struct overlay_list *overlay_list;
4856
4857/* Start handling an overlay. */
4858
4859void
9f88b410 4860lang_enter_overlay (vma_expr)
252b5132 4861 etree_type *vma_expr;
252b5132
RH		 4862{
4863 /* The grammar should prevent nested overlays from occurring. */
9f88b410 4864 ASSERT (overlay_vma == NULL && overlay_max == NULL);
252b5132
RH		 4865
4866 overlay_vma = vma_expr;
252b5132
RH		 4867}
4868
4869/* Start a section in an overlay. We handle this by calling
9f88b410
RS		 4870 lang_enter_output_section_statement with the correct VMA.
4871 lang_leave_overlay sets up the LMA and memory regions. */
252b5132
RH		 4872
4873void
4874lang_enter_overlay_section (name)
4875 const char *name;
4876{
4877 struct overlay_list *n;
4878 etree_type *size;
4879
4880 lang_enter_output_section_statement (name, overlay_vma, normal_section,
9f88b410 4881 0, 0, 0, 0);
252b5132 4882
9f88b410 4883 /* If this is the first section, then base the VMA of future
252b5132
RH		 4884 sections on this one. This will work correctly even if `.' is
4885 used in the addresses. */
4886 if (overlay_list == NULL)
9f88b410 4887 overlay_vma = exp_nameop (ADDR, name);
252b5132
RH		 4888
4889 /* Remember the section. */
4890 n = (struct overlay_list *) xmalloc (sizeof *n);
4891 n->os = current_section;
4892 n->next = overlay_list;
4893 overlay_list = n;
4894
4895 size = exp_nameop (SIZEOF, name);
4896
252b5132
RH		 4897 /* Arrange to work out the maximum section end address. */
4898 if (overlay_max == NULL)
4899 overlay_max = size;
4900 else
4901 overlay_max = exp_binop (MAX_K, overlay_max, size);
4902}
4903
4904/* Finish a section in an overlay. There isn't any special to do
4905 here. */
4906
4907void
4908lang_leave_overlay_section (fill, phdrs)
2c382fb6 4909 fill_type *fill;
252b5132
RH		 4910 struct lang_output_section_phdr_list *phdrs;
4911{
4912 const char *name;
4913 char *clean, *s2;
4914 const char *s1;
4915 char *buf;
4916
4917 name = current_section->name;
4918
9f88b410
RS		 4919 /* For now, assume that "*default*" is the run-time memory region and
4920 that no load-time region has been specified. It doesn't really
4921 matter what we say here, since lang_leave_overlay will override it. */
4922 lang_leave_output_section_statement (fill, "*default*", phdrs, 0);
252b5132
RH		 4923
4924 /* Define the magic symbols. */
4925
4926 clean = xmalloc (strlen (name) + 1);
4927 s2 = clean;
4928 for (s1 = name; *s1 != '\0'; s1++)
3882b010 4929 if (ISALNUM (*s1) || *s1 == '_')
252b5132
RH		 4930 *s2++ = *s1;
4931 *s2 = '\0';
4932
4933 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4934 sprintf (buf, "__load_start_%s", clean);
4935 lang_add_assignment (exp_assop ('=', buf,
4936 exp_nameop (LOADADDR, name)));
4937
4938 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4939 sprintf (buf, "__load_stop_%s", clean);
4940 lang_add_assignment (exp_assop ('=', buf,
4941 exp_binop ('+',
4942 exp_nameop (LOADADDR, name),
4943 exp_nameop (SIZEOF, name))));
4944
4945 free (clean);
4946}
4947
4948/* Finish an overlay. If there are any overlay wide settings, this
4949 looks through all the sections in the overlay and sets them. */
4950
4951void
9f88b410
RS		 4952lang_leave_overlay (lma_expr, nocrossrefs, fill, memspec, phdrs, lma_memspec)
4953 etree_type *lma_expr;
4954 int nocrossrefs;
2c382fb6 4955 fill_type *fill;
252b5132
RH		 4956 const char *memspec;
4957 struct lang_output_section_phdr_list *phdrs;
562d3460 4958 const char *lma_memspec;
252b5132
RH		 4959{
4960 lang_memory_region_type *region;
562d3460 4961 lang_memory_region_type *lma_region;
252b5132
RH		 4962 struct overlay_list *l;
4963 struct lang_nocrossref *nocrossref;
4964
ee3cc2e2
RS		 4965 lang_get_regions (&region, &lma_region,
4966 memspec, lma_memspec,
4967 lma_expr != 0);
562d3460 4968
252b5132
RH		 4969 nocrossref = NULL;
4970
9f88b410
RS		 4971 /* After setting the size of the last section, set '.' to end of the
4972 overlay region. */
4973 if (overlay_list != NULL)
4974 overlay_list->os->update_dot_tree
4975 = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
4976
252b5132
RH		 4977 l = overlay_list;
4978 while (l != NULL)
4979 {
4980 struct overlay_list *next;
4981
2c382fb6 4982 if (fill != (fill_type *) 0 && l->os->fill == (fill_type *) 0)
252b5132 4983 l->os->fill = fill;
1545243b 4984
9f88b410
RS		 4985 l->os->region = region;
4986 l->os->lma_region = lma_region;
4987
4988 /* The first section has the load address specified in the
4989 OVERLAY statement. The rest are worked out from that.
4990 The base address is not needed (and should be null) if
4991 an LMA region was specified. */
4992 if (l->next == 0)
4993 l->os->load_base = lma_expr;
4994 else if (lma_region == 0)
4995 l->os->load_base = exp_binop ('+',
4996 exp_nameop (LOADADDR, l->next->os->name),
4997 exp_nameop (SIZEOF, l->next->os->name));
1545243b 4998
252b5132
RH		 4999 if (phdrs != NULL && l->os->phdrs == NULL)
5000 l->os->phdrs = phdrs;
5001
9f88b410 5002 if (nocrossrefs)
252b5132
RH		 5003 {
5004 struct lang_nocrossref *nc;
5005
5006 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
5007 nc->name = l->os->name;
5008 nc->next = nocrossref;
5009 nocrossref = nc;
5010 }
5011
5012 next = l->next;
5013 free (l);
5014 l = next;
5015 }
5016
5017 if (nocrossref != NULL)
5018 lang_add_nocrossref (nocrossref);
5019
252b5132 5020 overlay_vma = NULL;
252b5132
RH		 5021 overlay_list = NULL;
5022 overlay_max = NULL;
5023}
5024\f
5025/* Version handling. This is only useful for ELF. */
5026
5027/* This global variable holds the version tree that we build. */
5028
5029struct bfd_elf_version_tree *lang_elf_version_info;
5030
5031static int
5032lang_vers_match_lang_c (expr, sym)
5033 struct bfd_elf_version_expr *expr;
5034 const char *sym;
5035{
5036 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5037 return 1;
5038 return fnmatch (expr->pattern, sym, 0) == 0;
5039}
5040
5041static int
5042lang_vers_match_lang_cplusplus (expr, sym)
5043 struct bfd_elf_version_expr *expr;
5044 const char *sym;
5045{
5046 char *alt_sym;
5047 int result;
5048
5049 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5050 return 1;
5051
08da4cac 5052 alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
252b5132
RH		 5053 if (!alt_sym)
5054 {
5055 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5056 Should we early out false in this case? */
5057 result = fnmatch (expr->pattern, sym, 0) == 0;
5058 }
5059 else
5060 {
5061 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5062 free (alt_sym);
5063 }
5064
5065 return result;
5066}
5067
5068static int
5069lang_vers_match_lang_java (expr, sym)
5070 struct bfd_elf_version_expr *expr;
5071 const char *sym;
5072{
5073 char *alt_sym;
5074 int result;
5075
5076 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5077 return 1;
5078
08da4cac 5079 alt_sym = cplus_demangle (sym, DMGL_JAVA);
252b5132
RH		 5080 if (!alt_sym)
5081 {
5082 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5083 Should we early out false in this case? */
5084 result = fnmatch (expr->pattern, sym, 0) == 0;
5085 }
5086 else
5087 {
5088 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5089 free (alt_sym);
5090 }
5091
5092 return result;
5093}
5094
5095/* This is called for each variable name or match expression. */
5096
5097struct bfd_elf_version_expr *
313e35ee 5098lang_new_vers_pattern (orig, new, lang)
252b5132
RH		 5099 struct bfd_elf_version_expr *orig;
5100 const char *new;
5101 const char *lang;
5102{
5103 struct bfd_elf_version_expr *ret;
5104
5105 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
5106 ret->next = orig;
5107 ret->pattern = new;
5108
5109 if (lang == NULL || strcasecmp (lang, "C") == 0)
5110 ret->match = lang_vers_match_lang_c;
5111 else if (strcasecmp (lang, "C++") == 0)
5112 ret->match = lang_vers_match_lang_cplusplus;
5113 else if (strcasecmp (lang, "Java") == 0)
5114 ret->match = lang_vers_match_lang_java;
5115 else
5116 {
5117 einfo (_("%X%P: unknown language `%s' in version information\n"),
5118 lang);
5119 ret->match = lang_vers_match_lang_c;
5120 }
5121
fac1652d 5122 return ldemul_new_vers_pattern (ret);
252b5132
RH		 5123}
5124
5125/* This is called for each set of variable names and match
5126 expressions. */
5127
5128struct bfd_elf_version_tree *
5129lang_new_vers_node (globals, locals)
5130 struct bfd_elf_version_expr *globals;
5131 struct bfd_elf_version_expr *locals;
5132{
5133 struct bfd_elf_version_tree *ret;
5134
5135 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5136 ret->next = NULL;
5137 ret->name = NULL;
5138 ret->vernum = 0;
5139 ret->globals = globals;
5140 ret->locals = locals;
5141 ret->deps = NULL;
5142 ret->name_indx = (unsigned int) -1;
5143 ret->used = 0;
5144 return ret;
5145}
5146
5147/* This static variable keeps track of version indices. */
5148
5149static int version_index;
5150
5151/* This is called when we know the name and dependencies of the
5152 version. */
5153
5154void
5155lang_register_vers_node (name, version, deps)
5156 const char *name;
5157 struct bfd_elf_version_tree *version;
5158 struct bfd_elf_version_deps *deps;
5159{
5160 struct bfd_elf_version_tree *t, **pp;
5161 struct bfd_elf_version_expr *e1;
5162
6b9b879a
JJ		 5163 if (name == NULL)
5164 name = "";
5165
5166 if ((name[0] == '\0' && lang_elf_version_info != NULL)
5167 || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
5168 {
5169 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5170 return;
5171 }
5172
252b5132
RH		 5173 /* Make sure this node has a unique name. */
5174 for (t = lang_elf_version_info; t != NULL; t = t->next)
5175 if (strcmp (t->name, name) == 0)
5176 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5177
5178 /* Check the global and local match names, and make sure there
5179 aren't any duplicates. */
5180
5181 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5182 {
5183 for (t = lang_elf_version_info; t != NULL; t = t->next)
5184 {
5185 struct bfd_elf_version_expr *e2;
5186
5187 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5188 if (strcmp (e1->pattern, e2->pattern) == 0)
5189 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5190 e1->pattern);
5191 }
5192 }
5193
5194 for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5195 {
5196 for (t = lang_elf_version_info; t != NULL; t = t->next)
5197 {
5198 struct bfd_elf_version_expr *e2;
5199
5200 for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5201 if (strcmp (e1->pattern, e2->pattern) == 0)
5202 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5203 e1->pattern);
5204 }
5205 }
5206
5207 version->deps = deps;
5208 version->name = name;
6b9b879a
JJ		 5209 if (name[0] != '\0')
5210 {
5211 ++version_index;
5212 version->vernum = version_index;
5213 }
5214 else
5215 version->vernum = 0;
252b5132
RH		 5216
5217 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5218 ;
5219 *pp = version;
5220}
5221
5222/* This is called when we see a version dependency. */
5223
5224struct bfd_elf_version_deps *
5225lang_add_vers_depend (list, name)
5226 struct bfd_elf_version_deps *list;
5227 const char *name;
5228{
5229 struct bfd_elf_version_deps *ret;
5230 struct bfd_elf_version_tree *t;
5231
5232 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5233 ret->next = list;
5234
5235 for (t = lang_elf_version_info; t != NULL; t = t->next)
5236 {
5237 if (strcmp (t->name, name) == 0)
5238 {
5239 ret->version_needed = t;
5240 return ret;
5241 }
5242 }
5243
5244 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5245
5246 return ret;
5247}
5248
5249static void
5250lang_do_version_exports_section ()
5251{
5252 struct bfd_elf_version_expr *greg = NULL, *lreg;
5253
5254 LANG_FOR_EACH_INPUT_STATEMENT (is)
5255 {
5256 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5257 char *contents, *p;
5258 bfd_size_type len;
5259
5260 if (sec == NULL)
b7a26f91 5261 continue;
252b5132
RH		 5262
5263 len = bfd_section_size (is->the_bfd, sec);
5264 contents = xmalloc (len);
5265 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
6f9efd97 5266 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
252b5132
RH		 5267
5268 p = contents;
89cdebba 5269 while (p < contents + len)
252b5132 5270 {
313e35ee 5271 greg = lang_new_vers_pattern (greg, p, NULL);
252b5132
RH		 5272 p = strchr (p, '\0') + 1;
5273 }
5274
5275 /* Do not free the contents, as we used them creating the regex. */
5276
5277 /* Do not include this section in the link. */
5278 bfd_set_section_flags (is->the_bfd, sec,
5279 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5280 }
5281
313e35ee 5282 lreg = lang_new_vers_pattern (NULL, "*", NULL);
252b5132
RH		 5283 lang_register_vers_node (command_line.version_exports_section,
5284 lang_new_vers_node (greg, lreg), NULL);
5285}
577a0623
AM		 5286
5287void
5288lang_add_unique (name)
5289 const char *name;
5290{
5291 struct unique_sections *ent;
5292
5293 for (ent = unique_section_list; ent; ent = ent->next)
5294 if (strcmp (ent->name, name) == 0)
5295 return;
5296
5297 ent = (struct unique_sections *) xmalloc (sizeof *ent);
5298 ent->name = xstrdup (name);
5299 ent->next = unique_section_list;
5300 unique_section_list = ent;
5301}
GDB Binutils - Deliverables
This page took 0.395385 seconds and 4 git commands to generate.