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