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