OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [ld/] [ldlang.c] - Blame information for rev 289

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 145 khays
/* Linker command language support.
2
   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 166 khays
   2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 145 khays
   Free Software Foundation, Inc.
5
 
6
   This file is part of the GNU Binutils.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21
   MA 02110-1301, USA.  */
22
 
23
#include "sysdep.h"
24
#include "bfd.h"
25
#include "libiberty.h"
26
#include "filenames.h"
27
#include "safe-ctype.h"
28
#include "obstack.h"
29
#include "bfdlink.h"
30
 
31
#include "ld.h"
32
#include "ldmain.h"
33
#include "ldexp.h"
34
#include "ldlang.h"
35
#include <ldgram.h>
36
#include "ldlex.h"
37
#include "ldmisc.h"
38
#include "ldctor.h"
39
#include "ldfile.h"
40
#include "ldemul.h"
41
#include "fnmatch.h"
42
#include "demangle.h"
43
#include "hashtab.h"
44
#include "libbfd.h"
45
#ifdef ENABLE_PLUGINS
46
#include "plugin.h"
47
#endif /* ENABLE_PLUGINS */
48
 
49
#ifndef offsetof
50
#define offsetof(TYPE, MEMBER) ((size_t) & (((TYPE*) 0)->MEMBER))
51
#endif
52
 
53
/* Locals variables.  */
54
static struct obstack stat_obstack;
55
static struct obstack map_obstack;
56
 
57
#define obstack_chunk_alloc xmalloc
58
#define obstack_chunk_free free
59
static const char *entry_symbol_default = "start";
60
static bfd_boolean placed_commons = FALSE;
61
static bfd_boolean stripped_excluded_sections = FALSE;
62
static lang_output_section_statement_type *default_common_section;
63
static bfd_boolean map_option_f;
64
static bfd_vma print_dot;
65
static lang_input_statement_type *first_file;
66
static const char *current_target;
67
static lang_statement_list_type statement_list;
68
static struct bfd_hash_table lang_definedness_table;
69
static lang_statement_list_type *stat_save[10];
70
static lang_statement_list_type **stat_save_ptr = &stat_save[0];
71
static struct unique_sections *unique_section_list;
72
static bfd_boolean ldlang_sysrooted_script = FALSE;
73
 
74
/* Forward declarations.  */
75
static void exp_init_os (etree_type *);
76
static void init_map_userdata (bfd *, asection *, void *);
77
static lang_input_statement_type *lookup_name (const char *);
78
static struct bfd_hash_entry *lang_definedness_newfunc
79
 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
80
static void insert_undefined (const char *);
81
static bfd_boolean sort_def_symbol (struct bfd_link_hash_entry *, void *);
82
static void print_statement (lang_statement_union_type *,
83
                             lang_output_section_statement_type *);
84
static void print_statement_list (lang_statement_union_type *,
85
                                  lang_output_section_statement_type *);
86
static void print_statements (void);
87
static void print_input_section (asection *, bfd_boolean);
88
static bfd_boolean lang_one_common (struct bfd_link_hash_entry *, void *);
89
static void lang_record_phdrs (void);
90
static void lang_do_version_exports_section (void);
91
static void lang_finalize_version_expr_head
92
  (struct bfd_elf_version_expr_head *);
93
 
94
/* Exported variables.  */
95
const char *output_target;
96
lang_output_section_statement_type *abs_output_section;
97
lang_statement_list_type lang_output_section_statement;
98
lang_statement_list_type *stat_ptr = &statement_list;
99
lang_statement_list_type file_chain = { NULL, NULL };
100
lang_statement_list_type input_file_chain;
101
struct bfd_sym_chain entry_symbol = { NULL, NULL };
102
const char *entry_section = ".text";
103
bfd_boolean entry_from_cmdline;
104
bfd_boolean undef_from_cmdline;
105
bfd_boolean lang_has_input_file = FALSE;
106
bfd_boolean had_output_filename = FALSE;
107
bfd_boolean lang_float_flag = FALSE;
108
bfd_boolean delete_output_file_on_failure = FALSE;
109
struct lang_phdr *lang_phdr_list;
110
struct lang_nocrossrefs *nocrossref_list;
111
bfd_boolean missing_file = FALSE;
112
 
113
 /* Functions that traverse the linker script and might evaluate
114
    DEFINED() need to increment this.  */
115
int lang_statement_iteration = 0;
116
 
117
etree_type *base; /* Relocation base - or null */
118
 
119
/* Return TRUE if the PATTERN argument is a wildcard pattern.
120
   Although backslashes are treated specially if a pattern contains
121
   wildcards, we do not consider the mere presence of a backslash to
122
   be enough to cause the pattern to be treated as a wildcard.
123
   That lets us handle DOS filenames more naturally.  */
124
#define wildcardp(pattern) (strpbrk ((pattern), "?*[") != NULL)
125
 
126
#define new_stat(x, y) \
127
  (x##_type *) new_statement (x##_enum, sizeof (x##_type), y)
128
 
129
#define outside_section_address(q) \
130
  ((q)->output_offset + (q)->output_section->vma)
131
 
132
#define outside_symbol_address(q) \
133
  ((q)->value + outside_section_address (q->section))
134
 
135
#define SECTION_NAME_MAP_LENGTH (16)
136
 
137
void *
138
stat_alloc (size_t size)
139
{
140
  return obstack_alloc (&stat_obstack, size);
141
}
142
 
143
static int
144
name_match (const char *pattern, const char *name)
145
{
146
  if (wildcardp (pattern))
147
    return fnmatch (pattern, name, 0);
148
  return strcmp (pattern, name);
149
}
150
 
151
/* If PATTERN is of the form archive:file, return a pointer to the
152
   separator.  If not, return NULL.  */
153
 
154
static char *
155
archive_path (const char *pattern)
156
{
157
  char *p = NULL;
158
 
159
  if (link_info.path_separator == 0)
160
    return p;
161
 
162
  p = strchr (pattern, link_info.path_separator);
163
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
164
  if (p == NULL || link_info.path_separator != ':')
165
    return p;
166
 
167
  /* Assume a match on the second char is part of drive specifier,
168
     as in "c:\silly.dos".  */
169
  if (p == pattern + 1 && ISALPHA (*pattern))
170
    p = strchr (p + 1, link_info.path_separator);
171
#endif
172
  return p;
173
}
174
 
175
/* Given that FILE_SPEC results in a non-NULL SEP result from archive_path,
176
   return whether F matches FILE_SPEC.  */
177
 
178
static bfd_boolean
179
input_statement_is_archive_path (const char *file_spec, char *sep,
180
                                 lang_input_statement_type *f)
181
{
182
  bfd_boolean match = FALSE;
183
 
184
  if ((*(sep + 1) == 0
185
       || name_match (sep + 1, f->filename) == 0)
186
      && ((sep != file_spec)
187
          == (f->the_bfd != NULL && f->the_bfd->my_archive != NULL)))
188
    {
189
      match = TRUE;
190
 
191
      if (sep != file_spec)
192
        {
193
          const char *aname = f->the_bfd->my_archive->filename;
194
          *sep = 0;
195
          match = name_match (file_spec, aname) == 0;
196
          *sep = link_info.path_separator;
197
        }
198
    }
199
  return match;
200
}
201
 
202
static bfd_boolean
203
unique_section_p (const asection *sec,
204
                  const lang_output_section_statement_type *os)
205
{
206
  struct unique_sections *unam;
207
  const char *secnam;
208
 
209
  if (link_info.relocatable
210
      && sec->owner != NULL
211
      && bfd_is_group_section (sec->owner, sec))
212
    return !(os != NULL
213
             && strcmp (os->name, DISCARD_SECTION_NAME) == 0);
214
 
215
  secnam = sec->name;
216
  for (unam = unique_section_list; unam; unam = unam->next)
217
    if (name_match (unam->name, secnam) == 0)
218
      return TRUE;
219
 
220
  return FALSE;
221
}
222
 
223
/* Generic traversal routines for finding matching sections.  */
224
 
225
/* Try processing a section against a wildcard.  This just calls
226
   the callback unless the filename exclusion list is present
227
   and excludes the file.  It's hardly ever present so this
228
   function is very fast.  */
229
 
230
static void
231
walk_wild_consider_section (lang_wild_statement_type *ptr,
232
                            lang_input_statement_type *file,
233
                            asection *s,
234
                            struct wildcard_list *sec,
235
                            callback_t callback,
236
                            void *data)
237
{
238
  struct name_list *list_tmp;
239
 
240 157 khays
  /* Propagate the section_flag_info from the wild statement to the section.  */
241
  s->section_flag_info = ptr->section_flag_list;
242
 
243 145 khays
  /* Don't process sections from files which were excluded.  */
244
  for (list_tmp = sec->spec.exclude_name_list;
245
       list_tmp;
246
       list_tmp = list_tmp->next)
247
    {
248
      char *p = archive_path (list_tmp->name);
249
 
250
      if (p != NULL)
251
        {
252
          if (input_statement_is_archive_path (list_tmp->name, p, file))
253
            return;
254
        }
255
 
256
      else if (name_match (list_tmp->name, file->filename) == 0)
257
        return;
258
 
259
      /* FIXME: Perhaps remove the following at some stage?  Matching
260
         unadorned archives like this was never documented and has
261
         been superceded by the archive:path syntax.  */
262
      else if (file->the_bfd != NULL
263
               && file->the_bfd->my_archive != NULL
264
               && name_match (list_tmp->name,
265
                              file->the_bfd->my_archive->filename) == 0)
266
        return;
267
    }
268
 
269
  (*callback) (ptr, sec, s, file, data);
270
}
271
 
272
/* Lowest common denominator routine that can handle everything correctly,
273
   but slowly.  */
274
 
275
static void
276
walk_wild_section_general (lang_wild_statement_type *ptr,
277
                           lang_input_statement_type *file,
278
                           callback_t callback,
279
                           void *data)
280
{
281
  asection *s;
282
  struct wildcard_list *sec;
283
 
284
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
285
    {
286
      sec = ptr->section_list;
287
      if (sec == NULL)
288
        (*callback) (ptr, sec, s, file, data);
289
 
290
      while (sec != NULL)
291
        {
292
          bfd_boolean skip = FALSE;
293
 
294
          if (sec->spec.name != NULL)
295
            {
296
              const char *sname = bfd_get_section_name (file->the_bfd, s);
297
 
298
              skip = name_match (sec->spec.name, sname) != 0;
299
            }
300
 
301
          if (!skip)
302
            walk_wild_consider_section (ptr, file, s, sec, callback, data);
303
 
304
          sec = sec->next;
305
        }
306
    }
307
}
308
 
309
/* Routines to find a single section given its name.  If there's more
310
   than one section with that name, we report that.  */
311
 
312
typedef struct
313
{
314
  asection *found_section;
315
  bfd_boolean multiple_sections_found;
316
} section_iterator_callback_data;
317
 
318
static bfd_boolean
319
section_iterator_callback (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *data)
320
{
321
  section_iterator_callback_data *d = (section_iterator_callback_data *) data;
322
 
323
  if (d->found_section != NULL)
324
    {
325
      d->multiple_sections_found = TRUE;
326
      return TRUE;
327
    }
328
 
329
  d->found_section = s;
330
  return FALSE;
331
}
332
 
333
static asection *
334
find_section (lang_input_statement_type *file,
335
              struct wildcard_list *sec,
336
              bfd_boolean *multiple_sections_found)
337
{
338
  section_iterator_callback_data cb_data = { NULL, FALSE };
339
 
340
  bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,
341
                              section_iterator_callback, &cb_data);
342
  *multiple_sections_found = cb_data.multiple_sections_found;
343
  return cb_data.found_section;
344
}
345
 
346
/* Code for handling simple wildcards without going through fnmatch,
347
   which can be expensive because of charset translations etc.  */
348
 
349
/* A simple wild is a literal string followed by a single '*',
350
   where the literal part is at least 4 characters long.  */
351
 
352
static bfd_boolean
353
is_simple_wild (const char *name)
354
{
355
  size_t len = strcspn (name, "*?[");
356
  return len >= 4 && name[len] == '*' && name[len + 1] == '\0';
357
}
358
 
359
static bfd_boolean
360
match_simple_wild (const char *pattern, const char *name)
361
{
362
  /* The first four characters of the pattern are guaranteed valid
363
     non-wildcard characters.  So we can go faster.  */
364
  if (pattern[0] != name[0] || pattern[1] != name[1]
365
      || pattern[2] != name[2] || pattern[3] != name[3])
366
    return FALSE;
367
 
368
  pattern += 4;
369
  name += 4;
370
  while (*pattern != '*')
371
    if (*name++ != *pattern++)
372
      return FALSE;
373
 
374
  return TRUE;
375
}
376
 
377
/* Return the numerical value of the init_priority attribute from
378
   section name NAME.  */
379
 
380
static unsigned long
381
get_init_priority (const char *name)
382
{
383
  char *end;
384
  unsigned long init_priority;
385
 
386
  /* GCC uses the following section names for the init_priority
387
     attribute with numerical values 101 and 65535 inclusive. A
388
     lower value means a higher priority.
389
 
390
     1: .init_array.NNNN/.fini_array.NNNN: Where NNNN is the
391
        decimal numerical value of the init_priority attribute.
392
        The order of execution in .init_array is forward and
393
        .fini_array is backward.
394
     2: .ctors.NNNN/.ctors.NNNN: Where NNNN is 65535 minus the
395
        decimal numerical value of the init_priority attribute.
396
        The order of execution in .ctors is backward and .dtors
397
        is forward.
398
   */
399
  if (strncmp (name, ".init_array.", 12) == 0
400
      || strncmp (name, ".fini_array.", 12) == 0)
401
    {
402
      init_priority = strtoul (name + 12, &end, 10);
403
      return *end ? 0 : init_priority;
404
    }
405
  else if (strncmp (name, ".ctors.", 7) == 0
406
           || strncmp (name, ".dtors.", 7) == 0)
407
    {
408
      init_priority = strtoul (name + 7, &end, 10);
409
      return *end ? 0 : 65535 - init_priority;
410
    }
411
 
412
  return 0;
413
}
414
 
415
/* Compare sections ASEC and BSEC according to SORT.  */
416
 
417
static int
418
compare_section (sort_type sort, asection *asec, asection *bsec)
419
{
420
  int ret;
421
  unsigned long ainit_priority, binit_priority;
422
 
423
  switch (sort)
424
    {
425
    default:
426
      abort ();
427
 
428
    case by_init_priority:
429
      ainit_priority
430
        = get_init_priority (bfd_get_section_name (asec->owner, asec));
431
      binit_priority
432
        = get_init_priority (bfd_get_section_name (bsec->owner, bsec));
433
      if (ainit_priority == 0 || binit_priority == 0)
434
        goto sort_by_name;
435
      ret = ainit_priority - binit_priority;
436
      if (ret)
437
        break;
438
      else
439
        goto sort_by_name;
440
 
441
    case by_alignment_name:
442
      ret = (bfd_section_alignment (bsec->owner, bsec)
443
             - bfd_section_alignment (asec->owner, asec));
444
      if (ret)
445
        break;
446
      /* Fall through.  */
447
 
448
    case by_name:
449
sort_by_name:
450
      ret = strcmp (bfd_get_section_name (asec->owner, asec),
451
                    bfd_get_section_name (bsec->owner, bsec));
452
      break;
453
 
454
    case by_name_alignment:
455
      ret = strcmp (bfd_get_section_name (asec->owner, asec),
456
                    bfd_get_section_name (bsec->owner, bsec));
457
      if (ret)
458
        break;
459
      /* Fall through.  */
460
 
461
    case by_alignment:
462
      ret = (bfd_section_alignment (bsec->owner, bsec)
463
             - bfd_section_alignment (asec->owner, asec));
464
      break;
465
    }
466
 
467
  return ret;
468
}
469
 
470
/* Build a Binary Search Tree to sort sections, unlike insertion sort
471
   used in wild_sort(). BST is considerably faster if the number of
472
   of sections are large.  */
473
 
474
static lang_section_bst_type **
475
wild_sort_fast (lang_wild_statement_type *wild,
476
                struct wildcard_list *sec,
477
                lang_input_statement_type *file ATTRIBUTE_UNUSED,
478
                asection *section)
479
{
480
  lang_section_bst_type **tree;
481
 
482
  tree = &wild->tree;
483
  if (!wild->filenames_sorted
484
      && (sec == NULL || sec->spec.sorted == none))
485
    {
486
      /* Append at the right end of tree.  */
487
      while (*tree)
488
        tree = &((*tree)->right);
489
      return tree;
490
    }
491
 
492
  while (*tree)
493
    {
494
      /* Find the correct node to append this section.  */
495
      if (compare_section (sec->spec.sorted, section, (*tree)->section) < 0)
496
        tree = &((*tree)->left);
497
      else
498
        tree = &((*tree)->right);
499
    }
500
 
501
  return tree;
502
}
503
 
504
/* Use wild_sort_fast to build a BST to sort sections.  */
505
 
506
static void
507
output_section_callback_fast (lang_wild_statement_type *ptr,
508
                              struct wildcard_list *sec,
509
                              asection *section,
510
                              lang_input_statement_type *file,
511
                              void *output)
512
{
513
  lang_section_bst_type *node;
514
  lang_section_bst_type **tree;
515
  lang_output_section_statement_type *os;
516
 
517
  os = (lang_output_section_statement_type *) output;
518
 
519
  if (unique_section_p (section, os))
520
    return;
521
 
522
  node = (lang_section_bst_type *) xmalloc (sizeof (lang_section_bst_type));
523
  node->left = 0;
524
  node->right = 0;
525
  node->section = section;
526
 
527
  tree = wild_sort_fast (ptr, sec, file, section);
528
  if (tree != NULL)
529
    *tree = node;
530
}
531
 
532
/* Convert a sorted sections' BST back to list form.  */
533
 
534
static void
535
output_section_callback_tree_to_list (lang_wild_statement_type *ptr,
536
                                      lang_section_bst_type *tree,
537
                                      void *output)
538
{
539
  if (tree->left)
540
    output_section_callback_tree_to_list (ptr, tree->left, output);
541
 
542
  lang_add_section (&ptr->children, tree->section,
543
                    (lang_output_section_statement_type *) output);
544
 
545
  if (tree->right)
546
    output_section_callback_tree_to_list (ptr, tree->right, output);
547
 
548
  free (tree);
549
}
550
 
551
/* Specialized, optimized routines for handling different kinds of
552
   wildcards */
553
 
554
static void
555
walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
556
                                lang_input_statement_type *file,
557
                                callback_t callback,
558
                                void *data)
559
{
560
  /* We can just do a hash lookup for the section with the right name.
561
     But if that lookup discovers more than one section with the name
562
     (should be rare), we fall back to the general algorithm because
563
     we would otherwise have to sort the sections to make sure they
564
     get processed in the bfd's order.  */
565
  bfd_boolean multiple_sections_found;
566
  struct wildcard_list *sec0 = ptr->handler_data[0];
567
  asection *s0 = find_section (file, sec0, &multiple_sections_found);
568
 
569
  if (multiple_sections_found)
570
    walk_wild_section_general (ptr, file, callback, data);
571
  else if (s0)
572
    walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
573
}
574
 
575
static void
576
walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
577
                                lang_input_statement_type *file,
578
                                callback_t callback,
579
                                void *data)
580
{
581
  asection *s;
582
  struct wildcard_list *wildsec0 = ptr->handler_data[0];
583
 
584
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
585
    {
586
      const char *sname = bfd_get_section_name (file->the_bfd, s);
587
      bfd_boolean skip = !match_simple_wild (wildsec0->spec.name, sname);
588
 
589
      if (!skip)
590
        walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
591
    }
592
}
593
 
594
static void
595
walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
596
                                lang_input_statement_type *file,
597
                                callback_t callback,
598
                                void *data)
599
{
600
  asection *s;
601
  struct wildcard_list *sec0 = ptr->handler_data[0];
602
  struct wildcard_list *wildsec1 = ptr->handler_data[1];
603
  bfd_boolean multiple_sections_found;
604
  asection *s0 = find_section (file, sec0, &multiple_sections_found);
605
 
606
  if (multiple_sections_found)
607
    {
608
      walk_wild_section_general (ptr, file, callback, data);
609
      return;
610
    }
611
 
612
  /* Note that if the section was not found, s0 is NULL and
613
     we'll simply never succeed the s == s0 test below.  */
614
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
615
    {
616
      /* Recall that in this code path, a section cannot satisfy more
617
         than one spec, so if s == s0 then it cannot match
618
         wildspec1.  */
619
      if (s == s0)
620
        walk_wild_consider_section (ptr, file, s, sec0, callback, data);
621
      else
622
        {
623
          const char *sname = bfd_get_section_name (file->the_bfd, s);
624
          bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
625
 
626
          if (!skip)
627
            walk_wild_consider_section (ptr, file, s, wildsec1, callback,
628
                                        data);
629
        }
630
    }
631
}
632
 
633
static void
634
walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
635
                                lang_input_statement_type *file,
636
                                callback_t callback,
637
                                void *data)
638
{
639
  asection *s;
640
  struct wildcard_list *sec0 = ptr->handler_data[0];
641
  struct wildcard_list *wildsec1 = ptr->handler_data[1];
642
  struct wildcard_list *wildsec2 = ptr->handler_data[2];
643
  bfd_boolean multiple_sections_found;
644
  asection *s0 = find_section (file, sec0, &multiple_sections_found);
645
 
646
  if (multiple_sections_found)
647
    {
648
      walk_wild_section_general (ptr, file, callback, data);
649
      return;
650
    }
651
 
652
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
653
    {
654
      if (s == s0)
655
        walk_wild_consider_section (ptr, file, s, sec0, callback, data);
656
      else
657
        {
658
          const char *sname = bfd_get_section_name (file->the_bfd, s);
659
          bfd_boolean skip = !match_simple_wild (wildsec1->spec.name, sname);
660
 
661
          if (!skip)
662
            walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
663
          else
664
            {
665
              skip = !match_simple_wild (wildsec2->spec.name, sname);
666
              if (!skip)
667
                walk_wild_consider_section (ptr, file, s, wildsec2, callback,
668
                                            data);
669
            }
670
        }
671
    }
672
}
673
 
674
static void
675
walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
676
                                lang_input_statement_type *file,
677
                                callback_t callback,
678
                                void *data)
679
{
680
  asection *s;
681
  struct wildcard_list *sec0 = ptr->handler_data[0];
682
  struct wildcard_list *sec1 = ptr->handler_data[1];
683
  struct wildcard_list *wildsec2 = ptr->handler_data[2];
684
  struct wildcard_list *wildsec3 = ptr->handler_data[3];
685
  bfd_boolean multiple_sections_found;
686
  asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1;
687
 
688
  if (multiple_sections_found)
689
    {
690
      walk_wild_section_general (ptr, file, callback, data);
691
      return;
692
    }
693
 
694
  s1 = find_section (file, sec1, &multiple_sections_found);
695
  if (multiple_sections_found)
696
    {
697
      walk_wild_section_general (ptr, file, callback, data);
698
      return;
699
    }
700
 
701
  for (s = file->the_bfd->sections; s != NULL; s = s->next)
702
    {
703
      if (s == s0)
704
        walk_wild_consider_section (ptr, file, s, sec0, callback, data);
705
      else
706
        if (s == s1)
707
          walk_wild_consider_section (ptr, file, s, sec1, callback, data);
708
        else
709
          {
710
            const char *sname = bfd_get_section_name (file->the_bfd, s);
711
            bfd_boolean skip = !match_simple_wild (wildsec2->spec.name,
712
                                                   sname);
713
 
714
            if (!skip)
715
              walk_wild_consider_section (ptr, file, s, wildsec2, callback,
716
                                          data);
717
            else
718
              {
719
                skip = !match_simple_wild (wildsec3->spec.name, sname);
720
                if (!skip)
721
                  walk_wild_consider_section (ptr, file, s, wildsec3,
722
                                              callback, data);
723
              }
724
          }
725
    }
726
}
727
 
728
static void
729
walk_wild_section (lang_wild_statement_type *ptr,
730
                   lang_input_statement_type *file,
731
                   callback_t callback,
732
                   void *data)
733
{
734
  if (file->just_syms_flag)
735
    return;
736
 
737
  (*ptr->walk_wild_section_handler) (ptr, file, callback, data);
738
}
739
 
740
/* Returns TRUE when name1 is a wildcard spec that might match
741
   something name2 can match.  We're conservative: we return FALSE
742
   only if the prefixes of name1 and name2 are different up to the
743
   first wildcard character.  */
744
 
745
static bfd_boolean
746
wild_spec_can_overlap (const char *name1, const char *name2)
747
{
748
  size_t prefix1_len = strcspn (name1, "?*[");
749
  size_t prefix2_len = strcspn (name2, "?*[");
750
  size_t min_prefix_len;
751
 
752
  /* Note that if there is no wildcard character, then we treat the
753
     terminating 0 as part of the prefix.  Thus ".text" won't match
754
     ".text." or ".text.*", for example.  */
755
  if (name1[prefix1_len] == '\0')
756
    prefix1_len++;
757
  if (name2[prefix2_len] == '\0')
758
    prefix2_len++;
759
 
760
  min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;
761
 
762
  return memcmp (name1, name2, min_prefix_len) == 0;
763
}
764
 
765
/* Select specialized code to handle various kinds of wildcard
766
   statements.  */
767
 
768
static void
769
analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
770
{
771
  int sec_count = 0;
772
  int wild_name_count = 0;
773
  struct wildcard_list *sec;
774
  int signature;
775
  int data_counter;
776
 
777
  ptr->walk_wild_section_handler = walk_wild_section_general;
778
  ptr->handler_data[0] = NULL;
779
  ptr->handler_data[1] = NULL;
780
  ptr->handler_data[2] = NULL;
781
  ptr->handler_data[3] = NULL;
782
  ptr->tree = NULL;
783
 
784
  /* Count how many wildcard_specs there are, and how many of those
785
     actually use wildcards in the name.  Also, bail out if any of the
786
     wildcard names are NULL. (Can this actually happen?
787
     walk_wild_section used to test for it.)  And bail out if any
788
     of the wildcards are more complex than a simple string
789
     ending in a single '*'.  */
790
  for (sec = ptr->section_list; sec != NULL; sec = sec->next)
791
    {
792
      ++sec_count;
793
      if (sec->spec.name == NULL)
794
        return;
795
      if (wildcardp (sec->spec.name))
796
        {
797
          ++wild_name_count;
798
          if (!is_simple_wild (sec->spec.name))
799
            return;
800
        }
801
    }
802
 
803
  /* The zero-spec case would be easy to optimize but it doesn't
804
     happen in practice.  Likewise, more than 4 specs doesn't
805
     happen in practice.  */
806
  if (sec_count == 0 || sec_count > 4)
807
    return;
808
 
809
  /* Check that no two specs can match the same section.  */
810
  for (sec = ptr->section_list; sec != NULL; sec = sec->next)
811
    {
812
      struct wildcard_list *sec2;
813
      for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)
814
        {
815
          if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))
816
            return;
817
        }
818
    }
819
 
820
  signature = (sec_count << 8) + wild_name_count;
821
  switch (signature)
822
    {
823
    case 0x0100:
824
      ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
825
      break;
826
    case 0x0101:
827
      ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
828
      break;
829
    case 0x0201:
830
      ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
831
      break;
832
    case 0x0302:
833
      ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
834
      break;
835
    case 0x0402:
836
      ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
837
      break;
838
    default:
839
      return;
840
    }
841
 
842
  /* Now fill the data array with pointers to the specs, first the
843
     specs with non-wildcard names, then the specs with wildcard
844
     names.  It's OK to process the specs in different order from the
845
     given order, because we've already determined that no section
846
     will match more than one spec.  */
847
  data_counter = 0;
848
  for (sec = ptr->section_list; sec != NULL; sec = sec->next)
849
    if (!wildcardp (sec->spec.name))
850
      ptr->handler_data[data_counter++] = sec;
851
  for (sec = ptr->section_list; sec != NULL; sec = sec->next)
852
    if (wildcardp (sec->spec.name))
853
      ptr->handler_data[data_counter++] = sec;
854
}
855
 
856
/* Handle a wild statement for a single file F.  */
857
 
858
static void
859
walk_wild_file (lang_wild_statement_type *s,
860
                lang_input_statement_type *f,
861
                callback_t callback,
862
                void *data)
863
{
864
  if (f->the_bfd == NULL
865
      || ! bfd_check_format (f->the_bfd, bfd_archive))
866
    walk_wild_section (s, f, callback, data);
867
  else
868
    {
869
      bfd *member;
870
 
871
      /* This is an archive file.  We must map each member of the
872
         archive separately.  */
873
      member = bfd_openr_next_archived_file (f->the_bfd, NULL);
874
      while (member != NULL)
875
        {
876
          /* When lookup_name is called, it will call the add_symbols
877
             entry point for the archive.  For each element of the
878
             archive which is included, BFD will call ldlang_add_file,
879
             which will set the usrdata field of the member to the
880
             lang_input_statement.  */
881
          if (member->usrdata != NULL)
882
            {
883
              walk_wild_section (s,
884
                                 (lang_input_statement_type *) member->usrdata,
885
                                 callback, data);
886
            }
887
 
888
          member = bfd_openr_next_archived_file (f->the_bfd, member);
889
        }
890
    }
891
}
892
 
893
static void
894
walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
895
{
896
  const char *file_spec = s->filename;
897
  char *p;
898
 
899
  if (file_spec == NULL)
900
    {
901
      /* Perform the iteration over all files in the list.  */
902
      LANG_FOR_EACH_INPUT_STATEMENT (f)
903
        {
904
          walk_wild_file (s, f, callback, data);
905
        }
906
    }
907
  else if ((p = archive_path (file_spec)) != NULL)
908
    {
909
      LANG_FOR_EACH_INPUT_STATEMENT (f)
910
        {
911
          if (input_statement_is_archive_path (file_spec, p, f))
912
            walk_wild_file (s, f, callback, data);
913
        }
914
    }
915
  else if (wildcardp (file_spec))
916
    {
917
      LANG_FOR_EACH_INPUT_STATEMENT (f)
918
        {
919
          if (fnmatch (file_spec, f->filename, 0) == 0)
920
            walk_wild_file (s, f, callback, data);
921
        }
922
    }
923
  else
924
    {
925
      lang_input_statement_type *f;
926
 
927
      /* Perform the iteration over a single file.  */
928
      f = lookup_name (file_spec);
929
      if (f)
930
        walk_wild_file (s, f, callback, data);
931
    }
932
}
933
 
934
/* lang_for_each_statement walks the parse tree and calls the provided
935
   function for each node, except those inside output section statements
936
   with constraint set to -1.  */
937
 
938
void
939
lang_for_each_statement_worker (void (*func) (lang_statement_union_type *),
940
                                lang_statement_union_type *s)
941
{
942
  for (; s != NULL; s = s->header.next)
943
    {
944
      func (s);
945
 
946
      switch (s->header.type)
947
        {
948
        case lang_constructors_statement_enum:
949
          lang_for_each_statement_worker (func, constructor_list.head);
950
          break;
951
        case lang_output_section_statement_enum:
952
          if (s->output_section_statement.constraint != -1)
953
            lang_for_each_statement_worker
954
              (func, s->output_section_statement.children.head);
955
          break;
956
        case lang_wild_statement_enum:
957
          lang_for_each_statement_worker (func,
958
                                          s->wild_statement.children.head);
959
          break;
960
        case lang_group_statement_enum:
961
          lang_for_each_statement_worker (func,
962
                                          s->group_statement.children.head);
963
          break;
964
        case lang_data_statement_enum:
965
        case lang_reloc_statement_enum:
966
        case lang_object_symbols_statement_enum:
967
        case lang_output_statement_enum:
968
        case lang_target_statement_enum:
969
        case lang_input_section_enum:
970
        case lang_input_statement_enum:
971
        case lang_assignment_statement_enum:
972
        case lang_padding_statement_enum:
973
        case lang_address_statement_enum:
974
        case lang_fill_statement_enum:
975
        case lang_insert_statement_enum:
976
          break;
977
        default:
978
          FAIL ();
979
          break;
980
        }
981
    }
982
}
983
 
984
void
985
lang_for_each_statement (void (*func) (lang_statement_union_type *))
986
{
987
  lang_for_each_statement_worker (func, statement_list.head);
988
}
989
 
990
/*----------------------------------------------------------------------*/
991
 
992
void
993
lang_list_init (lang_statement_list_type *list)
994
{
995
  list->head = NULL;
996
  list->tail = &list->head;
997
}
998
 
999
void
1000
push_stat_ptr (lang_statement_list_type *new_ptr)
1001
{
1002
  if (stat_save_ptr >= stat_save + sizeof (stat_save) / sizeof (stat_save[0]))
1003
    abort ();
1004
  *stat_save_ptr++ = stat_ptr;
1005
  stat_ptr = new_ptr;
1006
}
1007
 
1008
void
1009
pop_stat_ptr (void)
1010
{
1011
  if (stat_save_ptr <= stat_save)
1012
    abort ();
1013
  stat_ptr = *--stat_save_ptr;
1014
}
1015
 
1016
/* Build a new statement node for the parse tree.  */
1017
 
1018
static lang_statement_union_type *
1019
new_statement (enum statement_enum type,
1020
               size_t size,
1021
               lang_statement_list_type *list)
1022
{
1023
  lang_statement_union_type *new_stmt;
1024
 
1025
  new_stmt = (lang_statement_union_type *) stat_alloc (size);
1026
  new_stmt->header.type = type;
1027
  new_stmt->header.next = NULL;
1028
  lang_statement_append (list, new_stmt, &new_stmt->header.next);
1029
  return new_stmt;
1030
}
1031
 
1032
/* Build a new input file node for the language.  There are several
1033
   ways in which we treat an input file, eg, we only look at symbols,
1034
   or prefix it with a -l etc.
1035
 
1036
   We can be supplied with requests for input files more than once;
1037
   they may, for example be split over several lines like foo.o(.text)
1038
   foo.o(.data) etc, so when asked for a file we check that we haven't
1039
   got it already so we don't duplicate the bfd.  */
1040
 
1041
static lang_input_statement_type *
1042
new_afile (const char *name,
1043
           lang_input_file_enum_type file_type,
1044
           const char *target,
1045
           bfd_boolean add_to_list)
1046
{
1047
  lang_input_statement_type *p;
1048
 
1049
  if (add_to_list)
1050
    p = (lang_input_statement_type *) new_stat (lang_input_statement, stat_ptr);
1051
  else
1052
    {
1053
      p = (lang_input_statement_type *)
1054
          stat_alloc (sizeof (lang_input_statement_type));
1055
      p->header.type = lang_input_statement_enum;
1056
      p->header.next = NULL;
1057
    }
1058
 
1059
  lang_has_input_file = TRUE;
1060
  p->target = target;
1061
  p->sysrooted = FALSE;
1062
 
1063
  if (file_type == lang_input_file_is_l_enum
1064
      && name[0] == ':' && name[1] != '\0')
1065
    {
1066
      file_type = lang_input_file_is_search_file_enum;
1067
      name = name + 1;
1068
    }
1069
 
1070
  switch (file_type)
1071
    {
1072
    case lang_input_file_is_symbols_only_enum:
1073
      p->filename = name;
1074
      p->maybe_archive = FALSE;
1075
      p->real = TRUE;
1076
      p->local_sym_name = name;
1077
      p->just_syms_flag = TRUE;
1078
      p->search_dirs_flag = FALSE;
1079
      break;
1080
    case lang_input_file_is_fake_enum:
1081
      p->filename = name;
1082
      p->maybe_archive = FALSE;
1083
      p->real = FALSE;
1084
      p->local_sym_name = name;
1085
      p->just_syms_flag = FALSE;
1086
      p->search_dirs_flag = FALSE;
1087
      break;
1088
    case lang_input_file_is_l_enum:
1089
      p->maybe_archive = TRUE;
1090
      p->filename = name;
1091
      p->real = TRUE;
1092
      p->local_sym_name = concat ("-l", name, (const char *) NULL);
1093
      p->just_syms_flag = FALSE;
1094
      p->search_dirs_flag = TRUE;
1095
      break;
1096
    case lang_input_file_is_marker_enum:
1097
      p->filename = name;
1098
      p->maybe_archive = FALSE;
1099
      p->real = FALSE;
1100
      p->local_sym_name = name;
1101
      p->just_syms_flag = FALSE;
1102
      p->search_dirs_flag = TRUE;
1103
      break;
1104
    case lang_input_file_is_search_file_enum:
1105
      p->sysrooted = ldlang_sysrooted_script;
1106
      p->filename = name;
1107
      p->maybe_archive = FALSE;
1108
      p->real = TRUE;
1109
      p->local_sym_name = name;
1110
      p->just_syms_flag = FALSE;
1111
      p->search_dirs_flag = TRUE;
1112
      break;
1113
    case lang_input_file_is_file_enum:
1114
      p->filename = name;
1115
      p->maybe_archive = FALSE;
1116
      p->real = TRUE;
1117
      p->local_sym_name = name;
1118
      p->just_syms_flag = FALSE;
1119
      p->search_dirs_flag = FALSE;
1120
      break;
1121
    default:
1122
      FAIL ();
1123
    }
1124
  p->the_bfd = NULL;
1125
  p->next_real_file = NULL;
1126
  p->next = NULL;
1127
  p->dynamic = config.dynamic_link;
1128
  p->add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;
1129
  p->add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;
1130
  p->whole_archive = whole_archive;
1131
  p->loaded = FALSE;
1132
  p->missing_file = FALSE;
1133
#ifdef ENABLE_PLUGINS
1134
  p->claimed = FALSE;
1135
  p->claim_archive = FALSE;
1136 163 khays
  p->reload = FALSE;
1137 145 khays
#endif /* ENABLE_PLUGINS */
1138
 
1139
  lang_statement_append (&input_file_chain,
1140
                         (lang_statement_union_type *) p,
1141
                         &p->next_real_file);
1142
  return p;
1143
}
1144
 
