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