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