1145
lang_input_statement_type *
1146
lang_add_input_file (const char *name,
1147
                     lang_input_file_enum_type file_type,
1148
                     const char *target)
1149
{
1150
  return new_afile (name, file_type, target, TRUE);
1151
}
1152
 
1153
struct out_section_hash_entry
1154
{
1155
  struct bfd_hash_entry root;
1156
  lang_statement_union_type s;
1157
};
1158
 
1159
/* The hash table.  */
1160
 
1161
static struct bfd_hash_table output_section_statement_table;
1162
 
1163
/* Support routines for the hash table used by lang_output_section_find,
1164
   initialize the table, fill in an entry and remove the table.  */
1165
 
1166
static struct bfd_hash_entry *
1167
output_section_statement_newfunc (struct bfd_hash_entry *entry,
1168
                                  struct bfd_hash_table *table,
1169
                                  const char *string)
1170
{
1171
  lang_output_section_statement_type **nextp;
1172
  struct out_section_hash_entry *ret;
1173
 
1174
  if (entry == NULL)
1175
    {
1176
      entry = (struct bfd_hash_entry *) bfd_hash_allocate (table,
1177
                                                           sizeof (*ret));
1178
      if (entry == NULL)
1179
        return entry;
1180
    }
1181
 
1182
  entry = bfd_hash_newfunc (entry, table, string);
1183
  if (entry == NULL)
1184
    return entry;
1185
 
1186
  ret = (struct out_section_hash_entry *) entry;
1187
  memset (&ret->s, 0, sizeof (ret->s));
1188
  ret->s.header.type = lang_output_section_statement_enum;
1189
  ret->s.output_section_statement.subsection_alignment = -1;
1190
  ret->s.output_section_statement.section_alignment = -1;
1191
  ret->s.output_section_statement.block_value = 1;
1192
  lang_list_init (&ret->s.output_section_statement.children);
1193
  lang_statement_append (stat_ptr, &ret->s, &ret->s.header.next);
1194
 
1195
  /* For every output section statement added to the list, except the
1196
     first one, lang_output_section_statement.tail points to the "next"
1197
     field of the last element of the list.  */
1198
  if (lang_output_section_statement.head != NULL)
1199
    ret->s.output_section_statement.prev
1200
      = ((lang_output_section_statement_type *)
1201
         ((char *) lang_output_section_statement.tail
1202
          - offsetof (lang_output_section_statement_type, next)));
1203
 
1204
  /* GCC's strict aliasing rules prevent us from just casting the
1205
     address, so we store the pointer in a variable and cast that
1206
     instead.  */
1207
  nextp = &ret->s.output_section_statement.next;
1208
  lang_statement_append (&lang_output_section_statement,
1209
                         &ret->s,
1210
                         (lang_statement_union_type **) nextp);
1211
  return &ret->root;
1212
}
1213
 
1214
static void
1215
output_section_statement_table_init (void)
1216
{
1217
  if (!bfd_hash_table_init_n (&output_section_statement_table,
1218
                              output_section_statement_newfunc,
1219
                              sizeof (struct out_section_hash_entry),
1220
                              61))
1221
    einfo (_("%P%F: can not create hash table: %E\n"));
1222
}
1223
 
1224
static void
1225
output_section_statement_table_free (void)
1226
{
1227
  bfd_hash_table_free (&output_section_statement_table);
1228
}
1229
 
1230
/* Build enough state so that the parser can build its tree.  */
1231
 
1232
void
1233
lang_init (void)
1234
{
1235
  obstack_begin (&stat_obstack, 1000);
1236
 
1237
  stat_ptr = &statement_list;
1238
 
1239
  output_section_statement_table_init ();
1240
 
1241
  lang_list_init (stat_ptr);
1242
 
1243
  lang_list_init (&input_file_chain);
1244
  lang_list_init (&lang_output_section_statement);
1245
  lang_list_init (&file_chain);
1246
  first_file = lang_add_input_file (NULL, lang_input_file_is_marker_enum,
1247
                                    NULL);
1248
  abs_output_section =
1249
    lang_output_section_statement_lookup (BFD_ABS_SECTION_NAME, 0, TRUE);
1250
 
1251
  abs_output_section->bfd_section = bfd_abs_section_ptr;
1252
 
1253
  /* The value "3" is ad-hoc, somewhat related to the expected number of
1254
     DEFINED expressions in a linker script.  For most default linker
1255
     scripts, there are none.  Why a hash table then?  Well, it's somewhat
1256
     simpler to re-use working machinery than using a linked list in terms
1257
     of code-complexity here in ld, besides the initialization which just
1258
     looks like other code here.  */
1259
  if (!bfd_hash_table_init_n (&lang_definedness_table,
1260
                              lang_definedness_newfunc,
1261
                              sizeof (struct lang_definedness_hash_entry),
1262
                              3))
1263
    einfo (_("%P%F: can not create hash table: %E\n"));
1264
}
1265
 
1266
void
1267
lang_finish (void)
1268
{
1269
  output_section_statement_table_free ();
1270
}
1271
 
1272
/*----------------------------------------------------------------------
1273
  A region is an area of memory declared with the
1274
  MEMORY {  name:org=exp, len=exp ... }
1275
  syntax.
1276
 
1277
  We maintain a list of all the regions here.
1278
 
1279
  If no regions are specified in the script, then the default is used
1280
  which is created when looked up to be the entire data space.
1281
 
1282
  If create is true we are creating a region inside a MEMORY block.
1283
  In this case it is probably an error to create a region that has
1284
  already been created.  If we are not inside a MEMORY block it is
1285
  dubious to use an undeclared region name (except DEFAULT_MEMORY_REGION)
1286
  and so we issue a warning.
1287
 
1288
  Each region has at least one name.  The first name is either
1289
  DEFAULT_MEMORY_REGION or the name given in the MEMORY block.  You can add
1290
  alias names to an existing region within a script with
1291
  REGION_ALIAS (alias, region_name).  Each name corresponds to at most one
1292
  region.  */
1293
 
1294
static lang_memory_region_type *lang_memory_region_list;
1295
static lang_memory_region_type **lang_memory_region_list_tail
1296
  = &lang_memory_region_list;
1297
 
1298
lang_memory_region_type *
1299
lang_memory_region_lookup (const char *const name, bfd_boolean create)
1300
{
1301
  lang_memory_region_name *n;
1302
  lang_memory_region_type *r;
1303
  lang_memory_region_type *new_region;
1304
 
1305
  /* NAME is NULL for LMA memspecs if no region was specified.  */
1306
  if (name == NULL)
1307
    return NULL;
1308
 
1309
  for (r = lang_memory_region_list; r != NULL; r = r->next)
1310
    for (n = &r->name_list; n != NULL; n = n->next)
1311
      if (strcmp (n->name, name) == 0)
1312
        {
1313
          if (create)
1314
            einfo (_("%P:%S: warning: redeclaration of memory region `%s'\n"),
1315 166 khays
                   NULL, name);
1316 145 khays
          return r;
1317
        }
1318
 
1319
  if (!create && strcmp (name, DEFAULT_MEMORY_REGION))
1320 166 khays
    einfo (_("%P:%S: warning: memory region `%s' not declared\n"),
1321
           NULL, name);
1322 145 khays
 
1323
  new_region = (lang_memory_region_type *)
1324
      stat_alloc (sizeof (lang_memory_region_type));
1325
 
1326
  new_region->name_list.name = xstrdup (name);
1327
  new_region->name_list.next = NULL;
1328
  new_region->next = NULL;
1329
  new_region->origin = 0;
1330
  new_region->length = ~(bfd_size_type) 0;
1331
  new_region->current = 0;
1332
  new_region->last_os = NULL;
1333
  new_region->flags = 0;
1334
  new_region->not_flags = 0;
1335
  new_region->had_full_message = FALSE;
1336
 
1337
  *lang_memory_region_list_tail = new_region;
1338
  lang_memory_region_list_tail = &new_region->next;
1339
 
1340
  return new_region;
1341
}
1342
 
1343
void
1344
lang_memory_region_alias (const char * alias, const char * region_name)
1345
{
1346
  lang_memory_region_name * n;
1347
  lang_memory_region_type * r;
1348
  lang_memory_region_type * region;
1349
 
1350
  /* The default region must be unique.  This ensures that it is not necessary
1351
     to iterate through the name list if someone wants the check if a region is
1352
     the default memory region.  */
1353
  if (strcmp (region_name, DEFAULT_MEMORY_REGION) == 0
1354
      || strcmp (alias, DEFAULT_MEMORY_REGION) == 0)
1355 166 khays
    einfo (_("%F%P:%S: error: alias for default memory region\n"), NULL);
1356 145 khays
 
1357
  /* Look for the target region and check if the alias is not already
1358
     in use.  */
1359
  region = NULL;
1360
  for (r = lang_memory_region_list; r != NULL; r = r->next)
1361
    for (n = &r->name_list; n != NULL; n = n->next)
1362
      {
1363
        if (region == NULL && strcmp (n->name, region_name) == 0)
1364
          region = r;
1365
        if (strcmp (n->name, alias) == 0)
1366
          einfo (_("%F%P:%S: error: redefinition of memory region "
1367
                   "alias `%s'\n"),
1368 166 khays
                 NULL, alias);
1369 145 khays
      }
1370
 
1371
  /* Check if the target region exists.  */
1372
  if (region == NULL)
1373
    einfo (_("%F%P:%S: error: memory region `%s' "
1374
             "for alias `%s' does not exist\n"),
1375 166 khays
           NULL, region_name, alias);
1376 145 khays
 
1377
  /* Add alias to region name list.  */
1378
  n = (lang_memory_region_name *) stat_alloc (sizeof (lang_memory_region_name));
1379
  n->name = xstrdup (alias);
1380
  n->next = region->name_list.next;
1381
  region->name_list.next = n;
1382
}
1383
 
1384
static lang_memory_region_type *
1385
lang_memory_default (asection * section)
1386
{
1387
  lang_memory_region_type *p;
1388
 
1389
  flagword sec_flags = section->flags;
1390
 
1391
  /* Override SEC_DATA to mean a writable section.  */
1392
  if ((sec_flags & (SEC_ALLOC | SEC_READONLY | SEC_CODE)) == SEC_ALLOC)
1393
    sec_flags |= SEC_DATA;
1394
 
1395
  for (p = lang_memory_region_list; p != NULL; p = p->next)
1396
    {
1397
      if ((p->flags & sec_flags) != 0
1398
          && (p->not_flags & sec_flags) == 0)
1399
        {
1400
          return p;
1401
        }
1402
    }
1403
  return lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
1404
}
1405
 
1406
/* Find or create an output_section_statement with the given NAME.
1407
   If CONSTRAINT is non-zero match one with that constraint, otherwise
1408
   match any non-negative constraint.  If CREATE, always make a
1409
   new output_section_statement for SPECIAL CONSTRAINT.  */
1410
 
1411
lang_output_section_statement_type *
1412
lang_output_section_statement_lookup (const char *name,
1413
                                      int constraint,
1414
                                      bfd_boolean create)
1415
{
1416
  struct out_section_hash_entry *entry;
1417
 
1418
  entry = ((struct out_section_hash_entry *)
1419
           bfd_hash_lookup (&output_section_statement_table, name,
1420
                            create, FALSE));
1421
  if (entry == NULL)
1422
    {
1423
      if (create)
1424
        einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1425
      return NULL;
1426
    }
1427
 
1428
  if (entry->s.output_section_statement.name != NULL)
1429
    {
1430
      /* We have a section of this name, but it might not have the correct
1431
         constraint.  */
1432
      struct out_section_hash_entry *last_ent;
1433
 
1434
      name = entry->s.output_section_statement.name;
1435
      if (create && constraint == SPECIAL)
1436
        /* Not traversing to the end reverses the order of the second
1437
           and subsequent SPECIAL sections in the hash table chain,
1438
           but that shouldn't matter.  */
1439
        last_ent = entry;
1440
      else
1441
        do
1442
          {
1443
            if (constraint == entry->s.output_section_statement.constraint
1444
                || (constraint == 0
1445
                    && entry->s.output_section_statement.constraint >= 0))
1446
              return &entry->s.output_section_statement;
1447
            last_ent = entry;
1448
            entry = (struct out_section_hash_entry *) entry->root.next;
1449
          }
1450
        while (entry != NULL
1451
               && name == entry->s.output_section_statement.name);
1452
 
1453
      if (!create)
1454
        return NULL;
1455
 
1456
      entry
1457
        = ((struct out_section_hash_entry *)
1458
           output_section_statement_newfunc (NULL,
1459
                                             &output_section_statement_table,
1460
                                             name));
1461
      if (entry == NULL)
1462
        {
1463
          einfo (_("%P%F: failed creating section `%s': %E\n"), name);
1464
          return NULL;
1465
        }
1466
      entry->root = last_ent->root;
1467
      last_ent->root.next = &entry->root;
1468
    }
1469
 
1470
  entry->s.output_section_statement.name = name;
1471
  entry->s.output_section_statement.constraint = constraint;
1472
  return &entry->s.output_section_statement;
1473
}
1474
 
1475
/* Find the next output_section_statement with the same name as OS.
1476
   If CONSTRAINT is non-zero, find one with that constraint otherwise
1477
   match any non-negative constraint.  */
1478
 
1479
lang_output_section_statement_type *
1480
next_matching_output_section_statement (lang_output_section_statement_type *os,
1481
                                        int constraint)
1482
{
1483
  /* All output_section_statements are actually part of a
1484
     struct out_section_hash_entry.  */
1485
  struct out_section_hash_entry *entry = (struct out_section_hash_entry *)
1486
    ((char *) os
1487
     - offsetof (struct out_section_hash_entry, s.output_section_statement));
1488
  const char *name = os->name;
1489
 
1490
  ASSERT (name == entry->root.string);
1491
  do
1492
    {
1493
      entry = (struct out_section_hash_entry *) entry->root.next;
1494
      if (entry == NULL
1495
          || name != entry->s.output_section_statement.name)
1496
        return NULL;
1497
    }
1498
  while (constraint != entry->s.output_section_statement.constraint
1499
         && (constraint != 0
1500
             || entry->s.output_section_statement.constraint < 0));
1501
 
1502
  return &entry->s.output_section_statement;
1503
}
1504
 
1505
/* A variant of lang_output_section_find used by place_orphan.
1506
   Returns the output statement that should precede a new output
1507
   statement for SEC.  If an exact match is found on certain flags,
1508
   sets *EXACT too.  */
1509
 
1510
lang_output_section_statement_type *
1511
lang_output_section_find_by_flags (const asection *sec,
1512
                                   lang_output_section_statement_type **exact,
1513
                                   lang_match_sec_type_func match_type)
1514
{
1515
  lang_output_section_statement_type *first, *look, *found;
1516
  flagword flags;
1517
 
1518
  /* We know the first statement on this list is *ABS*.  May as well
1519
     skip it.  */
1520
  first = &lang_output_section_statement.head->output_section_statement;
1521
  first = first->next;
1522
 
1523
  /* First try for an exact match.  */
1524
  found = NULL;
1525
  for (look = first; look; look = look->next)
1526
    {
1527
      flags = look->flags;
1528
      if (look->bfd_section != NULL)
1529
        {
1530
          flags = look->bfd_section->flags;
1531
          if (match_type && !match_type (link_info.output_bfd,
1532
                                         look->bfd_section,
1533
                                         sec->owner, sec))
1534
            continue;
1535
        }
1536
      flags ^= sec->flags;
1537
      if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_READONLY
1538
                     | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1539
        found = look;
1540
    }
1541
  if (found != NULL)
1542
    {
1543
      if (exact != NULL)
1544
        *exact = found;
1545
      return found;
1546
    }
1547
 
1548
  if ((sec->flags & SEC_CODE) != 0
1549
      && (sec->flags & SEC_ALLOC) != 0)
1550
    {
1551
      /* Try for a rw code section.  */
1552
      for (look = first; look; look = look->next)
1553
        {
1554
          flags = look->flags;
1555
          if (look->bfd_section != NULL)
1556
            {
1557
              flags = look->bfd_section->flags;
1558
              if (match_type && !match_type (link_info.output_bfd,
1559
                                             look->bfd_section,
1560
                                             sec->owner, sec))
1561
                continue;
1562
            }
1563
          flags ^= sec->flags;
1564
          if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1565
                         | SEC_CODE | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1566
            found = look;
1567
        }
1568
    }
1569
  else if ((sec->flags & (SEC_READONLY | SEC_THREAD_LOCAL)) != 0
1570
           && (sec->flags & SEC_ALLOC) != 0)
1571
    {
1572
      /* .rodata can go after .text, .sdata2 after .rodata.  */
1573
      for (look = first; look; look = look->next)
1574
        {
1575
          flags = look->flags;
1576
          if (look->bfd_section != NULL)
1577
            {
1578
              flags = look->bfd_section->flags;
1579
              if (match_type && !match_type (link_info.output_bfd,
1580
                                             look->bfd_section,
1581
                                             sec->owner, sec))
1582
                continue;
1583
            }
1584
          flags ^= sec->flags;
1585
          if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1586
                         | SEC_READONLY | SEC_SMALL_DATA))
1587
              || (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1588
                             | SEC_READONLY))
1589
                  && !(look->flags & SEC_SMALL_DATA))
1590
              || (!(flags & (SEC_THREAD_LOCAL | SEC_ALLOC))
1591
                  && (look->flags & SEC_THREAD_LOCAL)
1592
                  && (!(flags & SEC_LOAD)
1593
                      || (look->flags & SEC_LOAD))))
1594
            found = look;
1595
        }
1596
    }
1597
  else if ((sec->flags & SEC_SMALL_DATA) != 0
1598
           && (sec->flags & SEC_ALLOC) != 0)
1599
    {
1600
      /* .sdata goes after .data, .sbss after .sdata.  */
1601
      for (look = first; look; look = look->next)
1602
        {
1603
          flags = look->flags;
1604
          if (look->bfd_section != NULL)
1605
            {
1606
              flags = look->bfd_section->flags;
1607
              if (match_type && !match_type (link_info.output_bfd,
1608
                                             look->bfd_section,
1609
                                             sec->owner, sec))
1610
                continue;
1611
            }
1612
          flags ^= sec->flags;
1613
          if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1614
                         | SEC_THREAD_LOCAL))
1615
              || ((look->flags & SEC_SMALL_DATA)
1616
                  && !(sec->flags & SEC_HAS_CONTENTS)))
1617
            found = look;
1618
        }
1619
    }
1620
  else if ((sec->flags & SEC_HAS_CONTENTS) != 0
1621
           && (sec->flags & SEC_ALLOC) != 0)
1622
    {
1623
      /* .data goes after .rodata.  */
1624
      for (look = first; look; look = look->next)
1625
        {
1626
          flags = look->flags;
1627
          if (look->bfd_section != NULL)
1628
            {
1629
              flags = look->bfd_section->flags;
1630
              if (match_type && !match_type (link_info.output_bfd,
1631
                                             look->bfd_section,
1632
                                             sec->owner, sec))
1633
                continue;
1634
            }
1635
          flags ^= sec->flags;
1636
          if (!(flags & (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
1637
                         | SEC_SMALL_DATA | SEC_THREAD_LOCAL)))
1638
            found = look;
1639
        }
1640
    }
1641
  else if ((sec->flags & SEC_ALLOC) != 0)
1642
    {
1643
      /* .bss goes after any other alloc section.  */
1644
      for (look = first; look; look = look->next)
1645
        {
1646
          flags = look->flags;
1647
          if (look->bfd_section != NULL)
1648
            {
1649
              flags = look->bfd_section->flags;
1650
              if (match_type && !match_type (link_info.output_bfd,
1651
                                             look->bfd_section,
1652
                                             sec->owner, sec))
1653
                continue;
1654
            }
1655
          flags ^= sec->flags;
1656
          if (!(flags & SEC_ALLOC))
1657
            found = look;
1658
        }
1659
    }
1660
  else
1661
    {
1662
      /* non-alloc go last.  */
1663
      for (look = first; look; look = look->next)
1664
        {
1665
          flags = look->flags;
1666
          if (look->bfd_section != NULL)
1667
            flags = look->bfd_section->flags;
1668
          flags ^= sec->flags;
1669
          if (!(flags & SEC_DEBUGGING))
1670
            found = look;
1671
        }
1672
      return found;
1673
    }
1674
 
1675
  if (found || !match_type)
1676
    return found;
1677
 
1678
  return lang_output_section_find_by_flags (sec, NULL, NULL);
1679
}
1680
 
1681
/* Find the last output section before given output statement.
1682
   Used by place_orphan.  */
1683
 
1684
static asection *
1685
output_prev_sec_find (lang_output_section_statement_type *os)
1686
{
1687
  lang_output_section_statement_type *lookup;
1688
 
1689
  for (lookup = os->prev; lookup != NULL; lookup = lookup->prev)
1690
    {
1691
      if (lookup->constraint < 0)
1692
        continue;
1693
 
1694
      if (lookup->bfd_section != NULL && lookup->bfd_section->owner != NULL)
1695
        return lookup->bfd_section;
1696
    }
1697
 
1698
  return NULL;
1699
}
1700
 
1701
/* Look for a suitable place for a new output section statement.  The
1702
   idea is to skip over anything that might be inside a SECTIONS {}
1703
   statement in a script, before we find another output section
1704
   statement.  Assignments to "dot" before an output section statement
1705
   are assumed to belong to it, except in two cases;  The first
1706
   assignment to dot, and assignments before non-alloc sections.
1707
   Otherwise we might put an orphan before . = . + SIZEOF_HEADERS or
1708
   similar assignments that set the initial address, or we might
1709
   insert non-alloc note sections among assignments setting end of
1710
   image symbols.  */
1711
 
1712
static lang_statement_union_type **
1713
insert_os_after (lang_output_section_statement_type *after)
1714
{
1715
  lang_statement_union_type **where;
1716
  lang_statement_union_type **assign = NULL;
1717
  bfd_boolean ignore_first;
1718
 
1719
  ignore_first
1720
    = after == &lang_output_section_statement.head->output_section_statement;
1721
 
1722
  for (where = &after->header.next;
1723
       *where != NULL;
1724
       where = &(*where)->header.next)
1725
    {
1726
      switch ((*where)->header.type)
1727
        {
1728
        case lang_assignment_statement_enum:
1729
          if (assign == NULL)
1730
            {
1731
              lang_assignment_statement_type *ass;
1732
 
1733
              ass = &(*where)->assignment_statement;
1734
              if (ass->exp->type.node_class != etree_assert
1735
                  && ass->exp->assign.dst[0] == '.'
1736
                  && ass->exp->assign.dst[1] == 0
1737
                  && !ignore_first)
1738
                assign = where;
1739
            }
1740
          ignore_first = FALSE;
1741
          continue;
1742
        case lang_wild_statement_enum:
1743
        case lang_input_section_enum:
1744
        case lang_object_symbols_statement_enum:
1745
        case lang_fill_statement_enum:
1746
        case lang_data_statement_enum:
1747
        case lang_reloc_statement_enum:
1748
        case lang_padding_statement_enum:
1749
        case lang_constructors_statement_enum:
1750
          assign = NULL;
1751
          continue;
1752
        case lang_output_section_statement_enum:
1753
          if (assign != NULL)
1754
            {
1755
              asection *s = (*where)->output_section_statement.bfd_section;
1756
 
1757
              if (s == NULL
1758
                  || s->map_head.s == NULL
1759
                  || (s->flags & SEC_ALLOC) != 0)
1760
                where = assign;
1761
            }
1762
          break;
1763
        case lang_input_statement_enum:
1764
        case lang_address_statement_enum:
1765
        case lang_target_statement_enum:
1766
        case lang_output_statement_enum:
1767
        case lang_group_statement_enum:
1768
        case lang_insert_statement_enum:
1769
          continue;
1770
        }
1771
      break;
1772
    }
1773
 
1774
  return where;
1775
}
1776
 
1777
lang_output_section_statement_type *
1778
lang_insert_orphan (asection *s,
1779
                    const char *secname,
1780
                    int constraint,
1781
                    lang_output_section_statement_type *after,
1782
                    struct orphan_save *place,
1783
                    etree_type *address,
1784
                    lang_statement_list_type *add_child)
1785
{
1786
  lang_statement_list_type add;
1787
  const char *ps;
1788
  lang_output_section_statement_type *os;
1789
  lang_output_section_statement_type **os_tail;
1790
 
1791
  /* If we have found an appropriate place for the output section
1792
     statements for this orphan, add them to our own private list,
1793
     inserting them later into the global statement list.  */
1794
  if (after != NULL)
1795
    {
1796
      lang_list_init (&add);
1797
      push_stat_ptr (&add);
1798
    }
1799
 
1800
  if (link_info.relocatable || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0)
1801
    address = exp_intop (0);
1802
 
1803
  os_tail = ((lang_output_section_statement_type **)
1804
             lang_output_section_statement.tail);
1805
  os = lang_enter_output_section_statement (secname, address, normal_section,
1806
                                            NULL, NULL, NULL, constraint);
1807
 
1808
  ps = NULL;
1809
  if (config.build_constructors && *os_tail == os)
1810
    {
1811
      /* If the name of the section is representable in C, then create
1812
         symbols to mark the start and the end of the section.  */
1813
      for (ps = secname; *ps != '\0'; ps++)
1814
        if (! ISALNUM ((unsigned char) *ps) && *ps != '_')
1815
          break;
1816
      if (*ps == '\0')
1817
        {
1818
          char *symname;
1819
          etree_type *e_align;
1820
 
1821
          symname = (char *) xmalloc (ps - secname + sizeof "__start_" + 1);
1822
          symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1823
          sprintf (symname + (symname[0] != 0), "__start_%s", secname);
1824
          e_align = exp_unop (ALIGN_K,
1825
                              exp_intop ((bfd_vma) 1 << s->alignment_power));
1826
          lang_add_assignment (exp_assign (".", e_align));
1827
          lang_add_assignment (exp_provide (symname,
1828
                                            exp_unop (ABSOLUTE,
1829
                                                      exp_nameop (NAME, ".")),
1830
                                            FALSE));
1831
        }
1832
    }
1833
 
1834
  if (add_child == NULL)
1835
    add_child = &os->children;
1836
  lang_add_section (add_child, s, os);
1837
 
1838
  if (after && (s->flags & (SEC_LOAD | SEC_ALLOC)) != 0)
1839
    {
1840
      const char *region = (after->region
1841
                            ? after->region->name_list.name
1842
                            : DEFAULT_MEMORY_REGION);
1843
      const char *lma_region = (after->lma_region
1844
                                ? after->lma_region->name_list.name
1845
                                : NULL);
1846
      lang_leave_output_section_statement (NULL, region, after->phdrs,
1847
                                           lma_region);
1848
    }
1849
  else
1850
    lang_leave_output_section_statement (NULL, DEFAULT_MEMORY_REGION, NULL,
1851
                                         NULL);
1852
 
1853
  if (ps != NULL && *ps == '\0')
1854
    {
1855
      char *symname;
1856
 
1857
      symname = (char *) xmalloc (ps - secname + sizeof "__stop_" + 1);
1858
      symname[0] = bfd_get_symbol_leading_char (link_info.output_bfd);
1859
      sprintf (symname + (symname[0] != 0), "__stop_%s", secname);
1860
      lang_add_assignment (exp_provide (symname,
1861
                                        exp_nameop (NAME, "."),
1862
                                        FALSE));
1863
    }
1864
 
1865
  /* Restore the global list pointer.  */
1866
  if (after != NULL)
1867
    pop_stat_ptr ();
1868
 
1869
  if (after != NULL && os->bfd_section != NULL)
1870
    {
1871
      asection *snew, *as;
1872
 
1873
      snew = os->bfd_section;
1874
 
1875
      /* Shuffle the bfd section list to make the output file look
1876
         neater.  This is really only cosmetic.  */
1877
      if (place->section == NULL
1878
          && after != (&lang_output_section_statement.head
1879
                       ->output_section_statement))
1880
        {
1881
          asection *bfd_section = after->bfd_section;
1882
 
1883
          /* If the output statement hasn't been used to place any input
1884
             sections (and thus doesn't have an output bfd_section),
1885
             look for the closest prior output statement having an
1886
             output section.  */
1887
          if (bfd_section == NULL)
1888
            bfd_section = output_prev_sec_find (after);
1889
 
1890
          if (bfd_section != NULL && bfd_section != snew)
1891
            place->section = &bfd_section->next;
1892
        }
1893
 
1894
      if (place->section == NULL)
1895
        place->section = &link_info.output_bfd->sections;
1896
 
1897
      as = *place->section;
1898
 
1899
      if (!as)
1900
        {
1901
          /* Put the section at the end of the list.  */
1902
 
1903
          /* Unlink the section.  */
1904
          bfd_section_list_remove (link_info.output_bfd, snew);
1905
 
1906
          /* Now tack it back on in the right place.  */
1907
          bfd_section_list_append (link_info.output_bfd, snew);
1908
        }
1909
      else if (as != snew && as->prev != snew)
1910
        {
1911
          /* Unlink the section.  */
1912
          bfd_section_list_remove (link_info.output_bfd, snew);
1913
 
1914
          /* Now tack it back on in the right place.  */
1915
          bfd_section_list_insert_before (link_info.output_bfd, as, snew);
1916
        }
1917
 
1918
      /* Save the end of this list.  Further ophans of this type will
1919
         follow the one we've just added.  */
1920
      place->section = &snew->next;
1921
 
1922
      /* The following is non-cosmetic.  We try to put the output
1923
         statements in some sort of reasonable order here, because they
1924
         determine the final load addresses of the orphan sections.
1925
         In addition, placing output statements in the wrong order may
1926
         require extra segments.  For instance, given a typical
1927
         situation of all read-only sections placed in one segment and
1928
         following that a segment containing all the read-write
1929
         sections, we wouldn't want to place an orphan read/write
1930
         section before or amongst the read-only ones.  */
1931
      if (add.head != NULL)
1932
        {
1933
          lang_output_section_statement_type *newly_added_os;
1934
 
1935
          if (place->stmt == NULL)
1936
            {
1937
              lang_statement_union_type **where = insert_os_after (after);
1938
 
1939
              *add.tail = *where;
1940
              *where = add.head;
1941
 
1942
              place->os_tail = &after->next;
1943
            }
1944
          else
1945
            {
1946
              /* Put it after the last orphan statement we added.  */
1947
              *add.tail = *place->stmt;
1948
              *place->stmt = add.head;
1949
            }
1950
 
1951
          /* Fix the global list pointer if we happened to tack our
1952
             new list at the tail.  */
1953
          if (*stat_ptr->tail == add.head)
1954
            stat_ptr->tail = add.tail;
1955
 
1956
          /* Save the end of this list.  */
1957
          place->stmt = add.tail;
1958
 
1959
          /* Do the same for the list of output section statements.  */
1960
          newly_added_os = *os_tail;
1961
          *os_tail = NULL;
1962
          newly_added_os->prev = (lang_output_section_statement_type *)
1963
            ((char *) place->os_tail
1964
             - offsetof (lang_output_section_statement_type, next));
1965
          newly_added_os->next = *place->os_tail;
1966
          if (newly_added_os->next != NULL)
1967
            newly_added_os->next->prev = newly_added_os;
1968
          *place->os_tail = newly_added_os;
1969
          place->os_tail = &newly_added_os->next;
1970
 
1971
          /* Fixing the global list pointer here is a little different.
1972
             We added to the list in lang_enter_output_section_statement,
1973
             trimmed off the new output_section_statment above when
1974
             assigning *os_tail = NULL, but possibly added it back in
1975
             the same place when assigning *place->os_tail.  */
1976
          if (*os_tail == NULL)
1977
            lang_output_section_statement.tail
1978
              = (lang_statement_union_type **) os_tail;
1979
        }
1980
    }
1981
  return os;
1982
}
1983
 
1984
static void
1985
lang_map_flags (flagword flag)
1986
{
1987
  if (flag & SEC_ALLOC)
1988
    minfo ("a");
1989
 
1990
  if (flag & SEC_CODE)
1991
    minfo ("x");
1992
 
1993
  if (flag & SEC_READONLY)
1994
    minfo ("r");
1995
 
1996
  if (flag & SEC_DATA)
1997
    minfo ("w");
1998
 
1999
  if (flag & SEC_LOAD)
2000
    minfo ("l");
2001
}
2002
 
2003
void
2004
lang_map (void)
2005
{
2006
  lang_memory_region_type *m;
2007
  bfd_boolean dis_header_printed = FALSE;
2008
  bfd *p;
2009
 
2010
  LANG_FOR_EACH_INPUT_STATEMENT (file)
2011
    {
2012
      asection *s;
2013
 
2014
      if ((file->the_bfd->flags & (BFD_LINKER_CREATED | DYNAMIC)) != 0
2015
          || file->just_syms_flag)
2016
        continue;
2017
 
2018
      for (s = file->the_bfd->sections; s != NULL; s = s->next)
2019
        if ((s->output_section == NULL
2020
             || s->output_section->owner != link_info.output_bfd)
2021
            && (s->flags & (SEC_LINKER_CREATED | SEC_KEEP)) == 0)
2022
          {
2023
            if (! dis_header_printed)
2024
              {
2025
                fprintf (config.map_file, _("\nDiscarded input sections\n\n"));
2026
                dis_header_printed = TRUE;
2027
              }
2028
 
2029
            print_input_section (s, TRUE);
2030
          }
2031
    }
2032
 
2033
  minfo (_("\nMemory Configuration\n\n"));
2034
  fprintf (config.map_file, "%-16s %-18s %-18s %s\n",
2035
           _("Name"), _("Origin"), _("Length"), _("Attributes"));
2036
 
2037
  for (m = lang_memory_region_list; m != NULL; m = m->next)
2038
    {
2039
      char buf[100];
2040
      int len;
2041
 
2042
      fprintf (config.map_file, "%-16s ", m->name_list.name);
2043
 
2044
      sprintf_vma (buf, m->origin);
2045
      minfo ("0x%s ", buf);
2046
      len = strlen (buf);
2047
      while (len < 16)
2048
        {
2049
          print_space ();
2050
          ++len;
2051
        }
2052
 
2053
      minfo ("0x%V", m->length);
2054
      if (m->flags || m->not_flags)
2055
        {
2056
#ifndef BFD64
2057
          minfo ("        ");
2058
#endif
2059
          if (m->flags)
2060
            {
2061
              print_space ();
2062
              lang_map_flags (m->flags);
2063
            }
2064
 
2065
          if (m->not_flags)
2066
            {
2067
              minfo (" !");
2068
              lang_map_flags (m->not_flags);
2069
            }
2070
        }
2071
 
2072
      print_nl ();
2073
    }
2074
 
2075
  fprintf (config.map_file, _("\nLinker script and memory map\n\n"));
2076
 
2077
  if (! link_info.reduce_memory_overheads)
2078
    {
2079
      obstack_begin (&map_obstack, 1000);
2080
      for (p = link_info.input_bfds; p != (bfd *) NULL; p = p->link_next)
2081
        bfd_map_over_sections (p, init_map_userdata, 0);
2082
      bfd_link_hash_traverse (link_info.hash, sort_def_symbol, 0);
2083
    }
2084
  lang_statement_iteration ++;
2085
  print_statements ();
2086
}
2087
 
