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