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