2088
static void
2089
init_map_userdata (bfd *abfd ATTRIBUTE_UNUSED,
2090
                   asection *sec,
2091
                   void *data ATTRIBUTE_UNUSED)
2092
{
2093
  fat_section_userdata_type *new_data
2094
    = ((fat_section_userdata_type *) (stat_alloc
2095
                                      (sizeof (fat_section_userdata_type))));
2096
 
2097
  ASSERT (get_userdata (sec) == NULL);
2098
  get_userdata (sec) = new_data;
2099
  new_data->map_symbol_def_tail = &new_data->map_symbol_def_head;
2100
  new_data->map_symbol_def_count = 0;
2101
}
2102
 
2103
static bfd_boolean
2104
sort_def_symbol (struct bfd_link_hash_entry *hash_entry,
2105
                 void *info ATTRIBUTE_UNUSED)
2106
{
2107
  if (hash_entry->type == bfd_link_hash_defined
2108
      || hash_entry->type == bfd_link_hash_defweak)
2109
    {
2110
      struct fat_user_section_struct *ud;
2111
      struct map_symbol_def *def;
2112
 
2113
      ud = (struct fat_user_section_struct *)
2114
          get_userdata (hash_entry->u.def.section);
2115
      if  (! ud)
2116
        {
2117
          /* ??? What do we have to do to initialize this beforehand?  */
2118
          /* The first time we get here is bfd_abs_section...  */
2119
          init_map_userdata (0, hash_entry->u.def.section, 0);
2120
          ud = (struct fat_user_section_struct *)
2121
              get_userdata (hash_entry->u.def.section);
2122
        }
2123
      else if  (!ud->map_symbol_def_tail)
2124
        ud->map_symbol_def_tail = &ud->map_symbol_def_head;
2125
 
2126
      def = (struct map_symbol_def *) obstack_alloc (&map_obstack, sizeof *def);
2127
      def->entry = hash_entry;
2128
      *(ud->map_symbol_def_tail) = def;
2129
      ud->map_symbol_def_tail = &def->next;
2130
      ud->map_symbol_def_count++;
2131
    }
2132
  return TRUE;
2133
}
2134
 
2135
/* Initialize an output section.  */
2136
 
2137
static void
2138
init_os (lang_output_section_statement_type *s, flagword flags)
2139
{
2140
  if (strcmp (s->name, DISCARD_SECTION_NAME) == 0)
2141
    einfo (_("%P%F: Illegal use of `%s' section\n"), DISCARD_SECTION_NAME);
2142
 
2143
  if (s->constraint != SPECIAL)
2144
    s->bfd_section = bfd_get_section_by_name (link_info.output_bfd, s->name);
2145
  if (s->bfd_section == NULL)
2146
    s->bfd_section = bfd_make_section_anyway_with_flags (link_info.output_bfd,
2147
                                                         s->name, flags);
2148
  if (s->bfd_section == NULL)
2149
    {
2150
      einfo (_("%P%F: output format %s cannot represent section called %s\n"),
2151
             link_info.output_bfd->xvec->name, s->name);
2152
    }
2153
  s->bfd_section->output_section = s->bfd_section;
2154
  s->bfd_section->output_offset = 0;
2155
 
2156
  if (!link_info.reduce_memory_overheads)
2157
    {
2158
      fat_section_userdata_type *new_userdata = (fat_section_userdata_type *)
2159
        stat_alloc (sizeof (fat_section_userdata_type));
2160
      memset (new_userdata, 0, sizeof (fat_section_userdata_type));
2161
      get_userdata (s->bfd_section) = new_userdata;
2162
    }
2163
 
2164
  /* If there is a base address, make sure that any sections it might
2165
     mention are initialized.  */
2166
  if (s->addr_tree != NULL)
2167
    exp_init_os (s->addr_tree);
2168
 
2169
  if (s->load_base != NULL)
2170
    exp_init_os (s->load_base);
2171
 
2172
  /* If supplied an alignment, set it.  */
2173
  if (s->section_alignment != -1)
2174
    s->bfd_section->alignment_power = s->section_alignment;
2175
}
2176
 
2177
/* Make sure that all output sections mentioned in an expression are
2178
   initialized.  */
2179
 
2180
static void
2181
exp_init_os (etree_type *exp)
2182
{
2183
  switch (exp->type.node_class)
2184
    {
2185
    case etree_assign:
2186
    case etree_provide:
2187
      exp_init_os (exp->assign.src);
2188
      break;
2189
 
2190
    case etree_binary:
2191
      exp_init_os (exp->binary.lhs);
2192
      exp_init_os (exp->binary.rhs);
2193
      break;
2194
 
2195
    case etree_trinary:
2196
      exp_init_os (exp->trinary.cond);
2197
      exp_init_os (exp->trinary.lhs);
2198
      exp_init_os (exp->trinary.rhs);
2199
      break;
2200
 
2201
    case etree_assert:
2202
      exp_init_os (exp->assert_s.child);
2203
      break;
2204
 
2205
    case etree_unary:
2206
      exp_init_os (exp->unary.child);
2207
      break;
2208
 
2209
    case etree_name:
2210
      switch (exp->type.node_code)
2211
        {
2212
        case ADDR:
2213
        case LOADADDR:
2214
        case SIZEOF:
2215
          {
2216
            lang_output_section_statement_type *os;
2217
 
2218
            os = lang_output_section_find (exp->name.name);
2219
            if (os != NULL && os->bfd_section == NULL)
2220
              init_os (os, 0);
2221
          }
2222
        }
2223
      break;
2224
 
2225
    default:
2226
      break;
2227
    }
2228
}
2229
 
2230
static void
2231
section_already_linked (bfd *abfd, asection *sec, void *data)
2232
{
2233
  lang_input_statement_type *entry = (lang_input_statement_type *) data;
2234
 
2235
  /* If we are only reading symbols from this object, then we want to
2236
     discard all sections.  */
2237
  if (entry->just_syms_flag)
2238
    {
2239
      bfd_link_just_syms (abfd, sec, &link_info);
2240
      return;
2241
    }
2242
 
2243
  if (!(abfd->flags & DYNAMIC))
2244
    bfd_section_already_linked (abfd, sec, &link_info);
2245
}
2246
 
2247
/* The wild routines.
2248
 
2249
   These expand statements like *(.text) and foo.o to a list of
2250
   explicit actions, like foo.o(.text), bar.o(.text) and
2251
   foo.o(.text, .data).  */
2252
 
2253
/* Add SECTION to the output section OUTPUT.  Do this by creating a
2254
   lang_input_section statement which is placed at PTR.  FILE is the
2255
   input file which holds SECTION.  */
2256
 
2257
void
2258
lang_add_section (lang_statement_list_type *ptr,
2259
                  asection *section,
2260
                  lang_output_section_statement_type *output)
2261
{
2262
  flagword flags = section->flags;
2263 157 khays
  struct flag_info *sflag_info = section->section_flag_info;
2264
 
2265 145 khays
  bfd_boolean discard;
2266
  lang_input_section_type *new_section;
2267 157 khays
  bfd *abfd = link_info.output_bfd;
2268 145 khays
 
2269
  /* Discard sections marked with SEC_EXCLUDE.  */
2270
  discard = (flags & SEC_EXCLUDE) != 0;
2271
 
2272
  /* Discard input sections which are assigned to a section named
2273
     DISCARD_SECTION_NAME.  */
2274
  if (strcmp (output->name, DISCARD_SECTION_NAME) == 0)
2275
    discard = TRUE;
2276
 
2277
  /* Discard debugging sections if we are stripping debugging
2278
     information.  */
2279
  if ((link_info.strip == strip_debugger || link_info.strip == strip_all)
2280
      && (flags & SEC_DEBUGGING) != 0)
2281
    discard = TRUE;
2282
 
2283
  if (discard)
2284
    {
2285
      if (section->output_section == NULL)
2286
        {
2287
          /* This prevents future calls from assigning this section.  */
2288
          section->output_section = bfd_abs_section_ptr;
2289
        }
2290
      return;
2291
    }
2292
 
2293 157 khays
  if (sflag_info)
2294
    {
2295
      if (sflag_info->flags_initialized == FALSE)
2296
        bfd_lookup_section_flags (&link_info, sflag_info);
2297
 
2298
      if (sflag_info->only_with_flags != 0
2299
          && sflag_info->not_with_flags != 0
2300
          && ((sflag_info->not_with_flags & flags) != 0
2301
               || (sflag_info->only_with_flags & flags)
2302
                   != sflag_info->only_with_flags))
2303
        return;
2304
 
2305
      if (sflag_info->only_with_flags != 0
2306
          && (sflag_info->only_with_flags & flags)
2307
              != sflag_info->only_with_flags)
2308
        return;
2309
 
2310
      if (sflag_info->not_with_flags != 0
2311
          && (sflag_info->not_with_flags & flags) != 0)
2312
        return;
2313
    }
2314
 
2315 145 khays
  if (section->output_section != NULL)
2316
    return;
2317
 
2318
  /* We don't copy the SEC_NEVER_LOAD flag from an input section
2319
     to an output section, because we want to be able to include a
2320
     SEC_NEVER_LOAD section in the middle of an otherwise loaded
2321
     section (I don't know why we want to do this, but we do).
2322
     build_link_order in ldwrite.c handles this case by turning
2323
     the embedded SEC_NEVER_LOAD section into a fill.  */
2324
  flags &= ~ SEC_NEVER_LOAD;
2325
 
2326
  /* If final link, don't copy the SEC_LINK_ONCE flags, they've
2327
     already been processed.  One reason to do this is that on pe
2328
     format targets, .text$foo sections go into .text and it's odd
2329
     to see .text with SEC_LINK_ONCE set.  */
2330
 
2331
  if (!link_info.relocatable)
2332
    flags &= ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC);
2333
 
2334
  switch (output->sectype)
2335
    {
2336
    case normal_section:
2337
    case overlay_section:
2338
      break;
2339
    case noalloc_section:
2340
      flags &= ~SEC_ALLOC;
2341
      break;
2342
    case noload_section:
2343
      flags &= ~SEC_LOAD;
2344
      flags |= SEC_NEVER_LOAD;
2345
      /* Unfortunately GNU ld has managed to evolve two different
2346
         meanings to NOLOAD in scripts.  ELF gets a .bss style noload,
2347
         alloc, no contents section.  All others get a noload, noalloc
2348
         section.  */
2349
      if (bfd_get_flavour (link_info.output_bfd) == bfd_target_elf_flavour)
2350
        flags &= ~SEC_HAS_CONTENTS;
2351
      else
2352
        flags &= ~SEC_ALLOC;
2353
      break;
2354
    }
2355
 
2356
  if (output->bfd_section == NULL)
2357
    init_os (output, flags);
2358
 
2359
  /* If SEC_READONLY is not set in the input section, then clear
2360
     it from the output section.  */
2361
  output->bfd_section->flags &= flags | ~SEC_READONLY;
2362
 
2363
  if (output->bfd_section->linker_has_input)
2364
    {
2365
      /* Only set SEC_READONLY flag on the first input section.  */
2366
      flags &= ~ SEC_READONLY;
2367
 
2368
      /* Keep SEC_MERGE and SEC_STRINGS only if they are the same.  */
2369
      if ((output->bfd_section->flags & (SEC_MERGE | SEC_STRINGS))
2370
          != (flags & (SEC_MERGE | SEC_STRINGS))
2371
          || ((flags & SEC_MERGE) != 0
2372
              && output->bfd_section->entsize != section->entsize))
2373
        {
2374
          output->bfd_section->flags &= ~ (SEC_MERGE | SEC_STRINGS);
2375
          flags &= ~ (SEC_MERGE | SEC_STRINGS);
2376
        }
2377
    }
2378
  output->bfd_section->flags |= flags;
2379
 
2380
  if (!output->bfd_section->linker_has_input)
2381
    {
2382
      output->bfd_section->linker_has_input = 1;
2383
      /* This must happen after flags have been updated.  The output
2384
         section may have been created before we saw its first input
2385
         section, eg. for a data statement.  */
2386
      bfd_init_private_section_data (section->owner, section,
2387
                                     link_info.output_bfd,
2388
                                     output->bfd_section,
2389
                                     &link_info);
2390
      if ((flags & SEC_MERGE) != 0)
2391
        output->bfd_section->entsize = section->entsize;
2392
    }
2393
 
2394
  if ((flags & SEC_TIC54X_BLOCK) != 0
2395
      && bfd_get_arch (section->owner) == bfd_arch_tic54x)
2396
    {
2397
      /* FIXME: This value should really be obtained from the bfd...  */
2398
      output->block_value = 128;
2399
    }
2400
 
2401
  if (section->alignment_power > output->bfd_section->alignment_power)
2402
    output->bfd_section->alignment_power = section->alignment_power;
2403
 
2404
  section->output_section = output->bfd_section;
2405
 
2406
  if (!link_info.relocatable
2407
      && !stripped_excluded_sections)
2408
    {
2409
      asection *s = output->bfd_section->map_tail.s;
2410
      output->bfd_section->map_tail.s = section;
2411
      section->map_head.s = NULL;
2412
      section->map_tail.s = s;
2413
      if (s != NULL)
2414
        s->map_head.s = section;
2415
      else
2416
        output->bfd_section->map_head.s = section;
2417
    }
2418
 
2419
  /* Add a section reference to the list.  */
2420
  new_section = new_stat (lang_input_section, ptr);
2421
  new_section->section = section;
2422
}
2423
 
2424
/* Handle wildcard sorting.  This returns the lang_input_section which
2425
   should follow the one we are going to create for SECTION and FILE,
2426
   based on the sorting requirements of WILD.  It returns NULL if the
2427
   new section should just go at the end of the current list.  */
2428
 
2429
static lang_statement_union_type *
2430
wild_sort (lang_wild_statement_type *wild,
2431
           struct wildcard_list *sec,
2432
           lang_input_statement_type *file,
2433
           asection *section)
2434
{
2435
  lang_statement_union_type *l;
2436
 
2437
  if (!wild->filenames_sorted
2438
      && (sec == NULL || sec->spec.sorted == none))
2439
    return NULL;
2440
 
2441
  for (l = wild->children.head; l != NULL; l = l->header.next)
2442
    {
2443
      lang_input_section_type *ls;
2444
 
2445
      if (l->header.type != lang_input_section_enum)
2446
        continue;
2447
      ls = &l->input_section;
2448
 
2449
      /* Sorting by filename takes precedence over sorting by section
2450
         name.  */
2451
 
2452
      if (wild->filenames_sorted)
2453
        {
2454
          const char *fn, *ln;
2455
          bfd_boolean fa, la;
2456
          int i;
2457
 
2458
          /* The PE support for the .idata section as generated by
2459
             dlltool assumes that files will be sorted by the name of
2460
             the archive and then the name of the file within the
2461
             archive.  */
2462
 
2463
          if (file->the_bfd != NULL
2464
              && bfd_my_archive (file->the_bfd) != NULL)
2465
            {
2466
              fn = bfd_get_filename (bfd_my_archive (file->the_bfd));
2467
              fa = TRUE;
2468
            }
2469
          else
2470
            {
2471
              fn = file->filename;
2472
              fa = FALSE;
2473
            }
2474
 
2475
          if (bfd_my_archive (ls->section->owner) != NULL)
2476
            {
2477
              ln = bfd_get_filename (bfd_my_archive (ls->section->owner));
2478
              la = TRUE;
2479
            }
2480
          else
2481
            {
2482
              ln = ls->section->owner->filename;
2483
              la = FALSE;
2484
            }
2485
 
2486
          i = filename_cmp (fn, ln);
2487
          if (i > 0)
2488
            continue;
2489
          else if (i < 0)
2490
            break;
2491
 
2492
          if (fa || la)
2493
            {
2494
              if (fa)
2495
                fn = file->filename;
2496
              if (la)
2497
                ln = ls->section->owner->filename;
2498
 
2499
              i = filename_cmp (fn, ln);
2500
              if (i > 0)
2501
                continue;
2502
              else if (i < 0)
2503
                break;
2504
            }
2505
        }
2506
 
2507
      /* Here either the files are not sorted by name, or we are
2508
         looking at the sections for this file.  */
2509
 
2510
      if (sec != NULL && sec->spec.sorted != none)
2511
        if (compare_section (sec->spec.sorted, section, ls->section) < 0)
2512
          break;
2513
    }
2514
 
2515
  return l;
2516
}
2517
 
2518
/* Expand a wild statement for a particular FILE.  SECTION may be
2519
   NULL, in which case it is a wild card.  */
2520
 
2521
static void
2522
output_section_callback (lang_wild_statement_type *ptr,
2523
                         struct wildcard_list *sec,
2524
                         asection *section,
2525
                         lang_input_statement_type *file,
2526
                         void *output)
2527
{
2528
  lang_statement_union_type *before;
2529
  lang_output_section_statement_type *os;
2530
 
2531
  os = (lang_output_section_statement_type *) output;
2532
 
2533
  /* Exclude sections that match UNIQUE_SECTION_LIST.  */
2534
  if (unique_section_p (section, os))
2535
    return;
2536
 
2537
  before = wild_sort (ptr, sec, file, section);
2538
 
2539
  /* Here BEFORE points to the lang_input_section which
2540
     should follow the one we are about to add.  If BEFORE
2541
     is NULL, then the section should just go at the end
2542
     of the current list.  */
2543
 
2544
  if (before == NULL)
2545
    lang_add_section (&ptr->children, section, os);
2546
  else
2547
    {
2548
      lang_statement_list_type list;
2549
      lang_statement_union_type **pp;
2550
 
2551
      lang_list_init (&list);
2552
      lang_add_section (&list, section, os);
2553
 
2554
      /* If we are discarding the section, LIST.HEAD will
2555
         be NULL.  */
2556
      if (list.head != NULL)
2557
        {
2558
          ASSERT (list.head->header.next == NULL);
2559
 
2560
          for (pp = &ptr->children.head;
2561
               *pp != before;
2562
               pp = &(*pp)->header.next)
2563
            ASSERT (*pp != NULL);
2564
 
2565
          list.head->header.next = *pp;
2566
          *pp = list.head;
2567
        }
2568
    }
2569
}
2570
 
2571
/* Check if all sections in a wild statement for a particular FILE
2572
   are readonly.  */
2573
 
2574
static void
2575
check_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
2576
                        struct wildcard_list *sec ATTRIBUTE_UNUSED,
2577
                        asection *section,
2578
                        lang_input_statement_type *file ATTRIBUTE_UNUSED,
2579
                        void *output)
2580
{
2581
  lang_output_section_statement_type *os;
2582
 
2583
  os = (lang_output_section_statement_type *) output;
2584
 
2585
  /* Exclude sections that match UNIQUE_SECTION_LIST.  */
2586
  if (unique_section_p (section, os))
2587
    return;
2588
 
2589
  if (section->output_section == NULL && (section->flags & SEC_READONLY) == 0)
2590
    os->all_input_readonly = FALSE;
2591
}
2592
 
2593
/* This is passed a file name which must have been seen already and
2594
   added to the statement tree.  We will see if it has been opened
2595
   already and had its symbols read.  If not then we'll read it.  */
2596
 
2597
static lang_input_statement_type *
2598
lookup_name (const char *name)
2599
{
2600
  lang_input_statement_type *search;
2601
 
2602
  for (search = (lang_input_statement_type *) input_file_chain.head;
2603
       search != NULL;
2604
       search = (lang_input_statement_type *) search->next_real_file)
2605
    {
2606
      /* Use the local_sym_name as the name of the file that has
2607
         already been loaded as filename might have been transformed
2608
         via the search directory lookup mechanism.  */
2609
      const char *filename = search->local_sym_name;
2610
 
2611
      if (filename != NULL
2612
          && filename_cmp (filename, name) == 0)
2613
        break;
2614
    }
2615
 
2616
  if (search == NULL)
2617
    search = new_afile (name, lang_input_file_is_search_file_enum,
2618
                        default_target, FALSE);
2619
 
2620
  /* If we have already added this file, or this file is not real
2621
     don't add this file.  */
2622
  if (search->loaded || !search->real)
2623
    return search;
2624
 
2625
  if (! load_symbols (search, NULL))
2626
    return NULL;
2627
 
2628
  return search;
2629
}
2630
 
2631
/* Save LIST as a list of libraries whose symbols should not be exported.  */
2632
 
2633
struct excluded_lib
2634
{
2635
  char *name;
2636
  struct excluded_lib *next;
2637
};
2638
static struct excluded_lib *excluded_libs;
2639
 
2640
void
2641
add_excluded_libs (const char *list)
2642
{
2643
  const char *p = list, *end;
2644
 
2645
  while (*p != '\0')
2646
    {
2647
      struct excluded_lib *entry;
2648
      end = strpbrk (p, ",:");
2649
      if (end == NULL)
2650
        end = p + strlen (p);
2651
      entry = (struct excluded_lib *) xmalloc (sizeof (*entry));
2652
      entry->next = excluded_libs;
2653
      entry->name = (char *) xmalloc (end - p + 1);
2654
      memcpy (entry->name, p, end - p);
2655
      entry->name[end - p] = '\0';
2656
      excluded_libs = entry;
2657
      if (*end == '\0')
2658
        break;
2659
      p = end + 1;
2660
    }
2661
}
2662
 
2663
static void
2664
check_excluded_libs (bfd *abfd)
2665
{
2666
  struct excluded_lib *lib = excluded_libs;
2667
 
2668
  while (lib)
2669
    {
2670
      int len = strlen (lib->name);
2671
      const char *filename = lbasename (abfd->filename);
2672
 
2673
      if (strcmp (lib->name, "ALL") == 0)
2674
        {
2675
          abfd->no_export = TRUE;
2676
          return;
2677
        }
2678
 
2679
      if (filename_ncmp (lib->name, filename, len) == 0
2680
          && (filename[len] == '\0'
2681
              || (filename[len] == '.' && filename[len + 1] == 'a'
2682
                  && filename[len + 2] == '\0')))
2683
        {
2684
          abfd->no_export = TRUE;
2685
          return;
2686
        }
2687
 
2688
      lib = lib->next;
2689
    }
2690
}
2691
 
2692
/* Get the symbols for an input file.  */
2693
 
2694
bfd_boolean
2695
load_symbols (lang_input_statement_type *entry,
2696
              lang_statement_list_type *place)
2697
{
2698
  char **matching;
2699
 
2700
  if (entry->loaded)
2701
    return TRUE;
2702
 
2703
  ldfile_open_file (entry);
2704
 
2705
  /* Do not process further if the file was missing.  */
2706
  if (entry->missing_file)
2707
    return TRUE;
2708
 
2709
  if (! bfd_check_format (entry->the_bfd, bfd_archive)
2710
      && ! bfd_check_format_matches (entry->the_bfd, bfd_object, &matching))
2711
    {
2712
      bfd_error_type err;
2713
      bfd_boolean save_ldlang_sysrooted_script;
2714
      bfd_boolean save_add_DT_NEEDED_for_regular;
2715
      bfd_boolean save_add_DT_NEEDED_for_dynamic;
2716
      bfd_boolean save_whole_archive;
2717
 
2718
      err = bfd_get_error ();
2719
 
2720
      /* See if the emulation has some special knowledge.  */
2721
      if (ldemul_unrecognized_file (entry))
2722
        return TRUE;
2723
 
2724
      if (err == bfd_error_file_ambiguously_recognized)
2725
        {
2726
          char **p;
2727
 
2728
          einfo (_("%B: file not recognized: %E\n"), entry->the_bfd);
2729
          einfo (_("%B: matching formats:"), entry->the_bfd);
2730
          for (p = matching; *p != NULL; p++)
2731
            einfo (" %s", *p);
2732
          einfo ("%F\n");
2733
        }
2734
      else if (err != bfd_error_file_not_recognized
2735
               || place == NULL)
2736
        einfo (_("%F%B: file not recognized: %E\n"), entry->the_bfd);
2737
 
2738
      bfd_close (entry->the_bfd);
2739
      entry->the_bfd = NULL;
2740
 
2741
      /* Try to interpret the file as a linker script.  */
2742
      ldfile_open_command_file (entry->filename);
2743
 
2744
      push_stat_ptr (place);
2745
      save_ldlang_sysrooted_script = ldlang_sysrooted_script;
2746
      ldlang_sysrooted_script = entry->sysrooted;
2747
      save_add_DT_NEEDED_for_regular = add_DT_NEEDED_for_regular;
2748
      add_DT_NEEDED_for_regular = entry->add_DT_NEEDED_for_regular;
2749
      save_add_DT_NEEDED_for_dynamic = add_DT_NEEDED_for_dynamic;
2750
      add_DT_NEEDED_for_dynamic = entry->add_DT_NEEDED_for_dynamic;
2751
      save_whole_archive = whole_archive;
2752
      whole_archive = entry->whole_archive;
2753
 
2754
      ldfile_assumed_script = TRUE;
2755
      parser_input = input_script;
2756
      /* We want to use the same -Bdynamic/-Bstatic as the one for
2757
         ENTRY.  */
2758
      config.dynamic_link = entry->dynamic;
2759
      yyparse ();
2760
      ldfile_assumed_script = FALSE;
2761
 
2762
      ldlang_sysrooted_script = save_ldlang_sysrooted_script;
2763
      add_DT_NEEDED_for_regular = save_add_DT_NEEDED_for_regular;
2764
      add_DT_NEEDED_for_dynamic = save_add_DT_NEEDED_for_dynamic;
2765
      whole_archive = save_whole_archive;
2766
      pop_stat_ptr ();
2767
 
2768
      return TRUE;
2769
    }
2770
 
2771
  if (ldemul_recognized_file (entry))
2772
    return TRUE;
2773
 
2774
  /* We don't call ldlang_add_file for an archive.  Instead, the
2775
     add_symbols entry point will call ldlang_add_file, via the
2776
     add_archive_element callback, for each element of the archive
2777
     which is used.  */
2778
  switch (bfd_get_format (entry->the_bfd))
2779
    {
2780
    default:
2781
      break;
2782
 
2783
    case bfd_object:
2784 163 khays
#ifdef ENABLE_PLUGINS
2785
      if (!entry->reload)
2786
#endif
2787
        ldlang_add_file (entry);
2788 145 khays
      if (trace_files || trace_file_tries)
2789
        info_msg ("%I\n", entry);
2790
      break;
2791
 
2792
    case bfd_archive:
2793
      check_excluded_libs (entry->the_bfd);
2794
 
2795
      if (entry->whole_archive)
2796
        {
2797
          bfd *member = NULL;
2798
          bfd_boolean loaded = TRUE;
2799
 
2800
          for (;;)
2801
            {
2802
              bfd *subsbfd;
2803
              member = bfd_openr_next_archived_file (entry->the_bfd, member);
2804
 
2805
              if (member == NULL)
2806
                break;
2807
 
2808
              if (! bfd_check_format (member, bfd_object))
2809
                {
2810
                  einfo (_("%F%B: member %B in archive is not an object\n"),
2811
                         entry->the_bfd, member);
2812
                  loaded = FALSE;
2813
                }
2814
 
2815
              subsbfd = member;
2816
              if (!(*link_info.callbacks
2817
                    ->add_archive_element) (&link_info, member,
2818
                                            "--whole-archive", &subsbfd))
2819
                abort ();
2820
 
2821
              /* Potentially, the add_archive_element hook may have set a
2822
                 substitute BFD for us.  */
2823
              if (!bfd_link_add_symbols (subsbfd, &link_info))
2824
                {
2825
                  einfo (_("%F%B: could not read symbols: %E\n"), member);
2826
                  loaded = FALSE;
2827
                }
2828
            }
2829
 
2830
          entry->loaded = loaded;
2831
          return loaded;
2832
        }
2833
      break;
2834
    }
2835
 
2836
  if (bfd_link_add_symbols (entry->the_bfd, &link_info))
2837
    entry->loaded = TRUE;
2838
  else
2839
    einfo (_("%F%B: could not read symbols: %E\n"), entry->the_bfd);
2840
 
2841
  return entry->loaded;
2842
}
2843
 
2844
/* Handle a wild statement.  S->FILENAME or S->SECTION_LIST or both
2845
   may be NULL, indicating that it is a wildcard.  Separate
2846
   lang_input_section statements are created for each part of the
2847
   expansion; they are added after the wild statement S.  OUTPUT is
2848
   the output section.  */
2849
 
2850
static void
2851
wild (lang_wild_statement_type *s,
2852
      const char *target ATTRIBUTE_UNUSED,
2853
      lang_output_section_statement_type *output)
2854
{
2855
  struct wildcard_list *sec;
2856
 
2857
  if (s->handler_data[0]
2858
      && s->handler_data[0]->spec.sorted == by_name
2859
      && !s->filenames_sorted)
2860
    {
2861
      lang_section_bst_type *tree;
2862
 
2863
      walk_wild (s, output_section_callback_fast, output);
2864
 
2865
      tree = s->tree;
2866
      if (tree)
2867
        {
2868
          output_section_callback_tree_to_list (s, tree, output);
2869
          s->tree = NULL;
2870
        }
2871
    }
2872
  else
2873
    walk_wild (s, output_section_callback, output);
2874
 
2875
  if (default_common_section == NULL)
2876
    for (sec = s->section_list; sec != NULL; sec = sec->next)
2877
      if (sec->spec.name != NULL && strcmp (sec->spec.name, "COMMON") == 0)
2878
        {
2879
          /* Remember the section that common is going to in case we
2880
             later get something which doesn't know where to put it.  */
2881
          default_common_section = output;
2882
          break;
2883
        }
2884
}
2885
 
2886
/* Return TRUE iff target is the sought target.  */
2887
 
2888
static int
2889
get_target (const bfd_target *target, void *data)
2890
{
2891
  const char *sought = (const char *) data;
2892
 
2893
  return strcmp (target->name, sought) == 0;
2894
}
2895
 
2896
/* Like strcpy() but convert to lower case as well.  */
2897
 
2898
static void
2899
stricpy (char *dest, char *src)
2900
{
2901
  char c;
2902
 
2903
  while ((c = *src++) != 0)
2904
    *dest++ = TOLOWER (c);
2905
 
2906
  *dest = 0;
2907
}
2908
 
2909
/* Remove the first occurrence of needle (if any) in haystack
2910
   from haystack.  */
2911
 
2912
static void
2913
strcut (char *haystack, char *needle)
2914
{
2915
  haystack = strstr (haystack, needle);
2916
 
2917
  if (haystack)
2918
    {
2919
      char *src;
2920
 
2921
      for (src = haystack + strlen (needle); *src;)
2922
        *haystack++ = *src++;
2923
 
2924
      *haystack = 0;
2925
    }
2926
}
2927
 
2928
/* Compare two target format name strings.
2929
   Return a value indicating how "similar" they are.  */
2930
 
2931
static int
2932
name_compare (char *first, char *second)
2933
{
2934
  char *copy1;
2935
  char *copy2;
2936
  int result;
2937
 
2938
  copy1 = (char *) xmalloc (strlen (first) + 1);
2939
  copy2 = (char *) xmalloc (strlen (second) + 1);
2940
 
2941
  /* Convert the names to lower case.  */
2942
  stricpy (copy1, first);
2943
  stricpy (copy2, second);
2944
 
2945
  /* Remove size and endian strings from the name.  */
2946
  strcut (copy1, "big");
2947
  strcut (copy1, "little");
2948
  strcut (copy2, "big");
2949
  strcut (copy2, "little");
2950
 
2951
  /* Return a value based on how many characters match,
2952
     starting from the beginning.   If both strings are
2953
     the same then return 10 * their length.  */
2954
  for (result = 0; copy1[result] == copy2[result]; result++)
2955
    if (copy1[result] == 0)
2956
      {
2957
        result *= 10;
2958
        break;
2959
      }
2960
 
2961
  free (copy1);
2962
  free (copy2);
2963
 
2964
  return result;
2965
}
2966
 
2967
/* Set by closest_target_match() below.  */
2968
static const bfd_target *winner;
2969
 
2970
/* Scan all the valid bfd targets looking for one that has the endianness
2971
   requirement that was specified on the command line, and is the nearest
2972
   match to the original output target.  */
2973
 
2974
static int
2975
closest_target_match (const bfd_target *target, void *data)
2976
{
2977
  const bfd_target *original = (const bfd_target *) data;
2978
 
2979
  if (command_line.endian == ENDIAN_BIG
2980
      && target->byteorder != BFD_ENDIAN_BIG)
2981
    return 0;
2982
 
2983
  if (command_line.endian == ENDIAN_LITTLE
2984
      && target->byteorder != BFD_ENDIAN_LITTLE)
2985
    return 0;
2986
 
2987
  /* Must be the same flavour.  */
2988
  if (target->flavour != original->flavour)
2989
    return 0;
2990
 
2991
  /* Ignore generic big and little endian elf vectors.  */
2992
  if (strcmp (target->name, "elf32-big") == 0
2993
      || strcmp (target->name, "elf64-big") == 0
2994
      || strcmp (target->name, "elf32-little") == 0
2995
      || strcmp (target->name, "elf64-little") == 0)
2996
    return 0;
2997
 
2998
  /* If we have not found a potential winner yet, then record this one.  */
2999
  if (winner == NULL)
3000
    {
3001
      winner = target;
3002
      return 0;
3003
    }
3004
 
3005
  /* Oh dear, we now have two potential candidates for a successful match.
3006
     Compare their names and choose the better one.  */
3007
  if (name_compare (target->name, original->name)
3008
      > name_compare (winner->name, original->name))
3009
    winner = target;
3010
 
3011
  /* Keep on searching until wqe have checked them all.  */
3012
  return 0;
3013
}
3014
 
3015
/* Return the BFD target format of the first input file.  */
3016
 
3017
static char *
3018
get_first_input_target (void)
3019
{
3020
  char *target = NULL;
3021
 
3022
  LANG_FOR_EACH_INPUT_STATEMENT (s)
3023
    {
3024
      if (s->header.type == lang_input_statement_enum
3025
          && s->real)
3026
        {
3027
          ldfile_open_file (s);
3028
 
3029
          if (s->the_bfd != NULL
3030
              && bfd_check_format (s->the_bfd, bfd_object))
3031
            {
3032
              target = bfd_get_target (s->the_bfd);
3033
 
3034
              if (target != NULL)
3035
                break;
3036
            }
3037
        }
3038
    }
3039
 
3040
  return target;
3041
}
3042
 
3043
const char *
3044
lang_get_output_target (void)
3045
{
3046
  const char *target;
3047
 
3048
  /* Has the user told us which output format to use?  */
3049
  if (output_target != NULL)
3050
    return output_target;
3051
 
3052
  /* No - has the current target been set to something other than
3053
     the default?  */
3054 157 khays
  if (current_target != default_target && current_target != NULL)
3055 145 khays
    return current_target;
3056
 
3057
  /* No - can we determine the format of the first input file?  */
3058
  target = get_first_input_target ();
3059
  if (target != NULL)
3060
    return target;
3061
 
3062
  /* Failed - use the default output target.  */
3063
  return default_target;
3064
}
3065
 
3066
/* Open the output file.  */
3067
 
