projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix a problem with static linking with cross tools.
[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
d08a14c3
AM		 2933 && (bfd_get_section_flags (output_bfd, os->bfd_section)
2934 & SEC_NEVER_LOAD) == 0
252b5132
RH		 2935 && ! link_info.relocateable
2936 && strcmp (os->region->name, "*default*") == 0
2937 && lang_memory_region_list != NULL
d1778b88
AM		 2938 && (strcmp (lang_memory_region_list->name,
2939 "*default*") != 0
252b5132
RH		 2940 || lang_memory_region_list->next != NULL))
2941 einfo (_("%P: warning: no memory region specified for section `%s'\n"),
d1778b88
AM		 2942 bfd_get_section_name (output_bfd,
2943 os->bfd_section));
252b5132
RH		 2944
2945 dot = os->region->current;
5f992e62 2946
252b5132
RH		 2947 if (os->section_alignment == -1)
2948 {
2949 bfd_vma olddot;
2950
2951 olddot = dot;
d1778b88
AM		 2952 dot = align_power (dot,
2953 os->bfd_section->alignment_power);
252b5132
RH		 2954
2955 if (dot != olddot && config.warn_section_align)
2956 einfo (_("%P: warning: changing start of section %s by %u bytes\n"),
2957 os->name, (unsigned int) (dot - olddot));
2958 }
2959 }
2960 else
2961 {
2962 etree_value_type r;
2963
2964 r = exp_fold_tree (os->addr_tree,
2965 abs_output_section,
2966 lang_allocating_phase_enum,
2967 dot, &dot);
2968 if (r.valid_p == false)
2969 {
2970 einfo (_("%F%S: non constant address expression for section %s\n"),
2971 os->name);
2972 }
2973 dot = r.value + r.section->bfd_section->vma;
2974 }
5f992e62 2975
252b5132
RH		 2976 /* The section starts here.
2977 First, align to what the section needs. */
2978
2979 if (os->section_alignment != -1)
2980 dot = align_power (dot, os->section_alignment);
2981
2982 bfd_set_section_vma (0, os->bfd_section, dot);
5f992e62 2983
252b5132
RH		 2984 os->bfd_section->output_offset = 0;
2985 }
2986
2d20f7bf
JJ		 2987 lang_size_sections_1 (os->children.head, os, &os->children.head,
2988 os->fill, dot, relax);
5f992e62 2989
08da4cac
KH		 2990 /* Put the section within the requested block size, or
2991 align at the block boundary. */
32edc927
TW		 2992 after = ALIGN_N (os->bfd_section->vma
2993 + os->bfd_section->_raw_size / opb,
252b5132
RH		 2994 /* The coercion here is important, see ld.h. */
2995 (bfd_vma) os->block_value);
2996
2997 if (bfd_is_abs_section (os->bfd_section))
2998 ASSERT (after == os->bfd_section->vma);
2999 else
5f992e62 3000 os->bfd_section->_raw_size =
08da4cac 3001 (after - os->bfd_section->vma) * opb;
4cbfc3ac 3002 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
252b5132
RH		 3003 os->processed = true;
3004
3005 /* Update dot in the region ?
3006 We only do this if the section is going to be allocated,
3007 since unallocated sections do not contribute to the region's
13392b77 3008 overall size in memory.
5f992e62 3009
cce4c4c5
NC		 3010 If the SEC_NEVER_LOAD bit is not set, it will affect the
3011 addresses of sections after it. We have to update
3012 dot. */
252b5132 3013 if (os->region != (lang_memory_region_type *) NULL
cce4c4c5
NC		 3014 && ((bfd_get_section_flags (output_bfd, os->bfd_section)
3015 & SEC_NEVER_LOAD) == 0
3016 || (bfd_get_section_flags (output_bfd, os->bfd_section)
3017 & (SEC_ALLOC | SEC_LOAD))))
252b5132
RH		 3018 {
3019 os->region->current = dot;
5f992e62 3020
562d3460 3021 /* Make sure the new address is within the region. */
08da4cac
KH		 3022 os_region_check (os, os->region, os->addr_tree,
3023 os->bfd_section->vma);
3024
3025 /* If there's no load address specified, use the run
3026 region as the load region. */
3027 if (os->lma_region == NULL && os->load_base == NULL)
3028 os->lma_region = os->region;
3029
3030 if (os->lma_region != NULL)
3031 {
3032 if (os->load_base != NULL)
3033 {
3034 einfo (_("%X%P: use an absolute load address or a load memory region, not both\n"));
3035 }
3036 else
3037 {
3038 /* Don't allocate twice. */
3039 if (os->lma_region != os->region)
3040 {
3041 /* Set load_base, which will be handled later. */
3042 os->load_base =
3043 exp_intop (os->lma_region->current);
3044 os->lma_region->current +=
3045 os->bfd_section->_raw_size / opb;
3046 os_region_check (os, os->lma_region, NULL,
3047 os->bfd_section->lma);
3048 }
3049 }
3050 }
252b5132
RH		 3051 }
3052 }
3053 break;
3054
3055 case lang_constructors_statement_enum:
2d20f7bf
JJ		 3056 dot = lang_size_sections_1 (constructor_list.head,
3057 output_section_statement,
3058 &s->wild_statement.children.head,
3059 fill, dot, relax);
252b5132
RH		 3060 break;
3061
3062 case lang_data_statement_enum:
3063 {
3064 unsigned int size = 0;
3065
08da4cac
KH		 3066 s->data_statement.output_vma =
3067 dot - output_section_statement->bfd_section->vma;
252b5132
RH		 3068 s->data_statement.output_section =
3069 output_section_statement->bfd_section;
3070
3071 switch (s->data_statement.type)
3072 {
08da4cac
KH		 3073 default:
3074 abort ();
252b5132
RH		 3075 case QUAD:
3076 case SQUAD:
3077 size = QUAD_SIZE;
3078 break;
3079 case LONG:
3080 size = LONG_SIZE;
3081 break;
3082 case SHORT:
3083 size = SHORT_SIZE;
3084 break;
3085 case BYTE:
3086 size = BYTE_SIZE;
3087 break;
3088 }
08da4cac
KH		 3089 if (size < opb)
3090 size = opb;
4cbfc3ac 3091 dot += size / opb;
252b5132
RH		 3092 output_section_statement->bfd_section->_raw_size += size;
3093 /* The output section gets contents, and then we inspect for
3094 any flags set in the input script which override any ALLOC. */
3095 output_section_statement->bfd_section->flags |= SEC_HAS_CONTENTS;
08da4cac
KH		 3096 if (!(output_section_statement->flags & SEC_NEVER_LOAD))
3097 {
3098 output_section_statement->bfd_section->flags |=
3099 SEC_ALLOC | SEC_LOAD;
3100 }
252b5132
RH		 3101 }
3102 break;
3103
3104 case lang_reloc_statement_enum:
3105 {
3106 int size;
3107
3108 s->reloc_statement.output_vma =
3109 dot - output_section_statement->bfd_section->vma;
3110 s->reloc_statement.output_section =
3111 output_section_statement->bfd_section;
3112 size = bfd_get_reloc_size (s->reloc_statement.howto);
4cbfc3ac 3113 dot += size / opb;
252b5132
RH		 3114 output_section_statement->bfd_section->_raw_size += size;
3115 }
3116 break;
5f992e62 3117
252b5132
RH		 3118 case lang_wild_statement_enum:
3119
2d20f7bf
JJ		 3120 dot = lang_size_sections_1 (s->wild_statement.children.head,
3121 output_section_statement,
3122 &s->wild_statement.children.head,
3123 fill, dot, relax);
252b5132
RH		 3124
3125 break;
3126
3127 case lang_object_symbols_statement_enum:
3128 link_info.create_object_symbols_section =
3129 output_section_statement->bfd_section;
3130 break;
3131 case lang_output_statement_enum:
3132 case lang_target_statement_enum:
3133 break;
3134 case lang_input_section_enum:
3135 {
3136 asection *i;
3137
3138 i = (*prev)->input_section.section;
3139 if (! relax)
3140 {
3141 if (i->_cooked_size == 0)
3142 i->_cooked_size = i->_raw_size;
3143 }
3144 else
3145 {
3146 boolean again;
3147
3148 if (! bfd_relax_section (i->owner, i, &link_info, &again))
3149 einfo (_("%P%F: can't relax section: %E\n"));
3150 if (again)
b3327aad 3151 *relax = true;
252b5132 3152 }
b3327aad
AM		 3153 dot = size_input_section (prev, output_section_statement,
3154 output_section_statement->fill, dot);
252b5132
RH		 3155 }
3156 break;
3157 case lang_input_statement_enum:
3158 break;
3159 case lang_fill_statement_enum:
08da4cac
KH		 3160 s->fill_statement.output_section =
3161 output_section_statement->bfd_section;
252b5132
RH		 3162
3163 fill = s->fill_statement.fill;
3164 break;
3165 case lang_assignment_statement_enum:
3166 {
3167 bfd_vma newdot = dot;
3168
3169 exp_fold_tree (s->assignment_statement.exp,
3170 output_section_statement,
3171 lang_allocating_phase_enum,
3172 dot,
3173 &newdot);
3174
3175 if (newdot != dot)
3176 {
252b5132
RH		 3177 if (output_section_statement == abs_output_section)
3178 {
3179 /* If we don't have an output section, then just adjust
3180 the default memory address. */
3181 lang_memory_region_lookup ("*default*")->current = newdot;
3182 }
b3327aad 3183 else
252b5132 3184 {
b3327aad
AM		 3185 /* Insert a pad after this statement. We can't
3186 put the pad before when relaxing, in case the
3187 assignment references dot. */
3188 insert_pad (&s->header.next, fill, (newdot - dot) * opb,
3189 output_section_statement->bfd_section, dot);
3190
3191 /* Don't neuter the pad below when relaxing. */
3192 s = s->header.next;
252b5132
RH		 3193 }
3194
3195 dot = newdot;
3196 }
3197 }
3198 break;
3199
3200 case lang_padding_statement_enum:
c0c330a7
AM		 3201 /* If this is the first time lang_size_sections is called,
3202 we won't have any padding statements. If this is the
3203 second or later passes when relaxing, we should allow
3204 padding to shrink. If padding is needed on this pass, it
3205 will be added back in. */
3206 s->padding_statement.size = 0;
6e814ff8
AM		 3207
3208 /* Make sure output_offset is valid. If relaxation shrinks
3209 the section and this pad isn't needed, it's possible to
3210 have output_offset larger than the final size of the
3211 section. bfd_set_section_contents will complain even for
3212 a pad size of zero. */
3213 s->padding_statement.output_offset
3214 = dot - output_section_statement->bfd_section->vma;
252b5132
RH		 3215 break;
3216
3217 case lang_group_statement_enum:
2d20f7bf
JJ		 3218 dot = lang_size_sections_1 (s->group_statement.children.head,
3219 output_section_statement,
3220 &s->group_statement.children.head,
3221 fill, dot, relax);
252b5132
RH		 3222 break;
3223
3224 default:
3225 FAIL ();
3226 break;
3227
c0c330a7 3228 /* We can only get here when relaxing is turned on. */
252b5132
RH		 3229 case lang_address_statement_enum:
3230 break;
3231 }
3232 prev = &s->header.next;
3233 }
3234 return dot;
3235}
3236
2d20f7bf
JJ		 3237bfd_vma
3238lang_size_sections (s, output_section_statement, prev, fill, dot, relax)
3239 lang_statement_union_type *s;
3240 lang_output_section_statement_type *output_section_statement;
3241 lang_statement_union_type **prev;
2c382fb6 3242 fill_type *fill;
2d20f7bf
JJ		 3243 bfd_vma dot;
3244 boolean *relax;
3245{
3246 bfd_vma result;
3247
3248 exp_data_seg.phase = exp_dataseg_none;
3249 result = lang_size_sections_1 (s, output_section_statement, prev, fill,
3250 dot, relax);
3251 if (exp_data_seg.phase == exp_dataseg_end_seen)
3252 {
3253 /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
3254 a page could be saved in the data segment. */
3255 bfd_vma first, last;
3256
3257 first = -exp_data_seg.base & (exp_data_seg.pagesize - 1);
3258 last = exp_data_seg.end & (exp_data_seg.pagesize - 1);
3259 if (first && last
3260 && ((exp_data_seg.base & ~(exp_data_seg.pagesize - 1))
3261 != (exp_data_seg.end & ~(exp_data_seg.pagesize - 1)))
3262 && first + last <= exp_data_seg.pagesize)
3263 {
3264 exp_data_seg.phase = exp_dataseg_adjust;
3265 result = lang_size_sections_1 (s, output_section_statement, prev,
3266 fill, dot, relax);
3267 }
3268 }
3269
3270 return result;
3271}
3272
252b5132
RH		 3273bfd_vma
3274lang_do_assignments (s, output_section_statement, fill, dot)
08da4cac
KH		 3275 lang_statement_union_type *s;
3276 lang_output_section_statement_type *output_section_statement;
2c382fb6 3277 fill_type *fill;
252b5132
RH		 3278 bfd_vma dot;
3279{
5f992e62
AM		 3280 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3281 ldfile_output_machine);
4cbfc3ac 3282
bba1a0c0 3283 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
252b5132
RH		 3284 {
3285 switch (s->header.type)
3286 {
3287 case lang_constructors_statement_enum:
3288 dot = lang_do_assignments (constructor_list.head,
3289 output_section_statement,
3290 fill,
3291 dot);
3292 break;
3293
3294 case lang_output_section_statement_enum:
3295 {
d1778b88 3296 lang_output_section_statement_type *os;
252b5132 3297
d1778b88 3298 os = &(s->output_section_statement);
252b5132
RH		 3299 if (os->bfd_section != NULL)
3300 {
3301 dot = os->bfd_section->vma;
3302 (void) lang_do_assignments (os->children.head, os,
3303 os->fill, dot);
4cbfc3ac
TW		 3304 dot = os->bfd_section->vma + os->bfd_section->_raw_size / opb;
3305
252b5132 3306 }
c13b1b77 3307 if (os->load_base)
252b5132
RH		 3308 {
3309 /* If nothing has been placed into the output section then
4de2d33d 3310 it won't have a bfd_section. */
5f992e62 3311 if (os->bfd_section)
252b5132 3312 {
5f992e62 3313 os->bfd_section->lma
08da4cac
KH		 3314 = exp_get_abs_int (os->load_base, 0, "load base",
3315 lang_final_phase_enum);
252b5132
RH		 3316 }
3317 }
3318 }
3319 break;
3320 case lang_wild_statement_enum:
3321
3322 dot = lang_do_assignments (s->wild_statement.children.head,
3323 output_section_statement,
3324 fill, dot);
3325
3326 break;
3327
3328 case lang_object_symbols_statement_enum:
3329 case lang_output_statement_enum:
3330 case lang_target_statement_enum:
3331#if 0
3332 case lang_common_statement_enum:
3333#endif
3334 break;
3335 case lang_data_statement_enum:
3336 {
3337 etree_value_type value;
3338
3339 value = exp_fold_tree (s->data_statement.exp,
3340 abs_output_section,
3341 lang_final_phase_enum, dot, &dot);
3342 s->data_statement.value = value.value;
3343 if (value.valid_p == false)
3344 einfo (_("%F%P: invalid data statement\n"));
3345 }
4cbfc3ac 3346 {
f6af82bd 3347 unsigned int size;
08da4cac
KH		 3348 switch (s->data_statement.type)
3349 {
3350 default:
3351 abort ();
3352 case QUAD:
3353 case SQUAD:
3354 size = QUAD_SIZE;
3355 break;
3356 case LONG:
3357 size = LONG_SIZE;
3358 break;
3359 case SHORT:
3360 size = SHORT_SIZE;
3361 break;
3362 case BYTE:
3363 size = BYTE_SIZE;
3364 break;
3365 }
3366 if (size < opb)
3367 size = opb;
3368 dot += size / opb;
3369 }
252b5132
RH		 3370 break;
3371
3372 case lang_reloc_statement_enum:
3373 {
3374 etree_value_type value;
3375
3376 value = exp_fold_tree (s->reloc_statement.addend_exp,
3377 abs_output_section,
3378 lang_final_phase_enum, dot, &dot);
3379 s->reloc_statement.addend_value = value.value;
3380 if (value.valid_p == false)
3381 einfo (_("%F%P: invalid reloc statement\n"));
3382 }
4cbfc3ac 3383 dot += bfd_get_reloc_size (s->reloc_statement.howto) / opb;
252b5132
RH		 3384 break;
3385
3386 case lang_input_section_enum:
3387 {
3388 asection *in = s->input_section.section;
3389
3390 if (in->_cooked_size != 0)
4cbfc3ac 3391 dot += in->_cooked_size / opb;
252b5132 3392 else
4cbfc3ac 3393 dot += in->_raw_size / opb;
252b5132
RH		 3394 }
3395 break;
3396
3397 case lang_input_statement_enum:
3398 break;
3399 case lang_fill_statement_enum:
3400 fill = s->fill_statement.fill;
3401 break;
3402 case lang_assignment_statement_enum:
3403 {
3404 exp_fold_tree (s->assignment_statement.exp,
3405 output_section_statement,
3406 lang_final_phase_enum,
3407 dot,
3408 &dot);
3409 }
3410
3411 break;
3412 case lang_padding_statement_enum:
4cbfc3ac 3413 dot += s->padding_statement.size / opb;
252b5132
RH		 3414 break;
3415
3416 case lang_group_statement_enum:
3417 dot = lang_do_assignments (s->group_statement.children.head,
3418 output_section_statement,
3419 fill, dot);
3420
3421 break;
3422
3423 default:
3424 FAIL ();
3425 break;
3426 case lang_address_statement_enum:
3427 break;
3428 }
3429
3430 }
3431 return dot;
3432}
3433
3434/* Fix any .startof. or .sizeof. symbols. When the assemblers see the
3435 operator .startof. (section_name), it produces an undefined symbol
3436 .startof.section_name. Similarly, when it sees
3437 .sizeof. (section_name), it produces an undefined symbol
3438 .sizeof.section_name. For all the output sections, we look for
3439 such symbols, and set them to the correct value. */
3440
3441static void
3442lang_set_startof ()
3443{
3444 asection *s;
3445
3446 if (link_info.relocateable)
3447 return;
3448
3449 for (s = output_bfd->sections; s != NULL; s = s->next)
3450 {
3451 const char *secname;
3452 char *buf;
3453 struct bfd_link_hash_entry *h;
3454
3455 secname = bfd_get_section_name (output_bfd, s);
3456 buf = xmalloc (10 + strlen (secname));
3457
3458 sprintf (buf, ".startof.%s", secname);
3459 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3460 if (h != NULL && h->type == bfd_link_hash_undefined)
3461 {
3462 h->type = bfd_link_hash_defined;
3463 h->u.def.value = bfd_get_section_vma (output_bfd, s);
3464 h->u.def.section = bfd_abs_section_ptr;
3465 }
3466
3467 sprintf (buf, ".sizeof.%s", secname);
3468 h = bfd_link_hash_lookup (link_info.hash, buf, false, false, true);
3469 if (h != NULL && h->type == bfd_link_hash_undefined)
3470 {
d1778b88
AM		 3471 unsigned opb;
3472
3473 opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3474 ldfile_output_machine);
252b5132
RH		 3475 h->type = bfd_link_hash_defined;
3476 if (s->_cooked_size != 0)
4cbfc3ac 3477 h->u.def.value = s->_cooked_size / opb;
252b5132 3478 else
4cbfc3ac 3479 h->u.def.value = s->_raw_size / opb;
252b5132
RH		 3480 h->u.def.section = bfd_abs_section_ptr;
3481 }
3482
3483 free (buf);
3484 }
3485}
3486
3487static void
3488lang_finish ()
3489{
3490 struct bfd_link_hash_entry *h;
3491 boolean warn;
3492
3493 if (link_info.relocateable || link_info.shared)
3494 warn = false;
3495 else
3496 warn = true;
3497
3498 if (entry_symbol == (char *) NULL)
3499 {
3500 /* No entry has been specified. Look for start, but don't warn
3501 if we don't find it. */
3502 entry_symbol = "start";
3503 warn = false;
3504 }
3505
3506 h = bfd_link_hash_lookup (link_info.hash, entry_symbol, false, false, true);
3507 if (h != (struct bfd_link_hash_entry *) NULL
3508 && (h->type == bfd_link_hash_defined
3509 || h->type == bfd_link_hash_defweak)
3510 && h->u.def.section->output_section != NULL)
3511 {
3512 bfd_vma val;
3513
3514 val = (h->u.def.value
3515 + bfd_get_section_vma (output_bfd,
3516 h->u.def.section->output_section)
3517 + h->u.def.section->output_offset);
3518 if (! bfd_set_start_address (output_bfd, val))
3519 einfo (_("%P%F:%s: can't set start address\n"), entry_symbol);
3520 }
3521 else
3522 {
3523 bfd_vma val;
5f992e62 3524 const char *send;
252b5132
RH		 3525
3526 /* We couldn't find the entry symbol. Try parsing it as a
3527 number. */
3528 val = bfd_scan_vma (entry_symbol, &send, 0);
3529 if (*send == '\0')
3530 {
3531 if (! bfd_set_start_address (output_bfd, val))
3532 einfo (_("%P%F: can't set start address\n"));
3533 }
3534 else
3535 {
3536 asection *ts;
3537
3538 /* Can't find the entry symbol, and it's not a number. Use
3539 the first address in the text section. */
1e281515 3540 ts = bfd_get_section_by_name (output_bfd, entry_section);
252b5132
RH		 3541 if (ts != (asection *) NULL)
3542 {
3543 if (warn)
3544 einfo (_("%P: warning: cannot find entry symbol %s; defaulting to %V\n"),
3545 entry_symbol, bfd_get_section_vma (output_bfd, ts));
3546 if (! bfd_set_start_address (output_bfd,
3547 bfd_get_section_vma (output_bfd,
3548 ts)))
3549 einfo (_("%P%F: can't set start address\n"));
3550 }
3551 else
3552 {
3553 if (warn)
3554 einfo (_("%P: warning: cannot find entry symbol %s; not setting start address\n"),
3555 entry_symbol);
3556 }
3557 }
3558 }
3559}
3560
3561/* This is a small function used when we want to ignore errors from
3562 BFD. */
3563
3564static void
3565#ifdef ANSI_PROTOTYPES
87f2a346 3566ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
252b5132
RH		 3567#else
3568ignore_bfd_errors (s)
87f2a346 3569 const char *s ATTRIBUTE_UNUSED;
252b5132
RH		 3570#endif
3571{
3572 /* Don't do anything. */
3573}
3574
3575/* Check that the architecture of all the input files is compatible
3576 with the output file. Also call the backend to let it do any
3577 other checking that is needed. */
3578
3579static void
3580lang_check ()
3581{
3582 lang_statement_union_type *file;
3583 bfd *input_bfd;
5f992e62 3584 const bfd_arch_info_type *compatible;
252b5132
RH		 3585
3586 for (file = file_chain.head;
3587 file != (lang_statement_union_type *) NULL;
3588 file = file->input_statement.next)
3589 {
3590 input_bfd = file->input_statement.the_bfd;
30cba025
AM		 3591 compatible = bfd_arch_get_compatible (input_bfd, output_bfd);
3592
3593 /* In general it is not possible to perform a relocatable
3594 link between differing object formats when the input
3595 file has relocations, because the relocations in the
3596 input format may not have equivalent representations in
3597 the output format (and besides BFD does not translate
3598 relocs for other link purposes than a final link). */
d35a52e2 3599 if ((link_info.relocateable || link_info.emitrelocations)
30cba025 3600 && (compatible == NULL
d35a52e2 3601 || bfd_get_flavour (input_bfd) != bfd_get_flavour (output_bfd))
30cba025
AM		 3602 && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
3603 {
3604 einfo (_("%P%F: Relocatable linking with relocations from format %s (%B) to format %s (%B) is not supported\n"),
3605 bfd_get_target (input_bfd), input_bfd,
3606 bfd_get_target (output_bfd), output_bfd);
3607 /* einfo with %F exits. */
3608 }
3609
252b5132
RH		 3610 if (compatible == NULL)
3611 {
3612 if (command_line.warn_mismatch)
3613 einfo (_("%P: warning: %s architecture of input file `%B' is incompatible with %s output\n"),
3614 bfd_printable_name (input_bfd), input_bfd,
3615 bfd_printable_name (output_bfd));
3616 }
b9247304 3617 else if (bfd_count_sections (input_bfd))
252b5132 3618 {
b9247304
L		 3619 /* If the input bfd has no contents, it shouldn't set the
3620 private data of the output bfd. */
3621
252b5132
RH		 3622 bfd_error_handler_type pfn = NULL;
3623
3624 /* If we aren't supposed to warn about mismatched input
3625 files, temporarily set the BFD error handler to a
3626 function which will do nothing. We still want to call
3627 bfd_merge_private_bfd_data, since it may set up
3628 information which is needed in the output file. */
3629 if (! command_line.warn_mismatch)
3630 pfn = bfd_set_error_handler (ignore_bfd_errors);
3631 if (! bfd_merge_private_bfd_data (input_bfd, output_bfd))
3632 {
3633 if (command_line.warn_mismatch)
3634 einfo (_("%E%X: failed to merge target specific data of file %B\n"),
3635 input_bfd);
3636 }
3637 if (! command_line.warn_mismatch)
3638 bfd_set_error_handler (pfn);
3639 }
3640 }
3641}
3642
3643/* Look through all the global common symbols and attach them to the
3644 correct section. The -sort-common command line switch may be used
3645 to roughly sort the entries by size. */
3646
3647static void
3648lang_common ()
3649{
4818e05f
AM		 3650 if (command_line.inhibit_common_definition)
3651 return;
252b5132
RH		 3652 if (link_info.relocateable
3653 && ! command_line.force_common_definition)
3654 return;
3655
3656 if (! config.sort_common)
3657 bfd_link_hash_traverse (link_info.hash, lang_one_common, (PTR) NULL);
3658 else
3659 {
3660 int power;
3661
3662 for (power = 4; power >= 0; power--)
3663 bfd_link_hash_traverse (link_info.hash, lang_one_common,
3664 (PTR) &power);
3665 }
3666}
3667
3668/* Place one common symbol in the correct section. */
3669
3670static boolean
3671lang_one_common (h, info)
3672 struct bfd_link_hash_entry *h;
3673 PTR info;
3674{
3675 unsigned int power_of_two;
3676 bfd_vma size;
3677 asection *section;
5f992e62
AM		 3678 unsigned opb = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3679 ldfile_output_machine);
252b5132
RH		 3680
3681 if (h->type != bfd_link_hash_common)
3682 return true;
3683
3684 size = h->u.c.size;
3685 power_of_two = h->u.c.p->alignment_power;
3686
3687 if (config.sort_common
3688 && power_of_two < (unsigned int) *(int *) info)
3689 return true;
3690
3691 section = h->u.c.p->section;
3692
3693 /* Increase the size of the section. */
4cbfc3ac
TW		 3694 section->_cooked_size = ALIGN_N ((section->_cooked_size + opb - 1) / opb,
3695 (bfd_size_type) (1 << power_of_two)) * opb;
252b5132
RH		 3696
3697 /* Adjust the alignment if necessary. */
3698 if (power_of_two > section->alignment_power)
3699 section->alignment_power = power_of_two;
3700
3701 /* Change the symbol from common to defined. */
3702 h->type = bfd_link_hash_defined;
3703 h->u.def.section = section;
3704 h->u.def.value = section->_cooked_size;
3705
3706 /* Increase the size of the section. */
3707 section->_cooked_size += size;
3708
3709 /* Make sure the section is allocated in memory, and make sure that
3710 it is no longer a common section. */
3711 section->flags |= SEC_ALLOC;
08da4cac 3712 section->flags &= ~SEC_IS_COMMON;
252b5132
RH		 3713
3714 if (config.map_file != NULL)
3715 {
3716 static boolean header_printed;
3717 int len;
3718 char *name;
3719 char buf[50];
3720
3721 if (! header_printed)
3722 {
3723 minfo (_("\nAllocating common symbols\n"));
3724 minfo (_("Common symbol size file\n\n"));
3725 header_printed = true;
3726 }
3727
3728 name = demangle (h->root.string);
3729 minfo ("%s", name);
3730 len = strlen (name);
3731 free (name);
3732
3733 if (len >= 19)
3734 {
3735 print_nl ();
3736 len = 0;
3737 }
3738 while (len < 20)
3739 {
3740 print_space ();
3741 ++len;
3742 }
3743
3744 minfo ("0x");
3745 if (size <= 0xffffffff)
3746 sprintf (buf, "%lx", (unsigned long) size);
3747 else
3748 sprintf_vma (buf, size);
3749 minfo ("%s", buf);
3750 len = strlen (buf);
3751
3752 while (len < 16)
3753 {
3754 print_space ();
3755 ++len;
3756 }
3757
3758 minfo ("%B\n", section->owner);
3759 }
3760
3761 return true;
3762}
3763
08da4cac
KH		 3764/* Run through the input files and ensure that every input section has
3765 somewhere to go. If one is found without a destination then create
3766 an input request and place it into the statement tree. */
252b5132
RH		 3767
3768static void
3769lang_place_orphans ()
3770{
e50d8076 3771 LANG_FOR_EACH_INPUT_STATEMENT (file)
252b5132
RH		 3772 {
3773 asection *s;
3774
3775 for (s = file->the_bfd->sections;
3776 s != (asection *) NULL;
3777 s = s->next)
3778 {
3779 if (s->output_section == (asection *) NULL)
3780 {
3781 /* This section of the file is not attatched, root
08da4cac 3782 around for a sensible place for it to go. */
252b5132
RH		 3783
3784 if (file->just_syms_flag)
3785 {
3786 /* We are only retrieving symbol values from this
3787 file. We want the symbols to act as though the
3788 values in the file are absolute. */
3789 s->output_section = bfd_abs_section_ptr;
3790 s->output_offset = s->vma;
3791 }
3792 else if (strcmp (s->name, "COMMON") == 0)
3793 {
3794 /* This is a lonely common section which must have
3795 come from an archive. We attach to the section
3796 with the wildcard. */
3797 if (! link_info.relocateable
3798 || command_line.force_common_definition)
3799 {
3800 if (default_common_section == NULL)
3801 {
3802#if 0
3803 /* This message happens when using the
3804 svr3.ifile linker script, so I have
3805 disabled it. */
3806 info_msg (_("%P: no [COMMON] command, defaulting to .bss\n"));
3807#endif
3808 default_common_section =
3809 lang_output_section_statement_lookup (".bss");
3810
3811 }
39dcfe18
AM		 3812 lang_add_section (&default_common_section->children, s,
3813 default_common_section, file);
252b5132
RH		 3814 }
3815 }
3816 else if (ldemul_place_orphan (file, s))
3817 ;
3818 else
3819 {
39dcfe18 3820 lang_output_section_statement_type *os;
252b5132 3821
39dcfe18
AM		 3822 os = lang_output_section_statement_lookup (s->name);
3823 lang_add_section (&os->children, s, os, file);
252b5132
RH		 3824 }
3825 }
3826 }
3827 }
3828}
3829
252b5132 3830void
aa8804e4 3831lang_set_flags (ptr, flags, invert)
252b5132 3832 lang_memory_region_type *ptr;
5f992e62 3833 const char *flags;
aa8804e4 3834 int invert;
252b5132 3835{
aa8804e4 3836 flagword *ptr_flags;
252b5132 3837
aa8804e4 3838 ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
252b5132
RH		 3839 while (*flags)
3840 {
3841 switch (*flags)
3842 {
252b5132
RH		 3843 case 'A': case 'a':
3844 *ptr_flags |= SEC_ALLOC;
3845 break;
3846
3847 case 'R': case 'r':
3848 *ptr_flags |= SEC_READONLY;
3849 break;
3850
3851 case 'W': case 'w':
3852 *ptr_flags |= SEC_DATA;
3853 break;
3854
3855 case 'X': case 'x':
3856 *ptr_flags |= SEC_CODE;
3857 break;
3858
3859 case 'L': case 'l':
3860 case 'I': case 'i':
3861 *ptr_flags |= SEC_LOAD;
3862 break;
3863
3864 default:
3865 einfo (_("%P%F: invalid syntax in flags\n"));
3866 break;
3867 }
3868 flags++;
3869 }
3870}
3871
3872/* Call a function on each input file. This function will be called
3873 on an archive, but not on the elements. */
3874
3875void
3876lang_for_each_input_file (func)
3877 void (*func) PARAMS ((lang_input_statement_type *));
3878{
3879 lang_input_statement_type *f;
3880
3881 for (f = (lang_input_statement_type *) input_file_chain.head;
3882 f != NULL;
3883 f = (lang_input_statement_type *) f->next_real_file)
3884 func (f);
3885}
3886
3887/* Call a function on each file. The function will be called on all
3888 the elements of an archive which are included in the link, but will
3889 not be called on the archive file itself. */
3890
3891void
3892lang_for_each_file (func)
3893 void (*func) PARAMS ((lang_input_statement_type *));
3894{
e50d8076 3895 LANG_FOR_EACH_INPUT_STATEMENT (f)
252b5132
RH		 3896 {
3897 func (f);
3898 }
3899}
3900
3901#if 0
3902
3903/* Not used. */
3904
3905void
3906lang_for_each_input_section (func)
08da4cac 3907 void (*func) PARAMS ((bfd *ab, asection *as));
252b5132 3908{
e50d8076 3909 LANG_FOR_EACH_INPUT_STATEMENT (f)
252b5132 3910 {
08da4cac 3911 asection *s;
252b5132
RH		 3912
3913 for (s = f->the_bfd->sections;
3914 s != (asection *) NULL;
3915 s = s->next)
3916 {
3917 func (f->the_bfd, s);
3918 }
3919 }
3920}
3921
3922#endif
3923
3924void
3925ldlang_add_file (entry)
08da4cac 3926 lang_input_statement_type *entry;
252b5132
RH		 3927{
3928 bfd **pp;
3929
3930 lang_statement_append (&file_chain,
3931 (lang_statement_union_type *) entry,
3932 &entry->next);
3933
3934 /* The BFD linker needs to have a list of all input BFDs involved in
3935 a link. */
3936 ASSERT (entry->the_bfd->link_next == (bfd *) NULL);
3937 ASSERT (entry->the_bfd != output_bfd);
3938 for (pp = &link_info.input_bfds;
3939 *pp != (bfd *) NULL;
3940 pp = &(*pp)->link_next)
3941 ;
3942 *pp = entry->the_bfd;
3943 entry->the_bfd->usrdata = (PTR) entry;
3944 bfd_set_gp_size (entry->the_bfd, g_switch_value);
3945
3946 /* Look through the sections and check for any which should not be
3947 included in the link. We need to do this now, so that we can
3948 notice when the backend linker tries to report multiple
3949 definition errors for symbols which are in sections we aren't
3950 going to link. FIXME: It might be better to entirely ignore
3951 symbols which are defined in sections which are going to be
3952 discarded. This would require modifying the backend linker for
3953 each backend which might set the SEC_LINK_ONCE flag. If we do
3954 this, we should probably handle SEC_EXCLUDE in the same way. */
3955
3956 bfd_map_over_sections (entry->the_bfd, section_already_linked, (PTR) entry);
3957}
3958
3959void
3960lang_add_output (name, from_script)
5f992e62 3961 const char *name;
252b5132
RH		 3962 int from_script;
3963{
3964 /* Make -o on command line override OUTPUT in script. */
3965 if (had_output_filename == false || !from_script)
3966 {
3967 output_filename = name;
3968 had_output_filename = true;
3969 }
3970}
3971
252b5132
RH		 3972static lang_output_section_statement_type *current_section;
3973
3974static int
3975topower (x)
3976 int x;
3977{
3978 unsigned int i = 1;
3979 int l;
3980
3981 if (x < 0)
3982 return -1;
3983
5f992e62 3984 for (l = 0; l < 32; l++)
252b5132
RH		 3985 {
3986 if (i >= (unsigned int) x)
3987 return l;
3988 i <<= 1;
3989 }
3990
3991 return 0;
3992}
3993
aea4bd9d 3994lang_output_section_statement_type *
252b5132
RH		 3995lang_enter_output_section_statement (output_section_statement_name,
3996 address_exp, sectype, block_value,
3997 align, subalign, ebase)
3998 const char *output_section_statement_name;
08da4cac 3999 etree_type *address_exp;
252b5132
RH		 4000 enum section_type sectype;
4001 bfd_vma block_value;
4002 etree_type *align;
4003 etree_type *subalign;
4004 etree_type *ebase;
4005{
4006 lang_output_section_statement_type *os;
4007
4008 current_section =
4009 os =
4010 lang_output_section_statement_lookup (output_section_statement_name);
4011
08da4cac
KH		 4012 /* Add this statement to tree. */
4013#if 0
4014 add_statement (lang_output_section_statement_enum,
4015 output_section_statement);
4016#endif
4017 /* Make next things chain into subchain of this. */
252b5132 4018
08da4cac
KH		 4019 if (os->addr_tree == (etree_type *) NULL)
4020 {
4021 os->addr_tree = address_exp;
4022 }
252b5132
RH		 4023 os->sectype = sectype;
4024 if (sectype != noload_section)
4025 os->flags = SEC_NO_FLAGS;
4026 else
4027 os->flags = SEC_NEVER_LOAD;
4028 os->block_value = block_value ? block_value : 1;
4029 stat_ptr = &os->children;
4030
08da4cac
KH		 4031 os->subsection_alignment =
4032 topower (exp_get_value_int (subalign, -1, "subsection alignment", 0));
4033 os->section_alignment =
4034 topower (exp_get_value_int (align, -1, "section alignment", 0));
252b5132
RH		 4035
4036 os->load_base = ebase;
aea4bd9d 4037 return os;
252b5132
RH		 4038}
4039
252b5132
RH		 4040void
4041lang_final ()
4042{
4043 lang_output_statement_type *new =
4044 new_stat (lang_output_statement, stat_ptr);
4045
4046 new->name = output_filename;
4047}
4048
08da4cac
KH		 4049/* Reset the current counters in the regions. */
4050
e3dc8847
HPN		 4051void
4052lang_reset_memory_regions ()
252b5132
RH		 4053{
4054 lang_memory_region_type *p = lang_memory_region_list;
b3327aad 4055 asection *o;
252b5132
RH		 4056
4057 for (p = lang_memory_region_list;
4058 p != (lang_memory_region_type *) NULL;
4059 p = p->next)
4060 {
4061 p->old_length = (bfd_size_type) (p->current - p->origin);
4062 p->current = p->origin;
4063 }
b3327aad
AM		 4064
4065 for (o = output_bfd->sections; o != NULL; o = o->next)
4066 o->_raw_size = 0;
252b5132
RH		 4067}
4068
b6bf44ba
AM		 4069/* If the wild pattern was marked KEEP, the member sections
4070 should be as well. */
252b5132
RH		 4071
4072static void
b6bf44ba 4073gc_section_callback (ptr, sec, section, file, data)
252b5132 4074 lang_wild_statement_type *ptr;
b6bf44ba 4075 struct wildcard_list *sec ATTRIBUTE_UNUSED;
4dec4d4e 4076 asection *section;
87f2a346 4077 lang_input_statement_type *file ATTRIBUTE_UNUSED;
5f992e62 4078 PTR data ATTRIBUTE_UNUSED;
252b5132 4079{
4dec4d4e
RH		 4080 if (ptr->keep_sections)
4081 section->flags |= SEC_KEEP;
252b5132
RH		 4082}
4083
b6bf44ba 4084/* Handle a wild statement, marking it against GC. */
252b5132
RH		 4085
4086static void
b6bf44ba 4087lang_gc_wild (s)
252b5132 4088 lang_wild_statement_type *s;
252b5132 4089{
b6bf44ba 4090 walk_wild (s, gc_section_callback, NULL);
252b5132
RH		 4091}
4092
4093/* Iterate over sections marking them against GC. */
4094
4095static void
4096lang_gc_sections_1 (s)
08da4cac 4097 lang_statement_union_type *s;
252b5132 4098{
bba1a0c0 4099 for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
252b5132
RH		 4100 {
4101 switch (s->header.type)
4102 {
4103 case lang_wild_statement_enum:
b6bf44ba 4104 lang_gc_wild (&s->wild_statement);
abc6ab0a 4105 break;
252b5132
RH		 4106 case lang_constructors_statement_enum:
4107 lang_gc_sections_1 (constructor_list.head);
4108 break;
4109 case lang_output_section_statement_enum:
4110 lang_gc_sections_1 (s->output_section_statement.children.head);
4111 break;
4112 case lang_group_statement_enum:
4113 lang_gc_sections_1 (s->group_statement.children.head);
4114 break;
4115 default:
4116 break;
4117 }
4118 }
4119}
4120
4121static void
4122lang_gc_sections ()
4123{
4124 struct bfd_link_hash_entry *h;
4125 ldlang_undef_chain_list_type *ulist, fake_list_start;
4126
4127 /* Keep all sections so marked in the link script. */
4128
4129 lang_gc_sections_1 (statement_list.head);
4130
4131 /* Keep all sections containing symbols undefined on the command-line.
4132 Handle the entry symbol at the same time. */
5f992e62 4133
7c83b342
DE		 4134 if (entry_symbol != NULL)
4135 {
4136 fake_list_start.next = ldlang_undef_chain_list_head;
4137 fake_list_start.name = (char *) entry_symbol;
4138 ulist = &fake_list_start;
4139 }
252b5132 4140 else
7c83b342 4141 ulist = ldlang_undef_chain_list_head;
252b5132 4142
7c83b342 4143 for (; ulist; ulist = ulist->next)
252b5132 4144 {
5f992e62 4145 h = bfd_link_hash_lookup (link_info.hash, ulist->name,
252b5132
RH		 4146 false, false, false);
4147
4148 if (h != (struct bfd_link_hash_entry *) NULL
08da4cac
KH		 4149 && (h->type == bfd_link_hash_defined
4150 || h->type == bfd_link_hash_defweak)
252b5132
RH		 4151 && ! bfd_is_abs_section (h->u.def.section))
4152 {
4153 h->u.def.section->flags |= SEC_KEEP;
4154 }
4155 }
4156
4157 bfd_gc_sections (output_bfd, &link_info);
4158}
4159
4160void
4161lang_process ()
4162{
4163 lang_reasonable_defaults ();
4164 current_target = default_target;
4165
08da4cac
KH		 4166 /* Open the output file. */
4167 lang_for_each_statement (ldlang_open_output);
252b5132
RH		 4168
4169 ldemul_create_output_section_statements ();
4170
08da4cac 4171 /* Add to the hash table all undefineds on the command line. */
252b5132
RH		 4172 lang_place_undefineds ();
4173
9503fd87
ILT		 4174 already_linked_table_init ();
4175
08da4cac 4176 /* Create a bfd for each input file. */
252b5132
RH		 4177 current_target = default_target;
4178 open_input_bfds (statement_list.head, false);
4179
4180 ldemul_after_open ();
4181
9503fd87
ILT		 4182 already_linked_table_free ();
4183
252b5132
RH		 4184 /* Make sure that we're not mixing architectures. We call this
4185 after all the input files have been opened, but before we do any
4186 other processing, so that any operations merge_private_bfd_data
4187 does on the output file will be known during the rest of the
4188 link. */
4189 lang_check ();
4190
4191 /* Handle .exports instead of a version script if we're told to do so. */
4192 if (command_line.version_exports_section)
4193 lang_do_version_exports_section ();
4194
4195 /* Build all sets based on the information gathered from the input
4196 files. */
4197 ldctor_build_sets ();
4198
4199 /* Remove unreferenced sections if asked to. */
4200 if (command_line.gc_sections)
4201 lang_gc_sections ();
4202
8550eb6e
JJ		 4203 /* If there were any SEC_MERGE sections, finish their merging, so that
4204 section sizes can be computed. This has to be done after GC of sections,
4205 so that GCed sections are not merged, but before assigning output
4206 sections, since removing whole input sections is hard then. */
4207 bfd_merge_sections (output_bfd, &link_info);
4208
08da4cac 4209 /* Size up the common data. */
252b5132
RH		 4210 lang_common ();
4211
4212 /* Run through the contours of the script and attach input sections
08da4cac 4213 to the correct output sections. */
252b5132
RH		 4214 map_input_to_output_sections (statement_list.head, (char *) NULL,
4215 (lang_output_section_statement_type *) NULL);
4216
08da4cac 4217 /* Find any sections not attached explicitly and handle them. */
252b5132
RH		 4218 lang_place_orphans ();
4219
862120bd
AM		 4220 if (! link_info.relocateable)
4221 {
4222 /* Look for a text section and set the readonly attribute in it. */
4223 asection *found = bfd_get_section_by_name (output_bfd, ".text");
4224
4225 if (found != (asection *) NULL)
4226 {
4227 if (config.text_read_only)
4228 found->flags |= SEC_READONLY;
4229 else
4230 found->flags &= ~SEC_READONLY;
4231 }
4232 }
4233
4234 /* Do anything special before sizing sections. This is where ELF
4235 and other back-ends size dynamic sections. */
252b5132
RH		 4236 ldemul_before_allocation ();
4237
4238 /* We must record the program headers before we try to fix the
4239 section positions, since they will affect SIZEOF_HEADERS. */
4240 lang_record_phdrs ();
4241
b3327aad
AM		 4242 /* Size up the sections. */
4243 lang_size_sections (statement_list.head,
4244 abs_output_section,
4245 &statement_list.head, 0, (bfd_vma) 0, NULL);
4246
08da4cac 4247 /* Now run around and relax if we can. */
252b5132
RH		 4248 if (command_line.relax)
4249 {
252b5132 4250 /* Keep relaxing until bfd_relax_section gives up. */
b3327aad
AM		 4251 boolean relax_again;
4252
252b5132
RH		 4253 do
4254 {
e3dc8847 4255 lang_reset_memory_regions ();
252b5132
RH		 4256
4257 relax_again = false;
4258
4259 /* Note: pe-dll.c does something like this also. If you find
4260 you need to change this code, you probably need to change
08da4cac 4261 pe-dll.c also. DJ */
252b5132
RH		 4262
4263 /* Do all the assignments with our current guesses as to
4264 section sizes. */
4265 lang_do_assignments (statement_list.head,
4266 abs_output_section,
2c382fb6 4267 (fill_type *) 0, (bfd_vma) 0);
252b5132
RH		 4268
4269 /* Perform another relax pass - this time we know where the
4270 globals are, so can make better guess. */
4271 lang_size_sections (statement_list.head,
4272 abs_output_section,
b3327aad
AM		 4273 &(statement_list.head), 0, (bfd_vma) 0,
4274 &relax_again);
252b5132
RH		 4275 }
4276 while (relax_again);
4277 }
252b5132
RH		 4278
4279 /* See if anything special should be done now we know how big
4280 everything is. */
4281 ldemul_after_allocation ();
4282
4283 /* Fix any .startof. or .sizeof. symbols. */
4284 lang_set_startof ();
4285
08da4cac
KH		 4286 /* Do all the assignments, now that we know the final resting places
4287 of all the symbols. */
252b5132
RH		 4288
4289 lang_do_assignments (statement_list.head,
4290 abs_output_section,
2c382fb6 4291 (fill_type *) 0, (bfd_vma) 0);
252b5132
RH		 4292
4293 /* Make sure that the section addresses make sense. */
4294 if (! link_info.relocateable
4295 && command_line.check_section_addresses)
4296 lang_check_section_addresses ();
5f992e62 4297
08da4cac 4298 /* Final stuffs. */
252b5132
RH		 4299
4300 ldemul_finish ();
4301 lang_finish ();
4302}
4303
4304/* EXPORTED TO YACC */
4305
4306void
b6bf44ba
AM		 4307lang_add_wild (filespec, section_list, keep_sections)
4308 struct wildcard_spec *filespec;
4309 struct wildcard_list *section_list;
252b5132 4310 boolean keep_sections;
252b5132 4311{
b6bf44ba
AM		 4312 struct wildcard_list *curr, *next;
4313 lang_wild_statement_type *new;
4314
4315 /* Reverse the list as the parser puts it back to front. */
4316 for (curr = section_list, section_list = NULL;
4317 curr != NULL;
4318 section_list = curr, curr = next)
4319 {
4320 if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
4321 placed_commons = true;
252b5132 4322
b6bf44ba
AM		 4323 next = curr->next;
4324 curr->next = section_list;
4325 }
4326
4327 if (filespec != NULL && filespec->name != NULL)
252b5132 4328 {
b6bf44ba
AM		 4329 if (strcmp (filespec->name, "*") == 0)
4330 filespec->name = NULL;
4331 else if (! wildcardp (filespec->name))
4332 lang_has_input_file = true;
252b5132 4333 }
b6bf44ba
AM		 4334
4335 new = new_stat (lang_wild_statement, stat_ptr);
4336 new->filename = NULL;
4337 new->filenames_sorted = false;
4338 if (filespec != NULL)
252b5132 4339 {
b6bf44ba
AM		 4340 new->filename = filespec->name;
4341 new->filenames_sorted = filespec->sorted;
252b5132 4342 }
b6bf44ba 4343 new->section_list = section_list;
252b5132 4344 new->keep_sections = keep_sections;
252b5132
RH		 4345 lang_list_init (&new->children);
4346}
4347
4348void
4349lang_section_start (name, address)
5f992e62 4350 const char *name;
08da4cac 4351 etree_type *address;
252b5132 4352{
d1778b88 4353 lang_address_statement_type *ad;
252b5132 4354
d1778b88 4355 ad = new_stat (lang_address_statement, stat_ptr);
252b5132
RH		 4356 ad->section_name = name;
4357 ad->address = address;
4358}
4359
4360/* Set the start symbol to NAME. CMDLINE is nonzero if this is called
4361 because of a -e argument on the command line, or zero if this is
4362 called by ENTRY in a linker script. Command line arguments take
4363 precedence. */
4364
4365void
4366lang_add_entry (name, cmdline)
5f992e62 4367 const char *name;
252b5132
RH		 4368 boolean cmdline;
4369{
4370 if (entry_symbol == NULL
4371 || cmdline
4372 || ! entry_from_cmdline)
4373 {
4374 entry_symbol = name;
4375 entry_from_cmdline = cmdline;
4376 }
4377}
4378
4379void
4380lang_add_target (name)
5f992e62 4381 const char *name;
252b5132
RH		 4382{
4383 lang_target_statement_type *new = new_stat (lang_target_statement,
4384 stat_ptr);
4385
4386 new->target = name;
4387
4388}
4389
4390void
4391lang_add_map (name)
5f992e62 4392 const char *name;
252b5132
RH		 4393{
4394 while (*name)
4395 {
4396 switch (*name)
4397 {
08da4cac 4398 case 'F':
252b5132
RH		 4399 map_option_f = true;
4400 break;
4401 }
4402 name++;
4403 }
4404}
4405
4406void
2c382fb6
AM		 4407lang_add_fill (fill)
4408 fill_type *fill;
252b5132
RH		 4409{
4410 lang_fill_statement_type *new = new_stat (lang_fill_statement,
4411 stat_ptr);
4412
2c382fb6 4413 new->fill = fill;
252b5132
RH		 4414}
4415
4416void
4417lang_add_data (type, exp)
4418 int type;
4419 union etree_union *exp;
4420{
4421
4422 lang_data_statement_type *new = new_stat (lang_data_statement,
4423 stat_ptr);
4424
4425 new->exp = exp;
4426 new->type = type;
4427
4428}
4429
4430/* Create a new reloc statement. RELOC is the BFD relocation type to
4431 generate. HOWTO is the corresponding howto structure (we could
4432 look this up, but the caller has already done so). SECTION is the
4433 section to generate a reloc against, or NAME is the name of the
4434 symbol to generate a reloc against. Exactly one of SECTION and
4435 NAME must be NULL. ADDEND is an expression for the addend. */
4436
4437void
4438lang_add_reloc (reloc, howto, section, name, addend)
4439 bfd_reloc_code_real_type reloc;
4440 reloc_howto_type *howto;
4441 asection *section;
4442 const char *name;
4443 union etree_union *addend;
4444{
4445 lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
5f992e62 4446
252b5132
RH		 4447 p->reloc = reloc;
4448 p->howto = howto;
4449 p->section = section;
4450 p->name = name;
4451 p->addend_exp = addend;
4452
4453 p->addend_value = 0;
4454 p->output_section = NULL;
4455 p->output_vma = 0;
4456}
4457
4458lang_assignment_statement_type *
4459lang_add_assignment (exp)
08da4cac 4460 etree_type *exp;
252b5132
RH		 4461{
4462 lang_assignment_statement_type *new = new_stat (lang_assignment_statement,
4463 stat_ptr);
4464
4465 new->exp = exp;
4466 return new;
4467}
4468
4469void
4470lang_add_attribute (attribute)
4471 enum statement_enum attribute;
4472{
4473 new_statement (attribute, sizeof (lang_statement_union_type), stat_ptr);
4474}
4475
4476void
4477lang_startup (name)
5f992e62 4478 const char *name;
252b5132
RH		 4479{
4480 if (startup_file != (char *) NULL)
4481 {
4482 einfo (_("%P%Fmultiple STARTUP files\n"));
4483 }
4484 first_file->filename = name;
4485 first_file->local_sym_name = name;
4486 first_file->real = true;
4487
4488 startup_file = name;
4489}
4490
4491void
4492lang_float (maybe)
4493 boolean maybe;
4494{
4495 lang_float_flag = maybe;
4496}
4497
4498void
562d3460 4499lang_leave_output_section_statement (fill, memspec, phdrs, lma_memspec)
2c382fb6 4500 fill_type *fill;
252b5132
RH		 4501 const char *memspec;
4502 struct lang_output_section_phdr_list *phdrs;
562d3460 4503 const char *lma_memspec;
252b5132
RH		 4504{
4505 current_section->fill = fill;
4506 current_section->region = lang_memory_region_lookup (memspec);
562d3460
TW		 4507 if (strcmp (lma_memspec, "*default*") != 0)
4508 {
4509 current_section->lma_region = lang_memory_region_lookup (lma_memspec);
08da4cac
KH		 4510 /* If no runtime region has been given, but the load region has
4511 been, use the load region. */
562d3460
TW		 4512 if (strcmp (memspec, "*default*") == 0)
4513 current_section->region = lang_memory_region_lookup (lma_memspec);
4514 }
252b5132
RH		 4515 current_section->phdrs = phdrs;
4516 stat_ptr = &statement_list;
4517}
4518
08da4cac
KH		 4519/* Create an absolute symbol with the given name with the value of the
4520 address of first byte of the section named.
4521
4522 If the symbol already exists, then do nothing. */
252b5132 4523
252b5132
RH		 4524void
4525lang_abs_symbol_at_beginning_of (secname, name)
4526 const char *secname;
4527 const char *name;
4528{
4529 struct bfd_link_hash_entry *h;
4530
4531 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4532 if (h == (struct bfd_link_hash_entry *) NULL)
4533 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4534
4535 if (h->type == bfd_link_hash_new
4536 || h->type == bfd_link_hash_undefined)
4537 {
4538 asection *sec;
4539
4540 h->type = bfd_link_hash_defined;
4541
4542 sec = bfd_get_section_by_name (output_bfd, secname);
4543 if (sec == (asection *) NULL)
4544 h->u.def.value = 0;
4545 else
4546 h->u.def.value = bfd_get_section_vma (output_bfd, sec);
4547
4548 h->u.def.section = bfd_abs_section_ptr;
4549 }
4550}
4551
08da4cac
KH		 4552/* Create an absolute symbol with the given name with the value of the
4553 address of the first byte after the end of the section named.
4554
4555 If the symbol already exists, then do nothing. */
252b5132 4556
252b5132
RH		 4557void
4558lang_abs_symbol_at_end_of (secname, name)
4559 const char *secname;
4560 const char *name;
4561{
4562 struct bfd_link_hash_entry *h;
4563
4564 h = bfd_link_hash_lookup (link_info.hash, name, true, true, true);
4565 if (h == (struct bfd_link_hash_entry *) NULL)
4566 einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
4567
4568 if (h->type == bfd_link_hash_new
4569 || h->type == bfd_link_hash_undefined)
4570 {
4571 asection *sec;
4572
4573 h->type = bfd_link_hash_defined;
4574
4575 sec = bfd_get_section_by_name (output_bfd, secname);
4576 if (sec == (asection *) NULL)
4577 h->u.def.value = 0;
4578 else
4579 h->u.def.value = (bfd_get_section_vma (output_bfd, sec)
4cbfc3ac
TW		 4580 + bfd_section_size (output_bfd, sec) /
4581 bfd_octets_per_byte (output_bfd));
252b5132
RH		 4582
4583 h->u.def.section = bfd_abs_section_ptr;
4584 }
4585}
4586
4587void
4588lang_statement_append (list, element, field)
08da4cac
KH		 4589 lang_statement_list_type *list;
4590 lang_statement_union_type *element;
4591 lang_statement_union_type **field;
252b5132
RH		 4592{
4593 *(list->tail) = element;
4594 list->tail = field;
4595}
4596
4597/* Set the output format type. -oformat overrides scripts. */
4598
4599void
4600lang_add_output_format (format, big, little, from_script)
4601 const char *format;
4602 const char *big;
4603 const char *little;
4604 int from_script;
4605{
4606 if (output_target == NULL || !from_script)
4607 {
4608 if (command_line.endian == ENDIAN_BIG
4609 && big != NULL)
4610 format = big;
4611 else if (command_line.endian == ENDIAN_LITTLE
4612 && little != NULL)
4613 format = little;
4614
4615 output_target = format;
4616 }
4617}
4618
4619/* Enter a group. This creates a new lang_group_statement, and sets
4620 stat_ptr to build new statements within the group. */
4621
4622void
4623lang_enter_group ()
4624{
4625 lang_group_statement_type *g;
4626
4627 g = new_stat (lang_group_statement, stat_ptr);
4628 lang_list_init (&g->children);
4629 stat_ptr = &g->children;
4630}
4631
4632/* Leave a group. This just resets stat_ptr to start writing to the
4633 regular list of statements again. Note that this will not work if
4634 groups can occur inside anything else which can adjust stat_ptr,
4635 but currently they can't. */
4636
4637void
4638lang_leave_group ()
4639{
4640 stat_ptr = &statement_list;
4641}
4642
4643/* Add a new program header. This is called for each entry in a PHDRS
4644 command in a linker script. */
4645
4646void
4647lang_new_phdr (name, type, filehdr, phdrs, at, flags)
4648 const char *name;
4649 etree_type *type;
4650 boolean filehdr;
4651 boolean phdrs;
4652 etree_type *at;
4653 etree_type *flags;
4654{
4655 struct lang_phdr *n, **pp;
4656
4657 n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
4658 n->next = NULL;
4659 n->name = name;
4660 n->type = exp_get_value_int (type, 0, "program header type",
4661 lang_final_phase_enum);
4662 n->filehdr = filehdr;
4663 n->phdrs = phdrs;
4664 n->at = at;
4665 n->flags = flags;
4666
4667 for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
4668 ;
4669 *pp = n;
4670}
4671
4672/* Record the program header information in the output BFD. FIXME: We
4673 should not be calling an ELF specific function here. */
4674
4675static void
4676lang_record_phdrs ()
4677{
4678 unsigned int alc;
4679 asection **secs;
4680 struct lang_output_section_phdr_list *last;
4681 struct lang_phdr *l;
4682 lang_statement_union_type *u;
4683
4684 alc = 10;
4685 secs = (asection **) xmalloc (alc * sizeof (asection *));
4686 last = NULL;
4687 for (l = lang_phdr_list; l != NULL; l = l->next)
4688 {
4689 unsigned int c;
4690 flagword flags;
4691 bfd_vma at;
4692
4693 c = 0;
4694 for (u = lang_output_section_statement.head;
4695 u != NULL;
4696 u = u->output_section_statement.next)
4697 {
4698 lang_output_section_statement_type *os;
4699 struct lang_output_section_phdr_list *pl;
4700
4701 os = &u->output_section_statement;
4702
4703 pl = os->phdrs;
4704 if (pl != NULL)
4705 last = pl;
4706 else
4707 {
4708 if (os->sectype == noload_section
4709 || os->bfd_section == NULL
4710 || (os->bfd_section->flags & SEC_ALLOC) == 0)
4711 continue;
4712 pl = last;
4713 }
4714
4715 if (os->bfd_section == NULL)
4716 continue;
4717
4718 for (; pl != NULL; pl = pl->next)
4719 {
4720 if (strcmp (pl->name, l->name) == 0)
4721 {
4722 if (c >= alc)
4723 {
4724 alc *= 2;
4725 secs = ((asection **)
4726 xrealloc (secs, alc * sizeof (asection *)));
4727 }
4728 secs[c] = os->bfd_section;
4729 ++c;
4730 pl->used = true;
4731 }
4732 }
4733 }
4734
4735 if (l->flags == NULL)
4736 flags = 0;
4737 else
4738 flags = exp_get_vma (l->flags, 0, "phdr flags",
4739 lang_final_phase_enum);
4740
4741 if (l->at == NULL)
4742 at = 0;
4743 else
4744 at = exp_get_vma (l->at, 0, "phdr load address",
4745 lang_final_phase_enum);
4746
4747 if (! bfd_record_phdr (output_bfd, l->type,
d1778b88 4748 l->flags != NULL, flags, l->at != NULL,
252b5132
RH		 4749 at, l->filehdr, l->phdrs, c, secs))
4750 einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
4751 }
4752
4753 free (secs);
4754
4755 /* Make sure all the phdr assignments succeeded. */
4756 for (u = lang_output_section_statement.head;
4757 u != NULL;
4758 u = u->output_section_statement.next)
4759 {
4760 struct lang_output_section_phdr_list *pl;
4761
4762 if (u->output_section_statement.bfd_section == NULL)
4763 continue;
4764
4765 for (pl = u->output_section_statement.phdrs;
4766 pl != NULL;
4767 pl = pl->next)
4768 if (! pl->used && strcmp (pl->name, "NONE") != 0)
4769 einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
4770 u->output_section_statement.name, pl->name);
4771 }
4772}
4773
4774/* Record a list of sections which may not be cross referenced. */
4775
4776void
4777lang_add_nocrossref (l)
4778 struct lang_nocrossref *l;
4779{
4780 struct lang_nocrossrefs *n;
4781
4782 n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
4783 n->next = nocrossref_list;
4784 n->list = l;
4785 nocrossref_list = n;
4786
4787 /* Set notice_all so that we get informed about all symbols. */
4788 link_info.notice_all = true;
4789}
4790\f
4791/* Overlay handling. We handle overlays with some static variables. */
4792
4793/* The overlay virtual address. */
4794static etree_type *overlay_vma;
4795
4796/* The overlay load address. */
4797static etree_type *overlay_lma;
4798
4799/* Whether nocrossrefs is set for this overlay. */
4800static int overlay_nocrossrefs;
4801
4802/* An expression for the maximum section size seen so far. */
4803static etree_type *overlay_max;
4804
4805/* A list of all the sections in this overlay. */
4806
89cdebba 4807struct overlay_list {
252b5132
RH		 4808 struct overlay_list *next;
4809 lang_output_section_statement_type *os;
4810};
4811
4812static struct overlay_list *overlay_list;
4813
4814/* Start handling an overlay. */
4815
4816void
4817lang_enter_overlay (vma_expr, lma_expr, nocrossrefs)
4818 etree_type *vma_expr;
4819 etree_type *lma_expr;
4820 int nocrossrefs;
4821{
4822 /* The grammar should prevent nested overlays from occurring. */
4823 ASSERT (overlay_vma == NULL
4824 && overlay_lma == NULL
4825 && overlay_list == NULL
4826 && overlay_max == NULL);
4827
4828 overlay_vma = vma_expr;
4829 overlay_lma = lma_expr;
4830 overlay_nocrossrefs = nocrossrefs;
4831}
4832
4833/* Start a section in an overlay. We handle this by calling
4834 lang_enter_output_section_statement with the correct VMA and LMA. */
4835
4836void
4837lang_enter_overlay_section (name)
4838 const char *name;
4839{
4840 struct overlay_list *n;
4841 etree_type *size;
4842
4843 lang_enter_output_section_statement (name, overlay_vma, normal_section,
4844 0, 0, 0, overlay_lma);
4845
4846 /* If this is the first section, then base the VMA and LMA of future
4847 sections on this one. This will work correctly even if `.' is
4848 used in the addresses. */
4849 if (overlay_list == NULL)
4850 {
4851 overlay_vma = exp_nameop (ADDR, name);
4852 overlay_lma = exp_nameop (LOADADDR, name);
4853 }
4854
4855 /* Remember the section. */
4856 n = (struct overlay_list *) xmalloc (sizeof *n);
4857 n->os = current_section;
4858 n->next = overlay_list;
4859 overlay_list = n;
4860
4861 size = exp_nameop (SIZEOF, name);
4862
4863 /* Adjust the LMA for the next section. */
4864 overlay_lma = exp_binop ('+', overlay_lma, size);
4865
4866 /* Arrange to work out the maximum section end address. */
4867 if (overlay_max == NULL)
4868 overlay_max = size;
4869 else
4870 overlay_max = exp_binop (MAX_K, overlay_max, size);
4871}
4872
4873/* Finish a section in an overlay. There isn't any special to do
4874 here. */
4875
4876void
4877lang_leave_overlay_section (fill, phdrs)
2c382fb6 4878 fill_type *fill;
252b5132
RH		 4879 struct lang_output_section_phdr_list *phdrs;
4880{
4881 const char *name;
4882 char *clean, *s2;
4883 const char *s1;
4884 char *buf;
4885
4886 name = current_section->name;
4887
5f992e62 4888 lang_leave_output_section_statement (fill, "*default*",
562d3460 4889 phdrs, "*default*");
252b5132
RH		 4890
4891 /* Define the magic symbols. */
4892
4893 clean = xmalloc (strlen (name) + 1);
4894 s2 = clean;
4895 for (s1 = name; *s1 != '\0'; s1++)
3882b010 4896 if (ISALNUM (*s1) || *s1 == '_')
252b5132
RH		 4897 *s2++ = *s1;
4898 *s2 = '\0';
4899
4900 buf = xmalloc (strlen (clean) + sizeof "__load_start_");
4901 sprintf (buf, "__load_start_%s", clean);
4902 lang_add_assignment (exp_assop ('=', buf,
4903 exp_nameop (LOADADDR, name)));
4904
4905 buf = xmalloc (strlen (clean) + sizeof "__load_stop_");
4906 sprintf (buf, "__load_stop_%s", clean);
4907 lang_add_assignment (exp_assop ('=', buf,
4908 exp_binop ('+',
4909 exp_nameop (LOADADDR, name),
4910 exp_nameop (SIZEOF, name))));
4911
4912 free (clean);
4913}
4914
4915/* Finish an overlay. If there are any overlay wide settings, this
4916 looks through all the sections in the overlay and sets them. */
4917
4918void
562d3460 4919lang_leave_overlay (fill, memspec, phdrs, lma_memspec)
2c382fb6 4920 fill_type *fill;
252b5132
RH		 4921 const char *memspec;
4922 struct lang_output_section_phdr_list *phdrs;
562d3460 4923 const char *lma_memspec;
252b5132
RH		 4924{
4925 lang_memory_region_type *region;
1545243b 4926 lang_memory_region_type * default_region;
562d3460 4927 lang_memory_region_type *lma_region;
252b5132
RH		 4928 struct overlay_list *l;
4929 struct lang_nocrossref *nocrossref;
4930
1545243b
NC		 4931 default_region = lang_memory_region_lookup ("*default*");
4932
252b5132
RH		 4933 if (memspec == NULL)
4934 region = NULL;
4935 else
4936 region = lang_memory_region_lookup (memspec);
4937
562d3460
TW		 4938 if (lma_memspec == NULL)
4939 lma_region = NULL;
4940 else
4941 lma_region = lang_memory_region_lookup (lma_memspec);
4942
252b5132
RH		 4943 nocrossref = NULL;
4944
4945 l = overlay_list;
4946 while (l != NULL)
4947 {
4948 struct overlay_list *next;
4949
2c382fb6 4950 if (fill != (fill_type *) 0 && l->os->fill == (fill_type *) 0)
252b5132 4951 l->os->fill = fill;
1545243b
NC		 4952
4953 /* Assign a region to the sections, if one has been specified.
4954 Override the assignment of the default section, but not
4955 other sections. */
4956 if (region != NULL &&
4957 (l->os->region == NULL ||
4958 l->os->region == default_region))
252b5132 4959 l->os->region = region;
1545243b 4960
c1eb1488
AM		 4961 /* We only set lma_region for the first overlay section, as
4962 subsequent overlay sections will have load_base set relative
02aa14fb
AM		 4963 to the first section. Also, don't set lma_region if
4964 load_base is specified. FIXME: There should really be a test
4965 that `AT ( LDADDR )' doesn't conflict with `AT >LMA_REGION'
4966 rather than letting LDADDR simply override LMA_REGION. */
4967 if (lma_region != NULL && l->os->lma_region == NULL
4968 && l->next == NULL && l->os->load_base == NULL)
08da4cac 4969 l->os->lma_region = lma_region;
1545243b 4970
252b5132
RH		 4971 if (phdrs != NULL && l->os->phdrs == NULL)
4972 l->os->phdrs = phdrs;
4973
4974 if (overlay_nocrossrefs)
4975 {
4976 struct lang_nocrossref *nc;
4977
4978 nc = (struct lang_nocrossref *) xmalloc (sizeof *nc);
4979 nc->name = l->os->name;
4980 nc->next = nocrossref;
4981 nocrossref = nc;
4982 }
4983
4984 next = l->next;
4985 free (l);
4986 l = next;
4987 }
4988
4989 if (nocrossref != NULL)
4990 lang_add_nocrossref (nocrossref);
4991
4992 /* Update . for the end of the overlay. */
4993 lang_add_assignment (exp_assop ('=', ".",
4994 exp_binop ('+', overlay_vma, overlay_max)));
4995
4996 overlay_vma = NULL;
4997 overlay_lma = NULL;
4998 overlay_nocrossrefs = 0;
4999 overlay_list = NULL;
5000 overlay_max = NULL;
5001}
5002\f
5003/* Version handling. This is only useful for ELF. */
5004
5005/* This global variable holds the version tree that we build. */
5006
5007struct bfd_elf_version_tree *lang_elf_version_info;
5008
5009static int
5010lang_vers_match_lang_c (expr, sym)
5011 struct bfd_elf_version_expr *expr;
5012 const char *sym;
5013{
5014 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5015 return 1;
5016 return fnmatch (expr->pattern, sym, 0) == 0;
5017}
5018
5019static int
5020lang_vers_match_lang_cplusplus (expr, sym)
5021 struct bfd_elf_version_expr *expr;
5022 const char *sym;
5023{
5024 char *alt_sym;
5025 int result;
5026
5027 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5028 return 1;
5029
08da4cac 5030 alt_sym = cplus_demangle (sym, /* DMGL_NO_TPARAMS */ 0);
252b5132
RH		 5031 if (!alt_sym)
5032 {
5033 /* cplus_demangle (also) returns NULL when it is not a C++ symbol.
5034 Should we early out false in this case? */
5035 result = fnmatch (expr->pattern, sym, 0) == 0;
5036 }
5037 else
5038 {
5039 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5040 free (alt_sym);
5041 }
5042
5043 return result;
5044}
5045
5046static int
5047lang_vers_match_lang_java (expr, sym)
5048 struct bfd_elf_version_expr *expr;
5049 const char *sym;
5050{
5051 char *alt_sym;
5052 int result;
5053
5054 if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
5055 return 1;
5056
08da4cac 5057 alt_sym = cplus_demangle (sym, DMGL_JAVA);
252b5132
RH		 5058 if (!alt_sym)
5059 {
5060 /* cplus_demangle (also) returns NULL when it is not a Java symbol.
5061 Should we early out false in this case? */
5062 result = fnmatch (expr->pattern, sym, 0) == 0;
5063 }
5064 else
5065 {
5066 result = fnmatch (expr->pattern, alt_sym, 0) == 0;
5067 free (alt_sym);
5068 }
5069
5070 return result;
5071}
5072
5073/* This is called for each variable name or match expression. */
5074
5075struct bfd_elf_version_expr *
313e35ee 5076lang_new_vers_pattern (orig, new, lang)
252b5132
RH		 5077 struct bfd_elf_version_expr *orig;
5078 const char *new;
5079 const char *lang;
5080{
5081 struct bfd_elf_version_expr *ret;
5082
5083 ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
5084 ret->next = orig;
5085 ret->pattern = new;
5086
5087 if (lang == NULL || strcasecmp (lang, "C") == 0)
5088 ret->match = lang_vers_match_lang_c;
5089 else if (strcasecmp (lang, "C++") == 0)
5090 ret->match = lang_vers_match_lang_cplusplus;
5091 else if (strcasecmp (lang, "Java") == 0)
5092 ret->match = lang_vers_match_lang_java;
5093 else
5094 {
5095 einfo (_("%X%P: unknown language `%s' in version information\n"),
5096 lang);
5097 ret->match = lang_vers_match_lang_c;
5098 }
5099
5100 return ret;
5101}
5102
5103/* This is called for each set of variable names and match
5104 expressions. */
5105
5106struct bfd_elf_version_tree *
5107lang_new_vers_node (globals, locals)
5108 struct bfd_elf_version_expr *globals;
5109 struct bfd_elf_version_expr *locals;
5110{
5111 struct bfd_elf_version_tree *ret;
5112
5113 ret = (struct bfd_elf_version_tree *) xmalloc (sizeof *ret);
5114 ret->next = NULL;
5115 ret->name = NULL;
5116 ret->vernum = 0;
5117 ret->globals = globals;
5118 ret->locals = locals;
5119 ret->deps = NULL;
5120 ret->name_indx = (unsigned int) -1;
5121 ret->used = 0;
5122 return ret;
5123}
5124
5125/* This static variable keeps track of version indices. */
5126
5127static int version_index;
5128
5129/* This is called when we know the name and dependencies of the
5130 version. */
5131
5132void
5133lang_register_vers_node (name, version, deps)
5134 const char *name;
5135 struct bfd_elf_version_tree *version;
5136 struct bfd_elf_version_deps *deps;
5137{
5138 struct bfd_elf_version_tree *t, **pp;
5139 struct bfd_elf_version_expr *e1;
5140
6b9b879a
JJ		 5141 if (name == NULL)
5142 name = "";
5143
5144 if ((name[0] == '\0' && lang_elf_version_info != NULL)
5145 || (lang_elf_version_info && lang_elf_version_info->name[0] == '\0'))
5146 {
5147 einfo (_("%X%P: anonymous version tag cannot be combined with other version tags\n"));
5148 return;
5149 }
5150
252b5132
RH		 5151 /* Make sure this node has a unique name. */
5152 for (t = lang_elf_version_info; t != NULL; t = t->next)
5153 if (strcmp (t->name, name) == 0)
5154 einfo (_("%X%P: duplicate version tag `%s'\n"), name);
5155
5156 /* Check the global and local match names, and make sure there
5157 aren't any duplicates. */
5158
5159 for (e1 = version->globals; e1 != NULL; e1 = e1->next)
5160 {
5161 for (t = lang_elf_version_info; t != NULL; t = t->next)
5162 {
5163 struct bfd_elf_version_expr *e2;
5164
5165 for (e2 = t->locals; e2 != NULL; e2 = e2->next)
5166 if (strcmp (e1->pattern, e2->pattern) == 0)
5167 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5168 e1->pattern);
5169 }
5170 }
5171
5172 for (e1 = version->locals; e1 != NULL; e1 = e1->next)
5173 {
5174 for (t = lang_elf_version_info; t != NULL; t = t->next)
5175 {
5176 struct bfd_elf_version_expr *e2;
5177
5178 for (e2 = t->globals; e2 != NULL; e2 = e2->next)
5179 if (strcmp (e1->pattern, e2->pattern) == 0)
5180 einfo (_("%X%P: duplicate expression `%s' in version information\n"),
5181 e1->pattern);
5182 }
5183 }
5184
5185 version->deps = deps;
5186 version->name = name;
6b9b879a
JJ		 5187 if (name[0] != '\0')
5188 {
5189 ++version_index;
5190 version->vernum = version_index;
5191 }
5192 else
5193 version->vernum = 0;
252b5132
RH		 5194
5195 for (pp = &lang_elf_version_info; *pp != NULL; pp = &(*pp)->next)
5196 ;
5197 *pp = version;
5198}
5199
5200/* This is called when we see a version dependency. */
5201
5202struct bfd_elf_version_deps *
5203lang_add_vers_depend (list, name)
5204 struct bfd_elf_version_deps *list;
5205 const char *name;
5206{
5207 struct bfd_elf_version_deps *ret;
5208 struct bfd_elf_version_tree *t;
5209
5210 ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
5211 ret->next = list;
5212
5213 for (t = lang_elf_version_info; t != NULL; t = t->next)
5214 {
5215 if (strcmp (t->name, name) == 0)
5216 {
5217 ret->version_needed = t;
5218 return ret;
5219 }
5220 }
5221
5222 einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
5223
5224 return ret;
5225}
5226
5227static void
5228lang_do_version_exports_section ()
5229{
5230 struct bfd_elf_version_expr *greg = NULL, *lreg;
5231
5232 LANG_FOR_EACH_INPUT_STATEMENT (is)
5233 {
5234 asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
5235 char *contents, *p;
5236 bfd_size_type len;
5237
5238 if (sec == NULL)
5239 continue;
5240
5241 len = bfd_section_size (is->the_bfd, sec);
5242 contents = xmalloc (len);
5243 if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
6f9efd97 5244 einfo (_("%X%P: unable to read .exports section contents\n"), sec);
252b5132
RH		 5245
5246 p = contents;
89cdebba 5247 while (p < contents + len)
252b5132 5248 {
313e35ee 5249 greg = lang_new_vers_pattern (greg, p, NULL);
252b5132
RH		 5250 p = strchr (p, '\0') + 1;
5251 }
5252
5253 /* Do not free the contents, as we used them creating the regex. */
5254
5255 /* Do not include this section in the link. */
5256 bfd_set_section_flags (is->the_bfd, sec,
5257 bfd_get_section_flags (is->the_bfd, sec) | SEC_EXCLUDE);
5258 }
5259
313e35ee 5260 lreg = lang_new_vers_pattern (NULL, "*", NULL);
252b5132
RH		 5261 lang_register_vers_node (command_line.version_exports_section,
5262 lang_new_vers_node (greg, lreg), NULL);
5263}
577a0623
AM		 5264
5265void
5266lang_add_unique (name)
5267 const char *name;
5268{
5269 struct unique_sections *ent;
5270
5271 for (ent = unique_section_list; ent; ent = ent->next)
5272 if (strcmp (ent->name, name) == 0)
5273 return;
5274
5275 ent = (struct unique_sections *) xmalloc (sizeof *ent);
5276 ent->name = xstrdup (name);
5277 ent->next = unique_section_list;
5278 unique_section_list = ent;
5279}
GDB Binutils - Deliverables
This page took 0.409113 seconds and 4 git commands to generate.