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