3068
static void
3069
open_output (const char *name)
3070
{
3071
  output_target = lang_get_output_target ();
3072
 
3073
  /* Has the user requested a particular endianness on the command
3074
     line?  */
3075
  if (command_line.endian != ENDIAN_UNSET)
3076
    {
3077
      const bfd_target *target;
3078
      enum bfd_endian desired_endian;
3079
 
3080
      /* Get the chosen target.  */
3081
      target = bfd_search_for_target (get_target, (void *) output_target);
3082
 
3083
      /* If the target is not supported, we cannot do anything.  */
3084
      if (target != NULL)
3085
        {
3086
          if (command_line.endian == ENDIAN_BIG)
3087
            desired_endian = BFD_ENDIAN_BIG;
3088
          else
3089
            desired_endian = BFD_ENDIAN_LITTLE;
3090
 
3091
          /* See if the target has the wrong endianness.  This should
3092
             not happen if the linker script has provided big and
3093
             little endian alternatives, but some scrips don't do
3094
             this.  */
3095
          if (target->byteorder != desired_endian)
3096
            {
3097
              /* If it does, then see if the target provides
3098
                 an alternative with the correct endianness.  */
3099
              if (target->alternative_target != NULL
3100
                  && (target->alternative_target->byteorder == desired_endian))
3101
                output_target = target->alternative_target->name;
3102
              else
3103
                {
3104
                  /* Try to find a target as similar as possible to
3105
                     the default target, but which has the desired
3106
                     endian characteristic.  */
3107
                  bfd_search_for_target (closest_target_match,
3108
                                         (void *) target);
3109
 
3110
                  /* Oh dear - we could not find any targets that
3111
                     satisfy our requirements.  */
3112
                  if (winner == NULL)
3113
                    einfo (_("%P: warning: could not find any targets"
3114
                             " that match endianness requirement\n"));
3115
                  else
3116
                    output_target = winner->name;
3117
                }
3118
            }
3119
        }
3120
    }
3121
 
3122
  link_info.output_bfd = bfd_openw (name, output_target);
3123
 
3124
  if (link_info.output_bfd == NULL)
3125
    {
3126
      if (bfd_get_error () == bfd_error_invalid_target)
3127
        einfo (_("%P%F: target %s not found\n"), output_target);
3128
 
3129
      einfo (_("%P%F: cannot open output file %s: %E\n"), name);
3130
    }
3131
 
3132
  delete_output_file_on_failure = TRUE;
3133
 
3134
  if (! bfd_set_format (link_info.output_bfd, bfd_object))
3135
    einfo (_("%P%F:%s: can not make object file: %E\n"), name);
3136
  if (! bfd_set_arch_mach (link_info.output_bfd,
3137
                           ldfile_output_architecture,
3138
                           ldfile_output_machine))
3139
    einfo (_("%P%F:%s: can not set architecture: %E\n"), name);
3140
 
3141
  link_info.hash = bfd_link_hash_table_create (link_info.output_bfd);
3142
  if (link_info.hash == NULL)
3143
    einfo (_("%P%F: can not create hash table: %E\n"));
3144
 
3145
  bfd_set_gp_size (link_info.output_bfd, g_switch_value);
3146
}
3147
 
3148
static void
3149
ldlang_open_output (lang_statement_union_type *statement)
3150
{
3151
  switch (statement->header.type)
3152
    {
3153
    case lang_output_statement_enum:
3154
      ASSERT (link_info.output_bfd == NULL);
3155
      open_output (statement->output_statement.name);
3156
      ldemul_set_output_arch ();
3157
      if (config.magic_demand_paged && !link_info.relocatable)
3158
        link_info.output_bfd->flags |= D_PAGED;
3159
      else
3160
        link_info.output_bfd->flags &= ~D_PAGED;
3161
      if (config.text_read_only)
3162
        link_info.output_bfd->flags |= WP_TEXT;
3163
      else
3164
        link_info.output_bfd->flags &= ~WP_TEXT;
3165
      if (link_info.traditional_format)
3166
        link_info.output_bfd->flags |= BFD_TRADITIONAL_FORMAT;
3167
      else
3168
        link_info.output_bfd->flags &= ~BFD_TRADITIONAL_FORMAT;
3169
      break;
3170
 
3171
    case lang_target_statement_enum:
3172
      current_target = statement->target_statement.target;
3173
      break;
3174
    default:
3175
      break;
3176
    }
3177
}
3178
 
3179
/* Convert between addresses in bytes and sizes in octets.
3180
   For currently supported targets, octets_per_byte is always a power
3181
   of two, so we can use shifts.  */
3182
#define TO_ADDR(X) ((X) >> opb_shift)
3183
#define TO_SIZE(X) ((X) << opb_shift)
3184
 
3185
/* Support the above.  */
3186
static unsigned int opb_shift = 0;
3187
 
3188
static void
3189
init_opb (void)
3190
{
3191
  unsigned x = bfd_arch_mach_octets_per_byte (ldfile_output_architecture,
3192
                                              ldfile_output_machine);
3193
  opb_shift = 0;
3194
  if (x > 1)
3195
    while ((x & 1) == 0)
3196
      {
3197
        x >>= 1;
3198
        ++opb_shift;
3199
      }
3200
  ASSERT (x == 1);
3201
}
3202
 
3203
/* Open all the input files.  */
3204
 
3205
enum open_bfd_mode
3206
  {
3207
    OPEN_BFD_NORMAL = 0,
3208
    OPEN_BFD_FORCE = 1,
3209
    OPEN_BFD_RESCAN = 2
3210
  };
3211
#ifdef ENABLE_PLUGINS
3212
static lang_input_statement_type *plugin_insert = NULL;
3213
#endif
3214
 
3215
static void
3216
open_input_bfds (lang_statement_union_type *s, enum open_bfd_mode mode)
3217
{
3218
  for (; s != NULL; s = s->header.next)
3219
    {
3220
      switch (s->header.type)
3221
        {
3222
        case lang_constructors_statement_enum:
3223
          open_input_bfds (constructor_list.head, mode);
3224
          break;
3225
        case lang_output_section_statement_enum:
3226
          open_input_bfds (s->output_section_statement.children.head, mode);
3227
          break;
3228
        case lang_wild_statement_enum:
3229
          /* Maybe we should load the file's symbols.  */
3230
          if ((mode & OPEN_BFD_RESCAN) == 0
3231
              && s->wild_statement.filename
3232
              && !wildcardp (s->wild_statement.filename)
3233
              && !archive_path (s->wild_statement.filename))
3234
            lookup_name (s->wild_statement.filename);
3235
          open_input_bfds (s->wild_statement.children.head, mode);
3236
          break;
3237
        case lang_group_statement_enum:
3238
          {
3239
            struct bfd_link_hash_entry *undefs;
3240
 
3241
            /* We must continually search the entries in the group
3242
               until no new symbols are added to the list of undefined
3243
               symbols.  */
3244
 
3245
            do
3246
              {
3247
                undefs = link_info.hash->undefs_tail;
3248
                open_input_bfds (s->group_statement.children.head,
3249
                                 mode | OPEN_BFD_FORCE);
3250
              }
3251
            while (undefs != link_info.hash->undefs_tail);
3252
          }
3253
          break;
3254
        case lang_target_statement_enum:
3255
          current_target = s->target_statement.target;
3256
          break;
3257
        case lang_input_statement_enum:
3258
          if (s->input_statement.real)
3259
            {
3260
              lang_statement_union_type **os_tail;
3261
              lang_statement_list_type add;
3262
 
3263
              s->input_statement.target = current_target;
3264
 
3265
              /* If we are being called from within a group, and this
3266
                 is an archive which has already been searched, then
3267
                 force it to be researched unless the whole archive
3268
                 has been loaded already.  Do the same for a rescan.  */
3269
              if (mode != OPEN_BFD_NORMAL
3270
#ifdef ENABLE_PLUGINS
3271
                  && ((mode & OPEN_BFD_RESCAN) == 0
3272
                      || plugin_insert == NULL)
3273
#endif
3274
                  && !s->input_statement.whole_archive
3275
                  && s->input_statement.loaded
3276
                  && bfd_check_format (s->input_statement.the_bfd,
3277
                                       bfd_archive))
3278
                s->input_statement.loaded = FALSE;
3279 163 khays
#ifdef ENABLE_PLUGINS
3280
              /* When rescanning, reload --as-needed shared libs.  */
3281
              else if ((mode & OPEN_BFD_RESCAN) != 0
3282
                       && plugin_insert == NULL
3283
                       && s->input_statement.loaded
3284
                       && s->input_statement.add_DT_NEEDED_for_regular
3285
                       && ((s->input_statement.the_bfd->flags) & DYNAMIC) != 0
3286
                       && plugin_should_reload (s->input_statement.the_bfd))
3287
                {
3288
                  s->input_statement.loaded = FALSE;
3289
                  s->input_statement.reload = TRUE;
3290
                }
3291
#endif
3292 145 khays
 
3293
              os_tail = lang_output_section_statement.tail;
3294
              lang_list_init (&add);
3295
 
3296
              if (! load_symbols (&s->input_statement, &add))
3297
                config.make_executable = FALSE;
3298
 
3299
              if (add.head != NULL)
3300
                {
3301
                  /* If this was a script with output sections then
3302
                     tack any added statements on to the end of the
3303
                     list.  This avoids having to reorder the output
3304
                     section statement list.  Very likely the user
3305
                     forgot -T, and whatever we do here will not meet
3306
                     naive user expectations.  */
3307
                  if (os_tail != lang_output_section_statement.tail)
3308
                    {
3309
                      einfo (_("%P: warning: %s contains output sections;"
3310
                               " did you forget -T?\n"),
3311
                             s->input_statement.filename);
3312
                      *stat_ptr->tail = add.head;
3313
                      stat_ptr->tail = add.tail;
3314
                    }
3315
                  else
3316
                    {
3317
                      *add.tail = s->header.next;
3318
                      s->header.next = add.head;
3319
                    }
3320
                }
3321
            }
3322
#ifdef ENABLE_PLUGINS
3323
          /* If we have found the point at which a plugin added new
3324
             files, clear plugin_insert to enable archive rescan.  */
3325
          if (&s->input_statement == plugin_insert)
3326
            plugin_insert = NULL;
3327
#endif
3328
          break;
3329
        case lang_assignment_statement_enum:
3330
          if (s->assignment_statement.exp->assign.hidden)
3331
            /* This is from a --defsym on the command line.  */
3332
            exp_fold_tree_no_dot (s->assignment_statement.exp);
3333
          break;
3334
        default:
3335
          break;
3336
        }
3337
    }
3338
 
3339
  /* Exit if any of the files were missing.  */
3340
  if (missing_file)
3341
    einfo ("%F");
3342
}
3343
 
3344
/* Add a symbol to a hash of symbols used in DEFINED (NAME) expressions.  */
3345
 
3346
void
3347
lang_track_definedness (const char *name)
3348
{
3349
  if (bfd_hash_lookup (&lang_definedness_table, name, TRUE, FALSE) == NULL)
3350
    einfo (_("%P%F: bfd_hash_lookup failed creating symbol %s\n"), name);
3351
}
3352
 
3353
/* New-function for the definedness hash table.  */
3354
 
3355
static struct bfd_hash_entry *
3356
lang_definedness_newfunc (struct bfd_hash_entry *entry,
3357
                          struct bfd_hash_table *table ATTRIBUTE_UNUSED,
3358
                          const char *name ATTRIBUTE_UNUSED)
3359
{
3360
  struct lang_definedness_hash_entry *ret
3361
    = (struct lang_definedness_hash_entry *) entry;
3362
 
3363
  if (ret == NULL)
3364
    ret = (struct lang_definedness_hash_entry *)
3365
      bfd_hash_allocate (table, sizeof (struct lang_definedness_hash_entry));
3366
 
3367
  if (ret == NULL)
3368
    einfo (_("%P%F: bfd_hash_allocate failed creating symbol %s\n"), name);
3369
 
3370
  ret->iteration = -1;
3371
  return &ret->root;
3372
}
3373
 
3374
/* Return the iteration when the definition of NAME was last updated.  A
3375
   value of -1 means that the symbol is not defined in the linker script
3376
   or the command line, but may be defined in the linker symbol table.  */
3377
 
3378
int
3379
lang_symbol_definition_iteration (const char *name)
3380
{
3381
  struct lang_definedness_hash_entry *defentry
3382
    = (struct lang_definedness_hash_entry *)
3383
    bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3384
 
3385
  /* We've already created this one on the presence of DEFINED in the
3386
     script, so it can't be NULL unless something is borked elsewhere in
3387
     the code.  */
3388
  if (defentry == NULL)
3389
    FAIL ();
3390
 
3391
  return defentry->iteration;
3392
}
3393
 
3394
/* Update the definedness state of NAME.  */
3395
 
3396
void
3397
lang_update_definedness (const char *name, struct bfd_link_hash_entry *h)
3398
{
3399
  struct lang_definedness_hash_entry *defentry
3400
    = (struct lang_definedness_hash_entry *)
3401
    bfd_hash_lookup (&lang_definedness_table, name, FALSE, FALSE);
3402
 
3403
  /* We don't keep track of symbols not tested with DEFINED.  */
3404
  if (defentry == NULL)
3405
    return;
3406
 
3407
  /* If the symbol was already defined, and not from an earlier statement
3408
     iteration, don't update the definedness iteration, because that'd
3409
     make the symbol seem defined in the linker script at this point, and
3410
     it wasn't; it was defined in some object.  If we do anyway, DEFINED
3411
     would start to yield false before this point and the construct "sym =
3412
     DEFINED (sym) ? sym : X;" would change sym to X despite being defined
3413
     in an object.  */
3414
  if (h->type != bfd_link_hash_undefined
3415
      && h->type != bfd_link_hash_common
3416
      && h->type != bfd_link_hash_new
3417
      && defentry->iteration == -1)
3418
    return;
3419
 
3420
  defentry->iteration = lang_statement_iteration;
3421
}
3422
 
3423
/* Add the supplied name to the symbol table as an undefined reference.
3424
   This is a two step process as the symbol table doesn't even exist at
3425
   the time the ld command line is processed.  First we put the name
3426
   on a list, then, once the output file has been opened, transfer the
3427
   name to the symbol table.  */
3428
 
3429
typedef struct bfd_sym_chain ldlang_undef_chain_list_type;
3430
 
3431
#define ldlang_undef_chain_list_head entry_symbol.next
3432
 
3433
void
3434
ldlang_add_undef (const char *const name, bfd_boolean cmdline)
3435
{
3436
  ldlang_undef_chain_list_type *new_undef;
3437
 
3438
  undef_from_cmdline = undef_from_cmdline || cmdline;
3439
  new_undef = (ldlang_undef_chain_list_type *) stat_alloc (sizeof (*new_undef));
3440
  new_undef->next = ldlang_undef_chain_list_head;
3441
  ldlang_undef_chain_list_head = new_undef;
3442
 
3443
  new_undef->name = xstrdup (name);
3444
 
3445
  if (link_info.output_bfd != NULL)
3446
    insert_undefined (new_undef->name);
3447
}
3448
 
3449
/* Insert NAME as undefined in the symbol table.  */
3450
 
3451
static void
3452
insert_undefined (const char *name)
3453
{
3454
  struct bfd_link_hash_entry *h;
3455
 
3456
  h = bfd_link_hash_lookup (link_info.hash, name, TRUE, FALSE, TRUE);
3457
  if (h == NULL)
3458
    einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
3459
  if (h->type == bfd_link_hash_new)
3460
    {
3461
      h->type = bfd_link_hash_undefined;
3462
      h->u.undef.abfd = NULL;
3463
      bfd_link_add_undef (link_info.hash, h);
3464
    }
3465
}
3466
 
3467
/* Run through the list of undefineds created above and place them
3468
   into the linker hash table as undefined symbols belonging to the
3469
   script file.  */
3470
 
3471
static void
3472
lang_place_undefineds (void)
3473
{
3474
  ldlang_undef_chain_list_type *ptr;
3475
 
3476
  for (ptr = ldlang_undef_chain_list_head; ptr != NULL; ptr = ptr->next)
3477
    insert_undefined (ptr->name);
3478
}
3479
 
3480
/* Check for all readonly or some readwrite sections.  */
3481
 
3482
static void
3483
check_input_sections
3484
  (lang_statement_union_type *s,
3485
   lang_output_section_statement_type *output_section_statement)
3486
{
3487
  for (; s != (lang_statement_union_type *) NULL; s = s->header.next)
3488
    {
3489
      switch (s->header.type)
3490
        {
3491
        case lang_wild_statement_enum:
3492
          walk_wild (&s->wild_statement, check_section_callback,
3493
                     output_section_statement);
3494
          if (! output_section_statement->all_input_readonly)
3495
            return;
3496
          break;
3497
        case lang_constructors_statement_enum:
3498
          check_input_sections (constructor_list.head,
3499
                                output_section_statement);
3500
          if (! output_section_statement->all_input_readonly)
3501
            return;
3502
          break;
3503
        case lang_group_statement_enum:
3504
          check_input_sections (s->group_statement.children.head,
3505
                                output_section_statement);
3506
          if (! output_section_statement->all_input_readonly)
3507
            return;
3508
          break;
3509
        default:
3510
          break;
3511
        }
3512
    }
3513
}
3514
 
3515
/* Update wildcard statements if needed.  */
3516
 
3517
static void
3518
update_wild_statements (lang_statement_union_type *s)
3519
{
3520
  struct wildcard_list *sec;
3521
 
3522
  switch (sort_section)
3523
    {
3524
    default:
3525
      FAIL ();
3526
 
3527
    case none:
3528
      break;
3529
 
3530
    case by_name:
3531
    case by_alignment:
3532
      for (; s != NULL; s = s->header.next)
3533
        {
3534
          switch (s->header.type)
3535
            {
3536
            default:
3537
              break;
3538
 
3539
            case lang_wild_statement_enum:
3540
              sec = s->wild_statement.section_list;
3541
              for (sec = s->wild_statement.section_list; sec != NULL;
3542
                   sec = sec->next)
3543
                {
3544
                  switch (sec->spec.sorted)
3545
                    {
3546
                    case none:
3547
                      sec->spec.sorted = sort_section;
3548
                      break;
3549
                    case by_name:
3550
                      if (sort_section == by_alignment)
3551
                        sec->spec.sorted = by_name_alignment;
3552
                      break;
3553
                    case by_alignment:
3554
                      if (sort_section == by_name)
3555
                        sec->spec.sorted = by_alignment_name;
3556
                      break;
3557
                    default:
3558
                      break;
3559
                    }
3560
                }
3561
              break;
3562
 
3563
            case lang_constructors_statement_enum:
3564
              update_wild_statements (constructor_list.head);
3565
              break;
3566
 
3567
            case lang_output_section_statement_enum:
3568
              update_wild_statements
3569
                (s->output_section_statement.children.head);
3570
              break;
3571
 
3572
            case lang_group_statement_enum:
3573
              update_wild_statements (s->group_statement.children.head);
3574
              break;
3575
            }
3576
        }
3577
      break;
3578
    }
3579
}
3580
 
3581
/* Open input files and attach to output sections.  */
3582
 
3583
static void
3584
map_input_to_output_sections
3585
  (lang_statement_union_type *s, const char *target,
3586
   lang_output_section_statement_type *os)
3587
{
3588
  for (; s != NULL; s = s->header.next)
3589
    {
3590
      lang_output_section_statement_type *tos;
3591
      flagword flags;
3592
 
3593
      switch (s->header.type)
3594
        {
3595
        case lang_wild_statement_enum:
3596
          wild (&s->wild_statement, target, os);
3597
          break;
3598
        case lang_constructors_statement_enum:
3599
          map_input_to_output_sections (constructor_list.head,
3600
                                        target,
3601
                                        os);
3602
          break;
3603
        case lang_output_section_statement_enum:
3604
          tos = &s->output_section_statement;
3605
          if (tos->constraint != 0)
3606
            {
3607
              if (tos->constraint != ONLY_IF_RW
3608
                  && tos->constraint != ONLY_IF_RO)
3609
                break;
3610
              tos->all_input_readonly = TRUE;
3611
              check_input_sections (tos->children.head, tos);
3612
              if (tos->all_input_readonly != (tos->constraint == ONLY_IF_RO))
3613
                {
3614
                  tos->constraint = -1;
3615
                  break;
3616
                }
3617
            }
3618
          map_input_to_output_sections (tos->children.head,
3619
                                        target,
3620
                                        tos);
3621
          break;
3622
        case lang_output_statement_enum:
3623
          break;
3624
        case lang_target_statement_enum:
3625
          target = s->target_statement.target;
3626
          break;
3627
        case lang_group_statement_enum:
3628
          map_input_to_output_sections (s->group_statement.children.head,
3629
                                        target,
3630
                                        os);
3631
          break;
3632
        case lang_data_statement_enum:
3633
          /* Make sure that any sections mentioned in the expression
3634
             are initialized.  */
3635
          exp_init_os (s->data_statement.exp);
3636
          /* The output section gets CONTENTS, ALLOC and LOAD, but
3637
             these may be overridden by the script.  */
3638
          flags = SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD;
3639
          switch (os->sectype)
3640
            {
3641
            case normal_section:
3642
            case overlay_section:
3643
              break;
3644
            case noalloc_section:
3645
              flags = SEC_HAS_CONTENTS;
3646
              break;
3647
            case noload_section:
3648
              if (bfd_get_flavour (link_info.output_bfd)
3649
                  == bfd_target_elf_flavour)
3650
                flags = SEC_NEVER_LOAD | SEC_ALLOC;
3651
              else
3652
                flags = SEC_NEVER_LOAD | SEC_HAS_CONTENTS;
3653
              break;
3654
            }
3655
          if (os->bfd_section == NULL)
3656
            init_os (os, flags);
3657
          else
3658
            os->bfd_section->flags |= flags;
3659
          break;
3660
        case lang_input_section_enum:
3661
          break;
3662
        case lang_fill_statement_enum:
3663
        case lang_object_symbols_statement_enum:
3664
        case lang_reloc_statement_enum:
3665
        case lang_padding_statement_enum:
3666
        case lang_input_statement_enum:
3667
          if (os != NULL && os->bfd_section == NULL)
3668
            init_os (os, 0);
3669
          break;
3670
        case lang_assignment_statement_enum:
3671
          if (os != NULL && os->bfd_section == NULL)
3672
            init_os (os, 0);
3673
 
3674
          /* Make sure that any sections mentioned in the assignment
3675
             are initialized.  */
3676
          exp_init_os (s->assignment_statement.exp);
3677
          break;
3678
        case lang_address_statement_enum:
3679
          /* Mark the specified section with the supplied address.
3680
             If this section was actually a segment marker, then the
3681
             directive is ignored if the linker script explicitly
3682
             processed the segment marker.  Originally, the linker
3683
             treated segment directives (like -Ttext on the
3684
             command-line) as section directives.  We honor the
3685
             section directive semantics for backwards compatibilty;
3686
             linker scripts that do not specifically check for
3687
             SEGMENT_START automatically get the old semantics.  */
3688
          if (!s->address_statement.segment
3689
              || !s->address_statement.segment->used)
3690
            {
3691
              const char *name = s->address_statement.section_name;
3692
 
3693
              /* Create the output section statement here so that
3694
                 orphans with a set address will be placed after other
3695
                 script sections.  If we let the orphan placement code
3696
                 place them in amongst other sections then the address
3697
                 will affect following script sections, which is
3698
                 likely to surprise naive users.  */
3699
              tos = lang_output_section_statement_lookup (name, 0, TRUE);
3700
              tos->addr_tree = s->address_statement.address;
3701
              if (tos->bfd_section == NULL)
3702
                init_os (tos, 0);
3703
            }
3704
          break;
3705
        case lang_insert_statement_enum:
3706
          break;
3707
        }
3708
    }
3709
}
3710
 
3711
/* An insert statement snips out all the linker statements from the
3712
   start of the list and places them after the output section
3713
   statement specified by the insert.  This operation is complicated
3714
   by the fact that we keep a doubly linked list of output section
3715
   statements as well as the singly linked list of all statements.  */
3716
 
3717
static void
3718
process_insert_statements (void)
3719
{
3720
  lang_statement_union_type **s;
3721
  lang_output_section_statement_type *first_os = NULL;
3722
  lang_output_section_statement_type *last_os = NULL;
3723
  lang_output_section_statement_type *os;
3724
 
3725
  /* "start of list" is actually the statement immediately after
3726
     the special abs_section output statement, so that it isn't
3727
     reordered.  */
3728
  s = &lang_output_section_statement.head;
3729
  while (*(s = &(*s)->header.next) != NULL)
3730
    {
3731
      if ((*s)->header.type == lang_output_section_statement_enum)
3732
        {
3733
          /* Keep pointers to the first and last output section
3734
             statement in the sequence we may be about to move.  */
3735
          os = &(*s)->output_section_statement;
3736
 
3737
          ASSERT (last_os == NULL || last_os->next == os);
3738
          last_os = os;
3739
 
3740
          /* Set constraint negative so that lang_output_section_find
3741
             won't match this output section statement.  At this
3742
             stage in linking constraint has values in the range
3743
             [-1, ONLY_IN_RW].  */
3744
          last_os->constraint = -2 - last_os->constraint;
3745
          if (first_os == NULL)
3746
            first_os = last_os;
3747
        }
3748
      else if ((*s)->header.type == lang_insert_statement_enum)
3749
        {
3750
          lang_insert_statement_type *i = &(*s)->insert_statement;
3751
          lang_output_section_statement_type *where;
3752
          lang_statement_union_type **ptr;
3753
          lang_statement_union_type *first;
3754
 
3755
          where = lang_output_section_find (i->where);
3756
          if (where != NULL && i->is_before)
3757
            {
3758
              do
3759
                where = where->prev;
3760
              while (where != NULL && where->constraint < 0);
3761
            }
3762
          if (where == NULL)
3763
            {
3764
              einfo (_("%F%P: %s not found for insert\n"), i->where);
3765
              return;
3766
            }
3767
 
3768
          /* Deal with reordering the output section statement list.  */
3769
          if (last_os != NULL)
3770
            {
3771
              asection *first_sec, *last_sec;
3772
              struct lang_output_section_statement_struct **next;
3773
 
3774
              /* Snip out the output sections we are moving.  */
3775
              first_os->prev->next = last_os->next;
3776
              if (last_os->next == NULL)
3777
                {
3778
                  next = &first_os->prev->next;
3779
                  lang_output_section_statement.tail
3780
                    = (lang_statement_union_type **) next;
3781
                }
3782
              else
3783
                last_os->next->prev = first_os->prev;
3784
              /* Add them in at the new position.  */
3785
              last_os->next = where->next;
3786
              if (where->next == NULL)
3787
                {
3788
                  next = &last_os->next;
3789
                  lang_output_section_statement.tail
3790
                    = (lang_statement_union_type **) next;
3791
                }
3792
              else
3793
                where->next->prev = last_os;
3794
              first_os->prev = where;
3795
              where->next = first_os;
3796
 
3797
              /* Move the bfd sections in the same way.  */
3798
              first_sec = NULL;
3799
              last_sec = NULL;
3800
              for (os = first_os; os != NULL; os = os->next)
3801
                {
3802
                  os->constraint = -2 - os->constraint;
3803
                  if (os->bfd_section != NULL
3804
                      && os->bfd_section->owner != NULL)
3805
                    {
3806
                      last_sec = os->bfd_section;
3807
                      if (first_sec == NULL)
3808
                        first_sec = last_sec;
3809
                    }
3810
                  if (os == last_os)
3811
                    break;
3812
                }
3813
              if (last_sec != NULL)
3814
                {
3815
                  asection *sec = where->bfd_section;
3816
                  if (sec == NULL)
3817
                    sec = output_prev_sec_find (where);
3818
 
3819
                  /* The place we want to insert must come after the
3820
                     sections we are moving.  So if we find no
3821
                     section or if the section is the same as our
3822
                     last section, then no move is needed.  */
3823
                  if (sec != NULL && sec != last_sec)
3824
                    {
3825
                      /* Trim them off.  */
3826
                      if (first_sec->prev != NULL)
3827
                        first_sec->prev->next = last_sec->next;
3828
                      else
3829
                        link_info.output_bfd->sections = last_sec->next;
3830
                      if (last_sec->next != NULL)
3831
                        last_sec->next->prev = first_sec->prev;
3832
                      else
3833
                        link_info.output_bfd->section_last = first_sec->prev;
3834
                      /* Add back.  */
3835
                      last_sec->next = sec->next;
3836
                      if (sec->next != NULL)
3837
                        sec->next->prev = last_sec;
3838
                      else
3839
                        link_info.output_bfd->section_last = last_sec;
3840
                      first_sec->prev = sec;
3841
                      sec->next = first_sec;
3842
                    }
3843
                }
3844
 
3845
              first_os = NULL;
3846
              last_os = NULL;
3847
            }
3848
 
3849
          ptr = insert_os_after (where);
3850
          /* Snip everything after the abs_section output statement we
3851
             know is at the start of the list, up to and including
3852
             the insert statement we are currently processing.  */
3853
          first = lang_output_section_statement.head->header.next;
3854
          lang_output_section_statement.head->header.next = (*s)->header.next;
3855
          /* Add them back where they belong.  */
3856
          *s = *ptr;
3857
          if (*s == NULL)
3858
            statement_list.tail = s;
3859
          *ptr = first;
3860
          s = &lang_output_section_statement.head;
3861
        }
3862
    }
3863
 
3864
  /* Undo constraint twiddling.  */
3865
  for (os = first_os; os != NULL; os = os->next)
3866
    {
3867
      os->constraint = -2 - os->constraint;
3868
      if (os == last_os)
3869
        break;
3870
    }
3871
}
3872
 
3873
/* An output section might have been removed after its statement was
3874
   added.  For example, ldemul_before_allocation can remove dynamic
3875
   sections if they turn out to be not needed.  Clean them up here.  */
3876
 
3877
void
3878
strip_excluded_output_sections (void)
3879
{
3880
  lang_output_section_statement_type *os;
3881
 
3882
  /* Run lang_size_sections (if not already done).  */
3883
  if (expld.phase != lang_mark_phase_enum)
3884
    {
3885
      expld.phase = lang_mark_phase_enum;
3886
      expld.dataseg.phase = exp_dataseg_none;
3887
      one_lang_size_sections_pass (NULL, FALSE);
3888
      lang_reset_memory_regions ();
3889
    }
3890
 
3891
  for (os = &lang_output_section_statement.head->output_section_statement;
3892
       os != NULL;
3893
       os = os->next)
3894
    {
3895
      asection *output_section;
3896
      bfd_boolean exclude;
3897
 
3898
      if (os->constraint < 0)
3899
        continue;
3900
 
3901
      output_section = os->bfd_section;
3902
      if (output_section == NULL)
3903
        continue;
3904
 
3905
      exclude = (output_section->rawsize == 0
3906
                 && (output_section->flags & SEC_KEEP) == 0
3907
                 && !bfd_section_removed_from_list (link_info.output_bfd,
3908
                                                    output_section));
3909
 
3910
      /* Some sections have not yet been sized, notably .gnu.version,
3911
         .dynsym, .dynstr and .hash.  These all have SEC_LINKER_CREATED
3912
         input sections, so don't drop output sections that have such
3913
         input sections unless they are also marked SEC_EXCLUDE.  */
3914
      if (exclude && output_section->map_head.s != NULL)
3915
        {
3916
          asection *s;
3917
 
3918
          for (s = output_section->map_head.s; s != NULL; s = s->map_head.s)
3919
            if ((s->flags & SEC_LINKER_CREATED) != 0
3920
                && (s->flags & SEC_EXCLUDE) == 0)
3921
              {
3922
                exclude = FALSE;
3923
                break;
3924
              }
3925
        }
3926
 
3927
      /* TODO: Don't just junk map_head.s, turn them into link_orders.  */
3928
      output_section->map_head.link_order = NULL;
3929
      output_section->map_tail.link_order = NULL;
3930
 
3931
      if (exclude)
3932
        {
3933
          /* We don't set bfd_section to NULL since bfd_section of the
3934
             removed output section statement may still be used.  */
3935
          if (!os->section_relative_symbol
3936
              && !os->update_dot_tree)
3937
            os->ignored = TRUE;
3938
          output_section->flags |= SEC_EXCLUDE;
3939
          bfd_section_list_remove (link_info.output_bfd, output_section);
3940
          link_info.output_bfd->section_count--;
3941
        }
3942
    }
3943
 
3944
  /* Stop future calls to lang_add_section from messing with map_head
3945
     and map_tail link_order fields.  */
3946
  stripped_excluded_sections = TRUE;
3947
}
3948
 
3949
static void
3950
print_output_section_statement
3951
  (lang_output_section_statement_type *output_section_statement)
3952
{
3953
  asection *section = output_section_statement->bfd_section;
3954
  int len;
3955
 
3956
  if (output_section_statement != abs_output_section)
3957
    {
3958
      minfo ("\n%s", output_section_statement->name);
3959
 
3960
      if (section != NULL)
3961
        {
3962
          print_dot = section->vma;
3963
 
3964
          len = strlen (output_section_statement->name);
3965
          if (len >= SECTION_NAME_MAP_LENGTH - 1)
3966
            {
3967
              print_nl ();
3968
              len = 0;
3969
            }
3970
          while (len < SECTION_NAME_MAP_LENGTH)
3971
            {
3972
              print_space ();
3973
              ++len;
3974
            }
3975
 
3976
          minfo ("0x%V %W", section->vma, section->size);
3977
 
3978
          if (section->vma != section->lma)
3979
            minfo (_(" load address 0x%V"), section->lma);
3980
 
3981
          if (output_section_statement->update_dot_tree != NULL)
3982
            exp_fold_tree (output_section_statement->update_dot_tree,
3983
                           bfd_abs_section_ptr, &print_dot);
3984
        }
3985
 
3986
      print_nl ();
3987
    }
3988
 
3989
  print_statement_list (output_section_statement->children.head,
3990
                        output_section_statement);
3991
}
3992
 
3993
/* Scan for the use of the destination in the right hand side
3994
   of an expression.  In such cases we will not compute the
3995
   correct expression, since the value of DST that is used on
3996
   the right hand side will be its final value, not its value
3997
   just before this expression is evaluated.  */
3998
 
3999
static bfd_boolean
4000
scan_for_self_assignment (const char * dst, etree_type * rhs)
4001
{
4002
  if (rhs == NULL || dst == NULL)
4003
    return FALSE;
4004
 
4005
  switch (rhs->type.node_class)
4006
    {
4007
    case etree_binary:
4008
      return (scan_for_self_assignment (dst, rhs->binary.lhs)
4009
              || scan_for_self_assignment (dst, rhs->binary.rhs));
4010
 
4011
    case etree_trinary:
4012
      return (scan_for_self_assignment (dst, rhs->trinary.lhs)
4013
              || scan_for_self_assignment (dst, rhs->trinary.rhs));
4014
 
4015
    case etree_assign:
4016
    case etree_provided:
4017
    case etree_provide:
4018
      if (strcmp (dst, rhs->assign.dst) == 0)
4019
        return TRUE;
4020
      return scan_for_self_assignment (dst, rhs->assign.src);
4021
 
4022
    case etree_unary:
4023
      return scan_for_self_assignment (dst, rhs->unary.child);
4024
 
4025
    case etree_value:
4026
      if (rhs->value.str)
4027
        return strcmp (dst, rhs->value.str) == 0;
4028
      return FALSE;
4029
 
4030
    case etree_name:
4031
      if (rhs->name.name)
4032
        return strcmp (dst, rhs->name.name) == 0;
4033
      return FALSE;
4034
 
4035
    default:
4036
      break;
4037
    }
4038
 
4039
  return FALSE;
4040
}
4041
 
4042
 
4043
static void
4044
print_assignment (lang_assignment_statement_type *assignment,
4045
                  lang_output_section_statement_type *output_section)
4046
{
4047
  unsigned int i;
4048
  bfd_boolean is_dot;
4049
  bfd_boolean computation_is_valid = TRUE;
4050
  etree_type *tree;
4051
  asection *osec;
4052
 
4053
  for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4054
    print_space ();
4055
 
4056
  if (assignment->exp->type.node_class == etree_assert)
4057
    {
4058
      is_dot = FALSE;
4059
      tree = assignment->exp->assert_s.child;
4060
      computation_is_valid = TRUE;
4061
    }
4062
  else
4063
    {
4064
      const char *dst = assignment->exp->assign.dst;
4065
 
4066
      is_dot = (dst[0] == '.' && dst[1] == 0);
4067
      tree = assignment->exp->assign.src;
4068
      computation_is_valid = is_dot || !scan_for_self_assignment (dst, tree);
4069
    }
4070
 
4071
  osec = output_section->bfd_section;
4072
  if (osec == NULL)
4073
    osec = bfd_abs_section_ptr;
4074
  exp_fold_tree (tree, osec, &print_dot);
4075
  if (expld.result.valid_p)
4076
    {
4077
      bfd_vma value;
4078
 
4079
      if (computation_is_valid)
4080
        {
4081
          value = expld.result.value;
4082
 
4083
          if (expld.result.section != NULL)
4084
            value += expld.result.section->vma;
4085
 
4086
          minfo ("0x%V", value);
4087
          if (is_dot)
4088
            print_dot = value;
4089
        }
4090
      else
4091
        {
4092
          struct bfd_link_hash_entry *h;
4093
 
4094
          h = bfd_link_hash_lookup (link_info.hash, assignment->exp->assign.dst,
4095
                                    FALSE, FALSE, TRUE);
4096
          if (h)
4097
            {
4098
              value = h->u.def.value;
4099
              value += h->u.def.section->output_section->vma;
4100
              value += h->u.def.section->output_offset;
4101
 
4102
              minfo ("[0x%V]", value);
4103
            }
4104
          else
4105
            minfo ("[unresolved]");
4106
        }
4107
    }
4108
  else
4109
    {
4110
      minfo ("*undef*   ");
4111
#ifdef BFD64
4112
      minfo ("        ");
4113
#endif
4114
    }
4115
 
4116
  minfo ("                ");
4117
  exp_print_tree (assignment->exp);
4118
  print_nl ();
4119
}
4120
 
