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