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