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