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