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