4121
static void
4122
print_input_statement (lang_input_statement_type *statm)
4123
{
4124
  if (statm->filename != NULL
4125
      && (statm->the_bfd == NULL
4126
          || (statm->the_bfd->flags & BFD_LINKER_CREATED) == 0))
4127
    fprintf (config.map_file, "LOAD %s\n", statm->filename);
4128
}
4129
 
4130
/* Print all symbols defined in a particular section.  This is called
4131
   via bfd_link_hash_traverse, or by print_all_symbols.  */
4132
 
4133
static bfd_boolean
4134
print_one_symbol (struct bfd_link_hash_entry *hash_entry, void *ptr)
4135
{
4136
  asection *sec = (asection *) ptr;
4137
 
4138
  if ((hash_entry->type == bfd_link_hash_defined
4139
       || hash_entry->type == bfd_link_hash_defweak)
4140
      && sec == hash_entry->u.def.section)
4141
    {
4142
      int i;
4143
 
4144
      for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4145
        print_space ();
4146
      minfo ("0x%V   ",
4147
             (hash_entry->u.def.value
4148
              + hash_entry->u.def.section->output_offset
4149
              + hash_entry->u.def.section->output_section->vma));
4150
 
4151
      minfo ("             %T\n", hash_entry->root.string);
4152
    }
4153
 
4154
  return TRUE;
4155
}
4156
 
4157
static int
4158
hash_entry_addr_cmp (const void *a, const void *b)
4159
{
4160
  const struct bfd_link_hash_entry *l = *(const struct bfd_link_hash_entry **)a;
4161
  const struct bfd_link_hash_entry *r = *(const struct bfd_link_hash_entry **)b;
4162
 
4163
  if (l->u.def.value < r->u.def.value)
4164
    return -1;
4165
  else if (l->u.def.value > r->u.def.value)
4166
    return 1;
4167
  else
4168
    return 0;
4169
}
4170
 
4171
static void
4172
print_all_symbols (asection *sec)
4173
{
4174
  struct fat_user_section_struct *ud =
4175
      (struct fat_user_section_struct *) get_userdata (sec);
4176
  struct map_symbol_def *def;
4177
  struct bfd_link_hash_entry **entries;
4178
  unsigned int i;
4179
 
4180
  if (!ud)
4181
    return;
4182
 
4183
  *ud->map_symbol_def_tail = 0;
4184
 
4185
  /* Sort the symbols by address.  */
4186
  entries = (struct bfd_link_hash_entry **)
4187
      obstack_alloc (&map_obstack, ud->map_symbol_def_count * sizeof (*entries));
4188
 
4189
  for (i = 0, def = ud->map_symbol_def_head; def; def = def->next, i++)
4190
    entries[i] = def->entry;
4191
 
4192
  qsort (entries, ud->map_symbol_def_count, sizeof (*entries),
4193
         hash_entry_addr_cmp);
4194
 
4195
  /* Print the symbols.  */
4196
  for (i = 0; i < ud->map_symbol_def_count; i++)
4197
    print_one_symbol (entries[i], sec);
4198
 
4199
  obstack_free (&map_obstack, entries);
4200
}
4201
 
4202
/* Print information about an input section to the map file.  */
4203
 
4204
static void
4205
print_input_section (asection *i, bfd_boolean is_discarded)
4206
{
4207
  bfd_size_type size = i->size;
4208
  int len;
4209
  bfd_vma addr;
4210
 
4211
  init_opb ();
4212
 
4213
  print_space ();
4214
  minfo ("%s", i->name);
4215
 
4216
  len = 1 + strlen (i->name);
4217
  if (len >= SECTION_NAME_MAP_LENGTH - 1)
4218
    {
4219
      print_nl ();
4220
      len = 0;
4221
    }
4222
  while (len < SECTION_NAME_MAP_LENGTH)
4223
    {
4224
      print_space ();
4225
      ++len;
4226
    }
4227
 
4228
  if (i->output_section != NULL
4229
      && i->output_section->owner == link_info.output_bfd)
4230
    addr = i->output_section->vma + i->output_offset;
4231
  else
4232
    {
4233
      addr = print_dot;
4234
      if (!is_discarded)
4235
        size = 0;
4236
    }
4237
 
4238
  minfo ("0x%V %W %B\n", addr, TO_ADDR (size), i->owner);
4239
 
4240
  if (size != i->rawsize && i->rawsize != 0)
4241
    {
4242
      len = SECTION_NAME_MAP_LENGTH + 3;
4243
#ifdef BFD64
4244
      len += 16;
4245
#else
4246
      len += 8;
4247
#endif
4248
      while (len > 0)
4249
        {
4250
          print_space ();
4251
          --len;
4252
        }
4253
 
4254
      minfo (_("%W (size before relaxing)\n"), i->rawsize);
4255
    }
4256
 
4257
  if (i->output_section != NULL
4258
      && i->output_section->owner == link_info.output_bfd)
4259
    {
4260
      if (link_info.reduce_memory_overheads)
4261
        bfd_link_hash_traverse (link_info.hash, print_one_symbol, i);
4262
      else
4263
        print_all_symbols (i);
4264
 
4265
      /* Update print_dot, but make sure that we do not move it
4266
         backwards - this could happen if we have overlays and a
4267
         later overlay is shorter than an earier one.  */
4268
      if (addr + TO_ADDR (size) > print_dot)
4269
        print_dot = addr + TO_ADDR (size);
4270
    }
4271
}
4272
 
4273
static void
4274
print_fill_statement (lang_fill_statement_type *fill)
4275
{
4276
  size_t size;
4277
  unsigned char *p;
4278
  fputs (" FILL mask 0x", config.map_file);
4279
  for (p = fill->fill->data, size = fill->fill->size; size != 0; p++, size--)
4280
    fprintf (config.map_file, "%02x", *p);
4281
  fputs ("\n", config.map_file);
4282
}
4283
 
4284
static void
4285
print_data_statement (lang_data_statement_type *data)
4286
{
4287
  int i;
4288
  bfd_vma addr;
4289
  bfd_size_type size;
4290
  const char *name;
4291
 
4292
  init_opb ();
4293
  for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4294
    print_space ();
4295
 
4296
  addr = data->output_offset;
4297
  if (data->output_section != NULL)
4298
    addr += data->output_section->vma;
4299
 
4300
  switch (data->type)
4301
    {
4302
    default:
4303
      abort ();
4304
    case BYTE:
4305
      size = BYTE_SIZE;
4306
      name = "BYTE";
4307
      break;
4308
    case SHORT:
4309
      size = SHORT_SIZE;
4310
      name = "SHORT";
4311
      break;
4312
    case LONG:
4313
      size = LONG_SIZE;
4314
      name = "LONG";
4315
      break;
4316
    case QUAD:
4317
      size = QUAD_SIZE;
4318
      name = "QUAD";
4319
      break;
4320
    case SQUAD:
4321
      size = QUAD_SIZE;
4322
      name = "SQUAD";
4323
      break;
4324
    }
4325
 
4326
  minfo ("0x%V %W %s 0x%v", addr, size, name, data->value);
4327
 
4328
  if (data->exp->type.node_class != etree_value)
4329
    {
4330
      print_space ();
4331
      exp_print_tree (data->exp);
4332
    }
4333
 
4334
  print_nl ();
4335
 
4336
  print_dot = addr + TO_ADDR (size);
4337
}
4338
 
4339
/* Print an address statement.  These are generated by options like
4340
   -Ttext.  */
4341
 
4342
static void
4343
print_address_statement (lang_address_statement_type *address)
4344
{
4345
  minfo (_("Address of section %s set to "), address->section_name);
4346
  exp_print_tree (address->address);
4347
  print_nl ();
4348
}
4349
 
4350
/* Print a reloc statement.  */
4351
 
4352
static void
4353
print_reloc_statement (lang_reloc_statement_type *reloc)
4354
{
4355
  int i;
4356
  bfd_vma addr;
4357
  bfd_size_type size;
4358
 
4359
  init_opb ();
4360
  for (i = 0; i < SECTION_NAME_MAP_LENGTH; i++)
4361
    print_space ();
4362
 
4363
  addr = reloc->output_offset;
4364
  if (reloc->output_section != NULL)
4365
    addr += reloc->output_section->vma;
4366
 
4367
  size = bfd_get_reloc_size (reloc->howto);
4368
 
4369
  minfo ("0x%V %W RELOC %s ", addr, size, reloc->howto->name);
4370
 
4371
  if (reloc->name != NULL)
4372
    minfo ("%s+", reloc->name);
4373
  else
4374
    minfo ("%s+", reloc->section->name);
4375
 
4376
  exp_print_tree (reloc->addend_exp);
4377
 
4378
  print_nl ();
4379
 
4380
  print_dot = addr + TO_ADDR (size);
4381
}
4382
 
4383
static void
4384
print_padding_statement (lang_padding_statement_type *s)
4385
{
4386
  int len;
4387
  bfd_vma addr;
4388
 
4389
  init_opb ();
4390
  minfo (" *fill*");
4391
 
4392
  len = sizeof " *fill*" - 1;
4393
  while (len < SECTION_NAME_MAP_LENGTH)
4394
    {
4395
      print_space ();
4396
      ++len;
4397
    }
4398
 
4399
  addr = s->output_offset;
4400
  if (s->output_section != NULL)
4401
    addr += s->output_section->vma;
4402
  minfo ("0x%V %W ", addr, (bfd_vma) s->size);
4403
 
4404
  if (s->fill->size != 0)
4405
    {
4406
      size_t size;
4407
      unsigned char *p;
4408
      for (p = s->fill->data, size = s->fill->size; size != 0; p++, size--)
4409
        fprintf (config.map_file, "%02x", *p);
4410
    }
4411
 
4412
  print_nl ();
4413
 
4414
  print_dot = addr + TO_ADDR (s->size);
4415
}
4416
 
4417
static void
4418
print_wild_statement (lang_wild_statement_type *w,
4419
                      lang_output_section_statement_type *os)
4420
{
4421
  struct wildcard_list *sec;
4422
 
4423
  print_space ();
4424
 
4425
  if (w->filenames_sorted)
4426
    minfo ("SORT(");
4427
  if (w->filename != NULL)
4428
    minfo ("%s", w->filename);
4429
  else
4430
    minfo ("*");
4431
  if (w->filenames_sorted)
4432
    minfo (")");
4433
 
4434
  minfo ("(");
4435
  for (sec = w->section_list; sec; sec = sec->next)
4436
    {
4437
      if (sec->spec.sorted)
4438
        minfo ("SORT(");
4439
      if (sec->spec.exclude_name_list != NULL)
4440
        {
4441
          name_list *tmp;
4442
          minfo ("EXCLUDE_FILE(%s", sec->spec.exclude_name_list->name);
4443
          for (tmp = sec->spec.exclude_name_list->next; tmp; tmp = tmp->next)
4444
            minfo (" %s", tmp->name);
4445
          minfo (") ");
4446
        }
4447
      if (sec->spec.name != NULL)
4448
        minfo ("%s", sec->spec.name);
4449
      else
4450
        minfo ("*");
4451
      if (sec->spec.sorted)
4452
        minfo (")");
4453
      if (sec->next)
4454
        minfo (" ");
4455
    }
4456
  minfo (")");
4457
 
4458
  print_nl ();
4459
 
4460
  print_statement_list (w->children.head, os);
4461
}
4462
 
4463
/* Print a group statement.  */
4464
 
4465
static void
4466
print_group (lang_group_statement_type *s,
4467
             lang_output_section_statement_type *os)
4468
{
4469
  fprintf (config.map_file, "START GROUP\n");
4470
  print_statement_list (s->children.head, os);
4471
  fprintf (config.map_file, "END GROUP\n");
4472
}
4473
 
4474
/* Print the list of statements in S.
4475
   This can be called for any statement type.  */
4476
 
4477
static void
4478
print_statement_list (lang_statement_union_type *s,
4479
                      lang_output_section_statement_type *os)
4480
{
4481
  while (s != NULL)
4482
    {
4483
      print_statement (s, os);
4484
      s = s->header.next;
4485
    }
4486
}
4487
 
4488
/* Print the first statement in statement list S.
4489
   This can be called for any statement type.  */
4490
 
4491
static void
4492
print_statement (lang_statement_union_type *s,
4493
                 lang_output_section_statement_type *os)
4494
{
4495
  switch (s->header.type)
4496
    {
4497
    default:
4498
      fprintf (config.map_file, _("Fail with %d\n"), s->header.type);
4499
      FAIL ();
4500
      break;
4501
    case lang_constructors_statement_enum:
4502
      if (constructor_list.head != NULL)
4503
        {
4504
          if (constructors_sorted)
4505
            minfo (" SORT (CONSTRUCTORS)\n");
4506
          else
4507
            minfo (" CONSTRUCTORS\n");
4508
          print_statement_list (constructor_list.head, os);
4509
        }
4510
      break;
4511
    case lang_wild_statement_enum:
4512
      print_wild_statement (&s->wild_statement, os);
4513
      break;
4514
    case lang_address_statement_enum:
4515
      print_address_statement (&s->address_statement);
4516
      break;
4517
    case lang_object_symbols_statement_enum:
4518
      minfo (" CREATE_OBJECT_SYMBOLS\n");
4519
      break;
4520
    case lang_fill_statement_enum:
4521
      print_fill_statement (&s->fill_statement);
4522
      break;
4523
    case lang_data_statement_enum:
4524
      print_data_statement (&s->data_statement);
4525
      break;
4526
    case lang_reloc_statement_enum:
4527
      print_reloc_statement (&s->reloc_statement);
4528
      break;
4529
    case lang_input_section_enum:
4530
      print_input_section (s->input_section.section, FALSE);
4531
      break;
4532
    case lang_padding_statement_enum:
4533
      print_padding_statement (&s->padding_statement);
4534
      break;
4535
    case lang_output_section_statement_enum:
4536
      print_output_section_statement (&s->output_section_statement);
4537
      break;
4538
    case lang_assignment_statement_enum:
4539
      print_assignment (&s->assignment_statement, os);
4540
      break;
4541
    case lang_target_statement_enum:
4542
      fprintf (config.map_file, "TARGET(%s)\n", s->target_statement.target);
4543
      break;
4544
    case lang_output_statement_enum:
4545
      minfo ("OUTPUT(%s", s->output_statement.name);
4546
      if (output_target != NULL)
4547
        minfo (" %s", output_target);
4548
      minfo (")\n");
4549
      break;
4550
    case lang_input_statement_enum:
4551
      print_input_statement (&s->input_statement);
4552
      break;
4553
    case lang_group_statement_enum:
4554
      print_group (&s->group_statement, os);
4555
      break;
4556
    case lang_insert_statement_enum:
4557
      minfo ("INSERT %s %s\n",
4558
             s->insert_statement.is_before ? "BEFORE" : "AFTER",
4559
             s->insert_statement.where);
4560
      break;
4561
    }
4562
}
4563
 
4564
static void
4565
print_statements (void)
4566
{
4567
  print_statement_list (statement_list.head, abs_output_section);
4568
}
4569
 
4570
/* Print the first N statements in statement list S to STDERR.
4571
   If N == 0, nothing is printed.
4572
   If N < 0, the entire list is printed.
4573
   Intended to be called from GDB.  */
4574
 
4575
void
4576
dprint_statement (lang_statement_union_type *s, int n)
4577
{
4578
  FILE *map_save = config.map_file;
4579
 
4580
  config.map_file = stderr;
4581
 
4582
  if (n < 0)
4583
    print_statement_list (s, abs_output_section);
4584
  else
4585
    {
4586
      while (s && --n >= 0)
4587
        {
4588
          print_statement (s, abs_output_section);
4589
          s = s->header.next;
4590
        }
4591
    }
4592
 
4593
  config.map_file = map_save;
4594
}
4595
 
4596
static void
4597
insert_pad (lang_statement_union_type **ptr,
4598
            fill_type *fill,
4599 166 khays
            bfd_size_type alignment_needed,
4600 145 khays
            asection *output_section,
4601
            bfd_vma dot)
4602
{
4603 166 khays
  static fill_type zero_fill;
4604 145 khays
  lang_statement_union_type *pad = NULL;
4605
 
4606
  if (ptr != &statement_list.head)
4607
    pad = ((lang_statement_union_type *)
4608
           ((char *) ptr - offsetof (lang_statement_union_type, header.next)));
4609
  if (pad != NULL
4610
      && pad->header.type == lang_padding_statement_enum
4611
      && pad->padding_statement.output_section == output_section)
4612
    {
4613
      /* Use the existing pad statement.  */
4614
    }
4615
  else if ((pad = *ptr) != NULL
4616
           && pad->header.type == lang_padding_statement_enum
4617
           && pad->padding_statement.output_section == output_section)
4618
    {
4619
      /* Use the existing pad statement.  */
4620
    }
4621
  else
4622
    {
4623
      /* Make a new padding statement, linked into existing chain.  */
4624
      pad = (lang_statement_union_type *)
4625
          stat_alloc (sizeof (lang_padding_statement_type));
4626
      pad->header.next = *ptr;
4627
      *ptr = pad;
4628
      pad->header.type = lang_padding_statement_enum;
4629
      pad->padding_statement.output_section = output_section;
4630
      if (fill == NULL)
4631
        fill = &zero_fill;
4632
      pad->padding_statement.fill = fill;
4633
    }
4634
  pad->padding_statement.output_offset = dot - output_section->vma;
4635
  pad->padding_statement.size = alignment_needed;
4636
  output_section->size += alignment_needed;
4637
}
4638
 
4639
/* Work out how much this section will move the dot point.  */
4640
 
4641
static bfd_vma
4642
size_input_section
4643
  (lang_statement_union_type **this_ptr,
4644
   lang_output_section_statement_type *output_section_statement,
4645
   fill_type *fill,
4646
   bfd_vma dot)
4647
{
4648
  lang_input_section_type *is = &((*this_ptr)->input_section);
4649
  asection *i = is->section;
4650
 
4651
  if (!((lang_input_statement_type *) i->owner->usrdata)->just_syms_flag
4652
      && (i->flags & SEC_EXCLUDE) == 0)
4653
    {
4654 166 khays
      bfd_size_type alignment_needed;
4655 145 khays
      asection *o;
4656
 
4657
      /* Align this section first to the input sections requirement,
4658
         then to the output section's requirement.  If this alignment
4659
         is greater than any seen before, then record it too.  Perform
4660
         the alignment by inserting a magic 'padding' statement.  */
4661
 
4662
      if (output_section_statement->subsection_alignment != -1)
4663
        i->alignment_power = output_section_statement->subsection_alignment;
4664
 
4665
      o = output_section_statement->bfd_section;
4666
      if (o->alignment_power < i->alignment_power)
4667
        o->alignment_power = i->alignment_power;
4668
 
4669
      alignment_needed = align_power (dot, i->alignment_power) - dot;
4670
 
4671
      if (alignment_needed != 0)
4672
        {
4673
          insert_pad (this_ptr, fill, TO_SIZE (alignment_needed), o, dot);
4674
          dot += alignment_needed;
4675
        }
4676
 
4677
      /* Remember where in the output section this input section goes.  */
4678
 
4679
      i->output_offset = dot - o->vma;
4680
 
4681
      /* Mark how big the output section must be to contain this now.  */
4682
      dot += TO_ADDR (i->size);
4683
      o->size = TO_SIZE (dot - o->vma);
4684
    }
4685
  else
4686
    {
4687
      i->output_offset = i->vma - output_section_statement->bfd_section->vma;
4688
    }
4689
 
4690
  return dot;
4691
}
4692
 
4693
static int
4694
sort_sections_by_lma (const void *arg1, const void *arg2)
4695
{
4696
  const asection *sec1 = *(const asection **) arg1;
4697
  const asection *sec2 = *(const asection **) arg2;
4698
 
4699
  if (bfd_section_lma (sec1->owner, sec1)
4700
      < bfd_section_lma (sec2->owner, sec2))
4701
    return -1;
4702
  else if (bfd_section_lma (sec1->owner, sec1)
4703
           > bfd_section_lma (sec2->owner, sec2))
4704
    return 1;
4705
  else if (sec1->id < sec2->id)
4706
    return -1;
4707
  else if (sec1->id > sec2->id)
4708
    return 1;
4709
 
4710
  return 0;
4711
}
4712
 
4713
#define IGNORE_SECTION(s) \
4714
  ((s->flags & SEC_ALLOC) == 0                           \
4715
   || ((s->flags & SEC_THREAD_LOCAL) != 0                \
4716
        && (s->flags & SEC_LOAD) == 0))
4717
 
4718
/* Check to see if any allocated sections overlap with other allocated
4719
   sections.  This can happen if a linker script specifies the output
4720
   section addresses of the two sections.  Also check whether any memory
4721
   region has overflowed.  */
4722
 
4723
static void
4724
lang_check_section_addresses (void)
4725
{
4726
  asection *s, *p;
4727
  asection **sections, **spp;
4728
  unsigned int count;
4729
  bfd_vma s_start;
4730
  bfd_vma s_end;
4731
  bfd_vma p_start;
4732
  bfd_vma p_end;
4733
  bfd_size_type amt;
4734
  lang_memory_region_type *m;
4735
 
4736
  if (bfd_count_sections (link_info.output_bfd) <= 1)
4737
    return;
4738
 
4739
  amt = bfd_count_sections (link_info.output_bfd) * sizeof (asection *);
4740
  sections = (asection **) xmalloc (amt);
4741
 
4742
  /* Scan all sections in the output list.  */
4743
  count = 0;
4744
  for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
4745
    {
4746
      /* Only consider loadable sections with real contents.  */
4747
      if (!(s->flags & SEC_LOAD)
4748
          || !(s->flags & SEC_ALLOC)
4749
          || s->size == 0)
4750
        continue;
4751
 
4752
      sections[count] = s;
4753
      count++;
4754
    }
4755
 
4756
  if (count <= 1)
4757
    return;
4758
 
4759
  qsort (sections, (size_t) count, sizeof (asection *),
4760
         sort_sections_by_lma);
4761
 
4762
  spp = sections;
4763
  s = *spp++;
4764
  s_start = s->lma;
4765
  s_end = s_start + TO_ADDR (s->size) - 1;
4766
  for (count--; count; count--)
4767
    {
4768
      /* We must check the sections' LMA addresses not their VMA
4769
         addresses because overlay sections can have overlapping VMAs
4770
         but they must have distinct LMAs.  */
4771
      p = s;
4772
      p_start = s_start;
4773
      p_end = s_end;
4774
      s = *spp++;
4775
      s_start = s->lma;
4776
      s_end = s_start + TO_ADDR (s->size) - 1;
4777
 
4778
      /* Look for an overlap.  We have sorted sections by lma, so we
4779
         know that s_start >= p_start.  Besides the obvious case of
4780
         overlap when the current section starts before the previous
4781
         one ends, we also must have overlap if the previous section
4782
         wraps around the address space.  */
4783
      if (s_start <= p_end
4784
          || p_end < p_start)
4785
        einfo (_("%X%P: section %s loaded at [%V,%V] overlaps section %s loaded at [%V,%V]\n"),
4786
               s->name, s_start, s_end, p->name, p_start, p_end);
4787
    }
4788
 
4789
  free (sections);
4790
 
4791
  /* If any memory region has overflowed, report by how much.
4792
     We do not issue this diagnostic for regions that had sections
4793
     explicitly placed outside their bounds; os_region_check's
4794
     diagnostics are adequate for that case.
4795
 
4796
     FIXME: It is conceivable that m->current - (m->origin + m->length)
4797
     might overflow a 32-bit integer.  There is, alas, no way to print
4798
     a bfd_vma quantity in decimal.  */
4799
  for (m = lang_memory_region_list; m; m = m->next)
4800
    if (m->had_full_message)
4801
      einfo (_("%X%P: region `%s' overflowed by %ld bytes\n"),
4802
             m->name_list.name, (long)(m->current - (m->origin + m->length)));
4803
 
4804
}
4805
 
4806
/* Make sure the new address is within the region.  We explicitly permit the
4807
   current address to be at the exact end of the region when the address is
4808
   non-zero, in case the region is at the end of addressable memory and the
4809
   calculation wraps around.  */
4810
 
4811
static void
4812
os_region_check (lang_output_section_statement_type *os,
4813
                 lang_memory_region_type *region,
4814
                 etree_type *tree,
4815
                 bfd_vma rbase)
4816
{
4817
  if ((region->current < region->origin
4818
       || (region->current - region->origin > region->length))
4819
      && ((region->current != region->origin + region->length)
4820
          || rbase == 0))
4821
    {
4822
      if (tree != NULL)
4823
        {
4824
          einfo (_("%X%P: address 0x%v of %B section `%s'"
4825
                   " is not within region `%s'\n"),
4826
                 region->current,
4827
                 os->bfd_section->owner,
4828
                 os->bfd_section->name,
4829
                 region->name_list.name);
4830
        }
4831
      else if (!region->had_full_message)
4832
        {
4833
          region->had_full_message = TRUE;
4834
 
4835
          einfo (_("%X%P: %B section `%s' will not fit in region `%s'\n"),
4836
                 os->bfd_section->owner,
4837
                 os->bfd_section->name,
4838
                 region->name_list.name);
4839
        }
4840
    }
4841
}
4842
 
4843
/* Set the sizes for all the output sections.  */
4844
 
4845
static bfd_vma
4846
lang_size_sections_1
4847
  (lang_statement_union_type **prev,
4848
   lang_output_section_statement_type *output_section_statement,
4849
   fill_type *fill,
4850
   bfd_vma dot,
4851
   bfd_boolean *relax,
4852
   bfd_boolean check_regions)
