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