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