4853
{
4854
  lang_statement_union_type *s;
4855
 
4856
  /* Size up the sections from their constituent parts.  */
4857
  for (s = *prev; s != NULL; s = s->header.next)
4858
    {
4859
      switch (s->header.type)
4860
        {
4861
        case lang_output_section_statement_enum:
4862
          {
4863
            bfd_vma newdot, after;
4864
            lang_output_section_statement_type *os;
4865
            lang_memory_region_type *r;
4866
            int section_alignment = 0;
4867
 
4868
            os = &s->output_section_statement;
4869
            if (os->constraint == -1)
4870
              break;
4871
 
4872
            /* FIXME: We shouldn't need to zero section vmas for ld -r
4873
               here, in lang_insert_orphan, or in the default linker scripts.
4874
               This is covering for coff backend linker bugs.  See PR6945.  */
4875
            if (os->addr_tree == NULL
4876
                && link_info.relocatable
4877
                && (bfd_get_flavour (link_info.output_bfd)
4878
                    == bfd_target_coff_flavour))
4879
              os->addr_tree = exp_intop (0);
4880
            if (os->addr_tree != NULL)
4881
              {
4882
                os->processed_vma = FALSE;
4883
                exp_fold_tree (os->addr_tree, bfd_abs_section_ptr, &dot);
4884
 
4885
                if (expld.result.valid_p)
4886
                  {
4887
                    dot = expld.result.value;
4888
                    if (expld.result.section != NULL)
4889
                      dot += expld.result.section->vma;
4890
                  }
4891
                else if (expld.phase != lang_mark_phase_enum)
4892
                  einfo (_("%F%S: non constant or forward reference"
4893
                           " address expression for section %s\n"),
4894 166 khays
                         os->addr_tree, os->name);
4895 145 khays
              }
4896
 
4897
            if (os->bfd_section == NULL)
4898
              /* This section was removed or never actually created.  */
4899
              break;
4900
 
4901
            /* If this is a COFF shared library section, use the size and
4902
               address from the input section.  FIXME: This is COFF
4903
               specific; it would be cleaner if there were some other way
4904
               to do this, but nothing simple comes to mind.  */
4905
            if (((bfd_get_flavour (link_info.output_bfd)
4906
                  == bfd_target_ecoff_flavour)
4907
                 || (bfd_get_flavour (link_info.output_bfd)
4908
                     == bfd_target_coff_flavour))
4909
                && (os->bfd_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
4910
              {
4911
                asection *input;
4912
 
4913
                if (os->children.head == NULL
4914
                    || os->children.head->header.next != NULL
4915
                    || (os->children.head->header.type
4916
                        != lang_input_section_enum))
4917
                  einfo (_("%P%X: Internal error on COFF shared library"
4918
                           " section %s\n"), os->name);
4919
 
4920
                input = os->children.head->input_section.section;
4921
                bfd_set_section_vma (os->bfd_section->owner,
4922
                                     os->bfd_section,
4923
                                     bfd_section_vma (input->owner, input));
4924
                os->bfd_section->size = input->size;
4925
                break;
4926
              }
4927
 
4928
            newdot = dot;
4929
            if (bfd_is_abs_section (os->bfd_section))
4930
              {
4931
                /* No matter what happens, an abs section starts at zero.  */
4932
                ASSERT (os->bfd_section->vma == 0);
4933
              }
4934
            else
4935
              {
4936
                if (os->addr_tree == NULL)
4937
                  {
4938
                    /* No address specified for this section, get one
4939
                       from the region specification.  */
4940
                    if (os->region == NULL
4941
                        || ((os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD))
4942
                            && os->region->name_list.name[0] == '*'
4943
                            && strcmp (os->region->name_list.name,
4944
                                       DEFAULT_MEMORY_REGION) == 0))
4945
                      {
4946
                        os->region = lang_memory_default (os->bfd_section);
4947
                      }
4948
 
4949
                    /* If a loadable section is using the default memory
4950
                       region, and some non default memory regions were
4951
                       defined, issue an error message.  */
4952
                    if (!os->ignored
4953
                        && !IGNORE_SECTION (os->bfd_section)
4954
                        && ! link_info.relocatable
4955
                        && check_regions
4956
                        && strcmp (os->region->name_list.name,
4957
                                   DEFAULT_MEMORY_REGION) == 0
4958
                        && lang_memory_region_list != NULL
4959
                        && (strcmp (lang_memory_region_list->name_list.name,
4960
                                    DEFAULT_MEMORY_REGION) != 0
4961
                            || lang_memory_region_list->next != NULL)
4962
                        && expld.phase != lang_mark_phase_enum)
4963
                      {
4964
                        /* By default this is an error rather than just a
4965
                           warning because if we allocate the section to the
4966
                           default memory region we can end up creating an
4967
                           excessively large binary, or even seg faulting when
4968
                           attempting to perform a negative seek.  See
4969
                           sources.redhat.com/ml/binutils/2003-04/msg00423.html
4970
                           for an example of this.  This behaviour can be
4971
                           overridden by the using the --no-check-sections
4972
                           switch.  */
4973
                        if (command_line.check_section_addresses)
4974
                          einfo (_("%P%F: error: no memory region specified"
4975
                                   " for loadable section `%s'\n"),
4976
                                 bfd_get_section_name (link_info.output_bfd,
4977
                                                       os->bfd_section));
4978
                        else
4979
                          einfo (_("%P: warning: no memory region specified"
4980
                                   " for loadable section `%s'\n"),
4981
                                 bfd_get_section_name (link_info.output_bfd,
4982
                                                       os->bfd_section));
4983
                      }
4984
 
4985
                    newdot = os->region->current;
4986
                    section_alignment = os->bfd_section->alignment_power;
4987
                  }
4988
                else
4989
                  section_alignment = os->section_alignment;
4990
 
4991
                /* Align to what the section needs.  */
4992
                if (section_alignment > 0)
4993
                  {
4994
                    bfd_vma savedot = newdot;
4995
                    newdot = align_power (newdot, section_alignment);
4996
 
4997
                    if (newdot != savedot
4998
                        && (config.warn_section_align
4999
                            || os->addr_tree != NULL)
5000
                        && expld.phase != lang_mark_phase_enum)
5001
                      einfo (_("%P: warning: changing start of section"
5002
                               " %s by %lu bytes\n"),
5003
                             os->name, (unsigned long) (newdot - savedot));
5004
                  }
5005
 
5006
                bfd_set_section_vma (0, os->bfd_section, newdot);
5007
 
5008
                os->bfd_section->output_offset = 0;
5009
              }
5010
 
5011
            lang_size_sections_1 (&os->children.head, os,
5012
                                  os->fill, newdot, relax, check_regions);
5013
 
5014
            os->processed_vma = TRUE;
5015
 
5016
            if (bfd_is_abs_section (os->bfd_section) || os->ignored)
5017
              /* Except for some special linker created sections,
5018
                 no output section should change from zero size
5019
                 after strip_excluded_output_sections.  A non-zero
5020
                 size on an ignored section indicates that some
5021
                 input section was not sized early enough.  */
5022
              ASSERT (os->bfd_section->size == 0);
5023
            else
5024
              {
5025
                dot = os->bfd_section->vma;
5026
 
5027
                /* Put the section within the requested block size, or
5028
                   align at the block boundary.  */
5029
                after = ((dot
5030
                          + TO_ADDR (os->bfd_section->size)
5031
                          + os->block_value - 1)
5032
                         & - (bfd_vma) os->block_value);
5033
 
5034
                os->bfd_section->size = TO_SIZE (after - os->bfd_section->vma);
5035
              }
5036
 
5037
            /* Set section lma.  */
5038
            r = os->region;
5039
            if (r == NULL)
5040
              r = lang_memory_region_lookup (DEFAULT_MEMORY_REGION, FALSE);
5041
 
5042
            if (os->load_base)
5043
              {
5044
                bfd_vma lma = exp_get_abs_int (os->load_base, 0, "load base");
5045
                os->bfd_section->lma = lma;
5046
              }
5047
            else if (os->lma_region != NULL)
5048
              {
5049
                bfd_vma lma = os->lma_region->current;
5050
 
5051
                if (section_alignment > 0)
5052
                  lma = align_power (lma, section_alignment);
5053
                os->bfd_section->lma = lma;
5054
              }
5055
            else if (r->last_os != NULL
5056
                     && (os->bfd_section->flags & SEC_ALLOC) != 0)
5057
              {
5058
                bfd_vma lma;
5059
                asection *last;
5060
 
5061
                last = r->last_os->output_section_statement.bfd_section;
5062
 
5063
                /* A backwards move of dot should be accompanied by
5064
                   an explicit assignment to the section LMA (ie.
5065
                   os->load_base set) because backwards moves can
5066
                   create overlapping LMAs.  */
5067
                if (dot < last->vma
5068
                    && os->bfd_section->size != 0
5069
                    && dot + os->bfd_section->size <= last->vma)
5070
                  {
5071
                    /* If dot moved backwards then leave lma equal to
5072
                       vma.  This is the old default lma, which might
5073
                       just happen to work when the backwards move is
5074
                       sufficiently large.  Nag if this changes anything,
5075
                       so people can fix their linker scripts.  */
5076
 
5077
                    if (last->vma != last->lma)
5078
                      einfo (_("%P: warning: dot moved backwards before `%s'\n"),
5079
                             os->name);
5080
                  }
5081
                else
5082
                  {
5083
                    /* If this is an overlay, set the current lma to that
5084
                       at the end of the previous section.  */
5085
                    if (os->sectype == overlay_section)
5086
                      lma = last->lma + last->size;
5087
 
5088
                    /* Otherwise, keep the same lma to vma relationship
5089
                       as the previous section.  */
5090
                    else
5091
                      lma = dot + last->lma - last->vma;
5092
 
5093
                    if (section_alignment > 0)
5094
                      lma = align_power (lma, section_alignment);
5095
                    os->bfd_section->lma = lma;
5096
                  }
5097
              }
5098
            os->processed_lma = TRUE;
5099
 
5100
            if (bfd_is_abs_section (os->bfd_section) || os->ignored)
5101
              break;
5102
 
5103
            /* Keep track of normal sections using the default
5104
               lma region.  We use this to set the lma for
5105
               following sections.  Overlays or other linker
5106
               script assignment to lma might mean that the
5107
               default lma == vma is incorrect.
5108
               To avoid warnings about dot moving backwards when using
5109
               -Ttext, don't start tracking sections until we find one
5110
               of non-zero size or with lma set differently to vma.  */
5111
            if (((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5112
                 || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0)
5113
                && (os->bfd_section->flags & SEC_ALLOC) != 0
5114
                && (os->bfd_section->size != 0
5115
                    || (r->last_os == NULL
5116
                        && os->bfd_section->vma != os->bfd_section->lma)
5117
                    || (r->last_os != NULL
5118
                        && dot >= (r->last_os->output_section_statement
5119
                                   .bfd_section->vma)))
5120
                && os->lma_region == NULL
5121
                && !link_info.relocatable)
5122
              r->last_os = s;
5123
 
5124
            /* .tbss sections effectively have zero size.  */
5125
            if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5126
                || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
5127
                || link_info.relocatable)
5128
              dot += TO_ADDR (os->bfd_section->size);
5129
 
5130
            if (os->update_dot_tree != 0)
5131
              exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
5132
 
5133
            /* Update dot in the region ?
5134
               We only do this if the section is going to be allocated,
5135
               since unallocated sections do not contribute to the region's
5136
               overall size in memory.  */
5137
            if (os->region != NULL
5138
                && (os->bfd_section->flags & (SEC_ALLOC | SEC_LOAD)))
5139
              {
5140
                os->region->current = dot;
5141
 
5142
                if (check_regions)
5143
                  /* Make sure the new address is within the region.  */
5144
                  os_region_check (os, os->region, os->addr_tree,
5145
                                   os->bfd_section->vma);
5146
 
5147
                if (os->lma_region != NULL && os->lma_region != os->region
5148
                    && (os->bfd_section->flags & SEC_LOAD))
5149
                  {
5150
                    os->lma_region->current
5151
                      = os->bfd_section->lma + TO_ADDR (os->bfd_section->size);
5152
 
5153
                    if (check_regions)
5154
                      os_region_check (os, os->lma_region, NULL,
5155
                                       os->bfd_section->lma);
5156
                  }
5157
              }
5158
          }
5159
          break;
5160
 
5161
        case lang_constructors_statement_enum:
5162
          dot = lang_size_sections_1 (&constructor_list.head,
5163
                                      output_section_statement,
5164
                                      fill, dot, relax, check_regions);
5165
          break;
5166
 
5167
        case lang_data_statement_enum:
5168
          {
5169
            unsigned int size = 0;
5170
 
5171
            s->data_statement.output_offset =
5172
              dot - output_section_statement->bfd_section->vma;
5173
            s->data_statement.output_section =
5174
              output_section_statement->bfd_section;
5175
 
5176
            /* We might refer to provided symbols in the expression, and
5177
               need to mark them as needed.  */
5178
            exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
5179
 
5180
            switch (s->data_statement.type)
5181
              {
5182
              default:
5183
                abort ();
5184
              case QUAD:
5185
              case SQUAD:
5186
                size = QUAD_SIZE;
5187
                break;
5188
              case LONG:
5189
                size = LONG_SIZE;
5190
                break;
5191
              case SHORT:
5192
                size = SHORT_SIZE;
5193
                break;
5194
              case BYTE:
5195
                size = BYTE_SIZE;
5196
                break;
5197
              }
5198
            if (size < TO_SIZE ((unsigned) 1))
5199
              size = TO_SIZE ((unsigned) 1);
5200
            dot += TO_ADDR (size);
5201
            output_section_statement->bfd_section->size += size;
5202
          }
5203
          break;
5204
 
5205
        case lang_reloc_statement_enum:
5206
          {
5207
            int size;
5208
 
5209
            s->reloc_statement.output_offset =
5210
              dot - output_section_statement->bfd_section->vma;
5211
            s->reloc_statement.output_section =
5212
              output_section_statement->bfd_section;
5213
            size = bfd_get_reloc_size (s->reloc_statement.howto);
5214
            dot += TO_ADDR (size);
5215
            output_section_statement->bfd_section->size += size;
5216
          }
5217
          break;
5218
 
5219
        case lang_wild_statement_enum:
5220
          dot = lang_size_sections_1 (&s->wild_statement.children.head,
5221
                                      output_section_statement,
5222
                                      fill, dot, relax, check_regions);
5223
          break;
5224
 
5225
        case lang_object_symbols_statement_enum:
5226
          link_info.create_object_symbols_section =
5227
            output_section_statement->bfd_section;
5228
          break;
5229
 
5230
        case lang_output_statement_enum:
5231
        case lang_target_statement_enum:
5232
          break;
5233
 
5234
        case lang_input_section_enum:
5235
          {
5236
            asection *i;
5237
 
5238
            i = s->input_section.section;
5239
            if (relax)
5240
              {
5241
                bfd_boolean again;
5242
 
5243
                if (! bfd_relax_section (i->owner, i, &link_info, &again))
5244
                  einfo (_("%P%F: can't relax section: %E\n"));
5245
                if (again)
5246
                  *relax = TRUE;
5247
              }
5248
            dot = size_input_section (prev, output_section_statement,
5249
                                      output_section_statement->fill, dot);
5250
          }
5251
          break;
5252
 
5253
        case lang_input_statement_enum:
5254
          break;
5255
 
5256
        case lang_fill_statement_enum:
5257
          s->fill_statement.output_section =
5258
            output_section_statement->bfd_section;
5259
 
5260
          fill = s->fill_statement.fill;
5261
          break;
5262
 
5263
        case lang_assignment_statement_enum:
5264
          {
5265
            bfd_vma newdot = dot;
5266
            etree_type *tree = s->assignment_statement.exp;
5267
 
5268
            expld.dataseg.relro = exp_dataseg_relro_none;
5269
 
5270
            exp_fold_tree (tree,
5271
                           output_section_statement->bfd_section,
5272
                           &newdot);
5273
 
5274
            if (expld.dataseg.relro == exp_dataseg_relro_start)
5275
              {
5276
                if (!expld.dataseg.relro_start_stat)
5277
                  expld.dataseg.relro_start_stat = s;
5278
                else
5279
                  {
5280
                    ASSERT (expld.dataseg.relro_start_stat == s);
5281
                  }
5282
              }
5283
            else if (expld.dataseg.relro == exp_dataseg_relro_end)
5284
              {
5285
                if (!expld.dataseg.relro_end_stat)
5286
                  expld.dataseg.relro_end_stat = s;
5287
                else
5288
                  {
5289
                    ASSERT (expld.dataseg.relro_end_stat == s);
5290
                  }
5291
              }
5292
            expld.dataseg.relro = exp_dataseg_relro_none;
5293
 
5294
            /* This symbol is relative to this section.  */
5295
            if ((tree->type.node_class == etree_provided
5296
                 || tree->type.node_class == etree_assign)
5297
                && (tree->assign.dst [0] != '.'
5298
                    || tree->assign.dst [1] != '\0'))
5299
              output_section_statement->section_relative_symbol = 1;
5300
 
5301
            if (!output_section_statement->ignored)
5302
              {
5303
                if (output_section_statement == abs_output_section)
5304
                  {
5305
                    /* If we don't have an output section, then just adjust
5306
                       the default memory address.  */
5307
                    lang_memory_region_lookup (DEFAULT_MEMORY_REGION,
5308
                                               FALSE)->current = newdot;
5309
                  }
5310
                else if (newdot != dot)
5311
                  {
5312
                    /* Insert a pad after this statement.  We can't
5313
                       put the pad before when relaxing, in case the
5314
                       assignment references dot.  */
5315
                    insert_pad (&s->header.next, fill, TO_SIZE (newdot - dot),
5316
                                output_section_statement->bfd_section, dot);
5317
 
5318
                    /* Don't neuter the pad below when relaxing.  */
5319
                    s = s->header.next;
5320
 
5321
                    /* If dot is advanced, this implies that the section
5322
                       should have space allocated to it, unless the
5323
                       user has explicitly stated that the section
5324
                       should not be allocated.  */
5325
                    if (output_section_statement->sectype != noalloc_section
5326
                        && (output_section_statement->sectype != noload_section
5327
                            || (bfd_get_flavour (link_info.output_bfd)
5328
                                == bfd_target_elf_flavour)))
5329
                      output_section_statement->bfd_section->flags |= SEC_ALLOC;
5330
                  }
5331
                dot = newdot;
5332
              }
5333
          }
5334
          break;
5335
 
5336
        case lang_padding_statement_enum:
5337
          /* If this is the first time lang_size_sections is called,
5338
             we won't have any padding statements.  If this is the
5339
             second or later passes when relaxing, we should allow
5340
             padding to shrink.  If padding is needed on this pass, it
5341
             will be added back in.  */
5342
          s->padding_statement.size = 0;
5343
 
5344
          /* Make sure output_offset is valid.  If relaxation shrinks
5345
             the section and this pad isn't needed, it's possible to
5346
             have output_offset larger than the final size of the
5347
             section.  bfd_set_section_contents will complain even for
5348
             a pad size of zero.  */
5349
          s->padding_statement.output_offset
5350
            = dot - output_section_statement->bfd_section->vma;
5351
          break;
5352
 
5353
        case lang_group_statement_enum:
5354
          dot = lang_size_sections_1 (&s->group_statement.children.head,
5355
                                      output_section_statement,
5356
                                      fill, dot, relax, check_regions);
5357
          break;
5358
 
5359
        case lang_insert_statement_enum:
5360
          break;
5361
 
5362
          /* We can only get here when relaxing is turned on.  */
5363
        case lang_address_statement_enum:
5364
          break;
5365
 
5366
        default:
5367
          FAIL ();
5368
          break;
5369
        }
5370
      prev = &s->header.next;
5371
    }
5372
  return dot;
5373
}
5374
 
5375
/* Callback routine that is used in _bfd_elf_map_sections_to_segments.
5376
   The BFD library has set NEW_SEGMENT to TRUE iff it thinks that
5377
   CURRENT_SECTION and PREVIOUS_SECTION ought to be placed into different
5378
   segments.  We are allowed an opportunity to override this decision.  */
5379
 
5380
bfd_boolean
5381
ldlang_override_segment_assignment (struct bfd_link_info * info ATTRIBUTE_UNUSED,
5382
                                    bfd * abfd ATTRIBUTE_UNUSED,
5383
                                    asection * current_section,
5384
                                    asection * previous_section,
5385
                                    bfd_boolean new_segment)
5386
{
5387
  lang_output_section_statement_type * cur;
5388
  lang_output_section_statement_type * prev;
5389
 
5390
  /* The checks below are only necessary when the BFD library has decided
5391
     that the two sections ought to be placed into the same segment.  */
5392
  if (new_segment)
5393
    return TRUE;
5394
 
5395
  /* Paranoia checks.  */
5396
  if (current_section == NULL || previous_section == NULL)
5397
    return new_segment;
5398
 
5399
  /* Find the memory regions associated with the two sections.
5400
     We call lang_output_section_find() here rather than scanning the list
5401
     of output sections looking for a matching section pointer because if
5402
     we have a large number of sections then a hash lookup is faster.  */
5403
  cur  = lang_output_section_find (current_section->name);
5404
  prev = lang_output_section_find (previous_section->name);
5405
 
5406
  /* More paranoia.  */
5407
  if (cur == NULL || prev == NULL)
5408
    return new_segment;
5409
 
5410
  /* If the regions are different then force the sections to live in
5411
     different segments.  See the email thread starting at the following
5412
     URL for the reasons why this is necessary:
5413
     http://sourceware.org/ml/binutils/2007-02/msg00216.html  */
5414
  return cur->region != prev->region;
5415
}
5416
 
5417
void
5418
one_lang_size_sections_pass (bfd_boolean *relax, bfd_boolean check_regions)
5419
{
5420
  lang_statement_iteration++;
5421
  lang_size_sections_1 (&statement_list.head, abs_output_section,
5422
                        0, 0, relax, check_regions);
5423
}
5424
 
5425
void
5426
lang_size_sections (bfd_boolean *relax, bfd_boolean check_regions)
5427
{
5428
  expld.phase = lang_allocating_phase_enum;
5429
  expld.dataseg.phase = exp_dataseg_none;
5430
 
5431
  one_lang_size_sections_pass (relax, check_regions);
5432
  if (expld.dataseg.phase == exp_dataseg_end_seen
5433
      && link_info.relro && expld.dataseg.relro_end)
5434
    {
5435
      /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_RELRO_END pair was seen, try
5436
         to put expld.dataseg.relro on a (common) page boundary.  */
5437
      bfd_vma min_base, old_base, relro_end, maxpage;
5438
 
5439
      expld.dataseg.phase = exp_dataseg_relro_adjust;
5440
      maxpage = expld.dataseg.maxpagesize;
5441
      /* MIN_BASE is the absolute minimum address we are allowed to start the
5442
         read-write segment (byte before will be mapped read-only).  */
5443
      min_base = (expld.dataseg.min_base + maxpage - 1) & ~(maxpage - 1);
5444
      /* OLD_BASE is the address for a feasible minimum address which will
5445
         still not cause a data overlap inside MAXPAGE causing file offset skip
5446
         by MAXPAGE.  */
5447
      old_base = expld.dataseg.base;
5448
      expld.dataseg.base += (-expld.dataseg.relro_end
5449
                             & (expld.dataseg.pagesize - 1));
5450
      /* Compute the expected PT_GNU_RELRO segment end.  */
5451
      relro_end = ((expld.dataseg.relro_end + expld.dataseg.pagesize - 1)
5452
                   & ~(expld.dataseg.pagesize - 1));
5453
      if (min_base + maxpage < expld.dataseg.base)
5454
        {
5455
          expld.dataseg.base -= maxpage;
5456
          relro_end -= maxpage;
5457
        }
5458
      lang_reset_memory_regions ();
5459
      one_lang_size_sections_pass (relax, check_regions);
5460
      if (expld.dataseg.relro_end > relro_end)
5461
        {
5462
          /* The alignment of sections between DATA_SEGMENT_ALIGN
5463
             and DATA_SEGMENT_RELRO_END caused huge padding to be
5464
             inserted at DATA_SEGMENT_RELRO_END.  Try to start a bit lower so
5465
             that the section alignments will fit in.  */
5466
          asection *sec;
5467
          unsigned int max_alignment_power = 0;
5468
 
5469
          /* Find maximum alignment power of sections between
5470
             DATA_SEGMENT_ALIGN and DATA_SEGMENT_RELRO_END.  */
5471
          for (sec = link_info.output_bfd->sections; sec; sec = sec->next)
5472
            if (sec->vma >= expld.dataseg.base
5473
                && sec->vma < expld.dataseg.relro_end
5474
                && sec->alignment_power > max_alignment_power)
5475
              max_alignment_power = sec->alignment_power;
5476
 
5477
          if (((bfd_vma) 1 << max_alignment_power) < expld.dataseg.pagesize)
5478
            {
5479
              if (expld.dataseg.base - (1 << max_alignment_power) < old_base)
5480
                expld.dataseg.base += expld.dataseg.pagesize;
5481
              expld.dataseg.base -= (1 << max_alignment_power);
5482
              lang_reset_memory_regions ();
5483
              one_lang_size_sections_pass (relax, check_regions);
5484
            }
5485
        }
5486
      link_info.relro_start = expld.dataseg.base;
5487
      link_info.relro_end = expld.dataseg.relro_end;
5488
    }
5489
  else if (expld.dataseg.phase == exp_dataseg_end_seen)
5490
    {
5491
      /* If DATA_SEGMENT_ALIGN DATA_SEGMENT_END pair was seen, check whether
5492
         a page could be saved in the data segment.  */
5493
      bfd_vma first, last;
5494
 
5495
      first = -expld.dataseg.base & (expld.dataseg.pagesize - 1);
5496
      last = expld.dataseg.end & (expld.dataseg.pagesize - 1);
5497
      if (first && last
5498
          && ((expld.dataseg.base & ~(expld.dataseg.pagesize - 1))
5499
              != (expld.dataseg.end & ~(expld.dataseg.pagesize - 1)))
5500
          && first + last <= expld.dataseg.pagesize)
5501
        {
5502
          expld.dataseg.phase = exp_dataseg_adjust;
5503
          lang_reset_memory_regions ();
5504
          one_lang_size_sections_pass (relax, check_regions);
5505
        }
5506
      else
5507
        expld.dataseg.phase = exp_dataseg_done;
5508
    }
5509
  else
5510
    expld.dataseg.phase = exp_dataseg_done;
5511
}
5512
 
5513
/* Worker function for lang_do_assignments.  Recursiveness goes here.  */
5514
 
5515
static bfd_vma
5516
lang_do_assignments_1 (lang_statement_union_type *s,
5517
                       lang_output_section_statement_type *current_os,
5518
                       fill_type *fill,
5519
                       bfd_vma dot)
5520
{
5521
  for (; s != NULL; s = s->header.next)
5522
    {
5523
      switch (s->header.type)
5524
        {
5525
        case lang_constructors_statement_enum:
5526
          dot = lang_do_assignments_1 (constructor_list.head,
5527
                                       current_os, fill, dot);
5528
          break;
5529
 
5530
        case lang_output_section_statement_enum:
5531
          {
5532
            lang_output_section_statement_type *os;
5533
 
5534
            os = &(s->output_section_statement);
5535
            if (os->bfd_section != NULL && !os->ignored)
5536
              {
5537
                dot = os->bfd_section->vma;
5538
 
5539
                lang_do_assignments_1 (os->children.head, os, os->fill, dot);
5540
 
5541
                /* .tbss sections effectively have zero size.  */
5542
                if ((os->bfd_section->flags & SEC_HAS_CONTENTS) != 0
5543
                    || (os->bfd_section->flags & SEC_THREAD_LOCAL) == 0
5544
                    || link_info.relocatable)
5545
                  dot += TO_ADDR (os->bfd_section->size);
5546
 
5547
                if (os->update_dot_tree != NULL)
5548
                  exp_fold_tree (os->update_dot_tree, bfd_abs_section_ptr, &dot);
5549
              }
5550
          }
5551
          break;
5552
 
5553
        case lang_wild_statement_enum:
5554
 
5555
          dot = lang_do_assignments_1 (s->wild_statement.children.head,
5556
                                       current_os, fill, dot);
5557
          break;
5558
 
5559
        case lang_object_symbols_statement_enum:
5560
        case lang_output_statement_enum:
5561
        case lang_target_statement_enum:
5562
          break;
5563
 
5564
        case lang_data_statement_enum:
5565
          exp_fold_tree (s->data_statement.exp, bfd_abs_section_ptr, &dot);
5566
          if (expld.result.valid_p)
5567
            {
5568
              s->data_statement.value = expld.result.value;
5569
              if (expld.result.section != NULL)
5570
                s->data_statement.value += expld.result.section->vma;
5571
            }
5572
          else
5573
            einfo (_("%F%P: invalid data statement\n"));
5574
          {
5575
            unsigned int size;
5576
            switch (s->data_statement.type)
5577
              {
5578
              default:
5579
                abort ();
5580
              case QUAD:
5581
              case SQUAD:
5582
                size = QUAD_SIZE;
5583
                break;
5584
              case LONG:
5585
                size = LONG_SIZE;
5586
                break;
5587
              case SHORT:
5588
                size = SHORT_SIZE;
5589
                break;
5590
              case BYTE:
5591
                size = BYTE_SIZE;
5592
                break;
5593
              }
5594
            if (size < TO_SIZE ((unsigned) 1))
5595
              size = TO_SIZE ((unsigned) 1);
5596
            dot += TO_ADDR (size);
5597
          }
5598
          break;
5599
 
5600
        case lang_reloc_statement_enum:
5601
          exp_fold_tree (s->reloc_statement.addend_exp,
5602
                         bfd_abs_section_ptr, &dot);
5603
          if (expld.result.valid_p)
5604
            s->reloc_statement.addend_value = expld.result.value;
5605
          else
5606
            einfo (_("%F%P: invalid reloc statement\n"));
5607
          dot += TO_ADDR (bfd_get_reloc_size (s->reloc_statement.howto));
5608
          break;
5609
 
5610
        case lang_input_section_enum:
5611
          {
5612
            asection *in = s->input_section.section;
5613
 
5614
            if ((in->flags & SEC_EXCLUDE) == 0)
5615
              dot += TO_ADDR (in->size);
5616
          }
5617
          break;
5618
 
5619
        case lang_input_statement_enum:
5620
          break;
5621
 
5622
        case lang_fill_statement_enum:
5623
          fill = s->fill_statement.fill;
5624
          break;
5625
 
5626
        case lang_assignment_statement_enum:
5627
          exp_fold_tree (s->assignment_statement.exp,
5628
                         current_os->bfd_section,
5629
                         &dot);
5630
          break;
5631
 
5632
        case lang_padding_statement_enum:
5633
          dot += TO_ADDR (s->padding_statement.size);
5634
          break;
5635
 
5636
        case lang_group_statement_enum:
5637
          dot = lang_do_assignments_1 (s->group_statement.children.head,
5638
                                       current_os, fill, dot);
5639
          break;
5640
 
5641
        case lang_insert_statement_enum:
5642
          break;
5643
 
5644
        case lang_address_statement_enum:
5645
          break;
5646
 
5647
        default:
5648
          FAIL ();
5649
          break;
5650
        }
5651
    }
5652
  return dot;
5653
}
5654
 
5655
void
5656
lang_do_assignments (lang_phase_type phase)
5657
{
5658
  expld.phase = phase;
5659
  lang_statement_iteration++;
5660
  lang_do_assignments_1 (statement_list.head, abs_output_section, NULL, 0);
5661
}
5662
 
5663
/* Fix any .startof. or .sizeof. symbols.  When the assemblers see the
5664
   operator .startof. (section_name), it produces an undefined symbol
5665
   .startof.section_name.  Similarly, when it sees
5666
   .sizeof. (section_name), it produces an undefined symbol
5667
   .sizeof.section_name.  For all the output sections, we look for
5668
   such symbols, and set them to the correct value.  */
5669
 
5670
static void
5671
lang_set_startof (void)
5672
{
5673
  asection *s;
5674
 
5675
  if (link_info.relocatable)
5676
    return;
5677
 
5678
  for (s = link_info.output_bfd->sections; s != NULL; s = s->next)
5679
    {
5680
      const char *secname;
5681
      char *buf;
5682
      struct bfd_link_hash_entry *h;
5683
 
5684
      secname = bfd_get_section_name (link_info.output_bfd, s);
5685
      buf = (char *) xmalloc (10 + strlen (secname));
5686
 
5687
      sprintf (buf, ".startof.%s", secname);
5688
      h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5689
      if (h != NULL && h->type == bfd_link_hash_undefined)
5690
        {
5691
          h->type = bfd_link_hash_defined;
5692
          h->u.def.value = bfd_get_section_vma (link_info.output_bfd, s);
5693
          h->u.def.section = bfd_abs_section_ptr;
5694
        }
5695
 
5696
      sprintf (buf, ".sizeof.%s", secname);
5697
      h = bfd_link_hash_lookup (link_info.hash, buf, FALSE, FALSE, TRUE);
5698
      if (h != NULL && h->type == bfd_link_hash_undefined)
5699
        {
5700
          h->type = bfd_link_hash_defined;
5701
          h->u.def.value = TO_ADDR (s->size);
5702
          h->u.def.section = bfd_abs_section_ptr;
5703
        }
5704
 
5705
      free (buf);
5706
    }
5707
}
5708
 
5709
static void
5710
lang_end (void)
5711
{
5712
  struct bfd_link_hash_entry *h;
5713
  bfd_boolean warn;
5714
 
5715
  if ((link_info.relocatable && !link_info.gc_sections)
5716
      || (link_info.shared && !link_info.executable))
5717
    warn = entry_from_cmdline;
5718
  else
5719
    warn = TRUE;
5720
 
5721
  /* Force the user to specify a root when generating a relocatable with
5722
     --gc-sections.  */
5723
  if (link_info.gc_sections && link_info.relocatable
5724
      && !(entry_from_cmdline || undef_from_cmdline))
5725
    einfo (_("%P%F: gc-sections requires either an entry or "
5726
             "an undefined symbol\n"));
5727
 
5728
  if (entry_symbol.name == NULL)
5729
    {
5730
      /* No entry has been specified.  Look for the default entry, but
5731
         don't warn if we don't find it.  */
5732
      entry_symbol.name = entry_symbol_default;
5733
      warn = FALSE;
5734
    }
5735
 
5736
  h = bfd_link_hash_lookup (link_info.hash, entry_symbol.name,
5737
                            FALSE, FALSE, TRUE);
5738
  if (h != NULL
5739
      && (h->type == bfd_link_hash_defined
5740
          || h->type == bfd_link_hash_defweak)
5741
      && h->u.def.section->output_section != NULL)
5742
    {
5743
      bfd_vma val;
5744
 
5745
      val = (h->u.def.value
5746
             + bfd_get_section_vma (link_info.output_bfd,
5747
                                    h->u.def.section->output_section)
5748
             + h->u.def.section->output_offset);
5749
      if (! bfd_set_start_address (link_info.output_bfd, val))
5750
        einfo (_("%P%F:%s: can't set start address\n"), entry_symbol.name);
5751
    }
5752
  else
5753
    {
5754
      bfd_vma val;
5755
      const char *send;
5756
 
5757
      /* We couldn't find the entry symbol.  Try parsing it as a
5758
         number.  */
5759
      val = bfd_scan_vma (entry_symbol.name, &send, 0);
5760
      if (*send == '\0')
5761
        {
5762
          if (! bfd_set_start_address (link_info.output_bfd, val))
5763
            einfo (_("%P%F: can't set start address\n"));
5764
        }
5765
      else
5766
        {
5767
          asection *ts;
5768
 
5769
          /* Can't find the entry symbol, and it's not a number.  Use
5770
             the first address in the text section.  */
5771
          ts = bfd_get_section_by_name (link_info.output_bfd, entry_section);
5772
          if (ts != NULL)
5773
            {
5774
              if (warn)
5775
                einfo (_("%P: warning: cannot find entry symbol %s;"
5776
                         " defaulting to %V\n"),
5777
                       entry_symbol.name,
5778
                       bfd_get_section_vma (link_info.output_bfd, ts));
5779
              if (!(bfd_set_start_address
5780
                    (link_info.output_bfd,
5781
                     bfd_get_section_vma (link_info.output_bfd, ts))))
5782
                einfo (_("%P%F: can't set start address\n"));
5783
            }
5784
          else
5785
            {
5786
              if (warn)
5787
                einfo (_("%P: warning: cannot find entry symbol %s;"
5788
                         " not setting start address\n"),
5789
                       entry_symbol.name);
5790
            }
5791
        }
5792
    }
5793
 
5794
  /* Don't bfd_hash_table_free (&lang_definedness_table);
5795
     map file output may result in a call of lang_track_definedness.  */
5796
}
5797
 
5798
/* This is a small function used when we want to ignore errors from
5799
   BFD.  */
5800
 
5801
static void
5802
ignore_bfd_errors (const char *s ATTRIBUTE_UNUSED, ...)
5803
{
5804
  /* Don't do anything.  */
5805
}
5806
 
5807
/* Check that the architecture of all the input files is compatible
5808
   with the output file.  Also call the backend to let it do any
5809
   other checking that is needed.  */
5810
 
5811
static void
5812
lang_check (void)
5813
{
5814
  lang_statement_union_type *file;
5815
  bfd *input_bfd;
5816
  const bfd_arch_info_type *compatible;
5817
 
5818
  for (file = file_chain.head; file != NULL; file = file->input_statement.next)
5819
    {
5820
#ifdef ENABLE_PLUGINS
5821
      /* Don't check format of files claimed by plugin.  */
5822
      if (file->input_statement.claimed)
5823
        continue;
5824
#endif /* ENABLE_PLUGINS */
5825
      input_bfd = file->input_statement.the_bfd;
5826
      compatible
5827
        = bfd_arch_get_compatible (input_bfd, link_info.output_bfd,
5828
                                   command_line.accept_unknown_input_arch);
5829
 
5830
      /* In general it is not possible to perform a relocatable
5831
         link between differing object formats when the input
5832
         file has relocations, because the relocations in the
5833
         input format may not have equivalent representations in
5834
         the output format (and besides BFD does not translate
5835
         relocs for other link purposes than a final link).  */
5836
      if ((link_info.relocatable || link_info.emitrelocations)
5837
          && (compatible == NULL
5838
              || (bfd_get_flavour (input_bfd)
5839
                  != bfd_get_flavour (link_info.output_bfd)))
5840
          && (bfd_get_file_flags (input_bfd) & HAS_RELOC) != 0)
5841
        {
5842
          einfo (_("%P%F: Relocatable linking with relocations from"
5843
                   " format %s (%B) to format %s (%B) is not supported\n"),
5844
                 bfd_get_target (input_bfd), input_bfd,
5845
                 bfd_get_target (link_info.output_bfd), link_info.output_bfd);
5846
          /* einfo with %F exits.  */
5847
        }
5848
 
5849
      if (compatible == NULL)
5850
        {
5851
          if (command_line.warn_mismatch)
5852
            einfo (_("%P%X: %s architecture of input file `%B'"
5853
                     " is incompatible with %s output\n"),
5854
                   bfd_printable_name (input_bfd), input_bfd,
5855
                   bfd_printable_name (link_info.output_bfd));
5856
        }
5857
      else if (bfd_count_sections (input_bfd))
5858
        {
5859
          /* If the input bfd has no contents, it shouldn't set the
5860
             private data of the output bfd.  */
5861
 
5862
          bfd_error_handler_type pfn = NULL;
5863
 
5864
          /* If we aren't supposed to warn about mismatched input
5865
             files, temporarily set the BFD error handler to a
5866
             function which will do nothing.  We still want to call
5867
             bfd_merge_private_bfd_data, since it may set up
5868
             information which is needed in the output file.  */
5869
          if (! command_line.warn_mismatch)
5870
            pfn = bfd_set_error_handler (ignore_bfd_errors);
5871
          if (! bfd_merge_private_bfd_data (input_bfd, link_info.output_bfd))
5872
            {
5873
              if (command_line.warn_mismatch)
5874
                einfo (_("%P%X: failed to merge target specific data"
5875
                         " of file %B\n"), input_bfd);
5876
            }
5877
          if (! command_line.warn_mismatch)
5878
            bfd_set_error_handler (pfn);
5879
        }
5880
    }
5881
}
5882
 
5883
/* Look through all the global common symbols and attach them to the
5884
   correct section.  The -sort-common command line switch may be used
5885
   to roughly sort the entries by alignment.  */
5886
 
5887
static void
5888
lang_common (void)
5889
{
5890
  if (command_line.inhibit_common_definition)
5891
    return;
5892
  if (link_info.relocatable
5893
      && ! command_line.force_common_definition)
5894
    return;
5895
 
5896
  if (! config.sort_common)
5897
    bfd_link_hash_traverse (link_info.hash, lang_one_common, NULL);
5898
  else
5899
    {
5900
      unsigned int power;
5901
 
5902
      if (config.sort_common == sort_descending)
5903
        {
5904
          for (power = 4; power > 0; power--)
5905
            bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5906
 
5907
          power = 0;
5908
          bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5909
        }
5910
      else
5911
        {
5912
          for (power = 0; power <= 4; power++)
5913
            bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5914
 
5915
          power = UINT_MAX;
5916
          bfd_link_hash_traverse (link_info.hash, lang_one_common, &power);
5917
        }
5918
    }
5919
}
5920
 
5921
/* Place one common symbol in the correct section.  */
5922
 
5923
static bfd_boolean
5924
lang_one_common (struct bfd_link_hash_entry *h, void *info)
5925
{
5926
  unsigned int power_of_two;
5927
  bfd_vma size;
5928
  asection *section;
5929
 
5930
  if (h->type != bfd_link_hash_common)
5931
    return TRUE;
5932
 
5933
  size = h->u.c.size;
5934
  power_of_two = h->u.c.p->alignment_power;
5935
 
5936
  if (config.sort_common == sort_descending
5937
      && power_of_two < *(unsigned int *) info)
5938
    return TRUE;
5939
  else if (config.sort_common == sort_ascending
5940
           && power_of_two > *(unsigned int *) info)
5941
    return TRUE;
5942
 
5943
  section = h->u.c.p->section;
5944
  if (!bfd_define_common_symbol (link_info.output_bfd, &link_info, h))
5945
    einfo (_("%P%F: Could not define common symbol `%T': %E\n"),
5946
           h->root.string);
5947
 
5948
  if (config.map_file != NULL)
5949
    {
5950
      static bfd_boolean header_printed;
5951
      int len;
5952
      char *name;
5953
      char buf[50];
5954
 
5955
      if (! header_printed)
5956
        {
5957
          minfo (_("\nAllocating common symbols\n"));
5958
          minfo (_("Common symbol       size              file\n\n"));
5959
          header_printed = TRUE;
5960
        }
5961
 
5962
      name = bfd_demangle (link_info.output_bfd, h->root.string,
5963
                           DMGL_ANSI | DMGL_PARAMS);
5964
      if (name == NULL)
5965
        {
5966
          minfo ("%s", h->root.string);
5967
          len = strlen (h->root.string);
5968
        }
5969
      else
5970
        {
5971
          minfo ("%s", name);
5972
          len = strlen (name);
5973
          free (name);
5974
        }
5975
 
5976
      if (len >= 19)
5977
        {
5978
          print_nl ();
5979
          len = 0;
5980
        }
5981
      while (len < 20)
5982
        {
5983
          print_space ();
5984
          ++len;
5985
        }
5986
 
5987
      minfo ("0x");
5988
      if (size <= 0xffffffff)
5989
        sprintf (buf, "%lx", (unsigned long) size);
5990
      else
5991
        sprintf_vma (buf, size);
5992
      minfo ("%s", buf);
5993
      len = strlen (buf);
5994
 
5995
      while (len < 16)
5996
        {
5997
          print_space ();
5998
          ++len;
5999
        }
6000
 
6001
      minfo ("%B\n", section->owner);
6002
    }
6003
 
6004
  return TRUE;
6005
}
6006
 
6007
/* Run through the input files and ensure that every input section has
6008
   somewhere to go.  If one is found without a destination then create
6009
   an input request and place it into the statement tree.  */
6010
 
6011
static void
6012
lang_place_orphans (void)
6013
{
6014
  LANG_FOR_EACH_INPUT_STATEMENT (file)
6015
    {
6016
      asection *s;
6017
 
6018
      for (s = file->the_bfd->sections; s != NULL; s = s->next)
6019
        {
6020
          if (s->output_section == NULL)
6021
            {
6022
              /* This section of the file is not attached, root
6023
                 around for a sensible place for it to go.  */
6024
 
6025
              if (file->just_syms_flag)
6026
                bfd_link_just_syms (file->the_bfd, s, &link_info);
6027
              else if ((s->flags & SEC_EXCLUDE) != 0)
6028
                s->output_section = bfd_abs_section_ptr;
6029
              else if (strcmp (s->name, "COMMON") == 0)
6030
                {
6031
                  /* This is a lonely common section which must have
6032
                     come from an archive.  We attach to the section
6033
                     with the wildcard.  */
6034
                  if (! link_info.relocatable
6035
                      || command_line.force_common_definition)
6036
                    {
6037
                      if (default_common_section == NULL)
6038
                        default_common_section
6039
                          = lang_output_section_statement_lookup (".bss", 0,
6040
                                                                  TRUE);
6041
                      lang_add_section (&default_common_section->children, s,
6042
                                        default_common_section);
6043
                    }
6044
                }
6045
              else
6046
                {
6047
                  const char *name = s->name;
6048
                  int constraint = 0;
6049
 
6050
                  if (config.unique_orphan_sections
6051
                      || unique_section_p (s, NULL))
6052
                    constraint = SPECIAL;
6053
 
6054
                  if (!ldemul_place_orphan (s, name, constraint))
6055
                    {
6056
                      lang_output_section_statement_type *os;
6057
                      os = lang_output_section_statement_lookup (name,
6058
                                                                 constraint,
6059
                                                                 TRUE);
6060
                      if (os->addr_tree == NULL
6061
                          && (link_info.relocatable
6062
                              || (s->flags & (SEC_LOAD | SEC_ALLOC)) == 0))
6063
                        os->addr_tree = exp_intop (0);
6064
                      lang_add_section (&os->children, s, os);
6065
                    }
6066
                }
6067
            }
6068
        }
6069
    }
6070
}
6071
 
6072
void
6073
lang_set_flags (lang_memory_region_type *ptr, const char *flags, int invert)
6074
{
6075
  flagword *ptr_flags;
6076
 
6077
  ptr_flags = invert ? &ptr->not_flags : &ptr->flags;
6078
  while (*flags)
6079
    {
6080
      switch (*flags)
6081
        {
6082
        case 'A': case 'a':
6083
          *ptr_flags |= SEC_ALLOC;
6084
          break;
6085
 
6086
        case 'R': case 'r':
6087
          *ptr_flags |= SEC_READONLY;
6088
          break;
6089
 
6090
        case 'W': case 'w':
6091
          *ptr_flags |= SEC_DATA;
6092
          break;
6093
 
6094
        case 'X': case 'x':
6095
          *ptr_flags |= SEC_CODE;
6096
          break;
6097
 
6098
        case 'L': case 'l':
6099
        case 'I': case 'i':
6100
          *ptr_flags |= SEC_LOAD;
6101
          break;
6102
 
6103
        default:
6104
          einfo (_("%P%F: invalid syntax in flags\n"));
6105
          break;
6106
        }
6107
      flags++;
6108
    }
6109
}
6110
 
6111
/* Call a function on each input file.  This function will be called
6112
   on an archive, but not on the elements.  */
6113
 
6114
void
6115
lang_for_each_input_file (void (*func) (lang_input_statement_type *))
6116
{
6117
  lang_input_statement_type *f;
6118
 
6119
  for (f = (lang_input_statement_type *) input_file_chain.head;
6120
       f != NULL;
6121
       f = (lang_input_statement_type *) f->next_real_file)
6122
    func (f);
6123
}
6124
 
6125
/* Call a function on each file.  The function will be called on all
6126
   the elements of an archive which are included in the link, but will
6127
   not be called on the archive file itself.  */
6128
 
6129
void
6130
lang_for_each_file (void (*func) (lang_input_statement_type *))
6131
{
6132
  LANG_FOR_EACH_INPUT_STATEMENT (f)
6133
    {
6134
      func (f);
6135
    }
6136
}
6137
 
6138
void
6139
ldlang_add_file (lang_input_statement_type *entry)
6140
{
6141
  lang_statement_append (&file_chain,
6142
                         (lang_statement_union_type *) entry,
6143
                         &entry->next);
6144
 
6145
  /* The BFD linker needs to have a list of all input BFDs involved in
6146
     a link.  */
6147
  ASSERT (entry->the_bfd->link_next == NULL);
6148
  ASSERT (entry->the_bfd != link_info.output_bfd);
6149
 
6150
  *link_info.input_bfds_tail = entry->the_bfd;
6151
  link_info.input_bfds_tail = &entry->the_bfd->link_next;
6152
  entry->the_bfd->usrdata = entry;
6153
  bfd_set_gp_size (entry->the_bfd, g_switch_value);
6154
 
6155
  /* Look through the sections and check for any which should not be
6156
     included in the link.  We need to do this now, so that we can
6157
     notice when the backend linker tries to report multiple
6158
     definition errors for symbols which are in sections we aren't
6159
     going to link.  FIXME: It might be better to entirely ignore
6160
     symbols which are defined in sections which are going to be
6161
     discarded.  This would require modifying the backend linker for
6162
     each backend which might set the SEC_LINK_ONCE flag.  If we do
6163
     this, we should probably handle SEC_EXCLUDE in the same way.  */
6164
 
6165
  bfd_map_over_sections (entry->the_bfd, section_already_linked, entry);
6166
}
6167
 
6168
void
6169
lang_add_output (const char *name, int from_script)
6170
{
6171
  /* Make -o on command line override OUTPUT in script.  */
6172
  if (!had_output_filename || !from_script)
6173
    {
6174
      output_filename = name;
6175
      had_output_filename = TRUE;
6176
    }
6177
}
6178
 
6179
static lang_output_section_statement_type *current_section;
6180
 
6181
static int
6182
topower (int x)
6183
{
6184
  unsigned int i = 1;
6185
  int l;
6186
 
6187
  if (x < 0)
6188
    return -1;
6189
 
6190
  for (l = 0; l < 32; l++)
6191
    {
6192
      if (i >= (unsigned int) x)
6193
        return l;
6194
      i <<= 1;
6195
    }
6196
 
6197
  return 0;
6198
}
6199
 
6200
lang_output_section_statement_type *
6201
lang_enter_output_section_statement (const char *output_section_statement_name,
6202
                                     etree_type *address_exp,
6203
                                     enum section_type sectype,
6204
                                     etree_type *align,
6205
                                     etree_type *subalign,
6206
                                     etree_type *ebase,
6207
                                     int constraint)
6208
{
6209
  lang_output_section_statement_type *os;
6210
 
6211
  os = lang_output_section_statement_lookup (output_section_statement_name,
6212
                                             constraint, TRUE);
6213
  current_section = os;
6214
 
6215
  if (os->addr_tree == NULL)
6216
    {
6217
      os->addr_tree = address_exp;
6218
    }
6219
  os->sectype = sectype;
6220
  if (sectype != noload_section)
6221
    os->flags = SEC_NO_FLAGS;
6222
  else
6223
    os->flags = SEC_NEVER_LOAD;
6224
  os->block_value = 1;
6225
 
6226
  /* Make next things chain into subchain of this.  */
6227
  push_stat_ptr (&os->children);
6228
 
6229
  os->subsection_alignment =
6230
    topower (exp_get_value_int (subalign, -1, "subsection alignment"));
6231
  os->section_alignment =
6232
    topower (exp_get_value_int (align, -1, "section alignment"));
6233
 
6234
  os->load_base = ebase;
6235
  return os;
6236
}
6237
 
6238
void
6239
lang_final (void)
6240
{
6241
  lang_output_statement_type *new_stmt;
6242
 
6243
  new_stmt = new_stat (lang_output_statement, stat_ptr);
6244
  new_stmt->name = output_filename;
6245
 
6246
}
6247
 
6248
/* Reset the current counters in the regions.  */
6249
 
6250
void
6251
lang_reset_memory_regions (void)
6252
{
6253
  lang_memory_region_type *p = lang_memory_region_list;
6254
  asection *o;
6255
  lang_output_section_statement_type *os;
6256
 
6257
  for (p = lang_memory_region_list; p != NULL; p = p->next)
6258
    {
6259
      p->current = p->origin;
6260
      p->last_os = NULL;
6261
    }
6262
 
6263
  for (os = &lang_output_section_statement.head->output_section_statement;
6264
       os != NULL;
6265
       os = os->next)
6266
    {
6267
      os->processed_vma = FALSE;
6268
      os->processed_lma = FALSE;
6269
    }
6270
 
6271
  for (o = link_info.output_bfd->sections; o != NULL; o = o->next)
6272
    {
6273
      /* Save the last size for possible use by bfd_relax_section.  */
6274
      o->rawsize = o->size;
6275
      o->size = 0;
6276
    }
6277
}
6278
 
6279
/* Worker for lang_gc_sections_1.  */
6280
 
6281
static void
6282
gc_section_callback (lang_wild_statement_type *ptr,
6283
                     struct wildcard_list *sec ATTRIBUTE_UNUSED,
6284
                     asection *section,
6285
                     lang_input_statement_type *file ATTRIBUTE_UNUSED,
6286
                     void *data ATTRIBUTE_UNUSED)
6287
{
6288
  /* If the wild pattern was marked KEEP, the member sections
6289
     should be as well.  */
6290
  if (ptr->keep_sections)
6291
    section->flags |= SEC_KEEP;
6292
}
6293
 
6294
/* Iterate over sections marking them against GC.  */
6295
 
6296
static void
6297
lang_gc_sections_1 (lang_statement_union_type *s)
6298
{
6299
  for (; s != NULL; s = s->header.next)
6300
    {
6301
      switch (s->header.type)
6302
        {
6303
        case lang_wild_statement_enum:
6304
          walk_wild (&s->wild_statement, gc_section_callback, NULL);
6305
          break;
6306
        case lang_constructors_statement_enum:
6307
          lang_gc_sections_1 (constructor_list.head);
6308
          break;
6309
        case lang_output_section_statement_enum:
6310
          lang_gc_sections_1 (s->output_section_statement.children.head);
6311
          break;
6312
        case lang_group_statement_enum:
6313
          lang_gc_sections_1 (s->group_statement.children.head);
6314
          break;
6315
        default:
6316
          break;
6317
        }
6318
    }
6319
}
6320
 
6321
static void
6322
lang_gc_sections (void)
6323
{
6324
  /* Keep all sections so marked in the link script.  */
6325
 
6326
  lang_gc_sections_1 (statement_list.head);
6327
 
6328
  /* SEC_EXCLUDE is ignored when doing a relocatable link, except in
6329
     the special case of debug info.  (See bfd/stabs.c)
6330
     Twiddle the flag here, to simplify later linker code.  */
6331
  if (link_info.relocatable)
6332
    {
6333
      LANG_FOR_EACH_INPUT_STATEMENT (f)
6334
        {
6335
          asection *sec;
6336
#ifdef ENABLE_PLUGINS
6337
          if (f->claimed)
6338
            continue;
6339
#endif
6340
          for (sec = f->the_bfd->sections; sec != NULL; sec = sec->next)
6341
            if ((sec->flags & SEC_DEBUGGING) == 0)
6342
              sec->flags &= ~SEC_EXCLUDE;
6343
        }
6344
    }
6345
 
6346
  if (link_info.gc_sections)
6347
    bfd_gc_sections (link_info.output_bfd, &link_info);
6348
}
6349
 
6350
/* Worker for lang_find_relro_sections_1.  */
6351
 
6352
static void
6353
find_relro_section_callback (lang_wild_statement_type *ptr ATTRIBUTE_UNUSED,
6354
                             struct wildcard_list *sec ATTRIBUTE_UNUSED,
6355
                             asection *section,
6356
                             lang_input_statement_type *file ATTRIBUTE_UNUSED,
6357
                             void *data)
6358
{
6359
  /* Discarded, excluded and ignored sections effectively have zero
6360
     size.  */
6361
  if (section->output_section != NULL
6362
      && section->output_section->owner == link_info.output_bfd
6363
      && (section->output_section->flags & SEC_EXCLUDE) == 0
6364
      && !IGNORE_SECTION (section)
6365
      && section->size != 0)
6366
    {
6367
      bfd_boolean *has_relro_section = (bfd_boolean *) data;
6368
      *has_relro_section = TRUE;
6369
    }
6370
}
6371
 
6372
/* Iterate over sections for relro sections.  */
6373
 
6374
static void
6375
lang_find_relro_sections_1 (lang_statement_union_type *s,
6376
                            bfd_boolean *has_relro_section)
6377
{
6378
  if (*has_relro_section)
6379
    return;
6380
 
6381
  for (; s != NULL; s = s->header.next)
6382
    {
6383
      if (s == expld.dataseg.relro_end_stat)
6384
        break;
6385
 
6386
      switch (s->header.type)
6387
        {
6388
        case lang_wild_statement_enum:
6389
          walk_wild (&s->wild_statement,
6390
                     find_relro_section_callback,
6391
                     has_relro_section);
6392
          break;
6393
        case lang_constructors_statement_enum:
6394
          lang_find_relro_sections_1 (constructor_list.head,
6395
                                      has_relro_section);
6396
          break;
6397
        case lang_output_section_statement_enum:
6398
          lang_find_relro_sections_1 (s->output_section_statement.children.head,
6399
                                      has_relro_section);
6400
          break;
6401
        case lang_group_statement_enum:
6402
          lang_find_relro_sections_1 (s->group_statement.children.head,
6403
                                      has_relro_section);
6404
          break;
6405
        default:
6406
          break;
6407
        }
6408
    }
6409
}
6410
 
6411
static void
6412
lang_find_relro_sections (void)
6413
{
6414
  bfd_boolean has_relro_section = FALSE;
6415
 
6416
  /* Check all sections in the link script.  */
6417
 
6418
  lang_find_relro_sections_1 (expld.dataseg.relro_start_stat,
6419
                              &has_relro_section);
6420
 
6421
  if (!has_relro_section)
6422
    link_info.relro = FALSE;
6423
}
6424
 
6425
/* Relax all sections until bfd_relax_section gives up.  */
6426
 
6427
void
6428
lang_relax_sections (bfd_boolean need_layout)
6429
{
6430
  if (RELAXATION_ENABLED)
6431
    {
6432
      /* We may need more than one relaxation pass.  */
6433
      int i = link_info.relax_pass;
6434
 
6435
      /* The backend can use it to determine the current pass.  */
6436
      link_info.relax_pass = 0;
6437
 
6438
      while (i--)
6439
        {
6440
          /* Keep relaxing until bfd_relax_section gives up.  */
6441
          bfd_boolean relax_again;
6442
 
6443
          link_info.relax_trip = -1;
6444
          do
6445
            {
6446
              link_info.relax_trip++;
6447
 
6448
              /* Note: pe-dll.c does something like this also.  If you find
6449
                 you need to change this code, you probably need to change
6450
                 pe-dll.c also.  DJ  */
6451
 
6452
              /* Do all the assignments with our current guesses as to
6453
                 section sizes.  */
6454
              lang_do_assignments (lang_assigning_phase_enum);
6455
 
6456
              /* We must do this after lang_do_assignments, because it uses
6457
                 size.  */
6458
              lang_reset_memory_regions ();
6459
 
6460
              /* Perform another relax pass - this time we know where the
6461
                 globals are, so can make a better guess.  */
6462
              relax_again = FALSE;
6463
              lang_size_sections (&relax_again, FALSE);
6464
            }
6465
          while (relax_again);
6466
 
6467
          link_info.relax_pass++;
6468
        }
6469
      need_layout = TRUE;
6470
    }
6471
 
6472
  if (need_layout)
6473
    {
6474
      /* Final extra sizing to report errors.  */
6475
      lang_do_assignments (lang_assigning_phase_enum);
6476
      lang_reset_memory_regions ();
6477
      lang_size_sections (NULL, TRUE);
6478
    }
6479
}
6480
 
6481
#ifdef ENABLE_PLUGINS
6482
/* Find the insert point for the plugin's replacement files.  We
6483
   place them after the first claimed real object file, or if the
6484
   first claimed object is an archive member, after the last real
6485
   object file immediately preceding the archive.  In the event
6486
   no objects have been claimed at all, we return the first dummy
6487
   object file on the list as the insert point; that works, but
6488
   the callee must be careful when relinking the file_chain as it
6489
   is not actually on that chain, only the statement_list and the
6490
   input_file list; in that case, the replacement files must be
6491
   inserted at the head of the file_chain.  */
6492
 
6493
static lang_input_statement_type *
6494
find_replacements_insert_point (void)
6495
{
6496
  lang_input_statement_type *claim1, *lastobject;
6497
  lastobject = &input_file_chain.head->input_statement;
6498
  for (claim1 = &file_chain.head->input_statement;
6499
       claim1 != NULL;
6500
       claim1 = &claim1->next->input_statement)
6501
    {
6502
      if (claim1->claimed)
6503
        return claim1->claim_archive ? lastobject : claim1;
6504
      /* Update lastobject if this is a real object file.  */
6505
      if (claim1->the_bfd && (claim1->the_bfd->my_archive == NULL))
6506
        lastobject = claim1;
6507
    }
6508
  /* No files were claimed by the plugin.  Choose the last object
6509
     file found on the list (maybe the first, dummy entry) as the
6510
     insert point.  */
6511
  return lastobject;
6512
}
6513
 
6514
/* Insert SRCLIST into DESTLIST after given element by chaining
6515
   on FIELD as the next-pointer.  (Counterintuitively does not need
6516
   a pointer to the actual after-node itself, just its chain field.)  */
6517
 
6518
static void
6519
lang_list_insert_after (lang_statement_list_type *destlist,
6520
                        lang_statement_list_type *srclist,
6521
                        lang_statement_union_type **field)
6522
{
6523
  *(srclist->tail) = *field;
6524
  *field = srclist->head;
6525
  if (destlist->tail == field)
6526
    destlist->tail = srclist->tail;
6527
}
6528
 
6529
/* Detach new nodes added to DESTLIST since the time ORIGLIST
6530
   was taken as a copy of it and leave them in ORIGLIST.  */
6531
 
6532
static void
6533
lang_list_remove_tail (lang_statement_list_type *destlist,
6534
                       lang_statement_list_type *origlist)
6535
{
6536
  union lang_statement_union **savetail;
6537
  /* Check that ORIGLIST really is an earlier state of DESTLIST.  */
6538
  ASSERT (origlist->head == destlist->head);
6539
  savetail = origlist->tail;
6540
  origlist->head = *(savetail);
6541
  origlist->tail = destlist->tail;
6542
  destlist->tail = savetail;
6543
  *savetail = NULL;
6544
}
6545
#endif /* ENABLE_PLUGINS */
6546
 
6547
void
6548
lang_process (void)
6549
{
6550
  /* Finalize dynamic list.  */
6551
  if (link_info.dynamic_list)
6552
    lang_finalize_version_expr_head (&link_info.dynamic_list->head);
6553
 
6554
  current_target = default_target;
6555
 
6556
  /* Open the output file.  */
6557
  lang_for_each_statement (ldlang_open_output);
6558
  init_opb ();
6559
 
6560
  ldemul_create_output_section_statements ();
6561
 
6562
  /* Add to the hash table all undefineds on the command line.  */
6563
  lang_place_undefineds ();
6564
 
6565
  if (!bfd_section_already_linked_table_init ())
6566
    einfo (_("%P%F: Failed to create hash table\n"));
6567
 
6568
  /* Create a bfd for each input file.  */
6569
  current_target = default_target;
6570
  open_input_bfds (statement_list.head, OPEN_BFD_NORMAL);
6571
 
6572
#ifdef ENABLE_PLUGINS
6573
  if (plugin_active_plugins_p ())
6574
    {
6575
      lang_statement_list_type added;
6576
      lang_statement_list_type files, inputfiles;
6577
 
6578
      /* Now all files are read, let the plugin(s) decide if there
6579
         are any more to be added to the link before we call the
6580
         emulation's after_open hook.  We create a private list of
6581
         input statements for this purpose, which we will eventually
6582
         insert into the global statment list after the first claimed
6583
         file.  */
6584
      added = *stat_ptr;
6585
      /* We need to manipulate all three chains in synchrony.  */
6586
      files = file_chain;
6587
      inputfiles = input_file_chain;
6588
      if (plugin_call_all_symbols_read ())
6589
        einfo (_("%P%F: %s: plugin reported error after all symbols read\n"),
6590
               plugin_error_plugin ());
6591
      /* Open any newly added files, updating the file chains.  */
6592 157 khays
      link_info.loading_lto_outputs = TRUE;
6593 166 khays
      open_input_bfds (*added.tail, OPEN_BFD_NORMAL);
6594 145 khays
      /* Restore the global list pointer now they have all been added.  */
6595
      lang_list_remove_tail (stat_ptr, &added);
6596
      /* And detach the fresh ends of the file lists.  */
6597
      lang_list_remove_tail (&file_chain, &files);
6598
      lang_list_remove_tail (&input_file_chain, &inputfiles);
6599
      /* Were any new files added?  */
6600
      if (added.head != NULL)
6601
        {
6602
          /* If so, we will insert them into the statement list immediately
6603
             after the first input file that was claimed by the plugin.  */
6604
          plugin_insert = find_replacements_insert_point ();
6605
          /* If a plugin adds input files without having claimed any, we
6606
             don't really have a good idea where to place them.  Just putting
6607
             them at the start or end of the list is liable to leave them
6608
             outside the crtbegin...crtend range.  */
6609
          ASSERT (plugin_insert != NULL);
6610
          /* Splice the new statement list into the old one.  */
6611
          lang_list_insert_after (stat_ptr, &added,
6612
                                  &plugin_insert->header.next);
6613
          /* Likewise for the file chains.  */
6614
          lang_list_insert_after (&input_file_chain, &inputfiles,
6615
                                  &plugin_insert->next_real_file);
6616
          /* We must be careful when relinking file_chain; we may need to
6617
             insert the new files at the head of the list if the insert
6618
             point chosen is the dummy first input file.  */
6619
          if (plugin_insert->filename)
6620
            lang_list_insert_after (&file_chain, &files, &plugin_insert->next);
6621
          else
6622
            lang_list_insert_after (&file_chain, &files, &file_chain.head);
6623
 
6624
          /* Rescan archives in case new undefined symbols have appeared.  */
6625
          open_input_bfds (statement_list.head, OPEN_BFD_RESCAN);
6626
        }
6627
    }
6628
#endif /* ENABLE_PLUGINS */
6629
 
6630
  link_info.gc_sym_list = &entry_symbol;
6631
  if (entry_symbol.name == NULL)
6632
    link_info.gc_sym_list = ldlang_undef_chain_list_head;
6633
 
6634
  ldemul_after_open ();
6635
 
6636
  bfd_section_already_linked_table_free ();
6637
 
6638
  /* Make sure that we're not mixing architectures.  We call this
6639
     after all the input files have been opened, but before we do any
6640
     other processing, so that any operations merge_private_bfd_data
6641
     does on the output file will be known during the rest of the
6642
     link.  */
6643
  lang_check ();
6644
 
6645
  /* Handle .exports instead of a version script if we're told to do so.  */
6646
  if (command_line.version_exports_section)
6647
    lang_do_version_exports_section ();
6648
 
6649
  /* Build all sets based on the information gathered from the input
6650
     files.  */
6651
  ldctor_build_sets ();
6652
 
6653 166 khays
  /* PR 13683: We must rerun the assignments prior to running garbage
6654
     collection in order to make sure that all symbol aliases are resolved.  */
6655
  lang_do_assignments (lang_mark_phase_enum);
6656
  expld.phase = lang_first_phase_enum;
6657
 
6658 145 khays
  /* Remove unreferenced sections if asked to.  */
6659
  lang_gc_sections ();
6660
 
6661
  /* Size up the common data.  */
6662
  lang_common ();
6663
 
6664
  /* Update wild statements.  */
6665
  update_wild_statements (statement_list.head);
6666
 
6667
  /* Run through the contours of the script and attach input sections
6668
     to the correct output sections.  */
6669
  lang_statement_iteration++;
6670
  map_input_to_output_sections (statement_list.head, NULL, NULL);
6671
 
6672
  process_insert_statements ();
6673
 
6674
  /* Find any sections not attached explicitly and handle them.  */
6675
  lang_place_orphans ();
6676
 
6677
  if (! link_info.relocatable)
6678
    {
6679
      asection *found;
6680
 
6681
      /* Merge SEC_MERGE sections.  This has to be done after GC of
6682
         sections, so that GCed sections are not merged, but before
6683
         assigning dynamic symbols, since removing whole input sections
6684
         is hard then.  */
6685
      bfd_merge_sections (link_info.output_bfd, &link_info);
6686
 
6687
      /* Look for a text section and set the readonly attribute in it.  */
6688
      found = bfd_get_section_by_name (link_info.output_bfd, ".text");
6689
 
6690
      if (found != NULL)
6691
        {
6692
          if (config.text_read_only)
6693
            found->flags |= SEC_READONLY;
6694
          else
6695
            found->flags &= ~SEC_READONLY;
6696
        }
6697
    }
6698
 
6699
  /* Do anything special before sizing sections.  This is where ELF
6700
     and other back-ends size dynamic sections.  */
6701
  ldemul_before_allocation ();
6702
 
6703
  /* We must record the program headers before we try to fix the
6704
     section positions, since they will affect SIZEOF_HEADERS.  */
6705
  lang_record_phdrs ();
6706
 
6707
  /* Check relro sections.  */
6708
  if (link_info.relro && ! link_info.relocatable)
6709
    lang_find_relro_sections ();
6710
 
6711
  /* Size up the sections.  */
6712
  lang_size_sections (NULL, ! RELAXATION_ENABLED);
6713
 
6714
  /* See if anything special should be done now we know how big
6715
     everything is.  This is where relaxation is done.  */
6716
  ldemul_after_allocation ();
6717
 
6718
  /* Fix any .startof. or .sizeof. symbols.  */
6719
  lang_set_startof ();
6720
 
6721
  /* Do all the assignments, now that we know the final resting places
6722
     of all the symbols.  */
6723
  lang_do_assignments (lang_final_phase_enum);
6724
 
6725
  ldemul_finish ();
6726
 
6727
  /* Make sure that the section addresses make sense.  */
6728
  if (command_line.check_section_addresses)
6729
    lang_check_section_addresses ();
6730
 
6731
  lang_end ();
6732
}
6733
 
6734
/* EXPORTED TO YACC */
6735
 
6736
void
6737
lang_add_wild (struct wildcard_spec *filespec,
6738
               struct wildcard_list *section_list,
6739
               bfd_boolean keep_sections)
6740
{
6741
  struct wildcard_list *curr, *next;
6742
  lang_wild_statement_type *new_stmt;
6743
 
6744
  /* Reverse the list as the parser puts it back to front.  */
6745
  for (curr = section_list, section_list = NULL;
6746
       curr != NULL;
6747
       section_list = curr, curr = next)
6748
    {
6749
      if (curr->spec.name != NULL && strcmp (curr->spec.name, "COMMON") == 0)
6750
        placed_commons = TRUE;
6751
 
6752
      next = curr->next;
6753
      curr->next = section_list;
6754
    }
6755
 
6756
  if (filespec != NULL && filespec->name != NULL)
6757
    {
6758
      if (strcmp (filespec->name, "*") == 0)
6759
        filespec->name = NULL;
6760
      else if (! wildcardp (filespec->name))
6761
        lang_has_input_file = TRUE;
6762
    }
6763
 
6764
  new_stmt = new_stat (lang_wild_statement, stat_ptr);
6765
  new_stmt->filename = NULL;
6766
  new_stmt->filenames_sorted = FALSE;
6767 157 khays
  new_stmt->section_flag_list = NULL;
6768 145 khays
  if (filespec != NULL)
6769
    {
6770
      new_stmt->filename = filespec->name;
6771
      new_stmt->filenames_sorted = filespec->sorted == by_name;
6772 157 khays
      new_stmt->section_flag_list = filespec->section_flag_list;
6773 145 khays
    }
6774
  new_stmt->section_list = section_list;
6775
  new_stmt->keep_sections = keep_sections;
6776
  lang_list_init (&new_stmt->children);
6777
  analyze_walk_wild_section_handler (new_stmt);
6778
}
6779
 
6780
void
6781
lang_section_start (const char *name, etree_type *address,
6782
                    const segment_type *segment)
6783
{
6784
  lang_address_statement_type *ad;
6785
 
6786
  ad = new_stat (lang_address_statement, stat_ptr);
6787
  ad->section_name = name;
6788
  ad->address = address;
6789
  ad->segment = segment;
6790
}
6791
 
6792
/* Set the start symbol to NAME.  CMDLINE is nonzero if this is called
6793
   because of a -e argument on the command line, or zero if this is
6794
   called by ENTRY in a linker script.  Command line arguments take
6795
   precedence.  */
6796
 
6797
void
6798
lang_add_entry (const char *name, bfd_boolean cmdline)
6799
{
6800
  if (entry_symbol.name == NULL
6801
      || cmdline
6802
      || ! entry_from_cmdline)
6803
    {
6804
      entry_symbol.name = name;
6805
      entry_from_cmdline = cmdline;
6806
    }
6807
}
6808
 
6809
/* Set the default start symbol to NAME.  .em files should use this,
6810
   not lang_add_entry, to override the use of "start" if neither the
6811
   linker script nor the command line specifies an entry point.  NAME
6812
   must be permanently allocated.  */
6813
void
6814
lang_default_entry (const char *name)
6815
{
6816
  entry_symbol_default = name;
6817
}
6818
 
6819
void
6820
lang_add_target (const char *name)
6821
{
6822
  lang_target_statement_type *new_stmt;
6823
 
6824
  new_stmt = new_stat (lang_target_statement, stat_ptr);
6825
  new_stmt->target = name;
6826
}
6827
 
6828
void
6829
lang_add_map (const char *name)
6830
{
6831
  while (*name)
6832
    {
6833
      switch (*name)
6834
        {
6835
        case 'F':
6836
          map_option_f = TRUE;
6837
          break;
6838
        }
6839
      name++;
6840
    }
6841
}
6842
 
6843
void
6844
lang_add_fill (fill_type *fill)
6845
{
6846
  lang_fill_statement_type *new_stmt;
6847
 
6848
  new_stmt = new_stat (lang_fill_statement, stat_ptr);
6849
  new_stmt->fill = fill;
6850
}
6851
 
6852
void
6853
lang_add_data (int type, union etree_union *exp)
6854
{
6855
  lang_data_statement_type *new_stmt;
6856
 
6857
  new_stmt = new_stat (lang_data_statement, stat_ptr);
6858
  new_stmt->exp = exp;
6859
  new_stmt->type = type;
6860
}
6861
 
6862
/* Create a new reloc statement.  RELOC is the BFD relocation type to
6863
   generate.  HOWTO is the corresponding howto structure (we could
6864
   look this up, but the caller has already done so).  SECTION is the
6865
   section to generate a reloc against, or NAME is the name of the
6866
   symbol to generate a reloc against.  Exactly one of SECTION and
6867
   NAME must be NULL.  ADDEND is an expression for the addend.  */
6868
 
6869
void
6870
lang_add_reloc (bfd_reloc_code_real_type reloc,
6871
                reloc_howto_type *howto,
6872
                asection *section,
6873
                const char *name,
6874
                union etree_union *addend)
6875
{
6876
  lang_reloc_statement_type *p = new_stat (lang_reloc_statement, stat_ptr);
6877
 
6878
  p->reloc = reloc;
6879
  p->howto = howto;
6880
  p->section = section;
6881
  p->name = name;
6882
  p->addend_exp = addend;
6883
 
6884
  p->addend_value = 0;
6885
  p->output_section = NULL;
6886
  p->output_offset = 0;
6887
}
6888
 
6889
lang_assignment_statement_type *
6890
lang_add_assignment (etree_type *exp)
6891
{
6892
  lang_assignment_statement_type *new_stmt;
6893
 
6894
  new_stmt = new_stat (lang_assignment_statement, stat_ptr);
6895
  new_stmt->exp = exp;
6896
  return new_stmt;
6897
}
6898
 
6899
void
6900
lang_add_attribute (enum statement_enum attribute)
6901
{
6902
  new_statement (attribute, sizeof (lang_statement_header_type), stat_ptr);
6903
}
6904
 
6905
void
6906
lang_startup (const char *name)
6907
{
6908
  if (first_file->filename != NULL)
6909
    {
6910
      einfo (_("%P%F: multiple STARTUP files\n"));
6911
    }
6912
  first_file->filename = name;
6913
  first_file->local_sym_name = name;
6914
  first_file->real = TRUE;
6915
}
6916
 
6917
void
6918
lang_float (bfd_boolean maybe)
6919
{
6920
  lang_float_flag = maybe;
6921
}
6922
 
6923
 
6924
/* Work out the load- and run-time regions from a script statement, and
6925
   store them in *LMA_REGION and *REGION respectively.
6926
 
6927
   MEMSPEC is the name of the run-time region, or the value of
6928
   DEFAULT_MEMORY_REGION if the statement didn't specify one.
6929
   LMA_MEMSPEC is the name of the load-time region, or null if the
6930
   statement didn't specify one.HAVE_LMA_P is TRUE if the statement
6931
   had an explicit load address.
6932
 
6933
   It is an error to specify both a load region and a load address.  */
6934
 
6935
static void
6936
lang_get_regions (lang_memory_region_type **region,
6937
                  lang_memory_region_type **lma_region,
6938
                  const char *memspec,
6939
                  const char *lma_memspec,
6940
                  bfd_boolean have_lma,
6941
                  bfd_boolean have_vma)
6942
{
6943
  *lma_region = lang_memory_region_lookup (lma_memspec, FALSE);
6944
 
6945
  /* If no runtime region or VMA has been specified, but the load region
6946
     has been specified, then use the load region for the runtime region
6947
     as well.  */
6948
  if (lma_memspec != NULL
6949
      && ! have_vma
6950
      && strcmp (memspec, DEFAULT_MEMORY_REGION) == 0)
6951
    *region = *lma_region;
6952
  else
6953
    *region = lang_memory_region_lookup (memspec, FALSE);
6954
 
6955
  if (have_lma && lma_memspec != 0)
6956 166 khays
    einfo (_("%X%P:%S: section has both a load address and a load region\n"),
6957
           NULL);
6958 145 khays
}
6959
 
6960
void
6961
lang_leave_output_section_statement (fill_type *fill, const char *memspec,
6962
                                     lang_output_section_phdr_list *phdrs,
6963
                                     const char *lma_memspec)
6964
{
6965
  lang_get_regions (&current_section->region,
6966
                    &current_section->lma_region,
6967
                    memspec, lma_memspec,
6968
                    current_section->load_base != NULL,
6969
                    current_section->addr_tree != NULL);
6970
 
6971
  /* If this section has no load region or base, but uses the same
6972
     region as the previous section, then propagate the previous
6973
     section's load region.  */
6974
 
6975
  if (current_section->lma_region == NULL
6976
      && current_section->load_base == NULL
6977
      && current_section->addr_tree == NULL
6978
      && current_section->region == current_section->prev->region)
6979
    current_section->lma_region = current_section->prev->lma_region;
6980
 
6981
  current_section->fill = fill;
6982
  current_section->phdrs = phdrs;
6983
  pop_stat_ptr ();
6984
}
6985
 
6986
/* Create an absolute symbol with the given name with the value of the
6987
   address of first byte of the section named.
6988
 
6989
   If the symbol already exists, then do nothing.  */
6990
 
6991
void
6992
lang_abs_symbol_at_beginning_of (const char *secname, const char *name)
6993
{
6994
  struct bfd_link_hash_entry *h;
6995
 
6996
  h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
6997
  if (h == NULL)
6998
    einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
6999
 
7000
  if (h->type == bfd_link_hash_new
7001
      || h->type == bfd_link_hash_undefined)
7002
    {
7003
      asection *sec;
7004
 
7005
      h->type = bfd_link_hash_defined;
7006
 
7007
      sec = bfd_get_section_by_name (link_info.output_bfd, secname);
7008
      if (sec == NULL)
7009
        h->u.def.value = 0;
7010
      else
7011
        h->u.def.value = bfd_get_section_vma (link_info.output_bfd, sec);
7012
 
7013
      h->u.def.section = bfd_abs_section_ptr;
7014
    }
7015
}
7016
 
7017
/* Create an absolute symbol with the given name with the value of the
7018
   address of the first byte after the end of the section named.
7019
 
7020
   If the symbol already exists, then do nothing.  */
7021
 
7022
void
7023
lang_abs_symbol_at_end_of (const char *secname, const char *name)
7024
{
7025
  struct bfd_link_hash_entry *h;
7026
 
7027
  h = bfd_link_hash_lookup (link_info.hash, name, TRUE, TRUE, TRUE);
7028
  if (h == NULL)
7029
    einfo (_("%P%F: bfd_link_hash_lookup failed: %E\n"));
7030
 
7031
  if (h->type == bfd_link_hash_new
7032
      || h->type == bfd_link_hash_undefined)
7033
    {
7034
      asection *sec;
7035
 
7036
      h->type = bfd_link_hash_defined;
7037
 
7038
      sec = bfd_get_section_by_name (link_info.output_bfd, secname);
7039
      if (sec == NULL)
7040
        h->u.def.value = 0;
7041
      else
7042
        h->u.def.value = (bfd_get_section_vma (link_info.output_bfd, sec)
7043
                          + TO_ADDR (sec->size));
7044
 
7045
      h->u.def.section = bfd_abs_section_ptr;
7046
    }
7047
}
7048
 
7049
void
7050
lang_statement_append (lang_statement_list_type *list,
7051
                       lang_statement_union_type *element,
7052
                       lang_statement_union_type **field)
7053
{
7054
  *(list->tail) = element;
7055
  list->tail = field;
7056
}
7057
 
7058
/* Set the output format type.  -oformat overrides scripts.  */
7059
 
7060
void
7061
lang_add_output_format (const char *format,
7062
                        const char *big,
7063
                        const char *little,
7064
                        int from_script)
7065
{
7066
  if (output_target == NULL || !from_script)
7067
    {
7068
      if (command_line.endian == ENDIAN_BIG
7069
          && big != NULL)
7070
        format = big;
7071
      else if (command_line.endian == ENDIAN_LITTLE
7072
               && little != NULL)
7073
        format = little;
7074
 
7075
      output_target = format;
7076
    }
7077
}
7078
 
7079
void
7080
lang_add_insert (const char *where, int is_before)
7081
{
7082
  lang_insert_statement_type *new_stmt;
7083
 
7084
  new_stmt = new_stat (lang_insert_statement, stat_ptr);
7085
  new_stmt->where = where;
7086
  new_stmt->is_before = is_before;
7087
  saved_script_handle = previous_script_handle;
7088
}
7089
 
7090
/* Enter a group.  This creates a new lang_group_statement, and sets
7091
   stat_ptr to build new statements within the group.  */
7092
 
7093
void
7094
lang_enter_group (void)
7095
{
7096
  lang_group_statement_type *g;
7097
 
7098
  g = new_stat (lang_group_statement, stat_ptr);
7099
  lang_list_init (&g->children);
7100
  push_stat_ptr (&g->children);
7101
}
7102
 
7103
/* Leave a group.  This just resets stat_ptr to start writing to the
7104
   regular list of statements again.  Note that this will not work if
7105
   groups can occur inside anything else which can adjust stat_ptr,
7106
   but currently they can't.  */
7107
 
7108
void
7109
lang_leave_group (void)
7110
{
7111
  pop_stat_ptr ();
7112
}
7113
 
7114
/* Add a new program header.  This is called for each entry in a PHDRS
7115
   command in a linker script.  */
7116
 
7117
void
7118
lang_new_phdr (const char *name,
7119
               etree_type *type,
7120
               bfd_boolean filehdr,
7121
               bfd_boolean phdrs,
7122
               etree_type *at,
7123
               etree_type *flags)
7124
{
7125
  struct lang_phdr *n, **pp;
7126
  bfd_boolean hdrs;
7127
 
7128
  n = (struct lang_phdr *) stat_alloc (sizeof (struct lang_phdr));
7129
  n->next = NULL;
7130
  n->name = name;
7131
  n->type = exp_get_value_int (type, 0, "program header type");
7132
  n->filehdr = filehdr;
7133
  n->phdrs = phdrs;
7134
  n->at = at;
7135
  n->flags = flags;
7136
 
7137
  hdrs = n->type == 1 && (phdrs || filehdr);
7138
 
7139
  for (pp = &lang_phdr_list; *pp != NULL; pp = &(*pp)->next)
7140
    if (hdrs
7141
        && (*pp)->type == 1
7142
        && !((*pp)->filehdr || (*pp)->phdrs))
7143
      {
7144 166 khays
        einfo (_("%X%P:%S: PHDRS and FILEHDR are not supported"
7145
                 " when prior PT_LOAD headers lack them\n"), NULL);
7146 145 khays
        hdrs = FALSE;
7147
      }
7148
 
7149
  *pp = n;
7150
}
7151
 
7152
/* Record the program header information in the output BFD.  FIXME: We
7153
   should not be calling an ELF specific function here.  */
7154
 
7155
static void
7156
lang_record_phdrs (void)
7157
{
7158
  unsigned int alc;
7159
  asection **secs;
7160
  lang_output_section_phdr_list *last;
7161
  struct lang_phdr *l;
7162
  lang_output_section_statement_type *os;
7163
 
7164
  alc = 10;
7165
  secs = (asection **) xmalloc (alc * sizeof (asection *));
7166
  last = NULL;
7167
 
7168
  for (l = lang_phdr_list; l != NULL; l = l->next)
7169
    {
7170
      unsigned int c;
7171
      flagword flags;
7172
      bfd_vma at;
7173
 
7174
      c = 0;
7175
      for (os = &lang_output_section_statement.head->output_section_statement;
7176
           os != NULL;
7177
           os = os->next)
7178
        {
7179
          lang_output_section_phdr_list *pl;
7180
 
7181
          if (os->constraint < 0)
7182
            continue;
7183
 
7184
          pl = os->phdrs;
7185
          if (pl != NULL)
7186
            last = pl;
7187
          else
7188
            {
7189
              if (os->sectype == noload_section
7190
                  || os->bfd_section == NULL
7191
                  || (os->bfd_section->flags & SEC_ALLOC) == 0)
7192
                continue;
7193
 
7194
              /* Don't add orphans to PT_INTERP header.  */
7195
              if (l->type == 3)
7196
                continue;
7197
 
7198
              if (last == NULL)
7199
                {
7200
                  lang_output_section_statement_type * tmp_os;
7201
 
7202
                  /* If we have not run across a section with a program
7203
                     header assigned to it yet, then scan forwards to find
7204
                     one.  This prevents inconsistencies in the linker's
7205
                     behaviour when a script has specified just a single
7206
                     header and there are sections in that script which are
7207
                     not assigned to it, and which occur before the first
7208
                     use of that header. See here for more details:
7209
                     http://sourceware.org/ml/binutils/2007-02/msg00291.html  */
7210
                  for (tmp_os = os; tmp_os; tmp_os = tmp_os->next)
7211
                    if (tmp_os->phdrs)
7212
                      {
7213
                        last = tmp_os->phdrs;
7214
                        break;
7215
                      }
7216
                  if (last == NULL)
7217
                    einfo (_("%F%P: no sections assigned to phdrs\n"));
7218
                }
7219
              pl = last;
7220
            }
7221
 
7222
          if (os->bfd_section == NULL)
7223
            continue;
7224
 
7225
          for (; pl != NULL; pl = pl->next)
7226
            {
7227
              if (strcmp (pl->name, l->name) == 0)
7228
                {
7229
                  if (c >= alc)
7230
                    {
7231
                      alc *= 2;
7232
                      secs = (asection **) xrealloc (secs,
7233
                                                     alc * sizeof (asection *));
7234
                    }
7235
                  secs[c] = os->bfd_section;
7236
                  ++c;
7237
                  pl->used = TRUE;
7238
                }
7239
            }
7240
        }
7241
 
7242
      if (l->flags == NULL)
7243
        flags = 0;
7244
      else
7245
        flags = exp_get_vma (l->flags, 0, "phdr flags");
7246
 
7247
      if (l->at == NULL)
7248
        at = 0;
7249
      else
7250
        at = exp_get_vma (l->at, 0, "phdr load address");
7251
 
7252
      if (! bfd_record_phdr (link_info.output_bfd, l->type,
7253
                             l->flags != NULL, flags, l->at != NULL,
7254
                             at, l->filehdr, l->phdrs, c, secs))
7255
        einfo (_("%F%P: bfd_record_phdr failed: %E\n"));
7256
    }
7257
 
7258
  free (secs);
7259
 
7260
  /* Make sure all the phdr assignments succeeded.  */
7261
  for (os = &lang_output_section_statement.head->output_section_statement;
7262
       os != NULL;
7263
       os = os->next)
7264
    {
7265
      lang_output_section_phdr_list *pl;
7266
 
7267
      if (os->constraint < 0
7268
          || os->bfd_section == NULL)
7269
        continue;
7270
 
7271
      for (pl = os->phdrs;
7272
           pl != NULL;
7273
           pl = pl->next)
7274
        if (! pl->used && strcmp (pl->name, "NONE") != 0)
7275
          einfo (_("%X%P: section `%s' assigned to non-existent phdr `%s'\n"),
7276
                 os->name, pl->name);
7277
    }
7278
}
7279
 
7280
/* Record a list of sections which may not be cross referenced.  */
7281
 
7282
void
7283
lang_add_nocrossref (lang_nocrossref_type *l)
7284
{
7285
  struct lang_nocrossrefs *n;
7286
 
7287
  n = (struct lang_nocrossrefs *) xmalloc (sizeof *n);
7288
  n->next = nocrossref_list;
7289
  n->list = l;
7290
  nocrossref_list = n;
7291
 
7292
  /* Set notice_all so that we get informed about all symbols.  */
7293
  link_info.notice_all = TRUE;
7294
}
7295
 
7296
/* Overlay handling.  We handle overlays with some static variables.  */
7297
 
7298
/* The overlay virtual address.  */
7299
static etree_type *overlay_vma;
7300
/* And subsection alignment.  */
7301
static etree_type *overlay_subalign;
7302
 
7303
/* An expression for the maximum section size seen so far.  */
7304
static etree_type *overlay_max;
7305
 
7306
/* A list of all the sections in this overlay.  */
7307
 
7308
struct overlay_list {
7309
  struct overlay_list *next;
7310
  lang_output_section_statement_type *os;
7311
};
7312
 
7313
static struct overlay_list *overlay_list;
7314
 
7315
/* Start handling an overlay.  */
7316
 
7317
void
7318
lang_enter_overlay (etree_type *vma_expr, etree_type *subalign)
7319
{
7320
  /* The grammar should prevent nested overlays from occurring.  */
7321
  ASSERT (overlay_vma == NULL
7322
          && overlay_subalign == NULL
7323
          && overlay_max == NULL);
7324
 
7325
  overlay_vma = vma_expr;
7326
  overlay_subalign = subalign;
7327
}
7328
 
7329
/* Start a section in an overlay.  We handle this by calling
7330
   lang_enter_output_section_statement with the correct VMA.
7331
   lang_leave_overlay sets up the LMA and memory regions.  */
7332
 
7333
void
7334
lang_enter_overlay_section (const char *name)
7335
{
7336
  struct overlay_list *n;
7337
  etree_type *size;
7338
 
7339
  lang_enter_output_section_statement (name, overlay_vma, overlay_section,
7340
                                       0, overlay_subalign, 0, 0);
7341
 
7342
  /* If this is the first section, then base the VMA of future
7343
     sections on this one.  This will work correctly even if `.' is
7344
     used in the addresses.  */
7345
  if (overlay_list == NULL)
7346
    overlay_vma = exp_nameop (ADDR, name);
7347
 
7348
  /* Remember the section.  */
7349
  n = (struct overlay_list *) xmalloc (sizeof *n);
7350
  n->os = current_section;
7351
  n->next = overlay_list;
7352
  overlay_list = n;
7353
 
7354
  size = exp_nameop (SIZEOF, name);
7355
 
7356
  /* Arrange to work out the maximum section end address.  */
7357
  if (overlay_max == NULL)
7358
    overlay_max = size;
7359
  else
7360
    overlay_max = exp_binop (MAX_K, overlay_max, size);
7361
}
7362
 
7363
/* Finish a section in an overlay.  There isn't any special to do
7364
   here.  */
7365
 
7366
void
7367
lang_leave_overlay_section (fill_type *fill,
7368
                            lang_output_section_phdr_list *phdrs)
7369
{
7370
  const char *name;
7371
  char *clean, *s2;
7372
  const char *s1;
7373
  char *buf;
7374
 
7375
  name = current_section->name;
7376
 
7377
  /* For now, assume that DEFAULT_MEMORY_REGION is the run-time memory
7378
     region and that no load-time region has been specified.  It doesn't
7379
     really matter what we say here, since lang_leave_overlay will
7380
     override it.  */
7381
  lang_leave_output_section_statement (fill, DEFAULT_MEMORY_REGION, phdrs, 0);
7382
 
7383
  /* Define the magic symbols.  */
7384
 
7385
  clean = (char *) xmalloc (strlen (name) + 1);
7386
  s2 = clean;
7387
  for (s1 = name; *s1 != '\0'; s1++)
7388
    if (ISALNUM (*s1) || *s1 == '_')
7389
      *s2++ = *s1;
7390
  *s2 = '\0';
7391
 
7392
  buf = (char *) xmalloc (strlen (clean) + sizeof "__load_start_");
7393
  sprintf (buf, "__load_start_%s", clean);
7394
  lang_add_assignment (exp_provide (buf,
7395
                                    exp_nameop (LOADADDR, name),
7396
                                    FALSE));
7397
 
7398
  buf = (char *) xmalloc (strlen (clean) + sizeof "__load_stop_");
7399
  sprintf (buf, "__load_stop_%s", clean);
7400
  lang_add_assignment (exp_provide (buf,
7401
                                    exp_binop ('+',
7402
                                               exp_nameop (LOADADDR, name),
7403
                                               exp_nameop (SIZEOF, name)),
7404
                                    FALSE));
7405
 
7406
  free (clean);
7407
}
7408
 
7409
/* Finish an overlay.  If there are any overlay wide settings, this
7410
   looks through all the sections in the overlay and sets them.  */
7411
 
7412
void
7413
lang_leave_overlay (etree_type *lma_expr,
7414
                    int nocrossrefs,
7415
                    fill_type *fill,
7416
                    const char *memspec,
7417
                    lang_output_section_phdr_list *phdrs,
7418
                    const char *lma_memspec)
7419
{
7420
  lang_memory_region_type *region;
7421
  lang_memory_region_type *lma_region;
7422
  struct overlay_list *l;
7423
  lang_nocrossref_type *nocrossref;
7424
 
7425
  lang_get_regions (&region, &lma_region,
7426
                    memspec, lma_memspec,
7427
                    lma_expr != NULL, FALSE);
7428
 
7429
  nocrossref = NULL;
7430
 
7431
  /* After setting the size of the last section, set '.' to end of the
7432
     overlay region.  */
7433
  if (overlay_list != NULL)
7434
    overlay_list->os->update_dot_tree
7435
      = exp_assign (".", exp_binop ('+', overlay_vma, overlay_max));
7436
 
7437
  l = overlay_list;
7438
  while (l != NULL)
7439
    {
7440
      struct overlay_list *next;
7441
 
7442
      if (fill != NULL && l->os->fill == NULL)
7443
        l->os->fill = fill;
7444
 
7445
      l->os->region = region;
7446
      l->os->lma_region = lma_region;
7447
 
7448
      /* The first section has the load address specified in the
7449
         OVERLAY statement.  The rest are worked out from that.
7450
         The base address is not needed (and should be null) if
7451
         an LMA region was specified.  */
7452
      if (l->next == 0)
7453
        {
7454
          l->os->load_base = lma_expr;
7455
          l->os->sectype = normal_section;
7456
        }
7457
      if (phdrs != NULL && l->os->phdrs == NULL)
7458
        l->os->phdrs = phdrs;
7459
 
7460
      if (nocrossrefs)
7461
        {
7462
          lang_nocrossref_type *nc;
7463
 
7464
          nc = (lang_nocrossref_type *) xmalloc (sizeof *nc);
7465
          nc->name = l->os->name;
7466
          nc->next = nocrossref;
7467
          nocrossref = nc;
7468
        }
7469
 
7470
      next = l->next;
7471
      free (l);
7472
      l = next;
7473
    }
7474
 
7475
  if (nocrossref != NULL)
7476
    lang_add_nocrossref (nocrossref);
7477
 
7478
  overlay_vma = NULL;
7479
  overlay_list = NULL;
7480
  overlay_max = NULL;
7481
}
7482
 
7483
/* Version handling.  This is only useful for ELF.  */
7484
 
7485
/* If PREV is NULL, return first version pattern matching particular symbol.
7486
   If PREV is non-NULL, return first version pattern matching particular
7487
   symbol after PREV (previously returned by lang_vers_match).  */
7488
 
7489
static struct bfd_elf_version_expr *
7490
lang_vers_match (struct bfd_elf_version_expr_head *head,
7491
                 struct bfd_elf_version_expr *prev,
7492
                 const char *sym)
7493
{
7494
  const char *c_sym;
7495
  const char *cxx_sym = sym;
7496
  const char *java_sym = sym;
7497
  struct bfd_elf_version_expr *expr = NULL;
7498
  enum demangling_styles curr_style;
7499
 
7500
  curr_style = CURRENT_DEMANGLING_STYLE;
7501
  cplus_demangle_set_style (no_demangling);
7502
  c_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_NO_OPTS);
7503
  if (!c_sym)
7504
    c_sym = sym;
7505
  cplus_demangle_set_style (curr_style);
7506
 
7507
  if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
7508
    {
7509
      cxx_sym = bfd_demangle (link_info.output_bfd, sym,
7510
                              DMGL_PARAMS | DMGL_ANSI);
7511
      if (!cxx_sym)
7512
        cxx_sym = sym;
7513
    }
7514
  if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
7515
    {
7516
      java_sym = bfd_demangle (link_info.output_bfd, sym, DMGL_JAVA);
7517
      if (!java_sym)
7518
        java_sym = sym;
7519
    }
7520
 
7521
  if (head->htab && (prev == NULL || prev->literal))
7522
    {
7523
      struct bfd_elf_version_expr e;
7524
 
7525
      switch (prev ? prev->mask : 0)
7526
        {
7527
        case 0:
7528
          if (head->mask & BFD_ELF_VERSION_C_TYPE)
7529
            {
7530
              e.pattern = c_sym;
7531
              expr = (struct bfd_elf_version_expr *)
7532
                  htab_find ((htab_t) head->htab, &e);
7533
              while (expr && strcmp (expr->pattern, c_sym) == 0)
7534
                if (expr->mask == BFD_ELF_VERSION_C_TYPE)
7535
                  goto out_ret;
7536
                else
7537
                  expr = expr->next;
7538
            }
7539
          /* Fallthrough */
7540
        case BFD_ELF_VERSION_C_TYPE:
7541
          if (head->mask & BFD_ELF_VERSION_CXX_TYPE)
7542
            {
7543
              e.pattern = cxx_sym;
7544
              expr = (struct bfd_elf_version_expr *)
7545
                  htab_find ((htab_t) head->htab, &e);
7546
              while (expr && strcmp (expr->pattern, cxx_sym) == 0)
7547
                if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
7548
                  goto out_ret;
7549
                else
7550
                  expr = expr->next;
7551
            }
7552
          /* Fallthrough */
7553
        case BFD_ELF_VERSION_CXX_TYPE:
7554
          if (head->mask & BFD_ELF_VERSION_JAVA_TYPE)
7555
            {
7556
              e.pattern = java_sym;
7557
              expr = (struct bfd_elf_version_expr *)
7558
                  htab_find ((htab_t) head->htab, &e);
7559
              while (expr && strcmp (expr->pattern, java_sym) == 0)
7560
                if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
7561
                  goto out_ret;
7562
                else
7563
                  expr = expr->next;
7564
            }
7565
          /* Fallthrough */
7566
        default:
7567
          break;
7568
        }
7569
    }
7570
 
7571
  /* Finally, try the wildcards.  */
7572
  if (prev == NULL || prev->literal)
7573
    expr = head->remaining;
7574
  else
7575
    expr = prev->next;
7576
  for (; expr; expr = expr->next)
7577
    {
7578
      const char *s;
7579
 
7580
      if (!expr->pattern)
7581
        continue;
7582
 
7583
      if (expr->pattern[0] == '*' && expr->pattern[1] == '\0')
7584
        break;
7585
 
7586
      if (expr->mask == BFD_ELF_VERSION_JAVA_TYPE)
7587
        s = java_sym;
7588
      else if (expr->mask == BFD_ELF_VERSION_CXX_TYPE)
7589
        s = cxx_sym;
7590
      else
7591
        s = c_sym;
7592
      if (fnmatch (expr->pattern, s, 0) == 0)
7593
        break;
7594
    }
7595
 
7596
 out_ret:
7597
  if (c_sym != sym)
7598
    free ((char *) c_sym);
7599
  if (cxx_sym != sym)
7600
    free ((char *) cxx_sym);
7601
  if (java_sym != sym)
7602
    free ((char *) java_sym);
7603
  return expr;
7604
}
7605
 
