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