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