7606
/* Return NULL if the PATTERN argument is a glob pattern, otherwise,
7607
   return a pointer to the symbol name with any backslash quotes removed.  */
7608
 
7609
static const char *
7610
realsymbol (const char *pattern)
7611
{
7612
  const char *p;
7613
  bfd_boolean changed = FALSE, backslash = FALSE;
7614
  char *s, *symbol = (char *) xmalloc (strlen (pattern) + 1);
7615
 
7616
  for (p = pattern, s = symbol; *p != '\0'; ++p)
7617
    {
7618
      /* It is a glob pattern only if there is no preceding
7619
         backslash.  */
7620
      if (backslash)
7621
        {
7622
          /* Remove the preceding backslash.  */
7623
          *(s - 1) = *p;
7624
          backslash = FALSE;
7625
          changed = TRUE;
7626
        }
7627
      else
7628
        {
7629
          if (*p == '?' || *p == '*' || *p == '[')
7630
            {
7631
              free (symbol);
7632
              return NULL;
7633
            }
7634
 
7635
          *s++ = *p;
7636
          backslash = *p == '\\';
7637
        }
7638
    }
7639
 
7640
  if (changed)
7641
    {
7642
      *s = '\0';
7643
      return symbol;
7644
    }
7645
  else
7646
    {
7647
      free (symbol);
7648
      return pattern;
7649
    }
7650
}
7651
 
