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