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