7652
/* This is called for each variable name or match expression.  NEW_NAME is
7653
   the name of the symbol to match, or, if LITERAL_P is FALSE, a glob
7654
   pattern to be matched against symbol names.  */
7655
 
7656
struct bfd_elf_version_expr *
7657
lang_new_vers_pattern (struct bfd_elf_version_expr *orig,
7658
                       const char *new_name,
7659
                       const char *lang,
7660
                       bfd_boolean literal_p)
7661
{
7662
  struct bfd_elf_version_expr *ret;
7663
 
7664
  ret = (struct bfd_elf_version_expr *) xmalloc (sizeof *ret);
7665
  ret->next = orig;
7666
  ret->symver = 0;
7667
  ret->script = 0;
7668
  ret->literal = TRUE;
7669
  ret->pattern = literal_p ? new_name : realsymbol (new_name);
7670
  if (ret->pattern == NULL)
7671
    {
7672
      ret->pattern = new_name;
7673
      ret->literal = FALSE;
7674
    }
7675
 
7676
  if (lang == NULL || strcasecmp (lang, "C") == 0)
7677
    ret->mask = BFD_ELF_VERSION_C_TYPE;
7678
  else if (strcasecmp (lang, "C++") == 0)
7679
    ret->mask = BFD_ELF_VERSION_CXX_TYPE;
7680
  else if (strcasecmp (lang, "Java") == 0)
7681
    ret->mask = BFD_ELF_VERSION_JAVA_TYPE;
7682
  else
7683
    {
7684
      einfo (_("%X%P: unknown language `%s' in version information\n"),
7685
             lang);
7686
      ret->mask = BFD_ELF_VERSION_C_TYPE;
7687
    }
7688
 
7689
  return ldemul_new_vers_pattern (ret);
7690
}
7691
 
7692
/* This is called for each set of variable names and match
7693
   expressions.  */
7694
 
7695
struct bfd_elf_version_tree *
7696
lang_new_vers_node (struct bfd_elf_version_expr *globals,
7697
                    struct bfd_elf_version_expr *locals)
7698
{
7699
  struct bfd_elf_version_tree *ret;
7700
 
7701
  ret = (struct bfd_elf_version_tree *) xcalloc (1, sizeof *ret);
7702
  ret->globals.list = globals;
7703
  ret->locals.list = locals;
7704
  ret->match = lang_vers_match;
7705
  ret->name_indx = (unsigned int) -1;
7706
  return ret;
7707
}
7708
 
7709
/* This static variable keeps track of version indices.  */
7710
 
7711
static int version_index;
7712
 
7713
static hashval_t
7714
version_expr_head_hash (const void *p)
7715
{
7716
  const struct bfd_elf_version_expr *e =
7717
      (const struct bfd_elf_version_expr *) p;
7718
 
7719
  return htab_hash_string (e->pattern);
7720
}
7721
 
7722
static int
7723
version_expr_head_eq (const void *p1, const void *p2)
7724
{
7725
  const struct bfd_elf_version_expr *e1 =
7726
      (const struct bfd_elf_version_expr *) p1;
7727
  const struct bfd_elf_version_expr *e2 =
7728
      (const struct bfd_elf_version_expr *) p2;
7729
 
7730
  return strcmp (e1->pattern, e2->pattern) == 0;
7731
}
7732
 
7733
static void
7734
lang_finalize_version_expr_head (struct bfd_elf_version_expr_head *head)
7735
{
7736
  size_t count = 0;
7737
  struct bfd_elf_version_expr *e, *next;
7738
  struct bfd_elf_version_expr **list_loc, **remaining_loc;
7739
 
7740
  for (e = head->list; e; e = e->next)
7741
    {
7742
      if (e->literal)
7743
        count++;
7744
      head->mask |= e->mask;
7745
    }
7746
 
7747
  if (count)
7748
    {
7749
      head->htab = htab_create (count * 2, version_expr_head_hash,
7750
                                version_expr_head_eq, NULL);
7751
      list_loc = &head->list;
7752
      remaining_loc = &head->remaining;
7753
      for (e = head->list; e; e = next)
7754
        {
7755
          next = e->next;
7756
          if (!e->literal)
7757
            {
7758
              *remaining_loc = e;
7759
              remaining_loc = &e->next;
7760
            }
7761
          else
7762
            {
7763
              void **loc = htab_find_slot ((htab_t) head->htab, e, INSERT);
7764
 
7765
              if (*loc)
7766
                {
7767
                  struct bfd_elf_version_expr *e1, *last;
7768
 
7769
                  e1 = (struct bfd_elf_version_expr *) *loc;
7770
                  last = NULL;
7771
                  do
7772
                    {
7773
                      if (e1->mask == e->mask)
7774
                        {
7775
                          last = NULL;
7776
                          break;
7777
                        }
7778
                      last = e1;
7779
                      e1 = e1->next;
7780
                    }
7781
                  while (e1 && strcmp (e1->pattern, e->pattern) == 0);
7782
 
7783
                  if (last == NULL)
7784
                    {
7785
                      /* This is a duplicate.  */
7786
                      /* FIXME: Memory leak.  Sometimes pattern is not
7787
                         xmalloced alone, but in larger chunk of memory.  */
7788
                      /* free (e->pattern); */
7789
                      free (e);
7790
                    }
7791
                  else
7792
                    {
7793
                      e->next = last->next;
7794
                      last->next = e;
7795
                    }
7796
                }
7797
              else
7798
                {
7799
                  *loc = e;
7800
                  *list_loc = e;
7801
                  list_loc = &e->next;
7802
                }
7803
            }
7804
        }
7805
      *remaining_loc = NULL;
7806
      *list_loc = head->remaining;
7807
    }
7808
  else
7809
    head->remaining = head->list;
7810
}
7811
 
7812
/* This is called when we know the name and dependencies of the
7813
   version.  */
7814
 
7815
void
7816
lang_register_vers_node (const char *name,
7817
                         struct bfd_elf_version_tree *version,
7818
                         struct bfd_elf_version_deps *deps)
7819
{
7820
  struct bfd_elf_version_tree *t, **pp;
7821
  struct bfd_elf_version_expr *e1;
7822
 
7823
  if (name == NULL)
7824
    name = "";
7825
 
7826 163 khays
  if (link_info.version_info != NULL
7827
      && (name[0] == '\0' || link_info.version_info->name[0] == '\0'))
7828 145 khays
    {
7829
      einfo (_("%X%P: anonymous version tag cannot be combined"
7830
               " with other version tags\n"));
7831
      free (version);
7832
      return;
7833
    }
7834
 
7835
  /* Make sure this node has a unique name.  */
7836 163 khays
  for (t = link_info.version_info; t != NULL; t = t->next)
7837 145 khays
    if (strcmp (t->name, name) == 0)
7838
      einfo (_("%X%P: duplicate version tag `%s'\n"), name);
7839
 
7840
  lang_finalize_version_expr_head (&version->globals);
7841
  lang_finalize_version_expr_head (&version->locals);
7842
 
7843
  /* Check the global and local match names, and make sure there
7844
     aren't any duplicates.  */
7845
 
7846
  for (e1 = version->globals.list; e1 != NULL; e1 = e1->next)
7847
    {
7848 163 khays
      for (t = link_info.version_info; t != NULL; t = t->next)
7849 145 khays
        {
7850
          struct bfd_elf_version_expr *e2;
7851
 
7852
          if (t->locals.htab && e1->literal)
7853
            {
7854
              e2 = (struct bfd_elf_version_expr *)
7855
                  htab_find ((htab_t) t->locals.htab, e1);
7856
              while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
7857
                {
7858
                  if (e1->mask == e2->mask)
7859
                    einfo (_("%X%P: duplicate expression `%s'"
7860
                             " in version information\n"), e1->pattern);
7861
                  e2 = e2->next;
7862
                }
7863
            }
7864
          else if (!e1->literal)
7865
            for (e2 = t->locals.remaining; e2 != NULL; e2 = e2->next)
7866
              if (strcmp (e1->pattern, e2->pattern) == 0
7867
                  && e1->mask == e2->mask)
7868
                einfo (_("%X%P: duplicate expression `%s'"
7869
                         " in version information\n"), e1->pattern);
7870
        }
7871
    }
7872
 
7873
  for (e1 = version->locals.list; e1 != NULL; e1 = e1->next)
7874
    {
7875 163 khays
      for (t = link_info.version_info; t != NULL; t = t->next)
7876 145 khays
        {
7877
          struct bfd_elf_version_expr *e2;
7878
 
7879
          if (t->globals.htab && e1->literal)
7880
            {
7881
              e2 = (struct bfd_elf_version_expr *)
7882
                  htab_find ((htab_t) t->globals.htab, e1);
7883
              while (e2 && strcmp (e1->pattern, e2->pattern) == 0)
7884
                {
7885
                  if (e1->mask == e2->mask)
7886
                    einfo (_("%X%P: duplicate expression `%s'"
7887
                             " in version information\n"),
7888
                           e1->pattern);
7889
                  e2 = e2->next;
7890
                }
7891
            }
7892
          else if (!e1->literal)
7893
            for (e2 = t->globals.remaining; e2 != NULL; e2 = e2->next)
7894
              if (strcmp (e1->pattern, e2->pattern) == 0
7895
                  && e1->mask == e2->mask)
7896
                einfo (_("%X%P: duplicate expression `%s'"
7897
                         " in version information\n"), e1->pattern);
7898
        }
7899
    }
7900
 
7901
  version->deps = deps;
7902
  version->name = name;
7903
  if (name[0] != '\0')
7904
    {
7905
      ++version_index;
7906
      version->vernum = version_index;
7907
    }
7908
  else
7909
    version->vernum = 0;
7910
 
7911 163 khays
  for (pp = &link_info.version_info; *pp != NULL; pp = &(*pp)->next)
7912 145 khays
    ;
7913
  *pp = version;
7914
}
7915
 
7916
/* This is called when we see a version dependency.  */
7917
 
7918
struct bfd_elf_version_deps *
7919
lang_add_vers_depend (struct bfd_elf_version_deps *list, const char *name)
7920
{
7921
  struct bfd_elf_version_deps *ret;
7922
  struct bfd_elf_version_tree *t;
7923
 
7924
  ret = (struct bfd_elf_version_deps *) xmalloc (sizeof *ret);
7925
  ret->next = list;
7926
 
7927 163 khays
  for (t = link_info.version_info; t != NULL; t = t->next)
7928 145 khays
    {
7929
      if (strcmp (t->name, name) == 0)
7930
        {
7931
          ret->version_needed = t;
7932
          return ret;
7933
        }
7934
    }
7935
 
7936
  einfo (_("%X%P: unable to find version dependency `%s'\n"), name);
7937
 
7938
  ret->version_needed = NULL;
7939
  return ret;
7940
}
7941
 
7942
static void
7943
lang_do_version_exports_section (void)
7944
{
7945
  struct bfd_elf_version_expr *greg = NULL, *lreg;
7946
 
7947
  LANG_FOR_EACH_INPUT_STATEMENT (is)
7948
    {
7949
      asection *sec = bfd_get_section_by_name (is->the_bfd, ".exports");
7950
      char *contents, *p;
7951
      bfd_size_type len;
7952
 
7953
      if (sec == NULL)
7954
        continue;
7955
 
7956
      len = sec->size;
7957
      contents = (char *) xmalloc (len);
7958
      if (!bfd_get_section_contents (is->the_bfd, sec, contents, 0, len))
7959
        einfo (_("%X%P: unable to read .exports section contents\n"), sec);
7960
 
7961
      p = contents;
7962
      while (p < contents + len)
7963
        {
7964
          greg = lang_new_vers_pattern (greg, p, NULL, FALSE);
7965
          p = strchr (p, '\0') + 1;
7966
        }
7967
 
7968
      /* Do not free the contents, as we used them creating the regex.  */
7969
 
7970
      /* Do not include this section in the link.  */
7971
      sec->flags |= SEC_EXCLUDE | SEC_KEEP;
7972
    }
7973
 
7974
  lreg = lang_new_vers_pattern (NULL, "*", NULL, FALSE);
7975
  lang_register_vers_node (command_line.version_exports_section,
7976
                           lang_new_vers_node (greg, lreg), NULL);
7977
}
7978
 
7979
void
7980
lang_add_unique (const char *name)
7981
{
7982
  struct unique_sections *ent;
7983
 
7984
  for (ent = unique_section_list; ent; ent = ent->next)
7985
    if (strcmp (ent->name, name) == 0)
7986
      return;
7987
 
7988
  ent = (struct unique_sections *) xmalloc (sizeof *ent);
7989
  ent->name = xstrdup (name);
7990
  ent->next = unique_section_list;
7991
  unique_section_list = ent;
7992
}
7993
 
7994
/* Append the list of dynamic symbols to the existing one.  */
7995
 
7996
void
7997
lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic)
7998
{
7999
  if (link_info.dynamic_list)
8000
    {
8001
      struct bfd_elf_version_expr *tail;
8002
      for (tail = dynamic; tail->next != NULL; tail = tail->next)
8003
        ;
8004
      tail->next = link_info.dynamic_list->head.list;
8005
      link_info.dynamic_list->head.list = dynamic;
8006
    }
8007
  else
8008
    {
8009
      struct bfd_elf_dynamic_list *d;
8010
 
8011
      d = (struct bfd_elf_dynamic_list *) xcalloc (1, sizeof *d);
8012
      d->head.list = dynamic;
8013
      d->match = lang_vers_match;
8014
      link_info.dynamic_list = d;
8015
    }
8016
}
8017
 
8018
/* Append the list of C++ typeinfo dynamic symbols to the existing
8019
   one.  */
8020
 
8021
void
8022
lang_append_dynamic_list_cpp_typeinfo (void)
8023
{
8024
  const char * symbols [] =
8025
    {
8026
      "typeinfo name for*",
8027
      "typeinfo for*"
8028
    };
8029
  struct bfd_elf_version_expr *dynamic = NULL;
8030
  unsigned int i;
8031
 
8032
  for (i = 0; i < ARRAY_SIZE (symbols); i++)
8033
    dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
8034
                                     FALSE);
8035
 
8036
  lang_append_dynamic_list (dynamic);
8037
}
8038
 
8039
/* Append the list of C++ operator new and delete dynamic symbols to the
8040
   existing one.  */
8041
 
8042
void
8043
lang_append_dynamic_list_cpp_new (void)
8044
{
8045
  const char * symbols [] =
8046
    {
8047
      "operator new*",
8048
      "operator delete*"
8049
    };
8050
  struct bfd_elf_version_expr *dynamic = NULL;
8051
  unsigned int i;
8052
 
8053
  for (i = 0; i < ARRAY_SIZE (symbols); i++)
8054
    dynamic = lang_new_vers_pattern (dynamic, symbols [i], "C++",
8055
                                     FALSE);
8056
 
8057
  lang_append_dynamic_list (dynamic);
8058
}
8059
 
8060
/* Scan a space and/or comma separated string of features.  */
8061
 
8062
void
8063
lang_ld_feature (char *str)
8064
{
8065
  char *p, *q;
8066
 
8067
  p = str;
8068
  while (*p)
8069
    {
8070
      char sep;
8071
      while (*p == ',' || ISSPACE (*p))
8072
        ++p;
8073
      if (!*p)
8074
        break;
8075
      q = p + 1;
8076
      while (*q && *q != ',' && !ISSPACE (*q))
8077
        ++q;
8078
      sep = *q;
8079
      *q = 0;
8080
      if (strcasecmp (p, "SANE_EXPR") == 0)
8081
        config.sane_expr = TRUE;
8082
      else
8083
        einfo (_("%X%P: unknown feature `%s'\n"), p);
8084
      *q = sep;
8085
      p = q;
8086
    }
8087
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.