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