projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elflink.h (elf_link_input_bfd): Remove BFD_VERSION_DATE dependent
[deliverable/binutils-gdb.git] / ld / ldlang.c
CommitLineData
252b5132 1/* Linker command language support.
a2b64bed 2 Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
34efb449 3 2001, 2002
252b5132
RH		 4 Free Software Foundation, Inc.
5
6This file is part of GLD, the Gnu Linker.
7
8GLD is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2, or (at your option)
11any later version.
12
13GLD is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with GLD; see the file COPYING. If not, write to the Free
20Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2102111-1307, USA. */
22
23#include "bfd.h"
24#include "sysdep.h"
25#include "libiberty.h"
3882b010 26#include "safe-ctype.h"
252b5132
RH		 27#include "obstack.h"
28#include "bfdlink.h"
29
30#include "ld.h"
31#include "ldmain.h"
252b5132
RH		 32#include "ldexp.h"
33#include "ldlang.h"
2c382fb6 34#include "ldgram.h"
252b5132
RH		 35#include "ldlex.h"
36#include "ldmisc.h"
37#include "ldctor.h"
38#include "ldfile.h"
b71e2778 39#include "ldemul.h"
252b5132
RH		 40#include "fnmatch.h"
41#include "demangle.h"
42
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
6770ec8c
NC		 1593 if (bfd_link_add_symbols (entry->the_bfd, &link_info))
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
252b5132
RH		 1790/* Open the output file. */
1791
1792static bfd *
1793open_output (name)
08da4cac 1794 const char *name;
252b5132 1795{
08da4cac 1796 bfd *output;
252b5132 1797
08da4cac 1798 /* Has the user told us which output format to use? */
252b5132
RH		 1799 if (output_target == (char *) NULL)
1800 {
08da4cac
KH		 1801 /* No - has the current target been set to something other than
1802 the default? */
e50d8076 1803 if (current_target != default_target)
252b5132 1804 output_target = current_target;
e50d8076 1805
08da4cac 1806 /* No - can we determine the format of the first input file? */
e50d8076
NC		 1807 else
1808 {
1809 output_target = get_first_input_target ();
1810
1811 /* Failed - use the default output target. */
1812 if (output_target == NULL)
1813 output_target = default_target;
1814 }
1815 }
5f992e62 1816
08da4cac
KH		 1817 /* Has the user requested a particular endianness on the command
1818 line? */
e50d8076
NC		 1819 if (command_line.endian != ENDIAN_UNSET)
1820 {
08da4cac 1821 const bfd_target *target;
1b69a0bf 1822 enum bfd_endian desired_endian;
e50d8076
NC		 1823
1824 /* Get the chosen target. */
5f992e62 1825 target = bfd_search_for_target (get_target, (PTR) output_target);
e50d8076 1826
c13b1b77
NC		 1827 /* If the target is not supported, we cannot do anything. */
1828 if (target != NULL)
e50d8076 1829 {
c13b1b77
NC		 1830 if (command_line.endian == ENDIAN_BIG)
1831 desired_endian = BFD_ENDIAN_BIG;
e50d8076 1832 else
c13b1b77 1833 desired_endian = BFD_ENDIAN_LITTLE;
5f992e62
AM		 1834
1835 /* See if the target has the wrong endianness. This should
1836 not happen if the linker script has provided big and
1837 little endian alternatives, but some scrips don't do
1838 this. */
c13b1b77 1839 if (target->byteorder != desired_endian)
e50d8076 1840 {
c13b1b77
NC		 1841 /* If it does, then see if the target provides
1842 an alternative with the correct endianness. */
1843 if (target->alternative_target != NULL
1844 && (target->alternative_target->byteorder == desired_endian))
1845 output_target = target->alternative_target->name;
e50d8076 1846 else
c13b1b77 1847 {
5f992e62
AM		 1848 /* Try to find a target as similar as possible to
1849 the default target, but which has the desired
1850 endian characteristic. */
d1778b88
AM		 1851 (void) bfd_search_for_target (closest_target_match,
1852 (PTR) target);
5f992e62
AM		 1853
1854 /* Oh dear - we could not find any targets that
1855 satisfy our requirements. */
c13b1b77
NC		 1856 if (winner == NULL)
1857 einfo (_("%P: warning: could not find any targets that match endianness requirement\n"));
1858 else
1859 output_target = winner->name;
1860 }
e50d8076
NC		 1861 }
1862 }
252b5132 1863 }
5f992e62 1864
252b5132
RH		 1865 output = bfd_openw (name, output_target);
1866
1867 if (output == (bfd *) NULL)
1868 {
1869 if (bfd_get_error () == bfd_error_invalid_target)
e50d8076
NC		 1870 einfo (_("%P%F: target %s not found\n"), output_target);
1871
252b5132
RH		 1872 einfo (_("%P%F: cannot open output file %s: %E\n"), name);
1873 }
1874
1875 delete_output_file_on_failure = true;
1876
08da4cac
KH		 1877#if 0
1878 output->flags |= D_PAGED;
1879#endif
252b5132
RH		 1880
1881 if (! bfd_set_format (output, bfd_object))
1882 einfo (_("%P%F:%s: can not make object file: %E\n"), name);
1883 if (! bfd_set_arch_mach (output,
1884 ldfile_output_architecture,
1885 ldfile_output_machine))
1886 einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
1887
1888 link_info.hash = bfd_link_hash_table_create (output);
1889 if (link_info.hash == (struct bfd_link_hash_table *) NULL)
1890 einfo (_("%P%F: can not create link hash table: %E\n"));
1891
1892 bfd_set_gp_size (output, g_switch_value);
1893 return output;
1894}
1895
252b5132
RH		 1896static void
1897ldlang_open_output (statement)
08da4cac 1898 lang_statement_union_type *statement;
252b5132
RH		 1899{
1900 switch (statement->header.type)
1901 {
1902 case lang_output_statement_enum:
1903 ASSERT (output_bfd == (bfd *) NULL);
1904 output_bfd = open_output (statement->output_statement.name);
1905 ldemul_set_output_arch ();
1906 if (config.magic_demand_paged && !link_info.relocateable)
1907 output_bfd->flags |= D_PAGED;
1908 else
1909 output_bfd->flags &= ~D_PAGED;
1910 if (config.text_read_only)
1911 output_bfd->flags |= WP_TEXT;
1912 else
1913 output_bfd->flags &= ~WP_TEXT;
1914 if (link_info.traditional_format)
1915 output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
1916 else
1917 output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
1918 break;
1919
1920 case lang_target_statement_enum:
1921 current_target = statement->target_statement.target;
1922 break;
1923 default:
1924 break;
1925 }
1926}
1927
1928/* Open all the input files. */
1929
1930static void
1931open_input_bfds (s, force)
1932 lang_statement_union_type *s;
1933 boolean force;
1934{
bba1a0c0 1935 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
252b5132
RH		 1936 {
1937 switch (s->header.type)
1938 {
1939 case lang_constructors_statement_enum:
1940 open_input_bfds (constructor_list.head, force);
1941 break;
1942 case lang_output_section_statement_enum:
1943 open_input_bfds (s->output_section_statement.children.head, force);
1944 break;
1945 case lang_wild_statement_enum:
08da4cac 1946 /* Maybe we should load the file's symbols. */
252b5132
RH		 1947 if (s->wild_statement.filename
1948 && ! wildcardp (s->wild_statement.filename))
1949 (void) lookup_name (s->wild_statement.filename);
1950 open_input_bfds (s->wild_statement.children.head, force);
1951 break;
1952 case lang_group_statement_enum:
1953 {
1954 struct bfd_link_hash_entry *undefs;
1955
1956 /* We must continually search the entries in the group
08da4cac
KH		 1957 until no new symbols are added to the list of undefined
1958 symbols. */
252b5132
RH		 1959
1960 do
1961 {
1962 undefs = link_info.hash->undefs_tail;
1963 open_input_bfds (s->group_statement.children.head, true);
1964 }
1965 while (undefs != link_info.hash->undefs_tail);
1966 }
1967 break;
1968 case lang_target_statement_enum:
1969 current_target = s->target_statement.target;
1970 break;
1971 case lang_input_statement_enum:
e50d8076 1972 if (s->input_statement.real)
252b5132
RH		 1973 {
1974 lang_statement_list_type add;
1975
1976 s->input_statement.target = current_target;
1977
1978 /* If we are being called from within a group, and this
1979 is an archive which has already been searched, then
cd4c806a
L		 1980 force it to be researched unless the whole archive
1981 has been loaded already. */
252b5132 1982 if (force
cd4c806a 1983 && !s->input_statement.whole_archive
252b5132
RH		 1984 && s->input_statement.loaded
1985 && bfd_check_format (s->input_statement.the_bfd,
1986 bfd_archive))
1987 s->input_statement.loaded = false;
1988
d1778b88 1989 lang_list_init (&add);
1276aefa 1990
6770ec8c
NC		 1991 if (! load_symbols (&s->input_statement, &add))
1992 config.make_executable = false;
252b5132
RH		 1993
1994 if (add.head != NULL)
1995 {
bba1a0c0
AM		 1996 *add.tail = s->header.next;
1997 s->header.next = add.head;
252b5132
RH		 1998 }
1999 }
2000 break;
2001 default:
2002 break;
2003 }
2004 }
2005}
2006
08da4cac
KH		 2007/* If there are [COMMONS] statements, put a wild one into the bss
2008 section. */
252b5132
RH		 2009
2010static void
2011lang_reasonable_defaults ()
2012{
2013#if 0
2014 lang_output_section_statement_lookup (".text");
2015 lang_output_section_statement_lookup (".data");
2016
08da4cac 2017 default_common_section = lang_output_section_statement_lookup (".bss");
252b5132 2018
252b5132
RH		 2019 if (placed_commons == false)
2020 {
2021 lang_wild_statement_type *new =
2022 new_stat (lang_wild_statement,
2023 &default_common_section->children);
2024
2025 new->section_name = "COMMON";
2026 new->filename = (char *) NULL;
2027 lang_list_init (&new->children);
2028 }
2029#endif
252b5132
RH		 2030}
2031
08da4cac 2032/* Add the supplied name to the symbol table as an undefined reference.
fcf0e35b
AM		 2033 This is a two step process as the symbol table doesn't even exist at
2034 the time the ld command line is processed. First we put the name
2035 on a list, then, once the output file has been opened, transfer the
2036 name to the symbol table. */
2037
e3e942e9 2038typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
252b5132 2039
e3e942e9 2040#define ldlang_undef_chain_list_head entry_symbol.next
252b5132
RH		 2041
2042void
2043ldlang_add_undef (name)
5f992e62 2044 const char *const name;
252b5132
RH		 2045{
2046 ldlang_undef_chain_list_type *new =
2047 ((ldlang_undef_chain_list_type *)
2048 stat_alloc (sizeof (ldlang_undef_chain_list_type)));
2049
2050 new->next = ldlang_undef_chain_list_head;
2051 ldlang_undef_chain_list_head = new;
2052
d1b2b2dc 2053 new->name = xstrdup (name);
fcf0e35b
AM		 2054
2055 if (output_bfd != NULL)
2056 insert_undefined (new->name);
2057}
2058
2059/* Insert NAME as undefined in the symbol table. */
2060
2061static void
2062insert_undefined (name)
2063 const char *name;
2064{
2065 struct bfd_link_hash_entry *h;
2066
2067 h = bfd_link_hash_lookup (link_info.hash, name, true, false, true);
2068 if (h == (struct bfd_link_hash_entry *) NULL)
2069 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
2070 if (h->type == bfd_link_hash_new)
2071 {
2072 h->type = bfd_link_hash_undefined;
2073 h->u.undef.abfd = NULL;
2074 bfd_link_add_undef (link_info.hash, h);
2075 }
252b5132
RH		 2076}
2077
2078/* Run through the list of undefineds created above and place them
2079 into the linker hash table as undefined symbols belonging to the
08da4cac
KH		 2080 script file. */
2081
252b5132
RH		 2082static void
2083lang_place_undefineds ()
2084{
2085 ldlang_undef_chain_list_type *ptr;
2086
2087 for (ptr = ldlang_undef_chain_list_head;
2088 ptr != (ldlang_undef_chain_list_type *) NULL;
2089 ptr = ptr->next)
2090 {
fcf0e35b 2091 insert_undefined (ptr->name);
252b5132
RH		 2092 }
2093}
2094
08da4cac
KH		 2095/* Open input files and attatch to output sections. */
2096
252b5132
RH		 2097static void
2098map_input_to_output_sections (s, target, output_section_statement)
08da4cac 2099 lang_statement_union_type *s;
5f992e62 2100 const char *target;
08da4cac 2101 lang_output_section_statement_type *output_section_statement;
252b5132 2102{
bba1a0c0 2103 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
252b5132
RH		 2104 {
2105 switch (s->header.type)
2106 {
252b5132 2107 case lang_wild_statement_enum:
b6bf44ba 2108 wild (&s->wild_statement, target, output_section_statement);
abc6ab0a 2109 break;
252b5132
RH		 2110 case lang_constructors_statement_enum:
2111 map_input_to_output_sections (constructor_list.head,
2112 target,
2113 output_section_statement);
2114 break;
2115 case lang_output_section_statement_enum:
2116 map_input_to_output_sections (s->output_section_statement.children.head,
2117 target,
2118 &s->output_section_statement);
2119 break;
2120 case lang_output_statement_enum:
2121 break;
2122 case lang_target_statement_enum:
2123 target = s->target_statement.target;
2124 break;
2125 case lang_group_statement_enum:
2126 map_input_to_output_sections (s->group_statement.children.head,
2127 target,
2128 output_section_statement);
2129 break;
2130 case lang_fill_statement_enum:
2131 case lang_input_section_enum:
2132 case lang_object_symbols_statement_enum:
2133 case lang_data_statement_enum:
2134 case lang_reloc_statement_enum:
2135 case lang_padding_statement_enum:
2136 case lang_input_statement_enum:
2137 if (output_section_statement != NULL
2138 && output_section_statement->bfd_section == NULL)
2139 init_os (output_section_statement);
2140 break;
2141 case lang_assignment_statement_enum:
2142 if (output_section_statement != NULL
2143 && output_section_statement->bfd_section == NULL)
2144 init_os (output_section_statement);
2145
2146 /* Make sure that any sections mentioned in the assignment
08da4cac 2147 are initialized. */
252b5132
RH		 2148 exp_init_os (s->assignment_statement.exp);
2149 break;
2150 case lang_afile_asection_pair_statement_enum:
2151 FAIL ();
2152 break;
2153 case lang_address_statement_enum:
08da4cac 2154 /* Mark the specified section with the supplied address. */
252b5132
RH		 2155 {
2156 lang_output_section_statement_type *os =
2157 lang_output_section_statement_lookup
2158 (s->address_statement.section_name);
2159
2160 if (os->bfd_section == NULL)
2161 init_os (os);
2162 os->addr_tree = s->address_statement.address;
2163 }
2164 break;
2165 }
2166 }
2167}
2168
4bd5a393
AM		 2169/* An output section might have been removed after its statement was
2170 added. For example, ldemul_before_allocation can remove dynamic
2171 sections if they turn out to be not needed. Clean them up here. */
2172
2173static void
2174strip_excluded_output_sections ()
2175{
2176 lang_statement_union_type *u;
2177
2178 for (u = lang_output_section_statement.head;
2179 u != NULL;
2180 u = u->output_section_statement.next)
2181 {
2182 lang_output_section_statement_type *os;
2183 asection *s;
2184
2185 os = &u->output_section_statement;
2186 s = os->bfd_section;
2187 if (s != NULL && (s->flags & SEC_EXCLUDE) != 0)
2188 {
2189 asection **p;
2190
2191 os->bfd_section = NULL;
2192
2193 for (p = &output_bfd->sections; *p; p = &(*p)->next)
2194 if (*p == s)
2195 {
2196 bfd_section_list_remove (output_bfd, p);
2197 output_bfd->section_count--;
2198 break;
2199 }
2200 }
2201 }
2202}
2203
252b5132
RH		 2204static void
2205print_output_section_statement (output_section_statement)
08da4cac 2206 lang_output_section_statement_type *output_section_statement;
252b5132
RH		 2207{
2208 asection *section = output_section_statement->bfd_section;
2209 int len;
2210
2211 if (output_section_statement != abs_output_section)
2212 {
2213 minfo ("\n%s", output_section_statement->name);
2214
2215 if (section != NULL)
2216 {
2217 print_dot = section->vma;
2218
2219 len = strlen (output_section_statement->name);
2220 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2221 {
2222 print_nl ();
2223 len = 0;
2224 }
2225 while (len < SECTION_NAME_MAP_LENGTH)
2226 {
2227 print_space ();
2228 ++len;
2229 }
2230
2231 minfo ("0x%V %W", section->vma, section->_raw_size);
2232
2233 if (output_section_statement->load_base != NULL)
2234 {
2235 bfd_vma addr;
2236
2237 addr = exp_get_abs_int (output_section_statement->load_base, 0,
2238 "load base", lang_final_phase_enum);
2239 minfo (_(" load address 0x%V"), addr);
2240 }
2241 }
2242
2243 print_nl ();
2244 }
2245
2246 print_statement_list (output_section_statement->children.head,
2247 output_section_statement);
2248}
2249
2250static void
2251print_assignment (assignment, output_section)
08da4cac
KH		 2252 lang_assignment_statement_type *assignment;
2253 lang_output_section_statement_type *output_section;
252b5132
RH		 2254{
2255 int i;
2256 etree_value_type result;
2257
2258 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2259 print_space ();
2260
2261 result = exp_fold_tree (assignment->exp->assign.src, output_section,
2262 lang_final_phase_enum, print_dot, &print_dot);
2263 if (result.valid_p)
7b17f854
RS		 2264 {
2265 const char *dst;
2266 bfd_vma value;
2267
2268 value = result.value + result.section->bfd_section->vma;
2269 dst = assignment->exp->assign.dst;
2270
2271 minfo ("0x%V", value);
2272 if (dst[0] == '.' && dst[1] == 0)
2273 print_dot = value;
2274 }
252b5132
RH		 2275 else
2276 {
2277 minfo ("*undef* ");
2278#ifdef BFD64
2279 minfo (" ");
2280#endif
2281 }
2282
2283 minfo (" ");
2284
2285 exp_print_tree (assignment->exp);
2286
2287 print_nl ();
2288}
2289
2290static void
2291print_input_statement (statm)
08da4cac 2292 lang_input_statement_type *statm;
252b5132
RH		 2293{
2294 if (statm->filename != (char *) NULL)
2295 {
2296 fprintf (config.map_file, "LOAD %s\n", statm->filename);
2297 }
2298}
2299
2300/* Print all symbols defined in a particular section. This is called
2301 via bfd_link_hash_traverse. */
2302
5f992e62 2303static boolean
252b5132
RH		 2304print_one_symbol (hash_entry, ptr)
2305 struct bfd_link_hash_entry *hash_entry;
2306 PTR ptr;
2307{
2308 asection *sec = (asection *) ptr;
2309
2310 if ((hash_entry->type == bfd_link_hash_defined
2311 || hash_entry->type == bfd_link_hash_defweak)
2312 && sec == hash_entry->u.def.section)
2313 {
2314 int i;
2315
2316 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2317 print_space ();
2318 minfo ("0x%V ",
2319 (hash_entry->u.def.value
2320 + hash_entry->u.def.section->output_offset
2321 + hash_entry->u.def.section->output_section->vma));
2322
2323 minfo (" %T\n", hash_entry->root.string);
2324 }
2325
2326 return true;
2327}
2328
2329/* Print information about an input section to the map file. */
2330
2331static void
2332print_input_section (in)
08da4cac 2333 lang_input_section_type *in;
252b5132
RH		 2334{
2335 asection *i = in->section;
2336 bfd_size_type size = i->_cooked_size != 0 ? i->_cooked_size : i->_raw_size;
5f992e62 2337 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
f6af82bd 2338 ldfile_output_machine);
252b5132
RH		 2339 if (size != 0)
2340 {
2341 print_space ();
2342
2343 minfo ("%s", i->name);
2344
2345 if (i->output_section != NULL)
2346 {
2347 int len;
2348
2349 len = 1 + strlen (i->name);
2350 if (len >= SECTION_NAME_MAP_LENGTH - 1)
2351 {
2352 print_nl ();
2353 len = 0;
2354 }
2355 while (len < SECTION_NAME_MAP_LENGTH)
2356 {
2357 print_space ();
2358 ++len;
2359 }
2360
2361 minfo ("0x%V %W %B\n",
4cbfc3ac 2362 i->output_section->vma + i->output_offset, size / opb,
252b5132
RH		 2363 i->owner);
2364
2365 if (i->_cooked_size != 0 && i->_cooked_size != i->_raw_size)
2366 {
2367 len = SECTION_NAME_MAP_LENGTH + 3;
2368#ifdef BFD64
2369 len += 16;
2370#else
2371 len += 8;
2372#endif
2373 while (len > 0)
2374 {
2375 print_space ();
2376 --len;
2377 }
2378
2379 minfo (_("%W (size before relaxing)\n"), i->_raw_size);
2380 }
2381
2382 bfd_link_hash_traverse (link_info.hash, print_one_symbol, (PTR) i);
2383
4cbfc3ac 2384 print_dot = i->output_section->vma + i->output_offset + size / opb;
252b5132
RH		 2385 }
2386 }
2387}
2388
2389static void
2390print_fill_statement (fill)
08da4cac 2391 lang_fill_statement_type *fill;
252b5132 2392{
2c382fb6
AM		 2393 size_t size;
2394 unsigned char *p;
2395 fputs (" FILL mask 0x", config.map_file);
2396 for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
2397 fprintf (config.map_file, "%02x", *p);
2398 fputs ("\n", config.map_file);
252b5132
RH		 2399}
2400
2401static void
2402print_data_statement (data)
08da4cac 2403 lang_data_statement_type *data;
252b5132
RH		 2404{
2405 int i;
2406 bfd_vma addr;
2407 bfd_size_type size;
2408 const char *name;
5f992e62 2409 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
f6af82bd 2410 ldfile_output_machine);
252b5132
RH		 2411
2412 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2413 print_space ();
2414
2415 addr = data->output_vma;
2416 if (data->output_section != NULL)
2417 addr += data->output_section->vma;
2418
2419 switch (data->type)
2420 {
2421 default:
2422 abort ();
2423 case BYTE:
2424 size = BYTE_SIZE;
2425 name = "BYTE";
2426 break;
2427 case SHORT:
2428 size = SHORT_SIZE;
2429 name = "SHORT";
2430 break;
2431 case LONG:
2432 size = LONG_SIZE;
2433 name = "LONG";
2434 break;
2435 case QUAD:
2436 size = QUAD_SIZE;
2437 name = "QUAD";
2438 break;
2439 case SQUAD:
2440 size = QUAD_SIZE;
2441 name = "SQUAD";
2442 break;
2443 }
2444
2445 minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
2446
2447 if (data->exp->type.node_class != etree_value)
2448 {
2449 print_space ();
2450 exp_print_tree (data->exp);
2451 }
2452
2453 print_nl ();
2454
4cbfc3ac
TW		 2455 print_dot = addr + size / opb;
2456
252b5132
RH		 2457}
2458
2459/* Print an address statement. These are generated by options like
2460 -Ttext. */
2461
2462static void
2463print_address_statement (address)
2464 lang_address_statement_type *address;
2465{
2466 minfo (_("Address of section %s set to "), address->section_name);
2467 exp_print_tree (address->address);
2468 print_nl ();
2469}
2470
2471/* Print a reloc statement. */
2472
2473static void
2474print_reloc_statement (reloc)
2475 lang_reloc_statement_type *reloc;
2476{
2477 int i;
2478 bfd_vma addr;
2479 bfd_size_type size;
5f992e62
AM		 2480 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2481 ldfile_output_machine);
252b5132
RH		 2482
2483 for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
2484 print_space ();
2485
2486 addr = reloc->output_vma;
2487 if (reloc->output_section != NULL)
2488 addr += reloc->output_section->vma;
2489
2490 size = bfd_get_reloc_size (reloc->howto);
2491
2492 minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
2493
2494 if (reloc->name != NULL)
2495 minfo ("%s+", reloc->name);
2496 else
2497 minfo ("%s+", reloc->section->name);
2498
2499 exp_print_tree (reloc->addend_exp);
2500
2501 print_nl ();
2502
4cbfc3ac 2503 print_dot = addr + size / opb;
5f992e62 2504}
252b5132
RH		 2505
2506static void
2507print_padding_statement (s)
2508 lang_padding_statement_type *s;
2509{
2510 int len;
2511 bfd_vma addr;
5f992e62
AM		 2512 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2513 ldfile_output_machine);
252b5132
RH		 2514
2515 minfo (" *fill*");
2516
2517 len = sizeof " *fill*" - 1;
2518 while (len < SECTION_NAME_MAP_LENGTH)
2519 {
2520 print_space ();
2521 ++len;
2522 }
2523
2524 addr = s->output_offset;
2525 if (s->output_section != NULL)
2526 addr += s->output_section->vma;
2c382fb6 2527 minfo ("0x%V %W ", addr, s->size);
252b5132 2528
2c382fb6
AM		 2529 if (s->fill->size != 0)
2530 {
2531 size_t size;
2532 unsigned char *p;
2533 for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
2534 fprintf (config.map_file, "%02x", *p);
2535 }
252b5132
RH		 2536
2537 print_nl ();
2538
4cbfc3ac 2539 print_dot = addr + s->size / opb;
252b5132
RH		 2540}
2541
2542static void
2543print_wild_statement (w, os)
08da4cac
KH		 2544 lang_wild_statement_type *w;
2545 lang_output_section_statement_type *os;
252b5132 2546{
b6bf44ba
AM		 2547 struct wildcard_list *sec;
2548
252b5132
RH		 2549 print_space ();
2550
2551 if (w->filenames_sorted)
2552 minfo ("SORT(");
08da4cac 2553 if (w->filename != NULL)
252b5132
RH		 2554 minfo ("%s", w->filename);
2555 else
2556 minfo ("*");
2557 if (w->filenames_sorted)
2558 minfo (")");
2559
2560 minfo ("(");
b6bf44ba
AM		 2561 for (sec = w->section_list; sec; sec = sec->next)
2562 {
2563 if (sec->spec.sorted)
2564 minfo ("SORT(");
2565 if (sec->spec.exclude_name_list != NULL)
2566 {
2567 name_list *tmp;
34786259 2568 minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
b6bf44ba 2569 for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
34786259
AM		 2570 minfo (" %s", tmp->name);
2571 minfo (") ");
b6bf44ba
AM		 2572 }
2573 if (sec->spec.name != NULL)
2574 minfo ("%s", sec->spec.name);
2575 else
2576 minfo ("*");
2577 if (sec->spec.sorted)
2578 minfo (")");
34786259
AM		 2579 if (sec->next)
2580 minfo (" ");
b6bf44ba 2581 }
252b5132
RH		 2582 minfo (")");
2583
2584 print_nl ();
2585
2586 print_statement_list (w->children.head, os);
2587}
2588
2589/* Print a group statement. */
2590
2591static void
2592print_group (s, os)
2593 lang_group_statement_type *s;
2594 lang_output_section_statement_type *os;
2595{
2596 fprintf (config.map_file, "START GROUP\n");
2597 print_statement_list (s->children.head, os);
2598 fprintf (config.map_file, "END GROUP\n");
2599}
2600
2601/* Print the list of statements in S.
2602 This can be called for any statement type. */
2603
2604static void
2605print_statement_list (s, os)
2606 lang_statement_union_type *s;
2607 lang_output_section_statement_type *os;
2608{
2609 while (s != NULL)
2610 {
2611 print_statement (s, os);
bba1a0c0 2612 s = s->header.next;
252b5132
RH		 2613 }
2614}
2615
2616/* Print the first statement in statement list S.
2617 This can be called for any statement type. */
2618
2619static void
2620print_statement (s, os)
2621 lang_statement_union_type *s;
2622 lang_output_section_statement_type *os;
2623{
2624 switch (s->header.type)
2625 {
2626 default:
2627 fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
2628 FAIL ();
2629 break;
2630 case lang_constructors_statement_enum:
2631 if (constructor_list.head != NULL)
2632 {
2633 if (constructors_sorted)
2634 minfo (" SORT (CONSTRUCTORS)\n");
2635 else
2636 minfo (" CONSTRUCTORS\n");
2637 print_statement_list (constructor_list.head, os);
2638 }
2639 break;
2640 case lang_wild_statement_enum:
2641 print_wild_statement (&s->wild_statement, os);
2642 break;
2643 case lang_address_statement_enum:
2644 print_address_statement (&s->address_statement);
2645 break;
2646 case lang_object_symbols_statement_enum:
2647 minfo (" CREATE_OBJECT_SYMBOLS\n");
2648 break;
2649 case lang_fill_statement_enum:
2650 print_fill_statement (&s->fill_statement);
2651 break;
2652 case lang_data_statement_enum:
2653 print_data_statement (&s->data_statement);
2654 break;
2655 case lang_reloc_statement_enum:
2656 print_reloc_statement (&s->reloc_statement);
2657 break;
2658 case lang_input_section_enum:
2659 print_input_section (&s->input_section);
2660 break;
2661 case lang_padding_statement_enum:
2662 print_padding_statement (&s->padding_statement);
2663 break;
2664 case lang_output_section_statement_enum:
2665 print_output_section_statement (&s->output_section_statement);
2666 break;
2667 case lang_assignment_statement_enum:
2668 print_assignment (&s->assignment_statement, os);
2669 break;
2670 case lang_target_statement_enum:
2671 fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
2672 break;
2673 case lang_output_statement_enum:
2674 minfo ("OUTPUT(%s", s->output_statement.name);
2675 if (output_target != NULL)
2676 minfo (" %s", output_target);
2677 minfo (")\n");
2678 break;
2679 case lang_input_statement_enum:
2680 print_input_statement (&s->input_statement);
2681 break;
2682 case lang_group_statement_enum:
2683 print_group (&s->group_statement, os);
2684 break;
2685 case lang_afile_asection_pair_statement_enum:
2686 FAIL ();
2687 break;
2688 }
2689}
2690
2691static void
2692print_statements ()
2693{
2694 print_statement_list (statement_list.head, abs_output_section);
2695}
2696
2697/* Print the first N statements in statement list S to STDERR.
2698 If N == 0, nothing is printed.
2699 If N < 0, the entire list is printed.
2700 Intended to be called from GDB. */
2701
2702void
2703dprint_statement (s, n)
08da4cac 2704 lang_statement_union_type *s;
252b5132
RH		 2705 int n;
2706{
2707 FILE *map_save = config.map_file;
2708
2709 config.map_file = stderr;
2710
2711 if (n < 0)
2712 print_statement_list (s, abs_output_section);
2713 else
2714 {
2715 while (s && --n >= 0)
2716 {
2717 print_statement (s, abs_output_section);
bba1a0c0 2718 s = s->header.next;
252b5132
RH		 2719 }
2720 }
2721
2722 config.map_file = map_save;
2723}
2724
b3327aad
AM		 2725static void
2726insert_pad (ptr, fill, alignment_needed, output_section, dot)
2727 lang_statement_union_type **ptr;
2c382fb6 2728 fill_type *fill;
b3327aad
AM		 2729 unsigned int alignment_needed;
2730 asection *output_section;
252b5132
RH		 2731 bfd_vma dot;
2732{
2c382fb6 2733 static fill_type zero_fill = { 1, { 0 } };
b3327aad 2734 lang_statement_union_type *pad;
b3327aad 2735
c0c330a7 2736 pad = ((lang_statement_union_type *)
2af02257 2737 ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
b3327aad 2738 if (ptr != &statement_list.head
2af02257 2739 && pad->header.type == lang_padding_statement_enum
b3327aad 2740 && pad->padding_statement.output_section == output_section)
252b5132 2741 {
b3327aad
AM		 2742 /* Use the existing pad statement. The above test on output
2743 section is probably redundant, but it doesn't hurt to check. */
252b5132 2744 }
b3327aad 2745 else
252b5132 2746 {
b3327aad
AM		 2747 /* Make a new padding statement, linked into existing chain. */
2748 pad = ((lang_statement_union_type *)
2749 stat_alloc (sizeof (lang_padding_statement_type)));
2750 pad->header.next = *ptr;
2751 *ptr = pad;
2752 pad->header.type = lang_padding_statement_enum;
2753 pad->padding_statement.output_section = output_section;
2c382fb6
AM		 2754 if (fill == (fill_type *) 0)
2755 fill = &zero_fill;
b3327aad 2756 pad->padding_statement.fill = fill;
252b5132 2757 }
b3327aad
AM		 2758 pad->padding_statement.output_offset = dot - output_section->vma;
2759 pad->padding_statement.size = alignment_needed;
2760 output_section->_raw_size += alignment_needed;
252b5132
RH		 2761}
2762
08da4cac
KH		 2763/* Work out how much this section will move the dot point. */
2764
252b5132 2765static bfd_vma
b3327aad 2766size_input_section (this_ptr, output_section_statement, fill, dot)
08da4cac
KH		 2767 lang_statement_union_type **this_ptr;
2768 lang_output_section_statement_type *output_section_statement;
2c382fb6 2769 fill_type *fill;
252b5132 2770 bfd_vma dot;
252b5132
RH		 2771{
2772 lang_input_section_type *is = &((*this_ptr)->input_section);
2773 asection *i = is->section;
2774
2775 if (is->ifile->just_syms_flag == false)
2776 {
b3327aad
AM		 2777 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
2778 ldfile_output_machine);
2779 unsigned int alignment_needed;
2780 asection *o;
2781
2782 /* Align this section first to the input sections requirement,
2783 then to the output section's requirement. If this alignment
2784 is greater than any seen before, then record it too. Perform
2785 the alignment by inserting a magic 'padding' statement. */
2786
252b5132 2787 if (output_section_statement->subsection_alignment != -1)
b3327aad
AM		 2788 i->alignment_power = output_section_statement->subsection_alignment;
2789
2790 o = output_section_statement->bfd_section;
2791 if (o->alignment_power < i->alignment_power)
2792 o->alignment_power = i->alignment_power;
252b5132 2793
b3327aad
AM		 2794 alignment_needed = align_power (dot, i->alignment_power) - dot;
2795
2796 if (alignment_needed != 0)
2797 {
2798 insert_pad (this_ptr, fill, alignment_needed * opb, o, dot);
2799 dot += alignment_needed;
2800 }
252b5132 2801
08da4cac 2802 /* Remember where in the output section this input section goes. */
252b5132 2803
b3327aad 2804 i->output_offset = dot - o->vma;
252b5132 2805
08da4cac 2806 /* Mark how big the output section must be to contain this now. */
252b5132 2807 if (i->_cooked_size != 0)
4cbfc3ac 2808 dot += i->_cooked_size / opb;
252b5132 2809 else
4cbfc3ac 2810 dot += i->_raw_size / opb;
b3327aad 2811 o->_raw_size = (dot - o->vma) * opb;
252b5132
RH		 2812 }
2813 else
2814 {
2815 i->output_offset = i->vma - output_section_statement->bfd_section->vma;
2816 }
2817
2818 return dot;
2819}
2820
33275c22 2821#define IGNORE_SECTION(bfd, s) \
d1778b88
AM		 2822 (((bfd_get_section_flags (bfd, s) & (SEC_ALLOC | SEC_LOAD)) \
2823 != (SEC_ALLOC | SEC_LOAD)) \
33275c22 2824 || bfd_section_size (bfd, s) == 0)
d1778b88 2825
252b5132
RH		 2826/* Check to see if any allocated sections overlap with other allocated
2827 sections. This can happen when the linker script specifically specifies
2828 the output section addresses of the two sections. */
08da4cac 2829
252b5132
RH		 2830static void
2831lang_check_section_addresses ()
2832{
08da4cac 2833 asection *s;
f6af82bd 2834 unsigned opb = bfd_octets_per_byte (output_bfd);
252b5132
RH		 2835
2836 /* Scan all sections in the output list. */
2837 for (s = output_bfd->sections; s != NULL; s = s->next)
33275c22 2838 {
08da4cac 2839 asection *os;
5f992e62 2840
33275c22
NC		 2841 /* Ignore sections which are not loaded or which have no contents. */
2842 if (IGNORE_SECTION (output_bfd, s))
2843 continue;
5f992e62 2844
33275c22
NC		 2845 /* Once we reach section 's' stop our seach. This prevents two
2846 warning messages from being produced, one for 'section A overlaps
2847 section B' and one for 'section B overlaps section A'. */
2848 for (os = output_bfd->sections; os != s; os = os->next)
2849 {
2850 bfd_vma s_start;
2851 bfd_vma s_end;
2852 bfd_vma os_start;
2853 bfd_vma os_end;
5f992e62 2854
33275c22
NC		 2855 /* Only consider loadable sections with real contents. */
2856 if (IGNORE_SECTION (output_bfd, os))
2857 continue;
252b5132 2858
33275c22
NC		 2859 /* We must check the sections' LMA addresses not their
2860 VMA addresses because overlay sections can have
2861 overlapping VMAs but they must have distinct LMAs. */
2862 s_start = bfd_section_lma (output_bfd, s);
2863 os_start = bfd_section_lma (output_bfd, os);
9e4ed18c
TW		 2864 s_end = s_start + bfd_section_size (output_bfd, s) / opb - 1;
2865 os_end = os_start + bfd_section_size (output_bfd, os) / opb - 1;
5f992e62 2866
33275c22
NC		 2867 /* Look for an overlap. */
2868 if ((s_end < os_start) || (s_start > os_end))
2869 continue;
5f992e62 2870
33275c22 2871 einfo (
252b5132 2872_("%X%P: section %s [%V -> %V] overlaps section %s [%V -> %V]\n"),
33275c22 2873 s->name, s_start, s_end, os->name, os_start, os_end);
5f992e62 2874
33275c22
NC		 2875 /* Once we have found one overlap for this section,
2876 stop looking for others. */
2877 break;
2878 }
2879 }
252b5132
RH		 2880}
2881
562d3460
TW		 2882/* Make sure the new address is within the region. We explicitly permit the
2883 current address to be at the exact end of the region when the address is
2884 non-zero, in case the region is at the end of addressable memory and the
5f992e62 2885 calculation wraps around. */
562d3460
TW		 2886
2887static void
2888os_region_check (os, region, tree, base)
08da4cac
KH		 2889 lang_output_section_statement_type *os;
2890 struct memory_region_struct *region;
2891 etree_type *tree;
2892 bfd_vma base;
562d3460
TW		 2893{
2894 if ((region->current < region->origin
2895 || (region->current - region->origin > region->length))
2896 && ((region->current != region->origin + region->length)
b7a26f91 2897 || base == 0))
562d3460
TW		 2898 {
2899 if (tree != (etree_type *) NULL)
b7a26f91
KH		 2900 {
2901 einfo (_("%X%P: address 0x%v of %B section %s is not within region %s\n"),
2902 region->current,
2903 os->bfd_section->owner,
2904 os->bfd_section->name,
2905 region->name);
2906 }
562d3460 2907 else
b7a26f91
KH		 2908 {
2909 einfo (_("%X%P: region %s is full (%B section %s)\n"),
2910 region->name,
2911 os->bfd_section->owner,
2912 os->bfd_section->name);
2913 }
562d3460
TW		 2914 /* Reset the region pointer. */
2915 region->current = region->origin;
2916 }
2917}
2918
252b5132
RH		 2919/* Set the sizes for all the output sections. */
2920
2d20f7bf
JJ		 2921static bfd_vma
2922lang_size_sections_1 (s, output_section_statement, prev, fill, dot, relax)
08da4cac
KH		 2923 lang_statement_union_type *s;
2924 lang_output_section_statement_type *output_section_statement;
2925 lang_statement_union_type **prev;
2c382fb6 2926 fill_type *fill;
252b5132 2927 bfd_vma dot;
b3327aad 2928 boolean *relax;
252b5132 2929{
5f992e62 2930 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
f6af82bd 2931 ldfile_output_machine);
4cbfc3ac 2932
252b5132 2933 /* Size up the sections from their constituent parts. */
bba1a0c0 2934 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
252b5132
RH		 2935 {
2936 switch (s->header.type)
2937 {
2938 case lang_output_section_statement_enum:
2939 {
2940 bfd_vma after;
d1778b88 2941 lang_output_section_statement_type *os;
252b5132 2942
d1778b88 2943 os = &s->output_section_statement;
252b5132
RH		 2944 if (os->bfd_section == NULL)
2945 /* This section was never actually created. */
2946 break;
2947
2948 /* If this is a COFF shared library section, use the size and
2949 address from the input section. FIXME: This is COFF
2950 specific; it would be cleaner if there were some other way
2951 to do this, but nothing simple comes to mind. */
2952 if ((os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
2953 {
08da4cac 2954 asection *input;
252b5132
RH		 2955
2956 if (os->children.head == NULL
bba1a0c0 2957 || os->children.head->header.next != NULL
252b5132
RH		 2958 || os->children.head->header.type != lang_input_section_enum)
2959 einfo (_("%P%X: Internal error on COFF shared library section %s\n"),
2960 os->name);
2961
2962 input = os->children.head->input_section.section;
2963 bfd_set_section_vma (os->bfd_section->owner,
2964 os->bfd_section,
2965 bfd_section_vma (input->owner, input));
2966 os->bfd_section->_raw_size = input->_raw_size;
2967 break;
2968 }
2969
2970 if (bfd_is_abs_section (os->bfd_section))
2971 {
2972 /* No matter what happens, an abs section starts at zero. */
2973 ASSERT (os->bfd_section->vma == 0);
2974 }
2975 else
2976 {
2977 if (os->addr_tree == (etree_type *) NULL)
2978 {
2979 /* No address specified for this section, get one
2980 from the region specification. */
2981 if (os->region == (lang_memory_region_type *) NULL
2982 || (((bfd_get_section_flags (output_bfd, os->bfd_section)
2983 & (SEC_ALLOC | SEC_LOAD)) != 0)
2984 && os->region->name[0] == '*'
2985 && strcmp (os->region->name, "*default*") == 0))
2986 {
2987 os->region = lang_memory_default (os->bfd_section);
2988 }
2989
2990 /* If a loadable section is using the default memory
2991 region, and some non default memory regions were
2992 defined, issue a warning. */
2993 if ((bfd_get_section_flags (output_bfd, os->bfd_section)
2994 & (SEC_ALLOC | SEC_LOAD)) != 0
d08a14c3
AM		 2995 && (bfd_get_section_flags (output_bfd, os->bfd_section)
2996 & SEC_NEVER_LOAD) == 0
252b5132
RH		 2997 && ! link_info.relocateable
2998 && strcmp (os->region->name, "*default*") == 0
2999 && lang_memory_region_list != NULL
d1778b88
AM		 3000 && (strcmp (lang_memory_region_list->name,
3001 "*default*") != 0
252b5132
RH		 3002 || lang_memory_region_list->next != NULL))
3003 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
d1778b88
AM		 3004 bfd_get_section_name (output_bfd,
3005 os->bfd_section));
252b5132
RH		 3006
3007 dot = os->region->current;
5f992e62 3008
252b5132
RH		 3009 if (os->section_alignment == -1)
3010 {
3011 bfd_vma olddot;
3012
3013 olddot = dot;
d1778b88
AM		 3014 dot = align_power (dot,
3015 os->bfd_section->alignment_power);
252b5132
RH		 3016
3017 if (dot != olddot && config.warn_section_align)
3018 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
3019 os->name, (unsigned int) (dot - olddot));
3020 }
3021 }
3022 else
3023 {
3024 etree_value_type r;
3025
3026 r = exp_fold_tree (os->addr_tree,
3027 abs_output_section,
3028 lang_allocating_phase_enum,
3029 dot, &dot);
3030 if (r.valid_p == false)
3031 {
3032 einfo (_("%F%S: non constant address expression for section %s\n"),
3033 os->name);
3034 }
3035 dot = r.value + r.section->bfd_section->vma;
3036 }
5f992e62 3037
252b5132
RH		 3038 /* The section starts here.
3039 First, align to what the section needs. */
3040
3041 if (os->section_alignment != -1)
3042 dot = align_power (dot, os->section_alignment);
3043
3044 bfd_set_section_vma (0, os->bfd_section, dot);
5f992e62 3045
252b5132
RH		 3046 os->bfd_section->output_offset = 0;
3047 }
3048
2d20f7bf
JJ		 3049 lang_size_sections_1 (os->children.head, os, &os->children.head,
3050 os->fill, dot, relax);
5f992e62 3051
08da4cac
KH		 3052 /* Put the section within the requested block size, or
3053 align at the block boundary. */
c553bb91 3054 after = align_n (os->bfd_section->vma
32edc927 3055 + os->bfd_section->_raw_size / opb,
252b5132
RH		 3056 (bfd_vma) os->block_value);
3057
3058 if (bfd_is_abs_section (os->bfd_section))
3059 ASSERT (after == os->bfd_section->vma);
13ae64f3 3060 else if ((os->bfd_section->flags & SEC_HAS_CONTENTS) == 0
704afa60
JJ		 3061 && (os->bfd_section->flags & SEC_THREAD_LOCAL)
3062 && ! link_info.relocateable)
13ae64f3 3063 os->bfd_section->_raw_size = 0;
252b5132 3064 else
5f992e62 3065 os->bfd_section->_raw_size =
08da4cac 3066 (after - os->bfd_section->vma) * opb;
9f88b410 3067
4cbfc3ac 3068 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
252b5132
RH		 3069 os->processed = true;
3070
9f88b410
RS		 3071 if (os->update_dot_tree != 0)
3072 exp_fold_tree (os->update_dot_tree, abs_output_section,
3073 lang_allocating_phase_enum, dot, &dot);
3074
252b5132
RH		 3075 /* Update dot in the region ?
3076 We only do this if the section is going to be allocated,
3077 since unallocated sections do not contribute to the region's
13392b77 3078 overall size in memory.
5f992e62 3079
cce4c4c5
NC		 3080 If the SEC_NEVER_LOAD bit is not set, it will affect the
3081 addresses of sections after it. We have to update
3082 dot. */
252b5132 3083 if (os->region != (lang_memory_region_type *) NULL
cce4c4c5
NC		 3084 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
3085 & SEC_NEVER_LOAD) == 0
3086 || (bfd_get_section_flags (output_bfd, os->bfd_section)
3087 & (SEC_ALLOC | SEC_LOAD))))
252b5132
RH		 3088 {
3089 os->region->current = dot;
5f992e62 3090
562d3460 3091 /* Make sure the new address is within the region. */
08da4cac
KH		 3092 os_region_check (os, os->region, os->addr_tree,
3093 os->bfd_section->vma);
3094
3095 /* If there's no load address specified, use the run
3096 region as the load region. */
3097 if (os->lma_region == NULL && os->load_base == NULL)
3098 os->lma_region = os->region;
3099
ee3cc2e2 3100 if (os->lma_region != NULL && os->lma_region != os->region)
08da4cac 3101 {
ee3cc2e2
RS		 3102 /* Set load_base, which will be handled later. */
3103 os->load_base = exp_intop (os->lma_region->current);
3104 os->lma_region->current +=
3105 os->bfd_section->_raw_size / opb;
3106 os_region_check (os, os->lma_region, NULL,
3107 os->bfd_section->lma);
08da4cac 3108 }
252b5132
RH		 3109 }
3110 }
3111 break;
3112
3113 case lang_constructors_statement_enum:
2d20f7bf
JJ		 3114 dot = lang_size_sections_1 (constructor_list.head,
3115 output_section_statement,
3116 &s->wild_statement.children.head,
3117 fill, dot, relax);
252b5132
RH		 3118 break;
3119
3120 case lang_data_statement_enum:
3121 {
3122 unsigned int size = 0;
3123
08da4cac
KH		 3124 s->data_statement.output_vma =
3125 dot - output_section_statement->bfd_section->vma;
252b5132
RH		 3126 s->data_statement.output_section =
3127 output_section_statement->bfd_section;
3128
3129 switch (s->data_statement.type)
3130 {
08da4cac
KH		 3131 default:
3132 abort ();
252b5132
RH		 3133 case QUAD:
3134 case SQUAD:
3135 size = QUAD_SIZE;
3136 break;
3137 case LONG:
3138 size = LONG_SIZE;
3139 break;
3140 case SHORT:
3141 size = SHORT_SIZE;
3142 break;
3143 case BYTE:
3144 size = BYTE_SIZE;
3145 break;
3146 }
08da4cac
KH		 3147 if (size < opb)
3148 size = opb;
4cbfc3ac 3149 dot += size / opb;
252b5132
RH		 3150 output_section_statement->bfd_section->_raw_size += size;
3151 /* The output section gets contents, and then we inspect for
3152 any flags set in the input script which override any ALLOC. */
3153 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
08da4cac
KH		 3154 if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3155 {
3156 output_section_statement->bfd_section->flags |=
3157 SEC_ALLOC | SEC_LOAD;
3158 }
252b5132
RH		 3159 }
3160 break;
3161
3162 case lang_reloc_statement_enum:
3163 {
3164 int size;
3165
3166 s->reloc_statement.output_vma =
3167 dot - output_section_statement->bfd_section->vma;
3168 s->reloc_statement.output_section =
3169 output_section_statement->bfd_section;
3170 size = bfd_get_reloc_size (s->reloc_statement.howto);
4cbfc3ac 3171 dot += size / opb;
252b5132
RH		 3172 output_section_statement->bfd_section->_raw_size += size;
3173 }
3174 break;
5f992e62 3175
252b5132
RH		 3176 case lang_wild_statement_enum:
3177
2d20f7bf
JJ		 3178 dot = lang_size_sections_1 (s->wild_statement.children.head,
3179 output_section_statement,
3180 &s->wild_statement.children.head,
3181 fill, dot, relax);
252b5132
RH		 3182
3183 break;
3184
3185 case lang_object_symbols_statement_enum:
3186 link_info.create_object_symbols_section =
3187 output_section_statement->bfd_section;
3188 break;
3189 case lang_output_statement_enum:
3190 case lang_target_statement_enum:
3191 break;
3192 case lang_input_section_enum:
3193 {
3194 asection *i;
3195
3196 i = (*prev)->input_section.section;
3197 if (! relax)
3198 {
3199 if (i->_cooked_size == 0)
3200 i->_cooked_size = i->_raw_size;
3201 }
3202 else
3203 {
3204 boolean again;
3205
3206 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3207 einfo (_("%P%F: can't relax section: %E\n"));
3208 if (again)
b3327aad 3209 *relax = true;
252b5132 3210 }
b3327aad
AM		 3211 dot = size_input_section (prev, output_section_statement,
3212 output_section_statement->fill, dot);
252b5132
RH		 3213 }
3214 break;
3215 case lang_input_statement_enum:
3216 break;
3217 case lang_fill_statement_enum:
08da4cac
KH		 3218 s->fill_statement.output_section =
3219 output_section_statement->bfd_section;
252b5132
RH		 3220
3221 fill = s->fill_statement.fill;
3222 break;
3223 case lang_assignment_statement_enum:
3224 {
3225 bfd_vma newdot = dot;
3226
3227 exp_fold_tree (s->assignment_statement.exp,
3228 output_section_statement,
3229 lang_allocating_phase_enum,
3230 dot,
3231 &newdot);
3232
3233 if (newdot != dot)
3234 {
252b5132
RH		 3235 if (output_section_statement == abs_output_section)
3236 {
3237 /* If we don't have an output section, then just adjust
3238 the default memory address. */
3239 lang_memory_region_lookup ("*default*")->current = newdot;
3240 }
b3327aad 3241 else
252b5132 3242 {
b3327aad
AM		 3243 /* Insert a pad after this statement. We can't
3244 put the pad before when relaxing, in case the
3245 assignment references dot. */
3246 insert_pad (&s->header.next, fill, (newdot - dot) * opb,
3247 output_section_statement->bfd_section, dot);
3248
3249 /* Don't neuter the pad below when relaxing. */
3250 s = s->header.next;
252b5132
RH		 3251 }
3252
3253 dot = newdot;
3254 }
3255 }
3256 break;
3257
3258 case lang_padding_statement_enum:
c0c330a7
AM		 3259 /* If this is the first time lang_size_sections is called,
3260 we won't have any padding statements. If this is the
3261 second or later passes when relaxing, we should allow
3262 padding to shrink. If padding is needed on this pass, it
3263 will be added back in. */
3264 s->padding_statement.size = 0;
6e814ff8
AM		 3265
3266 /* Make sure output_offset is valid. If relaxation shrinks
3267 the section and this pad isn't needed, it's possible to
3268 have output_offset larger than the final size of the
3269 section. bfd_set_section_contents will complain even for
3270 a pad size of zero. */
3271 s->padding_statement.output_offset
3272 = dot - output_section_statement->bfd_section->vma;
252b5132
RH		 3273 break;
3274
3275 case lang_group_statement_enum:
2d20f7bf
JJ		 3276 dot = lang_size_sections_1 (s->group_statement.children.head,
3277 output_section_statement,
3278 &s->group_statement.children.head,
3279 fill, dot, relax);
252b5132
RH		 3280 break;
3281
3282 default:
3283 FAIL ();
3284 break;
3285
c0c330a7 3286 /* We can only get here when relaxing is turned on. */
252b5132
RH		 3287 case lang_address_statement_enum:
3288 break;
3289 }
3290 prev = &s->header.next;
3291 }
3292 return dot;
3293}
3294
2d20f7bf
JJ		 3295bfd_vma
3296lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
3297 lang_statement_union_type *s;
3298 lang_output_section_statement_type *output_section_statement;
3299 lang_statement_union_type **prev;
2c382fb6 3300 fill_type *fill;
2d20f7bf
JJ		 3301 bfd_vma dot;
3302 boolean *relax;
3303{
3304 bfd_vma result;
3305
3306 exp_data_seg.phase = exp_dataseg_none;
3307 result = lang_size_sections_1 (s, output_section_statement, prev, fill,
3308 dot, relax);
3309 if (exp_data_seg.phase == exp_dataseg_end_seen)
3310 {
3311 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3312 a page could be saved in the data segment. */
3313 bfd_vma first, last;
3314
3315 first = -exp_data_seg.base & (exp_data_seg.pagesize - 1);
3316 last = exp_data_seg.end & (exp_data_seg.pagesize - 1);
3317 if (first && last
3318 && ((exp_data_seg.base & ~(exp_data_seg.pagesize - 1))
3319 != (exp_data_seg.end & ~(exp_data_seg.pagesize - 1)))
3320 && first + last <= exp_data_seg.pagesize)
3321 {
3322 exp_data_seg.phase = exp_dataseg_adjust;
3323 result = lang_size_sections_1 (s, output_section_statement, prev,
3324 fill, dot, relax);
3325 }
3326 }
3327
3328 return result;
3329}
3330
252b5132
RH		 3331bfd_vma
3332lang_do_assignments (s, output_section_statement, fill, dot)
08da4cac
KH		 3333 lang_statement_union_type *s;
3334 lang_output_section_statement_type *output_section_statement;
2c382fb6 3335 fill_type *fill;
252b5132
RH		 3336 bfd_vma dot;
3337{
5f992e62
AM		 3338 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3339 ldfile_output_machine);
4cbfc3ac 3340
bba1a0c0 3341 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
252b5132
RH		 3342 {
3343 switch (s->header.type)
3344 {
3345 case lang_constructors_statement_enum:
3346 dot = lang_do_assignments (constructor_list.head,
3347 output_section_statement,
3348 fill,
3349 dot);
3350 break;
3351
3352 case lang_output_section_statement_enum:
3353 {
d1778b88 3354 lang_output_section_statement_type *os;
252b5132 3355
d1778b88 3356 os = &(s->output_section_statement);
252b5132
RH		 3357 if (os->bfd_section != NULL)
3358 {
3359 dot = os->bfd_section->vma;
3360 (void) lang_do_assignments (os->children.head, os,
3361 os->fill, dot);
4cbfc3ac
TW		 3362 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3363
252b5132 3364 }
c13b1b77 3365 if (os->load_base)
252b5132
RH		 3366 {
3367 /* If nothing has been placed into the output section then
4de2d33d 3368 it won't have a bfd_section. */
5f992e62 3369 if (os->bfd_section)
252b5132 3370 {
5f992e62 3371 os->bfd_section->lma
08da4cac
KH		 3372 = exp_get_abs_int (os->load_base, 0, "load base",
3373 lang_final_phase_enum);
252b5132
RH		 3374 }
3375 }
3376 }
3377 break;
3378 case lang_wild_statement_enum:
3379
3380 dot = lang_do_assignments (s->wild_statement.children.head,
3381 output_section_statement,
3382 fill, dot);
3383
3384 break;
3385
3386 case lang_object_symbols_statement_enum:
3387 case lang_output_statement_enum:
3388 case lang_target_statement_enum:
3389#if 0
3390 case lang_common_statement_enum:
3391#endif
3392 break;
3393 case lang_data_statement_enum:
3394 {
3395 etree_value_type value;
3396
3397 value = exp_fold_tree (s->data_statement.exp,
3398 abs_output_section,
3399 lang_final_phase_enum, dot, &dot);
3400 s->data_statement.value = value.value;
3401 if (value.valid_p == false)
3402 einfo (_("%F%P: invalid data statement\n"));
3403 }
b7a26f91
KH		 3404 {
3405 unsigned int size;
08da4cac
KH		 3406 switch (s->data_statement.type)
3407 {
3408 default:
3409 abort ();
3410 case QUAD:
3411 case SQUAD:
3412 size = QUAD_SIZE;
3413 break;
3414 case LONG:
3415 size = LONG_SIZE;
3416 break;
3417 case SHORT:
3418 size = SHORT_SIZE;
3419 break;
3420 case BYTE:
3421 size = BYTE_SIZE;
3422 break;
3423 }
3424 if (size < opb)
3425 size = opb;
3426 dot += size / opb;
3427 }
252b5132
RH		 3428 break;
3429
3430 case lang_reloc_statement_enum:
3431 {
3432 etree_value_type value;
3433
3434 value = exp_fold_tree (s->reloc_statement.addend_exp,
3435 abs_output_section,
3436 lang_final_phase_enum, dot, &dot);
3437 s->reloc_statement.addend_value = value.value;
3438 if (value.valid_p == false)
3439 einfo (_("%F%P: invalid reloc statement\n"));
3440 }
4cbfc3ac 3441 dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
252b5132
RH		 3442 break;
3443
3444 case lang_input_section_enum:
3445 {
3446 asection *in = s->input_section.section;
3447
3448 if (in->_cooked_size != 0)
4cbfc3ac 3449 dot += in->_cooked_size / opb;
252b5132 3450 else
4cbfc3ac 3451 dot += in->_raw_size / opb;
252b5132
RH		 3452 }
3453 break;
3454
3455 case lang_input_statement_enum:
3456 break;
3457 case lang_fill_statement_enum:
3458 fill = s->fill_statement.fill;
3459 break;
3460 case lang_assignment_statement_enum:
3461 {
3462 exp_fold_tree (s->assignment_statement.exp,
3463 output_section_statement,
3464 lang_final_phase_enum,
3465 dot,
3466 &dot);
3467 }
3468
3469 break;
3470 case lang_padding_statement_enum:
4cbfc3ac 3471 dot += s->padding_statement.size / opb;
252b5132
RH		 3472 break;
3473
3474 case lang_group_statement_enum:
3475 dot = lang_do_assignments (s->group_statement.children.head,
3476 output_section_statement,
3477 fill, dot);
3478
3479 break;
3480
3481 default:
3482 FAIL ();
3483 break;
3484 case lang_address_statement_enum:
3485 break;
3486 }
3487
3488 }
3489 return dot;
3490}
3491
3492/* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3493 operator .startof. (section_name), it produces an undefined symbol
3494 .startof.section_name. Similarly, when it sees
3495 .sizeof. (section_name), it produces an undefined symbol
3496 .sizeof.section_name. For all the output sections, we look for
3497 such symbols, and set them to the correct value. */
3498
3499static void
3500lang_set_startof ()
3501{
3502 asection *s;
3503
3504 if (link_info.relocateable)
3505 return;
3506
3507 for (s = output_bfd->sections; s != NULL; s = s->next)
3508 {
3509 const char *secname;
3510 char *buf;
3511 struct bfd_link_hash_entry *h;
3512
3513 secname = bfd_get_section_name (output_bfd, s);
3514 buf = xmalloc (10 + strlen (secname));
3515
3516 sprintf (buf, ".startof.%s", secname);
3517 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3518 if (h != NULL && h->type == bfd_link_hash_undefined)
3519 {
3520 h->type = bfd_link_hash_defined;
3521 h->u.def.value = bfd_get_section_vma (output_bfd, s);
3522 h->u.def.section = bfd_abs_section_ptr;
3523 }
3524
3525 sprintf (buf, ".sizeof.%s", secname);
3526 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3527 if (h != NULL && h->type == bfd_link_hash_undefined)
3528 {
b7a26f91 3529 unsigned opb;
d1778b88 3530
b7a26f91 3531 opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
d1778b88 3532 ldfile_output_machine);
252b5132
RH		 3533 h->type = bfd_link_hash_defined;
3534 if (s->_cooked_size != 0)
4cbfc3ac 3535 h->u.def.value = s->_cooked_size / opb;
252b5132 3536 else
4cbfc3ac 3537 h->u.def.value = s->_raw_size / opb;
252b5132
RH		 3538 h->u.def.section = bfd_abs_section_ptr;
3539 }
3540
3541 free (buf);
3542 }
3543}
3544
3545static void
3546lang_finish ()
3547{
3548 struct bfd_link_hash_entry *h;
3549 boolean warn;
3550
3551 if (link_info.relocateable || link_info.shared)
3552 warn = false;
3553 else
3554 warn = true;
3555
e3e942e9 3556 if (entry_symbol.name == (const char *) NULL)
252b5132
RH		 3557 {
3558 /* No entry has been specified. Look for start, but don't warn
3559 if we don't find it. */
e3e942e9 3560 entry_symbol.name = "start";
252b5132
RH		 3561 warn = false;
3562 }
3563
e3e942e9
AM		 3564 h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
3565 false, false, true);
252b5132
RH		 3566 if (h != (struct bfd_link_hash_entry *) NULL
3567 && (h->type == bfd_link_hash_defined
3568 || h->type == bfd_link_hash_defweak)
3569 && h->u.def.section->output_section != NULL)
3570 {
3571 bfd_vma val;
3572
3573 val = (h->u.def.value
3574 + bfd_get_section_vma (output_bfd,
3575 h->u.def.section->output_section)
3576 + h->u.def.section->output_offset);
3577 if (! bfd_set_start_address (output_bfd, val))
e3e942e9 3578 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
252b5132
RH		 3579 }
3580 else
3581 {
3582 bfd_vma val;
5f992e62 3583 const char *send;
252b5132
RH		 3584
3585 /* We couldn't find the entry symbol. Try parsing it as a
3586 number. */
e3e942e9 3587 val = bfd_scan_vma (entry_symbol.name, &send, 0);
252b5132
RH		 3588 if (*send == '\0')
3589 {
3590 if (! bfd_set_start_address (output_bfd, val))
3591 einfo (_("%P%F: can't set start address\n"));
3592 }
3593 else
3594 {
3595 asection *ts;
3596
3597 /* Can't find the entry symbol, and it's not a number. Use
3598 the first address in the text section. */
1e281515 3599 ts = bfd_get_section_by_name (output_bfd, entry_section);
252b5132
RH		 3600 if (ts != (asection *) NULL)
3601 {
3602 if (warn)
3603 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
e3e942e9
AM		 3604 entry_symbol.name,
3605 bfd_get_section_vma (output_bfd, ts));
252b5132
RH		 3606 if (! bfd_set_start_address (output_bfd,
3607 bfd_get_section_vma (output_bfd,
3608 ts)))
3609 einfo (_("%P%F: can't set start address\n"));
3610 }
3611 else
3612 {
3613 if (warn)
3614 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
e3e942e9 3615 entry_symbol.name);
252b5132
RH		 3616 }
3617 }
3618 }
3619}
3620
3621/* This is a small function used when we want to ignore errors from
3622 BFD. */
3623
3624static void
3625#ifdef ANSI_PROTOTYPES
87f2a346 3626ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
252b5132
RH		 3627#else
3628ignore_bfd_errors (s)
87f2a346 3629 const char *s ATTRIBUTE_UNUSED;
252b5132
RH		 3630#endif
3631{
3632 /* Don't do anything. */
3633}
3634
3635/* Check that the architecture of all the input files is compatible
3636 with the output file. Also call the backend to let it do any
3637 other checking that is needed. */
3638
3639static void
3640lang_check ()
3641{
3642 lang_statement_union_type *file;
3643 bfd *input_bfd;
5f992e62 3644 const bfd_arch_info_type *compatible;
252b5132
RH		 3645
3646 for (file = file_chain.head;
3647 file != (lang_statement_union_type *) NULL;
3648 file = file->input_statement.next)
3649 {
3650 input_bfd = file->input_statement.the_bfd;
30cba025
AM		 3651 compatible = bfd_arch_get_compatible (input_bfd, output_bfd);
3652
3653 /* In general it is not possible to perform a relocatable
3654 link between differing object formats when the input
3655 file has relocations, because the relocations in the
3656 input format may not have equivalent representations in
3657 the output format (and besides BFD does not translate
3658 relocs for other link purposes than a final link). */
d35a52e2 3659 if ((link_info.relocateable || link_info.emitrelocations)
30cba025 3660 && (compatible == NULL
d35a52e2 3661 || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
30cba025
AM		 3662 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
3663 {
3664 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3665 bfd_get_target (input_bfd), input_bfd,
3666 bfd_get_target (output_bfd), output_bfd);
3667 /* einfo with %F exits. */
3668 }
3669
252b5132
RH		 3670 if (compatible == NULL)
3671 {
3672 if (command_line.warn_mismatch)
3673 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3674 bfd_printable_name (input_bfd), input_bfd,
3675 bfd_printable_name (output_bfd));
3676 }
b9247304 3677 else if (bfd_count_sections (input_bfd))
252b5132 3678 {
b9247304 3679 /* If the input bfd has no contents, it shouldn't set the
b7a26f91 3680 private data of the output bfd. */
b9247304 3681
252b5132
RH		 3682 bfd_error_handler_type pfn = NULL;
3683
3684 /* If we aren't supposed to warn about mismatched input
3685 files, temporarily set the BFD error handler to a
3686 function which will do nothing. We still want to call
3687 bfd_merge_private_bfd_data, since it may set up
3688 information which is needed in the output file. */
3689 if (! command_line.warn_mismatch)
3690 pfn = bfd_set_error_handler (ignore_bfd_errors);
3691 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3692 {
3693 if (command_line.warn_mismatch)
3694 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3695 input_bfd);
3696 }
3697 if (! command_line.warn_mismatch)
3698 bfd_set_error_handler (pfn);
3699 }
3700 }
3701}
3702
3703/* Look through all the global common symbols and attach them to the
3704 correct section. The -sort-common command line switch may be used
3705 to roughly sort the entries by size. */
3706
3707static void
3708lang_common ()
3709{
4818e05f
AM		 3710 if (command_line.inhibit_common_definition)
3711 return;
252b5132
RH		 3712 if (link_info.relocateable
3713 && ! command_line.force_common_definition)
3714 return;
3715
3716 if (! config.sort_common)
3717 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3718 else
3719 {
3720 int power;
3721
3722 for (power = 4; power >= 0; power--)
3723 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3724 (PTR) &power);
3725 }
3726}
3727
3728/* Place one common symbol in the correct section. */
3729
3730static boolean
3731lang_one_common (h, info)
3732 struct bfd_link_hash_entry *h;
3733 PTR info;
3734{
3735 unsigned int power_of_two;
3736 bfd_vma size;
3737 asection *section;
5f992e62
AM		 3738 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3739 ldfile_output_machine);
252b5132
RH		 3740
3741 if (h->type != bfd_link_hash_common)
3742 return true;
3743
3744 size = h->u.c.size;
3745 power_of_two = h->u.c.p->alignment_power;
3746
3747 if (config.sort_common
3748 && power_of_two < (unsigned int) *(int *) info)
3749 return true;
3750
3751 section = h->u.c.p->section;
3752
3753 /* Increase the size of the section. */
c553bb91
AM		 3754 section->_cooked_size = align_n ((section->_cooked_size + opb - 1) / opb,
3755 (bfd_vma) 1 << power_of_two) * opb;
252b5132
RH		 3756
3757 /* Adjust the alignment if necessary. */
3758 if (power_of_two > section->alignment_power)
3759 section->alignment_power = power_of_two;
3760
3761 /* Change the symbol from common to defined. */
3762 h->type = bfd_link_hash_defined;
3763 h->u.def.section = section;
3764 h->u.def.value = section->_cooked_size;
3765
3766 /* Increase the size of the section. */
3767 section->_cooked_size += size;
3768
3769 /* Make sure the section is allocated in memory, and make sure that
3770 it is no longer a common section. */
3771 section->flags |= SEC_ALLOC;
08da4cac 3772 section->flags &= ~SEC_IS_COMMON;
252b5132
RH		 3773
3774 if (config.map_file != NULL)
3775 {
3776 static boolean header_printed;
3777 int len;
3778 char *name;
3779 char buf[50];
3780
3781 if (! header_printed)
3782 {
3783 minfo (_("\nAllocating common symbols\n"));
3784 minfo (_("Common symbol size file\n\n"));
3785 header_printed = true;
3786 }
3787
3788 name = demangle (h->root.string);
3789 minfo ("%s", name);
3790 len = strlen (name);
3791 free (name);
3792
3793 if (len >= 19)
3794 {
3795 print_nl ();
3796 len = 0;
3797 }
3798 while (len < 20)
3799 {
3800 print_space ();
3801 ++len;
3802 }
3803
3804 minfo ("0x");
3805 if (size <= 0xffffffff)
3806 sprintf (buf, "%lx", (unsigned long) size);
3807 else
3808 sprintf_vma (buf, size);
3809 minfo ("%s", buf);
3810 len = strlen (buf);
3811
3812 while (len < 16)
3813 {
3814 print_space ();
3815 ++len;
3816 }
3817
3818 minfo ("%B\n", section->owner);
3819 }
3820
3821 return true;
3822}
3823
08da4cac
KH		 3824/* Run through the input files and ensure that every input section has
3825 somewhere to go. If one is found without a destination then create
3826 an input request and place it into the statement tree. */
252b5132
RH		 3827
3828static void
3829lang_place_orphans ()
3830{
e50d8076 3831 LANG_FOR_EACH_INPUT_STATEMENT (file)
252b5132
RH		 3832 {
3833 asection *s;
3834
3835 for (s = file->the_bfd->sections;
3836 s != (asection *) NULL;
3837 s = s->next)
3838 {
3839 if (s->output_section == (asection *) NULL)
3840 {
3841 /* This section of the file is not attatched, root
08da4cac 3842 around for a sensible place for it to go. */
252b5132
RH		 3843
3844 if (file->just_syms_flag)
3845 {
c2c01aa7 3846 abort ();
252b5132
RH		 3847 }
3848 else if (strcmp (s->name, "COMMON") == 0)
3849 {
3850 /* This is a lonely common section which must have
3851 come from an archive. We attach to the section
3852 with the wildcard. */
3853 if (! link_info.relocateable
3854 || command_line.force_common_definition)
3855 {
3856 if (default_common_section == NULL)
3857 {
3858#if 0
3859 /* This message happens when using the
3860 svr3.ifile linker script, so I have
3861 disabled it. */
3862 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3863#endif
3864 default_common_section =
3865 lang_output_section_statement_lookup (".bss");
3866
3867 }
39dcfe18
AM		 3868 lang_add_section (&default_common_section->children, s,
3869 default_common_section, file);
252b5132
RH		 3870 }
3871 }
3872 else if (ldemul_place_orphan (file, s))
3873 ;
3874 else
3875 {
39dcfe18 3876 lang_output_section_statement_type *os;
252b5132 3877
39dcfe18
AM		 3878 os = lang_output_section_statement_lookup (s->name);
3879 lang_add_section (&os->children, s, os, file);
252b5132
RH		 3880 }
3881 }
3882 }
3883 }
3884}
3885
252b5132 3886void
aa8804e4 3887lang_set_flags (ptr, flags, invert)
252b5132 3888 lang_memory_region_type *ptr;
5f992e62 3889 const char *flags;
aa8804e4 3890 int invert;
252b5132 3891{
aa8804e4 3892 flagword *ptr_flags;
252b5132 3893
aa8804e4 3894 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
252b5132
RH		 3895 while (*flags)
3896 {
3897 switch (*flags)
3898 {
252b5132
RH		 3899 case 'A': case 'a':
3900 *ptr_flags |= SEC_ALLOC;
3901 break;
3902
3903 case 'R': case 'r':
3904 *ptr_flags |= SEC_READONLY;
3905 break;
3906
3907 case 'W': case 'w':
3908 *ptr_flags |= SEC_DATA;
3909 break;
3910
3911 case 'X': case 'x':
3912 *ptr_flags |= SEC_CODE;
3913 break;
3914
3915 case 'L': case 'l':
3916 case 'I': case 'i':
3917 *ptr_flags |= SEC_LOAD;
3918 break;
3919
3920 default:
3921 einfo (_("%P%F: invalid syntax in flags\n"));
3922 break;
3923 }
3924 flags++;
3925 }
3926}
3927
3928/* Call a function on each input file. This function will be called
3929 on an archive, but not on the elements. */
3930
3931void
3932lang_for_each_input_file (func)
3933 void (*func) PARAMS ((lang_input_statement_type *));
3934{
3935 lang_input_statement_type *f;
3936
3937 for (f = (lang_input_statement_type *) input_file_chain.head;
3938 f != NULL;
3939 f = (lang_input_statement_type *) f->next_real_file)
3940 func (f);
3941}
3942
3943/* Call a function on each file. The function will be called on all
3944 the elements of an archive which are included in the link, but will
3945 not be called on the archive file itself. */
3946
3947void
3948lang_for_each_file (func)
3949 void (*func) PARAMS ((lang_input_statement_type *));
3950{
e50d8076 3951 LANG_FOR_EACH_INPUT_STATEMENT (f)
252b5132
RH		 3952 {
3953 func (f);
3954 }
3955}
3956
3957#if 0
3958
3959/* Not used. */
3960
3961void
3962lang_for_each_input_section (func)
08da4cac 3963 void (*func) PARAMS ((bfd *ab, asection *as));
252b5132 3964{
e50d8076 3965 LANG_FOR_EACH_INPUT_STATEMENT (f)
252b5132 3966 {
08da4cac 3967 asection *s;
252b5132
RH		 3968
3969 for (s = f->the_bfd->sections;
3970 s != (asection *) NULL;
3971 s = s->next)
3972 {
3973 func (f->the_bfd, s);
3974 }
3975 }
3976}
3977
3978#endif
3979
3980void
3981ldlang_add_file (entry)
08da4cac 3982 lang_input_statement_type *entry;
252b5132
RH		 3983{
3984 bfd **pp;
3985
3986 lang_statement_append (&file_chain,
3987 (lang_statement_union_type *) entry,
3988 &entry->next);
3989
3990 /* The BFD linker needs to have a list of all input BFDs involved in
3991 a link. */
3992 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3993 ASSERT (entry->the_bfd != output_bfd);
3994 for (pp = &link_info.input_bfds;
3995 *pp != (bfd *) NULL;
3996 pp = &(*pp)->link_next)
3997 ;
3998 *pp = entry->the_bfd;
3999 entry->the_bfd->usrdata = (PTR) entry;
4000 bfd_set_gp_size (entry->the_bfd, g_switch_value);
4001
4002 /* Look through the sections and check for any which should not be
4003 included in the link. We need to do this now, so that we can
4004 notice when the backend linker tries to report multiple
4005 definition errors for symbols which are in sections we aren't
4006 going to link. FIXME: It might be better to entirely ignore
4007 symbols which are defined in sections which are going to be
4008 discarded. This would require modifying the backend linker for
4009 each backend which might set the SEC_LINK_ONCE flag. If we do
4010 this, we should probably handle SEC_EXCLUDE in the same way. */
4011
4012 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
4013}
4014
4015void
4016lang_add_output (name, from_script)
5f992e62 4017 const char *name;
252b5132
RH		 4018 int from_script;
4019{
4020 /* Make -o on command line override OUTPUT in script. */
4021 if (had_output_filename == false || !from_script)
4022 {
4023 output_filename = name;
4024 had_output_filename = true;
4025 }
4026}
4027
252b5132
RH		 4028static lang_output_section_statement_type *current_section;
4029
4030static int
4031topower (x)
4032 int x;
4033{
4034 unsigned int i = 1;
4035 int l;
4036
4037 if (x < 0)
4038 return -1;
4039
5f992e62 4040 for (l = 0; l < 32; l++)
252b5132
RH		 4041 {
4042 if (i >= (unsigned int) x)
4043 return l;
4044 i <<= 1;
4045 }
4046
4047 return 0;
4048}
4049
aea4bd9d 4050lang_output_section_statement_type *
252b5132
RH		 4051lang_enter_output_section_statement (output_section_statement_name,
4052 address_exp, sectype, block_value,
4053 align, subalign, ebase)
4054 const char *output_section_statement_name;
08da4cac 4055 etree_type *address_exp;
252b5132
RH		 4056 enum section_type sectype;
4057 bfd_vma block_value;
4058 etree_type *align;
4059 etree_type *subalign;
4060 etree_type *ebase;
4061{
4062 lang_output_section_statement_type *os;
4063
4064 current_section =
4065 os =
4066 lang_output_section_statement_lookup (output_section_statement_name);
4067
08da4cac
KH		 4068 /* Add this statement to tree. */
4069#if 0
4070 add_statement (lang_output_section_statement_enum,
4071 output_section_statement);
4072#endif
4073 /* Make next things chain into subchain of this. */
252b5132 4074
08da4cac
KH		 4075 if (os->addr_tree == (etree_type *) NULL)
4076 {
4077 os->addr_tree = address_exp;
4078 }
252b5132
RH		 4079 os->sectype = sectype;
4080 if (sectype != noload_section)
4081 os->flags = SEC_NO_FLAGS;
4082 else
4083 os->flags = SEC_NEVER_LOAD;
4084 os->block_value = block_value ? block_value : 1;
4085 stat_ptr = &os->children;
4086
08da4cac
KH		 4087 os->subsection_alignment =
4088 topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
4089 os->section_alignment =
4090 topower (exp_get_value_int (align, -1, "section alignment", 0));
252b5132
RH		 4091
4092 os->load_base = ebase;
aea4bd9d 4093 return os;
252b5132
RH		 4094}
4095
252b5132
RH		 4096void
4097lang_final ()
4098{
4099 lang_output_statement_type *new =
4100 new_stat (lang_output_statement, stat_ptr);
4101
4102 new->name = output_filename;
4103}
4104
08da4cac
KH		 4105/* Reset the current counters in the regions. */
4106
e3dc8847
HPN		 4107void
4108lang_reset_memory_regions ()
252b5132
RH		 4109{
4110 lang_memory_region_type *p = lang_memory_region_list;
b3327aad 4111 asection *o;
252b5132
RH		 4112
4113 for (p = lang_memory_region_list;
4114 p != (lang_memory_region_type *) NULL;
4115 p = p->next)
4116 {
4117 p->old_length = (bfd_size_type) (p->current - p->origin);
4118 p->current = p->origin;
4119 }
b3327aad
AM		 4120
4121 for (o = output_bfd->sections; o != NULL; o = o->next)
4122 o->_raw_size = 0;
252b5132
RH		 4123}
4124
b6bf44ba
AM		 4125/* If the wild pattern was marked KEEP, the member sections
4126 should be as well. */
252b5132
RH		 4127
4128static void
b6bf44ba 4129gc_section_callback (ptr, sec, section, file, data)
252b5132 4130 lang_wild_statement_type *ptr;
b6bf44ba 4131 struct wildcard_list *sec ATTRIBUTE_UNUSED;
4dec4d4e 4132 asection *section;
87f2a346 4133 lang_input_statement_type *file ATTRIBUTE_UNUSED;
5f992e62 4134 PTR data ATTRIBUTE_UNUSED;
252b5132 4135{
4dec4d4e
RH		 4136 if (ptr->keep_sections)
4137 section->flags |= SEC_KEEP;
252b5132
RH		 4138}
4139
b6bf44ba 4140/* Handle a wild statement, marking it against GC. */
252b5132
RH		 4141
4142static void
b6bf44ba 4143lang_gc_wild (s)
252b5132 4144 lang_wild_statement_type *s;
252b5132 4145{
b6bf44ba 4146 walk_wild (s, gc_section_callback, NULL);
252b5132
RH		 4147}
4148
4149/* Iterate over sections marking them against GC. */
4150
4151static void
4152lang_gc_sections_1 (s)
08da4cac 4153 lang_statement_union_type *s;
252b5132 4154{
bba1a0c0 4155 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
252b5132
RH		 4156 {
4157 switch (s->header.type)
4158 {
4159 case lang_wild_statement_enum:
b6bf44ba 4160 lang_gc_wild (&s->wild_statement);
abc6ab0a 4161 break;
252b5132
RH		 4162 case lang_constructors_statement_enum:
4163 lang_gc_sections_1 (constructor_list.head);
4164 break;
4165 case lang_output_section_statement_enum:
4166 lang_gc_sections_1 (s->output_section_statement.children.head);
4167 break;
4168 case lang_group_statement_enum:
4169 lang_gc_sections_1 (s->group_statement.children.head);
4170 break;
4171 default:
4172 break;
4173 }
4174 }
4175}
4176
4177static void
4178lang_gc_sections ()
4179{
4180 struct bfd_link_hash_entry *h;
e3e942e9 4181 ldlang_undef_chain_list_type *ulist;
252b5132
RH		 4182
4183 /* Keep all sections so marked in the link script. */
4184
4185 lang_gc_sections_1 (statement_list.head);
4186
e3e942e9
AM		 4187 /* Keep all sections containing symbols undefined on the command-line,
4188 and the section containing the entry symbol. */
252b5132 4189
e3e942e9 4190 for (ulist = link_info.gc_sym_list; ulist; ulist = ulist->next)
252b5132 4191 {
5f992e62 4192 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
252b5132
RH		 4193 false, false, false);
4194
4195 if (h != (struct bfd_link_hash_entry *) NULL
08da4cac
KH		 4196 && (h->type == bfd_link_hash_defined
4197 || h->type == bfd_link_hash_defweak)
252b5132
RH		 4198 && ! bfd_is_abs_section (h->u.def.section))
4199 {
4200 h->u.def.section->flags |= SEC_KEEP;
4201 }
4202 }
4203
4204 bfd_gc_sections (output_bfd, &link_info);
4205}
4206
4207void
4208lang_process ()
4209{
4210 lang_reasonable_defaults ();
4211 current_target = default_target;
4212
08da4cac
KH		 4213 /* Open the output file. */
4214 lang_for_each_statement (ldlang_open_output);
252b5132
RH		 4215
4216 ldemul_create_output_section_statements ();
4217
08da4cac 4218 /* Add to the hash table all undefineds on the command line. */
252b5132
RH		 4219 lang_place_undefineds ();
4220
9503fd87
ILT		 4221 already_linked_table_init ();
4222
08da4cac 4223 /* Create a bfd for each input file. */
252b5132
RH		 4224 current_target = default_target;
4225 open_input_bfds (statement_list.head, false);
4226
e3e942e9
AM		 4227 link_info.gc_sym_list = &entry_symbol;
4228 if (entry_symbol.name == NULL)
4229 link_info.gc_sym_list = ldlang_undef_chain_list_head;
4230
252b5132
RH		 4231 ldemul_after_open ();
4232
9503fd87
ILT		 4233 already_linked_table_free ();
4234
252b5132
RH		 4235 /* Make sure that we're not mixing architectures. We call this
4236 after all the input files have been opened, but before we do any
4237 other processing, so that any operations merge_private_bfd_data
4238 does on the output file will be known during the rest of the
4239 link. */
4240 lang_check ();
4241
4242 /* Handle .exports instead of a version script if we're told to do so. */
4243 if (command_line.version_exports_section)
4244 lang_do_version_exports_section ();
4245
4246 /* Build all sets based on the information gathered from the input
4247 files. */
4248 ldctor_build_sets ();
4249
4250 /* Remove unreferenced sections if asked to. */
4251 if (command_line.gc_sections)
4252 lang_gc_sections ();
4253
8550eb6e
JJ		 4254 /* If there were any SEC_MERGE sections, finish their merging, so that
4255 section sizes can be computed. This has to be done after GC of sections,
4256 so that GCed sections are not merged, but before assigning output
4257 sections, since removing whole input sections is hard then. */
4258 bfd_merge_sections (output_bfd, &link_info);
4259
08da4cac 4260 /* Size up the common data. */
252b5132
RH		 4261 lang_common ();
4262
4263 /* Run through the contours of the script and attach input sections
08da4cac 4264 to the correct output sections. */
252b5132
RH		 4265 map_input_to_output_sections (statement_list.head, (char *) NULL,
4266 (lang_output_section_statement_type *) NULL);
4267
08da4cac 4268 /* Find any sections not attached explicitly and handle them. */
252b5132
RH		 4269 lang_place_orphans ();
4270
862120bd
AM		 4271 if (! link_info.relocateable)
4272 {
4273 /* Look for a text section and set the readonly attribute in it. */
4274 asection *found = bfd_get_section_by_name (output_bfd, ".text");
4275
4276 if (found != (asection *) NULL)
4277 {
4278 if (config.text_read_only)
4279 found->flags |= SEC_READONLY;
4280 else
4281 found->flags &= ~SEC_READONLY;
4282 }
4283 }
4284
4285 /* Do anything special before sizing sections. This is where ELF
4286 and other back-ends size dynamic sections. */
252b5132
RH		 4287 ldemul_before_allocation ();
4288
4bd5a393
AM		 4289 if (!link_info.relocateable)
4290 strip_excluded_output_sections ();
4291
252b5132
RH		 4292 /* We must record the program headers before we try to fix the
4293 section positions, since they will affect SIZEOF_HEADERS. */
4294 lang_record_phdrs ();
4295
b3327aad
AM		 4296 /* Size up the sections. */
4297 lang_size_sections (statement_list.head,
4298 abs_output_section,
4299 &statement_list.head, 0, (bfd_vma) 0, NULL);
4300
08da4cac 4301 /* Now run around and relax if we can. */
252b5132
RH		 4302 if (command_line.relax)
4303 {
252b5132 4304 /* Keep relaxing until bfd_relax_section gives up. */
b3327aad
AM		 4305 boolean relax_again;
4306
252b5132
RH		 4307 do
4308 {
e3dc8847 4309 lang_reset_memory_regions ();
252b5132
RH		 4310
4311 relax_again = false;
4312
4313 /* Note: pe-dll.c does something like this also. If you find
4314 you need to change this code, you probably need to change
08da4cac 4315 pe-dll.c also. DJ */
252b5132
RH		 4316
4317 /* Do all the assignments with our current guesses as to
4318 section sizes. */
4319 lang_do_assignments (statement_list.head,
4320 abs_output_section,
2c382fb6 4321 (fill_type *) 0, (bfd_vma) 0);
252b5132
RH		 4322
4323 /* Perform another relax pass - this time we know where the
0d6d936f 4324 globals are, so can make a better guess. */
252b5132
RH		 4325 lang_size_sections (statement_list.head,
4326 abs_output_section,
0d6d936f 4327 &statement_list.head, 0, (bfd_vma) 0,
b3327aad 4328 &relax_again);
252b5132
RH		 4329 }
4330 while (relax_again);
4331 }
252b5132
RH		 4332
4333 /* See if anything special should be done now we know how big
4334 everything is. */
4335 ldemul_after_allocation ();
4336
4337 /* Fix any .startof. or .sizeof. symbols. */
4338 lang_set_startof ();
4339
08da4cac
KH		 4340 /* Do all the assignments, now that we know the final resting places
4341 of all the symbols. */
252b5132
RH		 4342
4343 lang_do_assignments (statement_list.head,
4344 abs_output_section,
2c382fb6 4345 (fill_type *) 0, (bfd_vma) 0);
252b5132
RH		 4346
4347 /* Make sure that the section addresses make sense. */
4348 if (! link_info.relocateable
4349 && command_line.check_section_addresses)
4350 lang_check_section_addresses ();
5f992e62 4351
08da4cac 4352 /* Final stuffs. */
252b5132
RH		 4353
4354 ldemul_finish ();
4355 lang_finish ();
4356}
4357
4358/* EXPORTED TO YACC */
4359
4360void
b6bf44ba
AM		 4361lang_add_wild (filespec, section_list, keep_sections)
4362 struct wildcard_spec *filespec;
4363 struct wildcard_list *section_list;
252b5132 4364 boolean keep_sections;
252b5132 4365{
b6bf44ba
AM		 4366 struct wildcard_list *curr, *next;
4367 lang_wild_statement_type *new;
4368
4369 /* Reverse the list as the parser puts it back to front. */
4370 for (curr = section_list, section_list = NULL;
4371 curr != NULL;
4372 section_list = curr, curr = next)
4373 {
4374 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
4375 placed_commons = true;
252b5132 4376
b6bf44ba
AM		 4377 next = curr->next;
4378 curr->next = section_list;
4379 }
4380
4381 if (filespec != NULL && filespec->name != NULL)
252b5132 4382 {
b6bf44ba
AM		 4383 if (strcmp (filespec->name, "*") == 0)
4384 filespec->name = NULL;
4385 else if (! wildcardp (filespec->name))
4386 lang_has_input_file = true;
252b5132 4387 }
b6bf44ba
AM		 4388
4389 new = new_stat (lang_wild_statement, stat_ptr);
4390 new->filename = NULL;
4391 new->filenames_sorted = false;
4392 if (filespec != NULL)
252b5132 4393 {
b6bf44ba
AM		 4394 new->filename = filespec->name;
4395 new->filenames_sorted = filespec->sorted;
252b5132 4396 }
b6bf44ba 4397 new->section_list = section_list;
252b5132 4398 new->keep_sections = keep_sections;
252b5132
RH		 4399 lang_list_init (&new->children);
4400}
4401
4402void
4403lang_section_start (name, address)
5f992e62 4404 const char *name;
08da4cac 4405 etree_type *address;
252b5132 4406{
d1778b88 4407 lang_address_statement_type *ad;
252b5132 4408
d1778b88 4409 ad = new_stat (lang_address_statement, stat_ptr);
252b5132
RH		 4410 ad->section_name = name;
4411 ad->address = address;
4412}
4413
4414/* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4415 because of a -e argument on the command line, or zero if this is
4416 called by ENTRY in a linker script. Command line arguments take
4417 precedence. */
4418
4419void
4420lang_add_entry (name, cmdline)
5f992e62 4421 const char *name;
252b5132
RH		 4422 boolean cmdline;
4423{
e3e942e9 4424 if (entry_symbol.name == NULL
252b5132
RH		 4425 || cmdline
4426 || ! entry_from_cmdline)
4427 {
e3e942e9 4428 entry_symbol.name = name;
252b5132
RH		 4429 entry_from_cmdline = cmdline;
4430 }
4431}
4432
4433void
4434lang_add_target (name)
5f992e62 4435 const char *name;
252b5132
RH		 4436{
4437 lang_target_statement_type *new = new_stat (lang_target_statement,
4438 stat_ptr);
4439
4440 new->target = name;
4441
4442}
4443
4444void
4445lang_add_map (name)
5f992e62 4446 const char *name;
252b5132
RH		 4447{
4448 while (*name)
4449 {
4450 switch (*name)
4451 {
08da4cac 4452 case 'F':
252b5132
RH		 4453 map_option_f = true;
4454 break;
4455 }
4456 name++;
4457 }
4458}
4459
4460void
2c382fb6
AM		 4461lang_add_fill (fill)
4462 fill_type *fill;
252b5132
RH		 4463{
4464 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4465 stat_ptr);
4466
2c382fb6 4467 new->fill = fill;
252b5132
RH		 4468}
4469
4470void
4471lang_add_data (type, exp)
4472 int type;
4473 union etree_union *exp;
4474{
4475
4476 lang_data_statement_type *new = new_stat (lang_data_statement,
4477 stat_ptr);
4478
4479 new->exp = exp;
4480 new->type = type;
4481
4482}
4483
4484/* Create a new reloc statement. RELOC is the BFD relocation type to
4485 generate. HOWTO is the corresponding howto structure (we could
4486 look this up, but the caller has already done so). SECTION is the
4487 section to generate a reloc against, or NAME is the name of the
4488 symbol to generate a reloc against. Exactly one of SECTION and
4489 NAME must be NULL. ADDEND is an expression for the addend. */
4490
4491void
4492lang_add_reloc (reloc, howto, section, name, addend)
4493 bfd_reloc_code_real_type reloc;
4494 reloc_howto_type *howto;
4495 asection *section;
4496 const char *name;
4497 union etree_union *addend;
4498{
4499 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
5f992e62 4500
252b5132
RH		 4501 p->reloc = reloc;
4502 p->howto = howto;
4503 p->section = section;
4504 p->name = name;
4505 p->addend_exp = addend;
4506
4507 p->addend_value = 0;
4508 p->output_section = NULL;
4509 p->output_vma = 0;
4510}
4511
4512lang_assignment_statement_type *
4513lang_add_assignment (exp)
08da4cac 4514 etree_type *exp;
252b5132
RH		 4515{
4516 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4517 stat_ptr);
4518
4519 new->exp = exp;
4520 return new;
4521}
4522
4523void
4524lang_add_attribute (attribute)
4525 enum statement_enum attribute;
4526{
4527 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4528}
4529
4530void
4531lang_startup (name)
5f992e62 4532 const char *name;
252b5132
RH		 4533{
4534 if (startup_file != (char *) NULL)
4535 {
4536 einfo (_("%P%Fmultiple STARTUP files\n"));
4537 }
4538 first_file->filename = name;
4539 first_file->local_sym_name = name;
4540 first_file->real = true;
4541
4542 startup_file = name;
4543}
4544
4545void
4546lang_float (maybe)
4547 boolean maybe;
4548{
4549 lang_float_flag = maybe;
4550}
4551
ee3cc2e2
RS		 4552
4553/* Work out the load- and run-time regions from a script statement, and
4554 store them in *LMA_REGION and *REGION respectively.
4555
4556 MEMSPEC is the name of the run-time region, or "*default*" if the
4557 statement didn't specify one. LMA_MEMSPEC is the name of the
4558 load-time region, or null if the statement didn't specify one.
4559 HAVE_LMA_P is true if the statement had an explicit load address.
4560
4561 It is an error to specify both a load region and a load address. */
4562
4563static void
4564lang_get_regions (region, lma_region, memspec, lma_memspec, have_lma_p)
4565 struct memory_region_struct **region, **lma_region;
4566 const char *memspec, *lma_memspec;
4567 int have_lma_p;
4568{
4569 *lma_region = lang_memory_region_lookup (lma_memspec);
4570
4571 /* If no runtime region has been given, but the load region has
4572 been, use the load region. */
4573 if (lma_memspec != 0 && strcmp (memspec, "*default*") == 0)
4574 *region = *lma_region;
4575 else
4576 *region = lang_memory_region_lookup (memspec);
4577
4578 if (have_lma_p && lma_memspec != 0)
4579 einfo (_("%X%P:%S: section has both a load address and a load region\n"));
4580}
4581
252b5132 4582void
562d3460 4583lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
2c382fb6 4584 fill_type *fill;
252b5132
RH		 4585 const char *memspec;
4586 struct lang_output_section_phdr_list *phdrs;
562d3460 4587 const char *lma_memspec;
252b5132 4588{
ee3cc2e2
RS		 4589 lang_get_regions (&current_section->region,
4590 &current_section->lma_region,
4591 memspec, lma_memspec,
4592 current_section->load_base != 0);
252b5132 4593 current_section->fill = fill;
252b5132
RH		 4594 current_section->phdrs = phdrs;
4595 stat_ptr = &statement_list;
4596}
4597
08da4cac
KH		 4598/* Create an absolute symbol with the given name with the value of the
4599 address of first byte of the section named.
4600
4601 If the symbol already exists, then do nothing. */
252b5132 4602
252b5132
RH		 4603void
4604lang_abs_symbol_at_beginning_of (secname, name)
4605 const char *secname;
4606 const char *name;
4607{
4608 struct bfd_link_hash_entry *h;
4609
4610 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4611 if (h == (struct bfd_link_hash_entry *) NULL)
4612 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4613
4614 if (h->type == bfd_link_hash_new
4615 || h->type == bfd_link_hash_undefined)
4616 {
4617 asection *sec;
4618
4619 h->type = bfd_link_hash_defined;
4620
4621 sec = bfd_get_section_by_name (output_bfd, secname);
4622 if (sec == (asection *) NULL)
4623 h->u.def.value = 0;
4624 else
4625 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4626
4627 h->u.def.section = bfd_abs_section_ptr;
4628 }
4629}
4630
08da4cac
KH		 4631/* Create an absolute symbol with the given name with the value of the
4632 address of the first byte after the end of the section named.
4633
4634 If the symbol already exists, then do nothing. */
252b5132 4635
252b5132
RH		 4636void
4637lang_abs_symbol_at_end_of (secname, name)
4638 const char *secname;
4639 const char *name;
4640{
4641 struct bfd_link_hash_entry *h;
4642
4643 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4644 if (h == (struct bfd_link_hash_entry *) NULL)
4645 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4646
4647 if (h->type == bfd_link_hash_new
4648 || h->type == bfd_link_hash_undefined)
4649 {
4650 asection *sec;
4651
4652 h->type = bfd_link_hash_defined;
4653
4654 sec = bfd_get_section_by_name (output_bfd, secname);
4655 if (sec == (asection *) NULL)
4656 h->u.def.value = 0;
4657 else
4658 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4cbfc3ac
TW		 4659 + bfd_section_size (output_bfd, sec) /
4660 bfd_octets_per_byte (output_bfd));
252b5132
RH		 4661
4662 h->u.def.section = bfd_abs_section_ptr;
4663 }
4664}
4665
4666void
4667lang_statement_append (list, element, field)
08da4cac
KH		 4668 lang_statement_list_type *list;
4669 lang_statement_union_type *element;
4670 lang_statement_union_type **field;
252b5132
RH		 4671{
4672 *(list->tail) = element;
4673 list->tail = field;
4674}
4675
4676/* Set the output format type. -oformat overrides scripts. */
4677
4678void
4679lang_add_output_format (format, big, little, from_script)
4680 const char *format;
4681 const char *big;
4682 const char *little;
4683 int from_script;
4684{
4685 if (output_target == NULL || !from_script)
4686 {
4687 if (command_line.endian == ENDIAN_BIG
4688 && big != NULL)
4689 format = big;
4690 else if (command_line.endian == ENDIAN_LITTLE
4691 && little != NULL)
4692 format = little;
4693
4694 output_target = format;
4695 }
4696}
4697
4698/* Enter a group. This creates a new lang_group_statement, and sets
4699 stat_ptr to build new statements within the group. */
4700
4701void
4702lang_enter_group ()
4703{
4704 lang_group_statement_type *g;
4705
4706 g = new_stat (lang_group_statement, stat_ptr);
4707 lang_list_init (&g->children);
4708 stat_ptr = &g->children;
4709}
4710
4711/* Leave a group. This just resets stat_ptr to start writing to the
4712 regular list of statements again. Note that this will not work if
4713 groups can occur inside anything else which can adjust stat_ptr,
4714 but currently they can't. */
4715
4716void
4717lang_leave_group ()
4718{
4719 stat_ptr = &statement_list;
4720}
4721
4722/* Add a new program header. This is called for each entry in a PHDRS
4723 command in a linker script. */
4724
4725void
4726lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4727 const char *name;
4728 etree_type *type;
4729 boolean filehdr;
4730 boolean phdrs;
4731 etree_type *at;
4732 etree_type *flags;
4733{
4734 struct lang_phdr *n, **pp;
4735
4736 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4737 n->next = NULL;
4738 n->name = name;
4739 n->type = exp_get_value_int (type, 0, "program header type",
4740 lang_final_phase_enum);
4741 n->filehdr = filehdr;
4742 n->phdrs = phdrs;
4743 n->at = at;
4744 n->flags = flags;
4745
4746 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4747 ;
4748 *pp = n;
4749}
4750
4751/* Record the program header information in the output BFD. FIXME: We
4752 should not be calling an ELF specific function here. */
4753
4754static void
4755lang_record_phdrs ()
4756{
4757 unsigned int alc;
4758 asection **secs;
4759 struct lang_output_section_phdr_list *last;
4760 struct lang_phdr *l;
4761 lang_statement_union_type *u;
4762
4763 alc = 10;
4764 secs = (asection **) xmalloc (alc * sizeof (asection *));
4765 last = NULL;
4766 for (l = lang_phdr_list; l != NULL; l = l->next)
4767 {
4768 unsigned int c;
4769 flagword flags;
4770 bfd_vma at;
4771
4772 c = 0;
4773 for (u = lang_output_section_statement.head;
4774 u != NULL;
4775 u = u->output_section_statement.next)
4776 {
4777 lang_output_section_statement_type *os;
4778 struct lang_output_section_phdr_list *pl;
4779
4780 os = &u->output_section_statement;
4781
4782 pl = os->phdrs;
4783 if (pl != NULL)
4784 last = pl;
4785 else
4786 {
4787 if (os->sectype == noload_section
4788 || os->bfd_section == NULL
4789 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4790 continue;
4791 pl = last;
4792 }
4793
4794 if (os->bfd_section == NULL)
4795 continue;
4796
4797 for (; pl != NULL; pl = pl->next)
4798 {
4799 if (strcmp (pl->name, l->name) == 0)
4800 {
4801 if (c >= alc)
4802 {
4803 alc *= 2;
4804 secs = ((asection **)
4805 xrealloc (secs, alc * sizeof (asection *)));
4806 }
4807 secs[c] = os->bfd_section;
4808 ++c;
4809 pl->used = true;
4810 }
4811 }
4812 }
4813
4814 if (l->flags == NULL)
4815 flags = 0;
4816 else
4817 flags = exp_get_vma (l->flags, 0, "phdr flags",
4818 lang_final_phase_enum);
4819
4820 if (l->at == NULL)
4821 at = 0;
4822 else
4823 at = exp_get_vma (l->at, 0, "phdr load address",
4824 lang_final_phase_enum);
4825
4826 if (! bfd_record_phdr (output_bfd, l->type,
d1778b88 4827 l->flags != NULL, flags, l->at != NULL,
252b5132
RH		 4828 at, l->filehdr, l->phdrs, c, secs))
4829 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4830 }
4831
4832 free (secs);
4833
4834 /* Make sure all the phdr assignments succeeded. */
4835 for (u = lang_output_section_statement.head;
4836 u != NULL;
4837 u = u->output_section_statement.next)
4838 {
4839 struct lang_output_section_phdr_list *pl;
4840
4841 if (u->output_section_statement.bfd_section == NULL)
4842 continue;
4843
4844 for (pl = u->output_section_statement.phdrs;
4845 pl != NULL;
4846 pl = pl->next)
4847 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4848 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4849 u->output_section_statement.name, pl->name);
4850 }
4851}
4852
4853/* Record a list of sections which may not be cross referenced. */
4854
4855void
4856lang_add_nocrossref (l)
4857 struct lang_nocrossref *l;
4858{
4859 struct lang_nocrossrefs *n;
4860
4861 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4862 n->next = nocrossref_list;
4863 n->list = l;
4864 nocrossref_list = n;
4865
4866 /* Set notice_all so that we get informed about all symbols. */
4867 link_info.notice_all = true;
4868}
4869\f
4870/* Overlay handling. We handle overlays with some static variables. */
4871
4872/* The overlay virtual address. */
4873static etree_type *overlay_vma;
4874
252b5132
RH		 4875/* An expression for the maximum section size seen so far. */
4876static etree_type *overlay_max;
4877
4878/* A list of all the sections in this overlay. */
4879
89cdebba 4880struct overlay_list {
252b5132
RH		 4881 struct overlay_list *next;
4882 lang_output_section_statement_type *os;
4883};
4884
4885static struct overlay_list *overlay_list;
4886
4887/* Start handling an overlay. */
4888
4889void
9f88b410 4890lang_enter_overlay (vma_expr)
252b5132 4891 etree_type *vma_expr;
252b5132
RH		 4892{
4893 /* The grammar should prevent nested overlays from occurring. */
9f88b410 4894 ASSERT (overlay_vma == NULL && overlay_max == NULL);
252b5132
RH		 4895
4896 overlay_vma = vma_expr;
252b5132
RH		 4897}
4898
4899/* Start a section in an overlay. We handle this by calling
9f88b410
RS		 4900 lang_enter_output_section_statement with the correct VMA.
4901 lang_leave_overlay sets up the LMA and memory regions. */
252b5132
RH		 4902
4903void
4904lang_enter_overlay_section (name)
4905 const char *name;
4906{
4907 struct overlay_list *n;
4908 etree_type *size;
4909
4910 lang_enter_output_section_statement (name, overlay_vma, normal_section,
9f88b410 4911 0, 0, 0, 0);
252b5132 4912
9f88b410 4913 /* If this is the first section, then base the VMA of future
252b5132
RH		 4914 sections on this one. This will work correctly even if `.' is
4915 used in the addresses. */
4916 if (overlay_list == NULL)
9f88b410 4917 overlay_vma = exp_nameop (ADDR, name);
252b5132
RH		 4918
4919 /* Remember the section. */
4920 n = (struct overlay_list *) xmalloc (sizeof *n);
4921 n->os = current_section;
4922 n->next = overlay_list;
4923 overlay_list = n;
4924
4925 size = exp_nameop (SIZEOF, name);
4926
252b5132
RH		 4927 /* Arrange to work out the maximum section end address. */
4928 if (overlay_max == NULL)
4929 overlay_max = size;
4930 else
4931 overlay_max = exp_binop (MAX_K, overlay_max, size);
4932}
4933
4934/* Finish a section in an overlay. There isn't any special to do
4935 here. */
4936
4937void
4938lang_leave_overlay_section (fill, phdrs)
2c382fb6 4939 fill_type *fill;
252b5132
RH		 4940 struct lang_output_section_phdr_list *phdrs;
4941{
4942 const char *name;
4943 char *clean, *s2;
4944 const char *s1;
4945 char *buf;
4946
4947 name = current_section->name;
4948
9f88b410
RS		 4949 /* For now, assume that "*default*" is the run-time memory region and
4950 that no load-time region has been specified. It doesn't really
4951 matter what we say here, since lang_leave_overlay will override it. */
4952 lang_leave_output_section_statement (fill, "*default*", phdrs, 0);
252b5132
RH		 4953
4954 /* Define the magic symbols. */
4955
4956 clean = xmalloc (strlen (name) + 1);
4957 s2 = clean;
4958 for (s1 = name; *s1 != '\0'; s1++)
3882b010 4959 if (ISALNUM (*s1) || *s1 == '_')
252b5132
RH		 4960 *s2++ = *s1;
4961 *s2 = '\0';
4962
4963 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4964 sprintf (buf, "__load_start_%s", clean);
4965 lang_add_assignment (exp_assop ('=', buf,
4966 exp_nameop (LOADADDR, name)));
4967
4968 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4969 sprintf (buf, "__load_stop_%s", clean);
4970 lang_add_assignment (exp_assop ('=', buf,
4971 exp_binop ('+',
4972 exp_nameop (LOADADDR, name),
4973 exp_nameop (SIZEOF, name))));
4974
4975 free (clean);
4976}
4977
4978/* Finish an overlay. If there are any overlay wide settings, this
4979 looks through all the sections in the overlay and sets them. */
4980
4981void
9f88b410
RS		 4982lang_leave_overlay (lma_expr, nocrossrefs, fill, memspec, phdrs, lma_memspec)
4983 etree_type *lma_expr;
4984 int nocrossrefs;
2c382fb6 4985 fill_type *fill;
252b5132
RH		 4986 const char *memspec;
4987 struct lang_output_section_phdr_list *phdrs;
562d3460 4988 const char *lma_memspec;
252b5132
RH		 4989{
4990 lang_memory_region_type *region;
562d3460 4991 lang_memory_region_type *lma_region;
252b5132
RH		 4992 struct overlay_list *l;
4993 struct lang_nocrossref *nocrossref;
4994
ee3cc2e2
RS		 4995 lang_get_regions (&region, &lma_region,
4996 memspec, lma_memspec,
4997 lma_expr != 0);
562d3460 4998
252b5132
RH		 4999 nocrossref = NULL;
5000
9f88b410
RS		 5001 /* After setting the size of the last section, set '.' to end of the
5002 overlay region. */
5003 if (overlay_list != NULL)
5004 overlay_list->os->update_dot_tree
5005 = exp_assop ('=', ".", exp_binop ('+', overlay_vma, overlay_max));
5006
252b5132
RH		 5007 l = overlay_list;
5008 while (l != NULL)
5009 {
5010 struct overlay_list *next;
5011
2c382fb6 5012 if (fill != (fill_type *) 0 && l->os->fill == (fill_type *) 0)
252b5132 5013 l->os->fill = fill;
1545243b 5014
9f88b410
RS		 5015 l->os->region = region;
5016 l->os->lma_region = lma_region;
5017
5018 /* The first section has the load address specified in the
5019 OVERLAY statement. The rest are worked out from that.
5020 The base address is not needed (and should be null) if
5021 an LMA region was specified. */
5022 if (l->next == 0)
5023 l->os->load_base = lma_expr;
5024 else if (lma_region == 0)
5025 l->os->load_base = exp_binop ('+',
5026 exp_nameop (LOADADDR, l->next->os->name),
5027 exp_nameop (SIZEOF, l->next->os->name));
1545243b 5028
252b5132
RH		 5029 if (phdrs != NULL && l->os->phdrs == NULL)
5030 l->os->phdrs = phdrs;
5031
9f88b410 5032 if (nocrossrefs)
252b5132
RH		 5033 {
5034 struct lang_nocrossref *nc;
5035
5036 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
5037 nc->name = l->os->name;
5038 nc->next = nocrossref;
5039 nocrossref = nc;
5040 }
5041
5042 next = l->next;
5043 free (l);
5044 l = next;
5045 }
5046
5047 if (nocrossref != NULL)
5048 lang_add_nocrossref (nocrossref);
5049
252b5132 5050 overlay_vma = NULL;
252b5132
RH		 5051 overlay_list = NULL;
5052 overlay_max = NULL;
5053}
5054\f
5055/* Version handling. This is only useful for ELF. */
5056
5057/* This global variable holds the version tree that we build. */
5058
5059struct bfd_elf_version_tree *lang_elf_version_info;
5060
5061static int
5062lang_vers_match_lang_c (expr, sym)
5063 struct bfd_elf_version_expr *expr;
5064 const char *sym;
5065{
5066 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5067 return 1;
5068 return fnmatch (expr->pattern, sym, 0) == 0;
5069}
5070
5071static int
5072lang_vers_match_lang_cplusplus (expr, sym)
5073 struct bfd_elf_version_expr *expr;
5074 const char *sym;
5075{
5076 char *alt_sym;
5077 int result;
5078
5079 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5080 return 1;
5081
08da4cac 5082 alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
252b5132
RH		 5083 if (!alt_sym)
5084 {
5085 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5086 Should we early out false in this case? */
5087 result = fnmatch (expr->pattern, sym, 0) == 0;
5088 }
5089 else
5090 {
5091 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5092 free (alt_sym);
5093 }
5094
5095 return result;
5096}
5097
5098static int
5099lang_vers_match_lang_java (expr, sym)
5100 struct bfd_elf_version_expr *expr;
5101 const char *sym;
5102{
5103 char *alt_sym;
5104 int result;
5105
5106 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5107 return 1;
5108
08da4cac 5109 alt_sym = cplus_demangle (sym, DMGL_JAVA);
252b5132
RH		 5110 if (!alt_sym)
5111 {
5112 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5113 Should we early out false in this case? */
5114 result = fnmatch (expr->pattern, sym, 0) == 0;
5115 }
5116 else
5117 {
5118 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5119 free (alt_sym);
5120 }
5121
5122 return result;
5123}
5124
5125/* This is called for each variable name or match expression. */
5126
5127struct bfd_elf_version_expr *
313e35ee 5128lang_new_vers_pattern (orig, new, lang)
252b5132
RH		 5129 struct bfd_elf_version_expr *orig;
5130 const char *new;
5131 const char *lang;
5132{
5133 struct bfd_elf_version_expr *ret;
5134
5135 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
5136 ret->next = orig;
5137 ret->pattern = new;
31941635
L		 5138 ret->symver = 0;
5139 ret->script = 0;
252b5132
RH		 5140
5141 if (lang == NULL || strcasecmp (lang, "C") == 0)
5142 ret->match = lang_vers_match_lang_c;
5143 else if (strcasecmp (lang, "C++") == 0)
5144 ret->match = lang_vers_match_lang_cplusplus;
5145 else if (strcasecmp (lang, "Java") == 0)
5146 ret->match = lang_vers_match_lang_java;
5147 else
5148 {
5149 einfo (_("%X%P: unknown language `%s' in version information\n"),
5150 lang);
5151 ret->match = lang_vers_match_lang_c;
5152 }
5153
fac1652d 5154 return ldemul_new_vers_pattern (ret);
252b5132
RH		 5155}
5156
5157/* This is called for each set of variable names and match
5158 expressions. */
5159
5160struct bfd_elf_version_tree *
5161lang_new_vers_node (globals, locals)
5162 struct bfd_elf_version_expr *globals;
5163 struct bfd_elf_version_expr *locals;
5164{
5165 struct bfd_elf_version_tree *ret;
5166
5167 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5168 ret->next = NULL;
5169 ret->name = NULL;
5170 ret->vernum = 0;
5171 ret->globals = globals;
5172 ret->locals = locals;
5173 ret->deps = NULL;
5174 ret->name_indx = (unsigned int) -1;
5175 ret->used = 0;
5176 return ret;
5177}
5178
5179/* This static variable keeps track of version indices. */
5180
5181static int version_index;
5182
5183/* This is called when we know the name and dependencies of the
5184 version. */
5185
5186void
5187lang_register_vers_node (name, version, deps)
5188 const char *name;
5189 struct bfd_elf_version_tree *version;
5190 struct bfd_elf_version_deps *deps;
5191{
5192 struct bfd_elf_version_tree *t, **pp;
5193 struct bfd_elf_version_expr *e1;
5194
6b9b879a
JJ		 5195 if (name == NULL)
5196 name = "";
5197
5198 if ((name[0] == '\0' && lang_elf_version_info != NULL)
5199 || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
5200 {
5201 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5202 return;
5203 }
5204
252b5132
RH		 5205 /* Make sure this node has a unique name. */
5206 for (t = lang_elf_version_info; t != NULL; t = t->next)
5207 if (strcmp (t->name, name) == 0)
5208 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5209
5210 /* Check the global and local match names, and make sure there
5211 aren't any duplicates. */
5212
5213 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5214 {
5215 for (t = lang_elf_version_info; t != NULL; t = t->next)
5216 {
5217 struct bfd_elf_version_expr *e2;
5218
5219 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5220 if (strcmp (e1->pattern, e2->pattern) == 0)
5221 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5222 e1->pattern);
5223 }
5224 }
5225
5226 for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5227 {
5228 for (t = lang_elf_version_info; t != NULL; t = t->next)
5229 {
5230 struct bfd_elf_version_expr *e2;
5231
5232 for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5233 if (strcmp (e1->pattern, e2->pattern) == 0)
5234 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5235 e1->pattern);
5236 }
5237 }
5238
5239 version->deps = deps;
5240 version->name = name;
6b9b879a
JJ		 5241 if (name[0] != '\0')
5242 {
5243 ++version_index;
5244 version->vernum = version_index;
5245 }
5246 else
5247 version->vernum = 0;
252b5132
RH		 5248
5249 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5250 ;
5251 *pp = version;
5252}
5253
5254/* This is called when we see a version dependency. */
5255
5256struct bfd_elf_version_deps *
5257lang_add_vers_depend (list, name)
5258 struct bfd_elf_version_deps *list;
5259 const char *name;
5260{
5261 struct bfd_elf_version_deps *ret;
5262 struct bfd_elf_version_tree *t;
5263
5264 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5265 ret->next = list;
5266
5267 for (t = lang_elf_version_info; t != NULL; t = t->next)
5268 {
5269 if (strcmp (t->name, name) == 0)
5270 {
5271 ret->version_needed = t;
5272 return ret;
5273 }
5274 }
5275
5276 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5277
5278 return ret;
5279}
5280
5281static void
5282lang_do_version_exports_section ()
5283{
5284 struct bfd_elf_version_expr *greg = NULL, *lreg;
5285
5286 LANG_FOR_EACH_INPUT_STATEMENT (is)
5287 {
5288 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5289 char *contents, *p;
5290 bfd_size_type len;
5291
5292 if (sec == NULL)
b7a26f91 5293 continue;
252b5132
RH		 5294
5295 len = bfd_section_size (is->the_bfd, sec);
5296 contents = xmalloc (len);
5297 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
6f9efd97 5298 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
252b5132
RH		 5299
5300 p = contents;
89cdebba 5301 while (p < contents + len)
252b5132 5302 {
313e35ee 5303 greg = lang_new_vers_pattern (greg, p, NULL);
252b5132
RH		 5304 p = strchr (p, '\0') + 1;
5305 }
5306
5307 /* Do not free the contents, as we used them creating the regex. */
5308
5309 /* Do not include this section in the link. */
5310 bfd_set_section_flags (is->the_bfd, sec,
5311 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5312 }
5313
313e35ee 5314 lreg = lang_new_vers_pattern (NULL, "*", NULL);
252b5132
RH		 5315 lang_register_vers_node (command_line.version_exports_section,
5316 lang_new_vers_node (greg, lreg), NULL);
5317}
577a0623
AM		 5318
5319void
5320lang_add_unique (name)
5321 const char *name;
5322{
5323 struct unique_sections *ent;
5324
5325 for (ent = unique_section_list; ent; ent = ent->next)
5326 if (strcmp (ent->name, name) == 0)
5327 return;
5328
5329 ent = (struct unique_sections *) xmalloc (sizeof *ent);
5330 ent->name = xstrdup (name);
5331 ent->next = unique_section_list;
5332 unique_section_list = ent;
5333}
GDB Binutils - Deliverables
This page took 0.415373 seconds and 4 git commands to generate.