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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gold/] [script-sections.cc] - Blame information for rev 98

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

Line No. Rev Author Line
1 27 khays
// script-sections.cc -- linker script SECTIONS for gold
2
 
3
// Copyright 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4
// Written by Ian Lance Taylor <iant@google.com>.
5
 
6
// This file is part of gold.
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 "gold.h"
24
 
25
#include <cstring>
26
#include <algorithm>
27
#include <list>
28
#include <map>
29
#include <string>
30
#include <vector>
31
#include <fnmatch.h>
32
 
33
#include "parameters.h"
34
#include "object.h"
35
#include "layout.h"
36
#include "output.h"
37
#include "script-c.h"
38
#include "script.h"
39
#include "script-sections.h"
40
 
41
// Support for the SECTIONS clause in linker scripts.
42
 
43
namespace gold
44
{
45
 
46
// A region of memory.
47
class Memory_region
48
{
49
 public:
50
  Memory_region(const char* name, size_t namelen, unsigned int attributes,
51
                Expression* start, Expression* length)
52
    : name_(name, namelen),
53
      attributes_(attributes),
54
      start_(start),
55
      length_(length),
56
      current_offset_(0),
57
      vma_sections_(),
58
      lma_sections_(),
59
      last_section_(NULL)
60
  { }
61
 
62
  // Return the name of this region.
63
  const std::string&
64
  name() const
65
  { return this->name_; }
66
 
67
  // Return the start address of this region.
68
  Expression*
69
  start_address() const
70
  { return this->start_; }
71
 
72
  // Return the length of this region.
73
  Expression*
74
  length() const
75
  { return this->length_; }
76
 
77
  // Print the region (when debugging).
78
  void
79
  print(FILE*) const;
80
 
81
  // Return true if <name,namelen> matches this region.
82
  bool
83
  name_match(const char* name, size_t namelen)
84
  {
85
    return (this->name_.length() == namelen
86
            && strncmp(this->name_.c_str(), name, namelen) == 0);
87
  }
88
 
89
  Expression*
90
  get_current_address() const
91
  {
92
    return
93
      script_exp_binary_add(this->start_,
94
                            script_exp_integer(this->current_offset_));
95
  }
96
 
97
  void
98
  increment_offset(std::string section_name, uint64_t amount,
99
                   const Symbol_table* symtab, const Layout* layout)
100
  {
101
    this->current_offset_ += amount;
102
 
103
    if (this->current_offset_
104
        > this->length_->eval(symtab, layout, false))
105
      gold_error(_("section %s overflows end of region %s"),
106
                 section_name.c_str(), this->name_.c_str());
107
  }
108
 
109
  // Returns true iff there is room left in this region
110
  // for AMOUNT more bytes of data.
111
  bool
112
  has_room_for(const Symbol_table* symtab, const Layout* layout,
113
               uint64_t amount) const
114
  {
115
    return (this->current_offset_ + amount
116
            < this->length_->eval(symtab, layout, false));
117
  }
118
 
119
  // Return true if the provided section flags
120
  // are compatible with this region's attributes.
121
  bool
122
  attributes_compatible(elfcpp::Elf_Xword flags, elfcpp::Elf_Xword type) const;
123
 
124
  void
125
  add_section(Output_section_definition* sec, bool vma)
126
  {
127
    if (vma)
128
      this->vma_sections_.push_back(sec);
129
    else
130
      this->lma_sections_.push_back(sec);
131
  }
132
 
133
  typedef std::vector<Output_section_definition*> Section_list;
134
 
135
  // Return the start of the list of sections
136
  // whose VMAs are taken from this region.
137
  Section_list::const_iterator
138
  get_vma_section_list_start() const
139
  { return this->vma_sections_.begin(); }
140
 
141
  // Return the start of the list of sections
142
  // whose LMAs are taken from this region.
143
  Section_list::const_iterator
144
  get_lma_section_list_start() const
145
  { return this->lma_sections_.begin(); }
146
 
147
  // Return the end of the list of sections
148
  // whose VMAs are taken from this region.
149
  Section_list::const_iterator
150
  get_vma_section_list_end() const
151
  { return this->vma_sections_.end(); }
152
 
153
  // Return the end of the list of sections
154
  // whose LMAs are taken from this region.
155
  Section_list::const_iterator
156
  get_lma_section_list_end() const
157
  { return this->lma_sections_.end(); }
158
 
159
  Output_section_definition*
160
  get_last_section() const
161
  { return this->last_section_; }
162
 
163
  void
164
  set_last_section(Output_section_definition* sec)
165
  { this->last_section_ = sec; }
166
 
167
 private:
168
 
169
  std::string name_;
170
  unsigned int attributes_;
171
  Expression* start_;
172
  Expression* length_;
173
  // The offset to the next free byte in the region.
174
  // Note - for compatibility with GNU LD we only maintain one offset
175
  // regardless of whether the region is being used for VMA values,
176
  // LMA values, or both.
177
  uint64_t current_offset_;
178
  // A list of sections whose VMAs are set inside this region.
179
  Section_list vma_sections_;
180
  // A list of sections whose LMAs are set inside this region.
181
  Section_list lma_sections_;
182
  // The latest section to make use of this region.
183
  Output_section_definition* last_section_;
184
};
185
 
186
// Return true if the provided section flags
187
// are compatible with this region's attributes.
188
 
189
bool
190
Memory_region::attributes_compatible(elfcpp::Elf_Xword flags,
191
                                     elfcpp::Elf_Xword type) const
192
{
193
  unsigned int attrs = this->attributes_;
194
 
195
  // No attributes means that this region is not compatible with anything.
196
  if (attrs == 0)
197
    return false;
198
 
199
  bool match = true;
200
  do
201
    {
202
      switch (attrs & - attrs)
203
        {
204
        case MEM_EXECUTABLE:
205
          if ((flags & elfcpp::SHF_EXECINSTR) == 0)
206
            match = false;
207
          break;
208
 
209
        case MEM_WRITEABLE:
210
          if ((flags & elfcpp::SHF_WRITE) == 0)
211
            match = false;
212
          break;
213
 
214
        case MEM_READABLE:
215
          // All sections are presumed readable.
216
          break;
217
 
218
        case MEM_ALLOCATABLE:
219
          if ((flags & elfcpp::SHF_ALLOC) == 0)
220
            match = false;
221
          break;
222
 
223
        case MEM_INITIALIZED:
224
          if ((type & elfcpp::SHT_NOBITS) != 0)
225
            match = false;
226
          break;
227
        }
228
      attrs &= ~ (attrs & - attrs);
229
    }
230
  while (attrs != 0);
231
 
232
  return match;
233
}
234
 
235
// Print a memory region.
236
 
237
void
238
Memory_region::print(FILE* f) const
239
{
240
  fprintf(f, "  %s", this->name_.c_str());
241
 
242
  unsigned int attrs = this->attributes_;
243
  if (attrs != 0)
244
    {
245
      fprintf(f, " (");
246
      do
247
        {
248
          switch (attrs & - attrs)
249
            {
250
            case MEM_EXECUTABLE:  fputc('x', f); break;
251
            case MEM_WRITEABLE:   fputc('w', f); break;
252
            case MEM_READABLE:    fputc('r', f); break;
253
            case MEM_ALLOCATABLE: fputc('a', f); break;
254
            case MEM_INITIALIZED: fputc('i', f); break;
255
            default:
256
              gold_unreachable();
257
            }
258
          attrs &= ~ (attrs & - attrs);
259
        }
260
      while (attrs != 0);
261
      fputc(')', f);
262
    }
263
 
264
  fprintf(f, " : origin = ");
265
  this->start_->print(f);
266
  fprintf(f, ", length = ");
267
  this->length_->print(f);
268
  fprintf(f, "\n");
269
}
270
 
271
// Manage orphan sections.  This is intended to be largely compatible
272
// with the GNU linker.  The Linux kernel implicitly relies on
273
// something similar to the GNU linker's orphan placement.  We
274
// originally used a simpler scheme here, but it caused the kernel
275
// build to fail, and was also rather inefficient.
276
 
277
class Orphan_section_placement
278
{
279
 private:
280
  typedef Script_sections::Elements_iterator Elements_iterator;
281
 
282
 public:
283
  Orphan_section_placement();
284
 
285
  // Handle an output section during initialization of this mapping.
286
  void
287
  output_section_init(const std::string& name, Output_section*,
288
                      Elements_iterator location);
289
 
290
  // Initialize the last location.
291
  void
292
  last_init(Elements_iterator location);
293
 
294
  // Set *PWHERE to the address of an iterator pointing to the
295
  // location to use for an orphan section.  Return true if the
296
  // iterator has a value, false otherwise.
297
  bool
298
  find_place(Output_section*, Elements_iterator** pwhere);
299
 
300
  // Return the iterator being used for sections at the very end of
301
  // the linker script.
302
  Elements_iterator
303
  last_place() const;
304
 
305
 private:
306
  // The places that we specifically recognize.  This list is copied
307
  // from the GNU linker.
308
  enum Place_index
309
  {
310
    PLACE_TEXT,
311
    PLACE_RODATA,
312
    PLACE_DATA,
313
    PLACE_TLS,
314
    PLACE_TLS_BSS,
315
    PLACE_BSS,
316
    PLACE_REL,
317
    PLACE_INTERP,
318
    PLACE_NONALLOC,
319
    PLACE_LAST,
320
    PLACE_MAX
321
  };
322
 
323
  // The information we keep for a specific place.
324
  struct Place
325
  {
326
    // The name of sections for this place.
327
    const char* name;
328
    // Whether we have a location for this place.
329
    bool have_location;
330
    // The iterator for this place.
331
    Elements_iterator location;
332
  };
333
 
334
  // Initialize one place element.
335
  void
336
  initialize_place(Place_index, const char*);
337
 
338
  // The places.
339
  Place places_[PLACE_MAX];
340
  // True if this is the first call to output_section_init.
341
  bool first_init_;
342
};
343
 
344
// Initialize Orphan_section_placement.
345
 
346
Orphan_section_placement::Orphan_section_placement()
347
  : first_init_(true)
348
{
349
  this->initialize_place(PLACE_TEXT, ".text");
350
  this->initialize_place(PLACE_RODATA, ".rodata");
351
  this->initialize_place(PLACE_DATA, ".data");
352
  this->initialize_place(PLACE_TLS, NULL);
353
  this->initialize_place(PLACE_TLS_BSS, NULL);
354
  this->initialize_place(PLACE_BSS, ".bss");
355
  this->initialize_place(PLACE_REL, NULL);
356
  this->initialize_place(PLACE_INTERP, ".interp");
357
  this->initialize_place(PLACE_NONALLOC, NULL);
358
  this->initialize_place(PLACE_LAST, NULL);
359
}
360
 
361
// Initialize one place element.
362
 
363
void
364
Orphan_section_placement::initialize_place(Place_index index, const char* name)
365
{
366
  this->places_[index].name = name;
367
  this->places_[index].have_location = false;
368
}
369
 
370
// While initializing the Orphan_section_placement information, this
371
// is called once for each output section named in the linker script.
372
// If we found an output section during the link, it will be passed in
373
// OS.
374
 
375
void
376
Orphan_section_placement::output_section_init(const std::string& name,
377
                                              Output_section* os,
378
                                              Elements_iterator location)
379
{
380
  bool first_init = this->first_init_;
381
  this->first_init_ = false;
382
 
383
  for (int i = 0; i < PLACE_MAX; ++i)
384
    {
385
      if (this->places_[i].name != NULL && this->places_[i].name == name)
386
        {
387
          if (this->places_[i].have_location)
388
            {
389
              // We have already seen a section with this name.
390
              return;
391
            }
392
 
393
          this->places_[i].location = location;
394
          this->places_[i].have_location = true;
395
 
396
          // If we just found the .bss section, restart the search for
397
          // an unallocated section.  This follows the GNU linker's
398
          // behaviour.
399
          if (i == PLACE_BSS)
400
            this->places_[PLACE_NONALLOC].have_location = false;
401
 
402
          return;
403
        }
404
    }
405
 
406
  // Relocation sections.
407
  if (!this->places_[PLACE_REL].have_location
408
      && os != NULL
409
      && (os->type() == elfcpp::SHT_REL || os->type() == elfcpp::SHT_RELA)
410
      && (os->flags() & elfcpp::SHF_ALLOC) != 0)
411
    {
412
      this->places_[PLACE_REL].location = location;
413
      this->places_[PLACE_REL].have_location = true;
414
    }
415
 
416
  // We find the location for unallocated sections by finding the
417
  // first debugging or comment section after the BSS section (if
418
  // there is one).
419
  if (!this->places_[PLACE_NONALLOC].have_location
420
      && (name == ".comment" || Layout::is_debug_info_section(name.c_str())))
421
    {
422
      // We add orphan sections after the location in PLACES_.  We
423
      // want to store unallocated sections before LOCATION.  If this
424
      // is the very first section, we can't use it.
425
      if (!first_init)
426
        {
427
          --location;
428
          this->places_[PLACE_NONALLOC].location = location;
429
          this->places_[PLACE_NONALLOC].have_location = true;
430
        }
431
    }
432
}
433
 
434
// Initialize the last location.
435
 
436
void
437
Orphan_section_placement::last_init(Elements_iterator location)
438
{
439
  this->places_[PLACE_LAST].location = location;
440
  this->places_[PLACE_LAST].have_location = true;
441
}
442
 
443
// Set *PWHERE to the address of an iterator pointing to the location
444
// to use for an orphan section.  Return true if the iterator has a
445
// value, false otherwise.
446
 
447
bool
448
Orphan_section_placement::find_place(Output_section* os,
449
                                     Elements_iterator** pwhere)
450
{
451
  // Figure out where OS should go.  This is based on the GNU linker
452
  // code.  FIXME: The GNU linker handles small data sections
453
  // specially, but we don't.
454
  elfcpp::Elf_Word type = os->type();
455
  elfcpp::Elf_Xword flags = os->flags();
456
  Place_index index;
457
  if ((flags & elfcpp::SHF_ALLOC) == 0
458
      && !Layout::is_debug_info_section(os->name()))
459
    index = PLACE_NONALLOC;
460
  else if ((flags & elfcpp::SHF_ALLOC) == 0)
461
    index = PLACE_LAST;
462
  else if (type == elfcpp::SHT_NOTE)
463
    index = PLACE_INTERP;
464
  else if ((flags & elfcpp::SHF_TLS) != 0)
465
    {
466
      if (type == elfcpp::SHT_NOBITS)
467
        index = PLACE_TLS_BSS;
468
      else
469
        index = PLACE_TLS;
470
    }
471
  else if (type == elfcpp::SHT_NOBITS)
472
    index = PLACE_BSS;
473
  else if ((flags & elfcpp::SHF_WRITE) != 0)
474
    index = PLACE_DATA;
475
  else if (type == elfcpp::SHT_REL || type == elfcpp::SHT_RELA)
476
    index = PLACE_REL;
477
  else if ((flags & elfcpp::SHF_EXECINSTR) == 0)
478
    index = PLACE_RODATA;
479
  else
480
    index = PLACE_TEXT;
481
 
482
  // If we don't have a location yet, try to find one based on a
483
  // plausible ordering of sections.
484
  if (!this->places_[index].have_location)
485
    {
486
      Place_index follow;
487
      switch (index)
488
        {
489
        default:
490
          follow = PLACE_MAX;
491
          break;
492
        case PLACE_RODATA:
493
          follow = PLACE_TEXT;
494
          break;
495
        case PLACE_BSS:
496
          follow = PLACE_DATA;
497
          break;
498
        case PLACE_REL:
499
          follow = PLACE_TEXT;
500
          break;
501
        case PLACE_INTERP:
502
          follow = PLACE_TEXT;
503
          break;
504
        case PLACE_TLS:
505
          follow = PLACE_DATA;
506
          break;
507
        case PLACE_TLS_BSS:
508
          follow = PLACE_TLS;
509
          if (!this->places_[PLACE_TLS].have_location)
510
            follow = PLACE_DATA;
511
          break;
512
        }
513
      if (follow != PLACE_MAX && this->places_[follow].have_location)
514
        {
515
          // Set the location of INDEX to the location of FOLLOW.  The
516
          // location of INDEX will then be incremented by the caller,
517
          // so anything in INDEX will continue to be after anything
518
          // in FOLLOW.
519
          this->places_[index].location = this->places_[follow].location;
520
          this->places_[index].have_location = true;
521
        }
522
    }
523
 
524
  *pwhere = &this->places_[index].location;
525
  bool ret = this->places_[index].have_location;
526
 
527
  // The caller will set the location.
528
  this->places_[index].have_location = true;
529
 
530
  return ret;
531
}
532
 
533
// Return the iterator being used for sections at the very end of the
534
// linker script.
535
 
536
Orphan_section_placement::Elements_iterator
537
Orphan_section_placement::last_place() const
538
{
539
  gold_assert(this->places_[PLACE_LAST].have_location);
540
  return this->places_[PLACE_LAST].location;
541
}
542
 
543
// An element in a SECTIONS clause.
544
 
545
class Sections_element
546
{
547
 public:
548
  Sections_element()
549
  { }
550
 
551
  virtual ~Sections_element()
552
  { }
553
 
554
  // Return whether an output section is relro.
555
  virtual bool
556
  is_relro() const
557
  { return false; }
558
 
559
  // Record that an output section is relro.
560
  virtual void
561
  set_is_relro()
562
  { }
563
 
564
  // Create any required output sections.  The only real
565
  // implementation is in Output_section_definition.
566
  virtual void
567
  create_sections(Layout*)
568
  { }
569
 
570
  // Add any symbol being defined to the symbol table.
571
  virtual void
572
  add_symbols_to_table(Symbol_table*)
573
  { }
574
 
575
  // Finalize symbols and check assertions.
576
  virtual void
577
  finalize_symbols(Symbol_table*, const Layout*, uint64_t*)
578
  { }
579
 
580
  // Return the output section name to use for an input file name and
581
  // section name.  This only real implementation is in
582
  // Output_section_definition.
583
  virtual const char*
584
  output_section_name(const char*, const char*, Output_section***,
585
                      Script_sections::Section_type*)
586
  { return NULL; }
587
 
588
  // Initialize OSP with an output section.
589
  virtual void
590
  orphan_section_init(Orphan_section_placement*,
591
                      Script_sections::Elements_iterator)
592
  { }
593
 
594
  // Set section addresses.  This includes applying assignments if the
595
  // expression is an absolute value.
596
  virtual void
597
  set_section_addresses(Symbol_table*, Layout*, uint64_t*, uint64_t*,
598
                        uint64_t*)
599
  { }
600
 
601
  // Check a constraint (ONLY_IF_RO, etc.) on an output section.  If
602
  // this section is constrained, and the input sections do not match,
603
  // return the constraint, and set *POSD.
604
  virtual Section_constraint
605
  check_constraint(Output_section_definition**)
606
  { return CONSTRAINT_NONE; }
607
 
608
  // See if this is the alternate output section for a constrained
609
  // output section.  If it is, transfer the Output_section and return
610
  // true.  Otherwise return false.
611
  virtual bool
612
  alternate_constraint(Output_section_definition*, Section_constraint)
613
  { return false; }
614
 
615
  // Get the list of segments to use for an allocated section when
616
  // using a PHDRS clause.  If this is an allocated section, return
617
  // the Output_section, and set *PHDRS_LIST (the first parameter) to
618
  // the list of PHDRS to which it should be attached.  If the PHDRS
619
  // were not specified, don't change *PHDRS_LIST.  When not returning
620
  // NULL, set *ORPHAN (the second parameter) according to whether
621
  // this is an orphan section--one that is not mentioned in the
622
  // linker script.
623
  virtual Output_section*
624
  allocate_to_segment(String_list**, bool*)
625
  { return NULL; }
626
 
627
  // Look for an output section by name and return the address, the
628
  // load address, the alignment, and the size.  This is used when an
629
  // expression refers to an output section which was not actually
630
  // created.  This returns true if the section was found, false
631
  // otherwise.  The only real definition is for
632
  // Output_section_definition.
633
  virtual bool
634
  get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*,
635
                          uint64_t*) const
636
  { return false; }
637
 
638
  // Return the associated Output_section if there is one.
639
  virtual Output_section*
640
  get_output_section() const
641
  { return NULL; }
642
 
643
  // Set the section's memory regions.
644
  virtual void
645
  set_memory_region(Memory_region*, bool)
646
  { gold_error(_("Attempt to set a memory region for a non-output section")); }
647
 
648
  // Print the element for debugging purposes.
649
  virtual void
650
  print(FILE* f) const = 0;
651
};
652
 
653
// An assignment in a SECTIONS clause outside of an output section.
654
 
655
class Sections_element_assignment : public Sections_element
656
{
657
 public:
658
  Sections_element_assignment(const char* name, size_t namelen,
659
                              Expression* val, bool provide, bool hidden)
660
    : assignment_(name, namelen, false, val, provide, hidden)
661
  { }
662
 
663
  // Add the symbol to the symbol table.
664
  void
665
  add_symbols_to_table(Symbol_table* symtab)
666
  { this->assignment_.add_to_table(symtab); }
667
 
668
  // Finalize the symbol.
669
  void
670
  finalize_symbols(Symbol_table* symtab, const Layout* layout,
671
                   uint64_t* dot_value)
672
  {
673
    this->assignment_.finalize_with_dot(symtab, layout, *dot_value, NULL);
674
  }
675
 
676
  // Set the section address.  There is no section here, but if the
677
  // value is absolute, we set the symbol.  This permits us to use
678
  // absolute symbols when setting dot.
679
  void
680
  set_section_addresses(Symbol_table* symtab, Layout* layout,
681
                        uint64_t* dot_value, uint64_t*, uint64_t*)
682
  {
683
    this->assignment_.set_if_absolute(symtab, layout, true, *dot_value);
684
  }
685
 
686
  // Print for debugging.
687
  void
688
  print(FILE* f) const
689
  {
690
    fprintf(f, "  ");
691
    this->assignment_.print(f);
692
  }
693
 
694
 private:
695
  Symbol_assignment assignment_;
696
};
697
 
698
// An assignment to the dot symbol in a SECTIONS clause outside of an
699
// output section.
700
 
701
class Sections_element_dot_assignment : public Sections_element
702
{
703
 public:
704
  Sections_element_dot_assignment(Expression* val)
705
    : val_(val)
706
  { }
707
 
708
  // Finalize the symbol.
709
  void
710
  finalize_symbols(Symbol_table* symtab, const Layout* layout,
711
                   uint64_t* dot_value)
712
  {
713
    // We ignore the section of the result because outside of an
714
    // output section definition the dot symbol is always considered
715
    // to be absolute.
716
    *dot_value = this->val_->eval_with_dot(symtab, layout, true, *dot_value,
717
                                           NULL, NULL, NULL);
718
  }
719
 
720
  // Update the dot symbol while setting section addresses.
721
  void
722
  set_section_addresses(Symbol_table* symtab, Layout* layout,
723
                        uint64_t* dot_value, uint64_t* dot_alignment,
724
                        uint64_t* load_address)
725
  {
726
    *dot_value = this->val_->eval_with_dot(symtab, layout, false, *dot_value,
727
                                           NULL, NULL, dot_alignment);
728
    *load_address = *dot_value;
729
  }
730
 
731
  // Print for debugging.
732
  void
733
  print(FILE* f) const
734
  {
735
    fprintf(f, "  . = ");
736
    this->val_->print(f);
737
    fprintf(f, "\n");
738
  }
739
 
740
 private:
741
  Expression* val_;
742
};
743
 
744
// An assertion in a SECTIONS clause outside of an output section.
745
 
746
class Sections_element_assertion : public Sections_element
747
{
748
 public:
749
  Sections_element_assertion(Expression* check, const char* message,
750
                             size_t messagelen)
751
    : assertion_(check, message, messagelen)
752
  { }
753
 
754
  // Check the assertion.
755
  void
756
  finalize_symbols(Symbol_table* symtab, const Layout* layout, uint64_t*)
757
  { this->assertion_.check(symtab, layout); }
758
 
759
  // Print for debugging.
760
  void
761
  print(FILE* f) const
762
  {
763
    fprintf(f, "  ");
764
    this->assertion_.print(f);
765
  }
766
 
767
 private:
768
  Script_assertion assertion_;
769
};
770
 
771
// An element in an output section in a SECTIONS clause.
772
 
773
class Output_section_element
774
{
775
 public:
776
  // A list of input sections.
777
  typedef std::list<Output_section::Input_section> Input_section_list;
778
 
779
  Output_section_element()
780
  { }
781
 
782
  virtual ~Output_section_element()
783
  { }
784
 
785
  // Return whether this element requires an output section to exist.
786
  virtual bool
787
  needs_output_section() const
788
  { return false; }
789
 
790
  // Add any symbol being defined to the symbol table.
791
  virtual void
792
  add_symbols_to_table(Symbol_table*)
793
  { }
794
 
795
  // Finalize symbols and check assertions.
796
  virtual void
797
  finalize_symbols(Symbol_table*, const Layout*, uint64_t*, Output_section**)
798
  { }
799
 
800
  // Return whether this element matches FILE_NAME and SECTION_NAME.
801
  // The only real implementation is in Output_section_element_input.
802
  virtual bool
803
  match_name(const char*, const char*) const
804
  { return false; }
805
 
806
  // Set section addresses.  This includes applying assignments if the
807
  // expression is an absolute value.
808
  virtual void
809
  set_section_addresses(Symbol_table*, Layout*, Output_section*, uint64_t,
810
                        uint64_t*, uint64_t*, Output_section**, std::string*,
811
                        Input_section_list*)
812
  { }
813
 
814
  // Print the element for debugging purposes.
815
  virtual void
816
  print(FILE* f) const = 0;
817
 
818
 protected:
819
  // Return a fill string that is LENGTH bytes long, filling it with
820
  // FILL.
821
  std::string
822
  get_fill_string(const std::string* fill, section_size_type length) const;
823
};
824
 
825
std::string
826
Output_section_element::get_fill_string(const std::string* fill,
827
                                        section_size_type length) const
828
{
829
  std::string this_fill;
830
  this_fill.reserve(length);
831
  while (this_fill.length() + fill->length() <= length)
832
    this_fill += *fill;
833
  if (this_fill.length() < length)
834
    this_fill.append(*fill, 0, length - this_fill.length());
835
  return this_fill;
836
}
837
 
838
// A symbol assignment in an output section.
839
 
840
class Output_section_element_assignment : public Output_section_element
841
{
842
 public:
843
  Output_section_element_assignment(const char* name, size_t namelen,
844
                                    Expression* val, bool provide,
845
                                    bool hidden)
846
    : assignment_(name, namelen, false, val, provide, hidden)
847
  { }
848
 
849
  // Add the symbol to the symbol table.
850
  void
851
  add_symbols_to_table(Symbol_table* symtab)
852
  { this->assignment_.add_to_table(symtab); }
853
 
854
  // Finalize the symbol.
855
  void
856
  finalize_symbols(Symbol_table* symtab, const Layout* layout,
857
                   uint64_t* dot_value, Output_section** dot_section)
858
  {
859
    this->assignment_.finalize_with_dot(symtab, layout, *dot_value,
860
                                        *dot_section);
861
  }
862
 
863
  // Set the section address.  There is no section here, but if the
864
  // value is absolute, we set the symbol.  This permits us to use
865
  // absolute symbols when setting dot.
866
  void
867
  set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
868
                        uint64_t, uint64_t* dot_value, uint64_t*,
869
                        Output_section**, std::string*, Input_section_list*)
870
  {
871
    this->assignment_.set_if_absolute(symtab, layout, true, *dot_value);
872
  }
873
 
874
  // Print for debugging.
875
  void
876
  print(FILE* f) const
877
  {
878
    fprintf(f, "    ");
879
    this->assignment_.print(f);
880
  }
881
 
882
 private:
883
  Symbol_assignment assignment_;
884
};
885
 
886
// An assignment to the dot symbol in an output section.
887
 
888
class Output_section_element_dot_assignment : public Output_section_element
889
{
890
 public:
891
  Output_section_element_dot_assignment(Expression* val)
892
    : val_(val)
893
  { }
894
 
895
  // Finalize the symbol.
896
  void
897
  finalize_symbols(Symbol_table* symtab, const Layout* layout,
898
                   uint64_t* dot_value, Output_section** dot_section)
899
  {
900
    *dot_value = this->val_->eval_with_dot(symtab, layout, true, *dot_value,
901
                                           *dot_section, dot_section, NULL);
902
  }
903
 
904
  // Update the dot symbol while setting section addresses.
905
  void
906
  set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
907
                        uint64_t, uint64_t* dot_value, uint64_t*,
908
                        Output_section**, std::string*, Input_section_list*);
909
 
910
  // Print for debugging.
911
  void
912
  print(FILE* f) const
913
  {
914
    fprintf(f, "    . = ");
915
    this->val_->print(f);
916
    fprintf(f, "\n");
917
  }
918
 
919
 private:
920
  Expression* val_;
921
};
922
 
923
// Update the dot symbol while setting section addresses.
924
 
925
void
926
Output_section_element_dot_assignment::set_section_addresses(
927
    Symbol_table* symtab,
928
    Layout* layout,
929
    Output_section* output_section,
930
    uint64_t,
931
    uint64_t* dot_value,
932
    uint64_t* dot_alignment,
933
    Output_section** dot_section,
934
    std::string* fill,
935
    Input_section_list*)
936
{
937
  uint64_t next_dot = this->val_->eval_with_dot(symtab, layout, false,
938
                                                *dot_value, *dot_section,
939
                                                dot_section, dot_alignment);
940
  if (next_dot < *dot_value)
941
    gold_error(_("dot may not move backward"));
942
  if (next_dot > *dot_value && output_section != NULL)
943
    {
944
      section_size_type length = convert_to_section_size_type(next_dot
945
                                                              - *dot_value);
946
      Output_section_data* posd;
947
      if (fill->empty())
948
        posd = new Output_data_zero_fill(length, 0);
949
      else
950
        {
951
          std::string this_fill = this->get_fill_string(fill, length);
952
          posd = new Output_data_const(this_fill, 0);
953
        }
954
      output_section->add_output_section_data(posd);
955
      layout->new_output_section_data_from_script(posd);
956
    }
957
  *dot_value = next_dot;
958
}
959
 
960
// An assertion in an output section.
961
 
962
class Output_section_element_assertion : public Output_section_element
963
{
964
 public:
965
  Output_section_element_assertion(Expression* check, const char* message,
966
                                   size_t messagelen)
967
    : assertion_(check, message, messagelen)
968
  { }
969
 
970
  void
971
  print(FILE* f) const
972
  {
973
    fprintf(f, "    ");
974
    this->assertion_.print(f);
975
  }
976
 
977
 private:
978
  Script_assertion assertion_;
979
};
980
 
981
// We use a special instance of Output_section_data to handle BYTE,
982
// SHORT, etc.  This permits forward references to symbols in the
983
// expressions.
984
 
985
class Output_data_expression : public Output_section_data
986
{
987
 public:
988
  Output_data_expression(int size, bool is_signed, Expression* val,
989
                         const Symbol_table* symtab, const Layout* layout,
990
                         uint64_t dot_value, Output_section* dot_section)
991
    : Output_section_data(size, 0, true),
992
      is_signed_(is_signed), val_(val), symtab_(symtab),
993
      layout_(layout), dot_value_(dot_value), dot_section_(dot_section)
994
  { }
995
 
996
 protected:
997
  // Write the data to the output file.
998
  void
999
  do_write(Output_file*);
1000
 
1001
  // Write the data to a buffer.
1002
  void
1003
  do_write_to_buffer(unsigned char*);
1004
 
1005
  // Write to a map file.
1006
  void
1007
  do_print_to_mapfile(Mapfile* mapfile) const
1008
  { mapfile->print_output_data(this, _("** expression")); }
1009
 
1010
 private:
1011
  template<bool big_endian>
1012
  void
1013
  endian_write_to_buffer(uint64_t, unsigned char*);
1014
 
1015
  bool is_signed_;
1016
  Expression* val_;
1017
  const Symbol_table* symtab_;
1018
  const Layout* layout_;
1019
  uint64_t dot_value_;
1020
  Output_section* dot_section_;
1021
};
1022
 
1023
// Write the data element to the output file.
1024
 
1025
void
1026
Output_data_expression::do_write(Output_file* of)
1027
{
1028
  unsigned char* view = of->get_output_view(this->offset(), this->data_size());
1029
  this->write_to_buffer(view);
1030
  of->write_output_view(this->offset(), this->data_size(), view);
1031
}
1032
 
1033
// Write the data element to a buffer.
1034
 
1035
void
1036
Output_data_expression::do_write_to_buffer(unsigned char* buf)
1037
{
1038
  uint64_t val = this->val_->eval_with_dot(this->symtab_, this->layout_,
1039
                                           true, this->dot_value_,
1040
                                           this->dot_section_, NULL, NULL);
1041
 
1042
  if (parameters->target().is_big_endian())
1043
    this->endian_write_to_buffer<true>(val, buf);
1044
  else
1045
    this->endian_write_to_buffer<false>(val, buf);
1046
}
1047
 
1048
template<bool big_endian>
1049
void
1050
Output_data_expression::endian_write_to_buffer(uint64_t val,
1051
                                               unsigned char* buf)
1052
{
1053
  switch (this->data_size())
1054
    {
1055
    case 1:
1056
      elfcpp::Swap_unaligned<8, big_endian>::writeval(buf, val);
1057
      break;
1058
    case 2:
1059
      elfcpp::Swap_unaligned<16, big_endian>::writeval(buf, val);
1060
      break;
1061
    case 4:
1062
      elfcpp::Swap_unaligned<32, big_endian>::writeval(buf, val);
1063
      break;
1064
    case 8:
1065
      if (parameters->target().get_size() == 32)
1066
        {
1067
          val &= 0xffffffff;
1068
          if (this->is_signed_ && (val & 0x80000000) != 0)
1069
            val |= 0xffffffff00000000LL;
1070
        }
1071
      elfcpp::Swap_unaligned<64, big_endian>::writeval(buf, val);
1072
      break;
1073
    default:
1074
      gold_unreachable();
1075
    }
1076
}
1077
 
1078
// A data item in an output section.
1079
 
1080
class Output_section_element_data : public Output_section_element
1081
{
1082
 public:
1083
  Output_section_element_data(int size, bool is_signed, Expression* val)
1084
    : size_(size), is_signed_(is_signed), val_(val)
1085
  { }
1086
 
1087
  // If there is a data item, then we must create an output section.
1088
  bool
1089
  needs_output_section() const
1090
  { return true; }
1091
 
1092
  // Finalize symbols--we just need to update dot.
1093
  void
1094
  finalize_symbols(Symbol_table*, const Layout*, uint64_t* dot_value,
1095
                   Output_section**)
1096
  { *dot_value += this->size_; }
1097
 
1098
  // Store the value in the section.
1099
  void
1100
  set_section_addresses(Symbol_table*, Layout*, Output_section*, uint64_t,
1101
                        uint64_t* dot_value, uint64_t*, Output_section**,
1102
                        std::string*, Input_section_list*);
1103
 
1104
  // Print for debugging.
1105
  void
1106
  print(FILE*) const;
1107
 
1108
 private:
1109
  // The size in bytes.
1110
  int size_;
1111
  // Whether the value is signed.
1112
  bool is_signed_;
1113
  // The value.
1114
  Expression* val_;
1115
};
1116
 
1117
// Store the value in the section.
1118
 
1119
void
1120
Output_section_element_data::set_section_addresses(
1121
    Symbol_table* symtab,
1122
    Layout* layout,
1123
    Output_section* os,
1124
    uint64_t,
1125
    uint64_t* dot_value,
1126
    uint64_t*,
1127
    Output_section** dot_section,
1128
    std::string*,
1129
    Input_section_list*)
1130
{
1131
  gold_assert(os != NULL);
1132
  Output_data_expression* expression =
1133
    new Output_data_expression(this->size_, this->is_signed_, this->val_,
1134
                               symtab, layout, *dot_value, *dot_section);
1135
  os->add_output_section_data(expression);
1136
  layout->new_output_section_data_from_script(expression);
1137
  *dot_value += this->size_;
1138
}
1139
 
1140
// Print for debugging.
1141
 
1142
void
1143
Output_section_element_data::print(FILE* f) const
1144
{
1145
  const char* s;
1146
  switch (this->size_)
1147
    {
1148
    case 1:
1149
      s = "BYTE";
1150
      break;
1151
    case 2:
1152
      s = "SHORT";
1153
      break;
1154
    case 4:
1155
      s = "LONG";
1156
      break;
1157
    case 8:
1158
      if (this->is_signed_)
1159
        s = "SQUAD";
1160
      else
1161
        s = "QUAD";
1162
      break;
1163
    default:
1164
      gold_unreachable();
1165
    }
1166
  fprintf(f, "    %s(", s);
1167
  this->val_->print(f);
1168
  fprintf(f, ")\n");
1169
}
1170
 
1171
// A fill value setting in an output section.
1172
 
1173
class Output_section_element_fill : public Output_section_element
1174
{
1175
 public:
1176
  Output_section_element_fill(Expression* val)
1177
    : val_(val)
1178
  { }
1179
 
1180
  // Update the fill value while setting section addresses.
1181
  void
1182
  set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
1183
                        uint64_t, uint64_t* dot_value, uint64_t*,
1184
                        Output_section** dot_section,
1185
                        std::string* fill, Input_section_list*)
1186
  {
1187
    Output_section* fill_section;
1188
    uint64_t fill_val = this->val_->eval_with_dot(symtab, layout, false,
1189
                                                  *dot_value, *dot_section,
1190
                                                  &fill_section, NULL);
1191
    if (fill_section != NULL)
1192
      gold_warning(_("fill value is not absolute"));
1193
    // FIXME: The GNU linker supports fill values of arbitrary length.
1194
    unsigned char fill_buff[4];
1195
    elfcpp::Swap_unaligned<32, true>::writeval(fill_buff, fill_val);
1196
    fill->assign(reinterpret_cast<char*>(fill_buff), 4);
1197
  }
1198
 
1199
  // Print for debugging.
1200
  void
1201
  print(FILE* f) const
1202
  {
1203
    fprintf(f, "    FILL(");
1204
    this->val_->print(f);
1205
    fprintf(f, ")\n");
1206
  }
1207
 
1208
 private:
1209
  // The new fill value.
1210
  Expression* val_;
1211
};
1212
 
1213
// An input section specification in an output section
1214
 
1215
class Output_section_element_input : public Output_section_element
1216
{
1217
 public:
1218
  Output_section_element_input(const Input_section_spec* spec, bool keep);
1219
 
1220
  // Finalize symbols--just update the value of the dot symbol.
1221
  void
1222
  finalize_symbols(Symbol_table*, const Layout*, uint64_t* dot_value,
1223
                   Output_section** dot_section)
1224
  {
1225
    *dot_value = this->final_dot_value_;
1226
    *dot_section = this->final_dot_section_;
1227
  }
1228
 
1229
  // See whether we match FILE_NAME and SECTION_NAME as an input
1230
  // section.
1231
  bool
1232
  match_name(const char* file_name, const char* section_name) const;
1233
 
1234
  // Set the section address.
1235
  void
1236
  set_section_addresses(Symbol_table* symtab, Layout* layout, Output_section*,
1237
                        uint64_t subalign, uint64_t* dot_value, uint64_t*,
1238
                        Output_section**, std::string* fill,
1239
                        Input_section_list*);
1240
 
1241
  // Print for debugging.
1242
  void
1243
  print(FILE* f) const;
1244
 
1245
 private:
1246
  // An input section pattern.
1247
  struct Input_section_pattern
1248
  {
1249
    std::string pattern;
1250
    bool pattern_is_wildcard;
1251
    Sort_wildcard sort;
1252
 
1253
    Input_section_pattern(const char* patterna, size_t patternlena,
1254
                          Sort_wildcard sorta)
1255
      : pattern(patterna, patternlena),
1256
        pattern_is_wildcard(is_wildcard_string(this->pattern.c_str())),
1257
        sort(sorta)
1258
    { }
1259
  };
1260
 
1261
  typedef std::vector<Input_section_pattern> Input_section_patterns;
1262
 
1263
  // Filename_exclusions is a pair of filename pattern and a bool
1264
  // indicating whether the filename is a wildcard.
1265
  typedef std::vector<std::pair<std::string, bool> > Filename_exclusions;
1266
 
1267
  // Return whether STRING matches PATTERN, where IS_WILDCARD_PATTERN
1268
  // indicates whether this is a wildcard pattern.
1269
  static inline bool
1270
  match(const char* string, const char* pattern, bool is_wildcard_pattern)
1271
  {
1272
    return (is_wildcard_pattern
1273
            ? fnmatch(pattern, string, 0) == 0
1274
            : strcmp(string, pattern) == 0);
1275
  }
1276
 
1277
  // See if we match a file name.
1278
  bool
1279
  match_file_name(const char* file_name) const;
1280
 
1281
  // The file name pattern.  If this is the empty string, we match all
1282
  // files.
1283
  std::string filename_pattern_;
1284
  // Whether the file name pattern is a wildcard.
1285
  bool filename_is_wildcard_;
1286
  // How the file names should be sorted.  This may only be
1287
  // SORT_WILDCARD_NONE or SORT_WILDCARD_BY_NAME.
1288
  Sort_wildcard filename_sort_;
1289
  // The list of file names to exclude.
1290
  Filename_exclusions filename_exclusions_;
1291
  // The list of input section patterns.
1292
  Input_section_patterns input_section_patterns_;
1293
  // Whether to keep this section when garbage collecting.
1294
  bool keep_;
1295
  // The value of dot after including all matching sections.
1296
  uint64_t final_dot_value_;
1297
  // The section where dot is defined after including all matching
1298
  // sections.
1299
  Output_section* final_dot_section_;
1300
};
1301
 
1302
// Construct Output_section_element_input.  The parser records strings
1303
// as pointers into a copy of the script file, which will go away when
1304
// parsing is complete.  We make sure they are in std::string objects.
1305
 
1306
Output_section_element_input::Output_section_element_input(
1307
    const Input_section_spec* spec,
1308
    bool keep)
1309
  : filename_pattern_(),
1310
    filename_is_wildcard_(false),
1311
    filename_sort_(spec->file.sort),
1312
    filename_exclusions_(),
1313
    input_section_patterns_(),
1314
    keep_(keep),
1315
    final_dot_value_(0),
1316
    final_dot_section_(NULL)
1317
{
1318
  // The filename pattern "*" is common, and matches all files.  Turn
1319
  // it into the empty string.
1320
  if (spec->file.name.length != 1 || spec->file.name.value[0] != '*')
1321
    this->filename_pattern_.assign(spec->file.name.value,
1322
                                   spec->file.name.length);
1323
  this->filename_is_wildcard_ = is_wildcard_string(this->filename_pattern_.c_str());
1324
 
1325
  if (spec->input_sections.exclude != NULL)
1326
    {
1327
      for (String_list::const_iterator p =
1328
             spec->input_sections.exclude->begin();
1329
           p != spec->input_sections.exclude->end();
1330
           ++p)
1331
        {
1332
          bool is_wildcard = is_wildcard_string((*p).c_str());
1333
          this->filename_exclusions_.push_back(std::make_pair(*p,
1334
                                                              is_wildcard));
1335
        }
1336
    }
1337
 
1338
  if (spec->input_sections.sections != NULL)
1339
    {
1340
      Input_section_patterns& isp(this->input_section_patterns_);
1341
      for (String_sort_list::const_iterator p =
1342
             spec->input_sections.sections->begin();
1343
           p != spec->input_sections.sections->end();
1344
           ++p)
1345
        isp.push_back(Input_section_pattern(p->name.value, p->name.length,
1346
                                            p->sort));
1347
    }
1348
}
1349
 
1350
// See whether we match FILE_NAME.
1351
 
1352
bool
1353
Output_section_element_input::match_file_name(const char* file_name) const
1354
{
1355
  if (!this->filename_pattern_.empty())
1356
    {
1357
      // If we were called with no filename, we refuse to match a
1358
      // pattern which requires a file name.
1359
      if (file_name == NULL)
1360
        return false;
1361
 
1362
      if (!match(file_name, this->filename_pattern_.c_str(),
1363
                 this->filename_is_wildcard_))
1364
        return false;
1365
    }
1366
 
1367
  if (file_name != NULL)
1368
    {
1369
      // Now we have to see whether FILE_NAME matches one of the
1370
      // exclusion patterns, if any.
1371
      for (Filename_exclusions::const_iterator p =
1372
             this->filename_exclusions_.begin();
1373
           p != this->filename_exclusions_.end();
1374
           ++p)
1375
        {
1376
          if (match(file_name, p->first.c_str(), p->second))
1377
            return false;
1378
        }
1379
    }
1380
 
1381
  return true;
1382
}
1383
 
1384
// See whether we match FILE_NAME and SECTION_NAME.
1385
 
1386
bool
1387
Output_section_element_input::match_name(const char* file_name,
1388
                                         const char* section_name) const
1389
{
1390
  if (!this->match_file_name(file_name))
1391
    return false;
1392
 
1393
  // If there are no section name patterns, then we match.
1394
  if (this->input_section_patterns_.empty())
1395
    return true;
1396
 
1397
  // See whether we match the section name patterns.
1398
  for (Input_section_patterns::const_iterator p =
1399
         this->input_section_patterns_.begin();
1400
       p != this->input_section_patterns_.end();
1401
       ++p)
1402
    {
1403
      if (match(section_name, p->pattern.c_str(), p->pattern_is_wildcard))
1404
        return true;
1405
    }
1406
 
1407
  // We didn't match any section names, so we didn't match.
1408
  return false;
1409
}
1410
 
1411
// Information we use to sort the input sections.
1412
 
1413
class Input_section_info
1414
{
1415
 public:
1416
  Input_section_info(const Output_section::Input_section& input_section)
1417
    : input_section_(input_section), section_name_(),
1418
      size_(0), addralign_(1)
1419
  { }
1420
 
1421
  // Return the simple input section.
1422
  const Output_section::Input_section&
1423
  input_section() const
1424
  { return this->input_section_; }
1425
 
1426
  // Return the object.
1427
  Relobj*
1428
  relobj() const
1429
  { return this->input_section_.relobj(); }
1430
 
1431
  // Return the section index.
1432
  unsigned int
1433
  shndx()
1434
  { return this->input_section_.shndx(); }
1435
 
1436
  // Return the section name.
1437
  const std::string&
1438
  section_name() const
1439
  { return this->section_name_; }
1440
 
1441
  // Set the section name.
1442
  void
1443
  set_section_name(const std::string name)
1444
  { this->section_name_ = name; }
1445
 
1446
  // Return the section size.
1447
  uint64_t
1448
  size() const
1449
  { return this->size_; }
1450
 
1451
  // Set the section size.
1452
  void
1453
  set_size(uint64_t size)
1454
  { this->size_ = size; }
1455
 
1456
  // Return the address alignment.
1457
  uint64_t
1458
  addralign() const
1459
  { return this->addralign_; }
1460
 
1461
  // Set the address alignment.
1462
  void
1463
  set_addralign(uint64_t addralign)
1464
  { this->addralign_ = addralign; }
1465
 
1466
 private:
1467
  // Input section, can be a relaxed section.
1468
  Output_section::Input_section input_section_;
1469
  // Name of the section. 
1470
  std::string section_name_;
1471
  // Section size.
1472
  uint64_t size_;
1473
  // Address alignment.
1474
  uint64_t addralign_;
1475
};
1476
 
1477
// A class to sort the input sections.
1478
 
1479
class Input_section_sorter
1480
{
1481
 public:
1482
  Input_section_sorter(Sort_wildcard filename_sort, Sort_wildcard section_sort)
1483
    : filename_sort_(filename_sort), section_sort_(section_sort)
1484
  { }
1485
 
1486
  bool
1487
  operator()(const Input_section_info&, const Input_section_info&) const;
1488
 
1489
 private:
1490
  Sort_wildcard filename_sort_;
1491
  Sort_wildcard section_sort_;
1492
};
1493
 
1494
bool
1495
Input_section_sorter::operator()(const Input_section_info& isi1,
1496
                                 const Input_section_info& isi2) const
1497
{
1498
  if (this->section_sort_ == SORT_WILDCARD_BY_NAME
1499
      || this->section_sort_ == SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
1500
      || (this->section_sort_ == SORT_WILDCARD_BY_ALIGNMENT_BY_NAME
1501
          && isi1.addralign() == isi2.addralign()))
1502
    {
1503
      if (isi1.section_name() != isi2.section_name())
1504
        return isi1.section_name() < isi2.section_name();
1505
    }
1506
  if (this->section_sort_ == SORT_WILDCARD_BY_ALIGNMENT
1507
      || this->section_sort_ == SORT_WILDCARD_BY_NAME_BY_ALIGNMENT
1508
      || this->section_sort_ == SORT_WILDCARD_BY_ALIGNMENT_BY_NAME)
1509
    {
1510
      if (isi1.addralign() != isi2.addralign())
1511
        return isi1.addralign() < isi2.addralign();
1512
    }
1513
  if (this->filename_sort_ == SORT_WILDCARD_BY_NAME)
1514
    {
1515
      if (isi1.relobj()->name() != isi2.relobj()->name())
1516
        return (isi1.relobj()->name() < isi2.relobj()->name());
1517
    }
1518
 
1519
  // Otherwise we leave them in the same order.
1520
  return false;
1521
}
1522
 
1523
// Set the section address.  Look in INPUT_SECTIONS for sections which
1524
// match this spec, sort them as specified, and add them to the output
1525
// section.
1526
 
1527
void
1528
Output_section_element_input::set_section_addresses(
1529
    Symbol_table*,
1530
    Layout* layout,
1531
    Output_section* output_section,
1532
    uint64_t subalign,
1533
    uint64_t* dot_value,
1534
    uint64_t*,
1535
    Output_section** dot_section,
1536
    std::string* fill,
1537
    Input_section_list* input_sections)
1538
{
1539
  // We build a list of sections which match each
1540
  // Input_section_pattern.
1541
 
1542
  typedef std::vector<std::vector<Input_section_info> > Matching_sections;
1543
  size_t input_pattern_count = this->input_section_patterns_.size();
1544
  if (input_pattern_count == 0)
1545
    input_pattern_count = 1;
1546
  Matching_sections matching_sections(input_pattern_count);
1547
 
1548
  // Look through the list of sections for this output section.  Add
1549
  // each one which matches to one of the elements of
1550
  // MATCHING_SECTIONS.
1551
 
1552
  Input_section_list::iterator p = input_sections->begin();
1553
  while (p != input_sections->end())
1554
    {
1555
      Relobj* relobj = p->relobj();
1556
      unsigned int shndx = p->shndx();
1557
      Input_section_info isi(*p);
1558
 
1559
      // Calling section_name and section_addralign is not very
1560
      // efficient.
1561
 
1562
      // Lock the object so that we can get information about the
1563
      // section.  This is OK since we know we are single-threaded
1564
      // here.
1565
      {
1566
        const Task* task = reinterpret_cast<const Task*>(-1);
1567
        Task_lock_obj<Object> tl(task, relobj);
1568
 
1569
        isi.set_section_name(relobj->section_name(shndx));
1570
        if (p->is_relaxed_input_section())
1571
          {
1572
            // We use current data size because relaxed section sizes may not
1573
            // have finalized yet.
1574
            isi.set_size(p->relaxed_input_section()->current_data_size());
1575
            isi.set_addralign(p->relaxed_input_section()->addralign());
1576
          }
1577
        else
1578
          {
1579
            isi.set_size(relobj->section_size(shndx));
1580
            isi.set_addralign(relobj->section_addralign(shndx));
1581
          }
1582
      }
1583
 
1584
      if (!this->match_file_name(relobj->name().c_str()))
1585
        ++p;
1586
      else if (this->input_section_patterns_.empty())
1587
        {
1588
          matching_sections[0].push_back(isi);
1589
          p = input_sections->erase(p);
1590
        }
1591
      else
1592
        {
1593
          size_t i;
1594
          for (i = 0; i < input_pattern_count; ++i)
1595
            {
1596
              const Input_section_pattern&
1597
                isp(this->input_section_patterns_[i]);
1598
              if (match(isi.section_name().c_str(), isp.pattern.c_str(),
1599
                        isp.pattern_is_wildcard))
1600
                break;
1601
            }
1602
 
1603
          if (i >= this->input_section_patterns_.size())
1604
            ++p;
1605
          else
1606
            {
1607
              matching_sections[i].push_back(isi);
1608
              p = input_sections->erase(p);
1609
            }
1610
        }
1611
    }
1612
 
1613
  // Look through MATCHING_SECTIONS.  Sort each one as specified,
1614
  // using a stable sort so that we get the default order when
1615
  // sections are otherwise equal.  Add each input section to the
1616
  // output section.
1617
 
1618
  uint64_t dot = *dot_value;
1619
  for (size_t i = 0; i < input_pattern_count; ++i)
1620
    {
1621
      if (matching_sections[i].empty())
1622
        continue;
1623
 
1624
      gold_assert(output_section != NULL);
1625
 
1626
      const Input_section_pattern& isp(this->input_section_patterns_[i]);
1627
      if (isp.sort != SORT_WILDCARD_NONE
1628
          || this->filename_sort_ != SORT_WILDCARD_NONE)
1629
        std::stable_sort(matching_sections[i].begin(),
1630
                         matching_sections[i].end(),
1631
                         Input_section_sorter(this->filename_sort_,
1632
                                              isp.sort));
1633
 
1634
      for (std::vector<Input_section_info>::const_iterator p =
1635
             matching_sections[i].begin();
1636
           p != matching_sections[i].end();
1637
           ++p)
1638
        {
1639
          // Override the original address alignment if SUBALIGN is specified
1640
          // and is greater than the original alignment.  We need to make a
1641
          // copy of the input section to modify the alignment.
1642
          Output_section::Input_section sis(p->input_section());
1643
 
1644
          uint64_t this_subalign = sis.addralign();
1645
          if (!sis.is_input_section())
1646
            sis.output_section_data()->finalize_data_size();
1647
          uint64_t data_size = sis.data_size();
1648
          if (this_subalign < subalign)
1649
            {
1650
              this_subalign = subalign;
1651
              sis.set_addralign(subalign);
1652
            }
1653
 
1654
          uint64_t address = align_address(dot, this_subalign);
1655
 
1656
          if (address > dot && !fill->empty())
1657
            {
1658
              section_size_type length =
1659
                convert_to_section_size_type(address - dot);
1660
              std::string this_fill = this->get_fill_string(fill, length);
1661
              Output_section_data* posd = new Output_data_const(this_fill, 0);
1662
              output_section->add_output_section_data(posd);
1663
              layout->new_output_section_data_from_script(posd);
1664
            }
1665
 
1666
          output_section->add_script_input_section(sis);
1667
          dot = address + data_size;
1668
        }
1669
    }
1670
 
1671
  // An SHF_TLS/SHT_NOBITS section does not take up any
1672
  // address space.
1673
  if (output_section == NULL
1674
      || (output_section->flags() & elfcpp::SHF_TLS) == 0
1675
      || output_section->type() != elfcpp::SHT_NOBITS)
1676
    *dot_value = dot;
1677
 
1678
  this->final_dot_value_ = *dot_value;
1679
  this->final_dot_section_ = *dot_section;
1680
}
1681
 
1682
// Print for debugging.
1683
 
1684
void
1685
Output_section_element_input::print(FILE* f) const
1686
{
1687
  fprintf(f, "    ");
1688
 
1689
  if (this->keep_)
1690
    fprintf(f, "KEEP(");
1691
 
1692
  if (!this->filename_pattern_.empty())
1693
    {
1694
      bool need_close_paren = false;
1695
      switch (this->filename_sort_)
1696
        {
1697
        case SORT_WILDCARD_NONE:
1698
          break;
1699
        case SORT_WILDCARD_BY_NAME:
1700
          fprintf(f, "SORT_BY_NAME(");
1701
          need_close_paren = true;
1702
          break;
1703
        default:
1704
          gold_unreachable();
1705
        }
1706
 
1707
      fprintf(f, "%s", this->filename_pattern_.c_str());
1708
 
1709
      if (need_close_paren)
1710
        fprintf(f, ")");
1711
    }
1712
 
1713
  if (!this->input_section_patterns_.empty()
1714
      || !this->filename_exclusions_.empty())
1715
    {
1716
      fprintf(f, "(");
1717
 
1718
      bool need_space = false;
1719
      if (!this->filename_exclusions_.empty())
1720
        {
1721
          fprintf(f, "EXCLUDE_FILE(");
1722
          bool need_comma = false;
1723
          for (Filename_exclusions::const_iterator p =
1724
                 this->filename_exclusions_.begin();
1725
               p != this->filename_exclusions_.end();
1726
               ++p)
1727
            {
1728
              if (need_comma)
1729
                fprintf(f, ", ");
1730
              fprintf(f, "%s", p->first.c_str());
1731
              need_comma = true;
1732
            }
1733
          fprintf(f, ")");
1734
          need_space = true;
1735
        }
1736
 
1737
      for (Input_section_patterns::const_iterator p =
1738
             this->input_section_patterns_.begin();
1739
           p != this->input_section_patterns_.end();
1740
           ++p)
1741
        {
1742
          if (need_space)
1743
            fprintf(f, " ");
1744
 
1745
          int close_parens = 0;
1746
          switch (p->sort)
1747
            {
1748
            case SORT_WILDCARD_NONE:
1749
              break;
1750
            case SORT_WILDCARD_BY_NAME:
1751
              fprintf(f, "SORT_BY_NAME(");
1752
              close_parens = 1;
1753
              break;
1754
            case SORT_WILDCARD_BY_ALIGNMENT:
1755
              fprintf(f, "SORT_BY_ALIGNMENT(");
1756
              close_parens = 1;
1757
              break;
1758
            case SORT_WILDCARD_BY_NAME_BY_ALIGNMENT:
1759
              fprintf(f, "SORT_BY_NAME(SORT_BY_ALIGNMENT(");
1760
              close_parens = 2;
1761
              break;
1762
            case SORT_WILDCARD_BY_ALIGNMENT_BY_NAME:
1763
              fprintf(f, "SORT_BY_ALIGNMENT(SORT_BY_NAME(");
1764
              close_parens = 2;
1765
              break;
1766
            default:
1767
              gold_unreachable();
1768
            }
1769
 
1770
          fprintf(f, "%s", p->pattern.c_str());
1771
 
1772
          for (int i = 0; i < close_parens; ++i)
1773
            fprintf(f, ")");
1774
 
1775
          need_space = true;
1776
        }
1777
 
1778
      fprintf(f, ")");
1779
    }
1780
 
1781
  if (this->keep_)
1782
    fprintf(f, ")");
1783
 
1784
  fprintf(f, "\n");
1785
}
1786
 
1787
// An output section.
1788
 
1789
class Output_section_definition : public Sections_element
1790
{
1791
 public:
1792
  typedef Output_section_element::Input_section_list Input_section_list;
1793
 
1794
  Output_section_definition(const char* name, size_t namelen,
1795
                            const Parser_output_section_header* header);
1796
 
1797
  // Finish the output section with the information in the trailer.
1798
  void
1799
  finish(const Parser_output_section_trailer* trailer);
1800
 
1801
  // Add a symbol to be defined.
1802
  void
1803
  add_symbol_assignment(const char* name, size_t length, Expression* value,
1804
                        bool provide, bool hidden);
1805
 
1806
  // Add an assignment to the special dot symbol.
1807
  void
1808
  add_dot_assignment(Expression* value);
1809
 
1810
  // Add an assertion.
1811
  void
1812
  add_assertion(Expression* check, const char* message, size_t messagelen);
1813
 
1814
  // Add a data item to the current output section.
1815
  void
1816
  add_data(int size, bool is_signed, Expression* val);
1817
 
1818
  // Add a setting for the fill value.
1819
  void
1820
  add_fill(Expression* val);
1821
 
1822
  // Add an input section specification.
1823
  void
1824
  add_input_section(const Input_section_spec* spec, bool keep);
1825
 
1826
  // Return whether the output section is relro.
1827
  bool
1828
  is_relro() const
1829
  { return this->is_relro_; }
1830
 
1831
  // Record that the output section is relro.
1832
  void
1833
  set_is_relro()
1834
  { this->is_relro_ = true; }
1835
 
1836
  // Create any required output sections.
1837
  void
1838
  create_sections(Layout*);
1839
 
1840
  // Add any symbols being defined to the symbol table.
1841
  void
1842
  add_symbols_to_table(Symbol_table* symtab);
1843
 
1844
  // Finalize symbols and check assertions.
1845
  void
1846
  finalize_symbols(Symbol_table*, const Layout*, uint64_t*);
1847
 
1848
  // Return the output section name to use for an input file name and
1849
  // section name.
1850
  const char*
1851
  output_section_name(const char* file_name, const char* section_name,
1852
                      Output_section***, Script_sections::Section_type*);
1853
 
1854
  // Initialize OSP with an output section.
1855
  void
1856
  orphan_section_init(Orphan_section_placement* osp,
1857
                      Script_sections::Elements_iterator p)
1858
  { osp->output_section_init(this->name_, this->output_section_, p); }
1859
 
1860
  // Set the section address.
1861
  void
1862
  set_section_addresses(Symbol_table* symtab, Layout* layout,
1863
                        uint64_t* dot_value, uint64_t*,
1864
                        uint64_t* load_address);
1865
 
1866
  // Check a constraint (ONLY_IF_RO, etc.) on an output section.  If
1867
  // this section is constrained, and the input sections do not match,
1868
  // return the constraint, and set *POSD.
1869
  Section_constraint
1870
  check_constraint(Output_section_definition** posd);
1871
 
1872
  // See if this is the alternate output section for a constrained
1873
  // output section.  If it is, transfer the Output_section and return
1874
  // true.  Otherwise return false.
1875
  bool
1876
  alternate_constraint(Output_section_definition*, Section_constraint);
1877
 
1878
  // Get the list of segments to use for an allocated section when
1879
  // using a PHDRS clause.
1880
  Output_section*
1881
  allocate_to_segment(String_list** phdrs_list, bool* orphan);
1882
 
1883
  // Look for an output section by name and return the address, the
1884
  // load address, the alignment, and the size.  This is used when an
1885
  // expression refers to an output section which was not actually
1886
  // created.  This returns true if the section was found, false
1887
  // otherwise.
1888
  bool
1889
  get_output_section_info(const char*, uint64_t*, uint64_t*, uint64_t*,
1890
                          uint64_t*) const;
1891
 
1892
  // Return the associated Output_section if there is one.
1893
  Output_section*
1894
  get_output_section() const
1895
  { return this->output_section_; }
1896
 
1897
  // Print the contents to the FILE.  This is for debugging.
1898
  void
1899
  print(FILE*) const;
1900
 
1901
  // Return the output section type if specified or Script_sections::ST_NONE.
1902
  Script_sections::Section_type
1903
  section_type() const;
1904
 
1905
  // Store the memory region to use.
1906
  void
1907
  set_memory_region(Memory_region*, bool set_vma);
1908
 
1909
  void
1910
  set_section_vma(Expression* address)
1911
  { this->address_ = address; }
1912
 
1913
  void
1914
  set_section_lma(Expression* address)
1915
  { this->load_address_ = address; }
1916
 
1917
  const std::string&
1918
  get_section_name() const
1919
  { return this->name_; }
1920
 
1921
 private:
1922
  static const char*
1923
  script_section_type_name(Script_section_type);
1924
 
1925
  typedef std::vector<Output_section_element*> Output_section_elements;
1926
 
1927
  // The output section name.
1928
  std::string name_;
1929
  // The address.  This may be NULL.
1930
  Expression* address_;
1931
  // The load address.  This may be NULL.
1932
  Expression* load_address_;
1933
  // The alignment.  This may be NULL.
1934
  Expression* align_;
1935
  // The input section alignment.  This may be NULL.
1936
  Expression* subalign_;
1937
  // The constraint, if any.
1938
  Section_constraint constraint_;
1939
  // The fill value.  This may be NULL.
1940
  Expression* fill_;
1941
  // The list of segments this section should go into.  This may be
1942
  // NULL.
1943
  String_list* phdrs_;
1944
  // The list of elements defining the section.
1945
  Output_section_elements elements_;
1946
  // The Output_section created for this definition.  This will be
1947
  // NULL if none was created.
1948
  Output_section* output_section_;
1949
  // The address after it has been evaluated.
1950
  uint64_t evaluated_address_;
1951
  // The load address after it has been evaluated.
1952
  uint64_t evaluated_load_address_;
1953
  // The alignment after it has been evaluated.
1954
  uint64_t evaluated_addralign_;
1955
  // The output section is relro.
1956
  bool is_relro_;
1957
  // The output section type if specified.
1958
  enum Script_section_type script_section_type_;
1959
};
1960
 
1961
// Constructor.
1962
 
1963
Output_section_definition::Output_section_definition(
1964
    const char* name,
1965
    size_t namelen,
1966
    const Parser_output_section_header* header)
1967
  : name_(name, namelen),
1968
    address_(header->address),
1969
    load_address_(header->load_address),
1970
    align_(header->align),
1971
    subalign_(header->subalign),
1972
    constraint_(header->constraint),
1973
    fill_(NULL),
1974
    phdrs_(NULL),
1975
    elements_(),
1976
    output_section_(NULL),
1977
    evaluated_address_(0),
1978
    evaluated_load_address_(0),
1979
    evaluated_addralign_(0),
1980
    is_relro_(false),
1981
    script_section_type_(header->section_type)
1982
{
1983
}
1984
 
1985
// Finish an output section.
1986
 
1987
void
1988
Output_section_definition::finish(const Parser_output_section_trailer* trailer)
1989
{
1990
  this->fill_ = trailer->fill;
1991
  this->phdrs_ = trailer->phdrs;
1992
}
1993
 
1994
// Add a symbol to be defined.
1995
 
1996
void
1997
Output_section_definition::add_symbol_assignment(const char* name,
1998
                                                 size_t length,
1999
                                                 Expression* value,
2000
                                                 bool provide,
2001
                                                 bool hidden)
2002
{
2003
  Output_section_element* p = new Output_section_element_assignment(name,
2004
                                                                    length,
2005
                                                                    value,
2006
                                                                    provide,
2007
                                                                    hidden);
2008
  this->elements_.push_back(p);
2009
}
2010
 
2011
// Add an assignment to the special dot symbol.
2012
 
2013
void
2014
Output_section_definition::add_dot_assignment(Expression* value)
2015
{
2016
  Output_section_element* p = new Output_section_element_dot_assignment(value);
2017
  this->elements_.push_back(p);
2018
}
2019
 
2020
// Add an assertion.
2021
 
2022
void
2023
Output_section_definition::add_assertion(Expression* check,
2024
                                         const char* message,
2025
                                         size_t messagelen)
2026
{
2027
  Output_section_element* p = new Output_section_element_assertion(check,
2028
                                                                   message,
2029
                                                                   messagelen);
2030
  this->elements_.push_back(p);
2031
}
2032
 
2033
// Add a data item to the current output section.
2034
 
2035
void
2036
Output_section_definition::add_data(int size, bool is_signed, Expression* val)
2037
{
2038
  Output_section_element* p = new Output_section_element_data(size, is_signed,
2039
                                                              val);
2040
  this->elements_.push_back(p);
2041
}
2042
 
2043
// Add a setting for the fill value.
2044
 
2045
void
2046
Output_section_definition::add_fill(Expression* val)
2047
{
2048
  Output_section_element* p = new Output_section_element_fill(val);
2049
  this->elements_.push_back(p);
2050
}
2051
 
2052
// Add an input section specification.
2053
 
2054
void
2055
Output_section_definition::add_input_section(const Input_section_spec* spec,
2056
                                             bool keep)
2057
{
2058
  Output_section_element* p = new Output_section_element_input(spec, keep);
2059
  this->elements_.push_back(p);
2060
}
2061
 
2062
// Create any required output sections.  We need an output section if
2063
// there is a data statement here.
2064
 
2065
void
2066
Output_section_definition::create_sections(Layout* layout)
2067
{
2068
  if (this->output_section_ != NULL)
2069
    return;
2070
  for (Output_section_elements::const_iterator p = this->elements_.begin();
2071
       p != this->elements_.end();
2072
       ++p)
2073
    {
2074
      if ((*p)->needs_output_section())
2075
        {
2076
          const char* name = this->name_.c_str();
2077
          this->output_section_ =
2078
            layout->make_output_section_for_script(name, this->section_type());
2079
          return;
2080
        }
2081
    }
2082
}
2083
 
2084
// Add any symbols being defined to the symbol table.
2085
 
2086
void
2087
Output_section_definition::add_symbols_to_table(Symbol_table* symtab)
2088
{
2089
  for (Output_section_elements::iterator p = this->elements_.begin();
2090
       p != this->elements_.end();
2091
       ++p)
2092
    (*p)->add_symbols_to_table(symtab);
2093
}
2094
 
2095
// Finalize symbols and check assertions.
2096
 
2097
void
2098
Output_section_definition::finalize_symbols(Symbol_table* symtab,
2099
                                            const Layout* layout,
2100
                                            uint64_t* dot_value)
2101
{
2102
  if (this->output_section_ != NULL)
2103
    *dot_value = this->output_section_->address();
2104
  else
2105
    {
2106
      uint64_t address = *dot_value;
2107
      if (this->address_ != NULL)
2108
        {
2109
          address = this->address_->eval_with_dot(symtab, layout, true,
2110
                                                  *dot_value, NULL,
2111
                                                  NULL, NULL);
2112
        }
2113
      if (this->align_ != NULL)
2114
        {
2115
          uint64_t align = this->align_->eval_with_dot(symtab, layout, true,
2116
                                                       *dot_value, NULL,
2117
                                                       NULL, NULL);
2118
          address = align_address(address, align);
2119
        }
2120
      *dot_value = address;
2121
    }
2122
 
2123
  Output_section* dot_section = this->output_section_;
2124
  for (Output_section_elements::iterator p = this->elements_.begin();
2125
       p != this->elements_.end();
2126
       ++p)
2127
    (*p)->finalize_symbols(symtab, layout, dot_value, &dot_section);
2128
}
2129
 
2130
// Return the output section name to use for an input section name.
2131
 
2132
const char*
2133
Output_section_definition::output_section_name(
2134
    const char* file_name,
2135
    const char* section_name,
2136
    Output_section*** slot,
2137
    Script_sections::Section_type* psection_type)
2138
{
2139
  // Ask each element whether it matches NAME.
2140
  for (Output_section_elements::const_iterator p = this->elements_.begin();
2141
       p != this->elements_.end();
2142
       ++p)
2143
    {
2144
      if ((*p)->match_name(file_name, section_name))
2145
        {
2146
          // We found a match for NAME, which means that it should go
2147
          // into this output section.
2148
          *slot = &this->output_section_;
2149
          *psection_type = this->section_type();
2150
          return this->name_.c_str();
2151
        }
2152
    }
2153
 
2154
  // We don't know about this section name.
2155
  return NULL;
2156
}
2157
 
2158
// Return true if memory from START to START + LENGTH is contained
2159
// within a memory region.
2160
 
2161
bool
2162
Script_sections::block_in_region(Symbol_table* symtab, Layout* layout,
2163
                                 uint64_t start, uint64_t length) const
2164
{
2165
  if (this->memory_regions_ == NULL)
2166
    return false;
2167
 
2168
  for (Memory_regions::const_iterator mr = this->memory_regions_->begin();
2169
       mr != this->memory_regions_->end();
2170
       ++mr)
2171
    {
2172
      uint64_t s = (*mr)->start_address()->eval(symtab, layout, false);
2173
      uint64_t l = (*mr)->length()->eval(symtab, layout, false);
2174
 
2175
      if (s <= start
2176
          && (s + l) >= (start + length))
2177
        return true;
2178
    }
2179
 
2180
  return false;
2181
}
2182
 
2183
// Find a memory region that should be used by a given output SECTION.
2184
// If provided set PREVIOUS_SECTION_RETURN to point to the last section
2185
// that used the return memory region.
2186
 
2187
Memory_region*
2188
Script_sections::find_memory_region(
2189
    Output_section_definition* section,
2190
    bool find_vma_region,
2191
    Output_section_definition** previous_section_return)
2192
{
2193
  if (previous_section_return != NULL)
2194
    * previous_section_return = NULL;
2195
 
2196
  // Walk the memory regions specified in this script, if any.
2197
  if (this->memory_regions_ == NULL)
2198
    return NULL;
2199
 
2200
  // The /DISCARD/ section never gets assigned to any region.
2201
  if (section->get_section_name() == "/DISCARD/")
2202
    return NULL;
2203
 
2204
  Memory_region* first_match = NULL;
2205
 
2206
  // First check to see if a region has been assigned to this section.
2207
  for (Memory_regions::const_iterator mr = this->memory_regions_->begin();
2208
       mr != this->memory_regions_->end();
2209
       ++mr)
2210
    {
2211
      if (find_vma_region)
2212
        {
2213
          for (Memory_region::Section_list::const_iterator s =
2214
                 (*mr)->get_vma_section_list_start();
2215
               s != (*mr)->get_vma_section_list_end();
2216
               ++s)
2217
            if ((*s) == section)
2218
              {
2219
                (*mr)->set_last_section(section);
2220
                return *mr;
2221
              }
2222
        }
2223
      else
2224
        {
2225
          for (Memory_region::Section_list::const_iterator s =
2226
                 (*mr)->get_lma_section_list_start();
2227
               s != (*mr)->get_lma_section_list_end();
2228
               ++s)
2229
            if ((*s) == section)
2230
              {
2231
                (*mr)->set_last_section(section);
2232
                return *mr;
2233
              }
2234
        }
2235
 
2236
      // Make a note of the first memory region whose attributes
2237
      // are compatible with the section.  If we do not find an
2238
      // explicit region assignment, then we will return this region.
2239
      Output_section* out_sec = section->get_output_section();
2240
      if (first_match == NULL
2241
          && out_sec != NULL
2242
          && (*mr)->attributes_compatible(out_sec->flags(),
2243
                                          out_sec->type()))
2244
        first_match = *mr;
2245
    }
2246
 
2247
  // With LMA computations, if an explicit region has not been specified then
2248
  // we will want to set the difference between the VMA and the LMA of the
2249
  // section were searching for to be the same as the difference between the
2250
  // VMA and LMA of the last section to be added to first matched region.
2251
  // Hence, if it was asked for, we return a pointer to the last section
2252
  // known to be used by the first matched region.
2253
  if (first_match != NULL
2254
      && previous_section_return != NULL)
2255
    *previous_section_return = first_match->get_last_section();
2256
 
2257
  return first_match;
2258
}
2259
 
2260
// Set the section address.  Note that the OUTPUT_SECTION_ field will
2261
// be NULL if no input sections were mapped to this output section.
2262
// We still have to adjust dot and process symbol assignments.
2263
 
2264
void
2265
Output_section_definition::set_section_addresses(Symbol_table* symtab,
2266
                                                 Layout* layout,
2267
                                                 uint64_t* dot_value,
2268
                                                 uint64_t* dot_alignment,
2269
                                                 uint64_t* load_address)
2270
{
2271
  Memory_region* vma_region = NULL;
2272
  Memory_region* lma_region = NULL;
2273
  Script_sections* script_sections =
2274
    layout->script_options()->script_sections();
2275
  uint64_t address;
2276
  uint64_t old_dot_value = *dot_value;
2277
  uint64_t old_load_address = *load_address;
2278
 
2279
  // Decide the start address for the section.  The algorithm is:
2280
  // 1) If an address has been specified in a linker script, use that.
2281
  // 2) Otherwise if a memory region has been specified for the section,
2282
  //    use the next free address in the region.
2283
  // 3) Otherwise if memory regions have been specified find the first
2284
  //    region whose attributes are compatible with this section and
2285
  //    install it into that region.
2286
  // 4) Otherwise use the current location counter.
2287
 
2288
  if (this->output_section_ != NULL
2289
      // Check for --section-start.
2290
      && parameters->options().section_start(this->output_section_->name(),
2291
                                             &address))
2292
    ;
2293
  else if (this->address_ == NULL)
2294
    {
2295
      vma_region = script_sections->find_memory_region(this, true, NULL);
2296
 
2297
      if (vma_region != NULL)
2298
        address = vma_region->get_current_address()->eval(symtab, layout,
2299
                                                          false);
2300
      else
2301
        address = *dot_value;
2302
    }
2303
  else
2304
    address = this->address_->eval_with_dot(symtab, layout, true,
2305
                                            *dot_value, NULL, NULL,
2306
                                            dot_alignment);
2307
  uint64_t align;
2308
  if (this->align_ == NULL)
2309
    {
2310
      if (this->output_section_ == NULL)
2311
        align = 0;
2312
      else
2313
        align = this->output_section_->addralign();
2314
    }
2315
  else
2316
    {
2317
      Output_section* align_section;
2318
      align = this->align_->eval_with_dot(symtab, layout, true, *dot_value,
2319
                                          NULL, &align_section, NULL);
2320
      if (align_section != NULL)
2321
        gold_warning(_("alignment of section %s is not absolute"),
2322
                     this->name_.c_str());
2323
      if (this->output_section_ != NULL)
2324
        this->output_section_->set_addralign(align);
2325
    }
2326
 
2327
  address = align_address(address, align);
2328
 
2329
  uint64_t start_address = address;
2330
 
2331
  *dot_value = address;
2332
 
2333
  // Except for NOLOAD sections, the address of non-SHF_ALLOC sections is
2334
  // forced to zero, regardless of what the linker script wants.
2335
  if (this->output_section_ != NULL
2336
      && ((this->output_section_->flags() & elfcpp::SHF_ALLOC) != 0
2337
          || this->output_section_->is_noload()))
2338
    this->output_section_->set_address(address);
2339
 
2340
  this->evaluated_address_ = address;
2341
  this->evaluated_addralign_ = align;
2342
 
2343
  uint64_t laddr;
2344
 
2345
  if (this->load_address_ == NULL)
2346
    {
2347
      Output_section_definition* previous_section;
2348
 
2349
      // Determine if an LMA region has been set for this section.
2350
      lma_region = script_sections->find_memory_region(this, false,
2351
                                                       &previous_section);
2352
 
2353
      if (lma_region != NULL)
2354
        {
2355
          if (previous_section == NULL)
2356
            // The LMA address was explicitly set to the given region.
2357
            laddr = lma_region->get_current_address()->eval(symtab, layout,
2358
                                                            false);
2359
          else
2360
            {
2361
              // We are not going to use the discovered lma_region, so
2362
              // make sure that we do not update it in the code below.
2363
              lma_region = NULL;
2364
 
2365
              if (this->address_ != NULL || previous_section == this)
2366
                {
2367
                  // Either an explicit VMA address has been set, or an
2368
                  // explicit VMA region has been set, so set the LMA equal to
2369
                  // the VMA.
2370
                  laddr = address;
2371
                }
2372
              else
2373
                {
2374
                  // The LMA address was not explicitly or implicitly set.
2375
                  //
2376
                  // We have been given the first memory region that is
2377
                  // compatible with the current section and a pointer to the
2378
                  // last section to use this region.  Set the LMA of this
2379
                  // section so that the difference between its' VMA and LMA
2380
                  // is the same as the difference between the VMA and LMA of
2381
                  // the last section in the given region.
2382
                  laddr = address + (previous_section->evaluated_load_address_
2383
                                     - previous_section->evaluated_address_);
2384
                }
2385
            }
2386
 
2387
          if (this->output_section_ != NULL)
2388
            this->output_section_->set_load_address(laddr);
2389
        }
2390
      else
2391
        {
2392
          // Do not set the load address of the output section, if one exists.
2393
          // This allows future sections to determine what the load address
2394
          // should be.  If none is ever set, it will default to being the
2395
          // same as the vma address.
2396
          laddr = address;
2397
        }
2398
    }
2399
  else
2400
    {
2401
      laddr = this->load_address_->eval_with_dot(symtab, layout, true,
2402
                                                 *dot_value,
2403
                                                 this->output_section_,
2404
                                                 NULL, NULL);
2405
      if (this->output_section_ != NULL)
2406
        this->output_section_->set_load_address(laddr);
2407
    }
2408
 
2409
  this->evaluated_load_address_ = laddr;
2410
 
2411
  uint64_t subalign;
2412
  if (this->subalign_ == NULL)
2413
    subalign = 0;
2414
  else
2415
    {
2416
      Output_section* subalign_section;
2417
      subalign = this->subalign_->eval_with_dot(symtab, layout, true,
2418
                                                *dot_value, NULL,
2419
                                                &subalign_section, NULL);
2420
      if (subalign_section != NULL)
2421
        gold_warning(_("subalign of section %s is not absolute"),
2422
                     this->name_.c_str());
2423
    }
2424
 
2425
  std::string fill;
2426
  if (this->fill_ != NULL)
2427
    {
2428
      // FIXME: The GNU linker supports fill values of arbitrary
2429
      // length.
2430
      Output_section* fill_section;
2431
      uint64_t fill_val = this->fill_->eval_with_dot(symtab, layout, true,
2432
                                                     *dot_value,
2433
                                                     NULL, &fill_section,
2434
                                                     NULL);
2435
      if (fill_section != NULL)
2436
        gold_warning(_("fill of section %s is not absolute"),
2437
                     this->name_.c_str());
2438
      unsigned char fill_buff[4];
2439
      elfcpp::Swap_unaligned<32, true>::writeval(fill_buff, fill_val);
2440
      fill.assign(reinterpret_cast<char*>(fill_buff), 4);
2441
    }
2442
 
2443
  Input_section_list input_sections;
2444
  if (this->output_section_ != NULL)
2445
    {
2446
      // Get the list of input sections attached to this output
2447
      // section.  This will leave the output section with only
2448
      // Output_section_data entries.
2449
      address += this->output_section_->get_input_sections(address,
2450
                                                           fill,
2451
                                                           &input_sections);
2452
      *dot_value = address;
2453
    }
2454
 
2455
  Output_section* dot_section = this->output_section_;
2456
  for (Output_section_elements::iterator p = this->elements_.begin();
2457
       p != this->elements_.end();
2458
       ++p)
2459
    (*p)->set_section_addresses(symtab, layout, this->output_section_,
2460
                                subalign, dot_value, dot_alignment,
2461
                                &dot_section, &fill, &input_sections);
2462
 
2463
  gold_assert(input_sections.empty());
2464
 
2465
  if (vma_region != NULL)
2466
    {
2467
      // Update the VMA region being used by the section now that we know how
2468
      // big it is.  Use the current address in the region, rather than
2469
      // start_address because that might have been aligned upwards and we
2470
      // need to allow for the padding.
2471
      Expression* addr = vma_region->get_current_address();
2472
      uint64_t size = *dot_value - addr->eval(symtab, layout, false);
2473
 
2474
      vma_region->increment_offset(this->get_section_name(), size,
2475
                                   symtab, layout);
2476
    }
2477
 
2478
  // If the LMA region is different from the VMA region, then increment the
2479
  // offset there as well.  Note that we use the same "dot_value -
2480
  // start_address" formula that is used in the load_address assignment below.
2481
  if (lma_region != NULL && lma_region != vma_region)
2482
    lma_region->increment_offset(this->get_section_name(),
2483
                                 *dot_value - start_address,
2484
                                 symtab, layout);
2485
 
2486
  // Compute the load address for the following section.
2487
  if (this->output_section_ == NULL)
2488
    *load_address = *dot_value;
2489
  else if (this->load_address_ == NULL)
2490
    {
2491
      if (lma_region == NULL)
2492
        *load_address = *dot_value;
2493
      else
2494
        *load_address =
2495
          lma_region->get_current_address()->eval(symtab, layout, false);
2496
    }
2497
  else
2498
    *load_address = (this->output_section_->load_address()
2499
                     + (*dot_value - start_address));
2500
 
2501
  if (this->output_section_ != NULL)
2502
    {
2503
      if (this->is_relro_)
2504
        this->output_section_->set_is_relro();
2505
      else
2506
        this->output_section_->clear_is_relro();
2507
 
2508
      // If this is a NOLOAD section, keep dot and load address unchanged.
2509
      if (this->output_section_->is_noload())
2510
        {
2511
          *dot_value = old_dot_value;
2512
          *load_address = old_load_address;
2513
        }
2514
    }
2515
}
2516
 
2517
// Check a constraint (ONLY_IF_RO, etc.) on an output section.  If
2518
// this section is constrained, and the input sections do not match,
2519
// return the constraint, and set *POSD.
2520
 
2521
Section_constraint
2522
Output_section_definition::check_constraint(Output_section_definition** posd)
2523
{
2524
  switch (this->constraint_)
2525
    {
2526
    case CONSTRAINT_NONE:
2527
      return CONSTRAINT_NONE;
2528
 
2529
    case CONSTRAINT_ONLY_IF_RO:
2530
      if (this->output_section_ != NULL
2531
          && (this->output_section_->flags() & elfcpp::SHF_WRITE) != 0)
2532
        {
2533
          *posd = this;
2534
          return CONSTRAINT_ONLY_IF_RO;
2535
        }
2536
      return CONSTRAINT_NONE;
2537
 
2538
    case CONSTRAINT_ONLY_IF_RW:
2539
      if (this->output_section_ != NULL
2540
          && (this->output_section_->flags() & elfcpp::SHF_WRITE) == 0)
2541
        {
2542
          *posd = this;
2543
          return CONSTRAINT_ONLY_IF_RW;
2544
        }
2545
      return CONSTRAINT_NONE;
2546
 
2547
    case CONSTRAINT_SPECIAL:
2548
      if (this->output_section_ != NULL)
2549
        gold_error(_("SPECIAL constraints are not implemented"));
2550
      return CONSTRAINT_NONE;
2551
 
2552
    default:
2553
      gold_unreachable();
2554
    }
2555
}
2556
 
2557
// See if this is the alternate output section for a constrained
2558
// output section.  If it is, transfer the Output_section and return
2559
// true.  Otherwise return false.
2560
 
2561
bool
2562
Output_section_definition::alternate_constraint(
2563
    Output_section_definition* posd,
2564
    Section_constraint constraint)
2565
{
2566
  if (this->name_ != posd->name_)
2567
    return false;
2568
 
2569
  switch (constraint)
2570
    {
2571
    case CONSTRAINT_ONLY_IF_RO:
2572
      if (this->constraint_ != CONSTRAINT_ONLY_IF_RW)
2573
        return false;
2574
      break;
2575
 
2576
    case CONSTRAINT_ONLY_IF_RW:
2577
      if (this->constraint_ != CONSTRAINT_ONLY_IF_RO)
2578
        return false;
2579
      break;
2580
 
2581
    default:
2582
      gold_unreachable();
2583
    }
2584
 
2585
  // We have found the alternate constraint.  We just need to move
2586
  // over the Output_section.  When constraints are used properly,
2587
  // THIS should not have an output_section pointer, as all the input
2588
  // sections should have matched the other definition.
2589
 
2590
  if (this->output_section_ != NULL)
2591
    gold_error(_("mismatched definition for constrained sections"));
2592
 
2593
  this->output_section_ = posd->output_section_;
2594
  posd->output_section_ = NULL;
2595
 
2596
  if (this->is_relro_)
2597
    this->output_section_->set_is_relro();
2598
  else
2599
    this->output_section_->clear_is_relro();
2600
 
2601
  return true;
2602
}
2603
 
2604
// Get the list of segments to use for an allocated section when using
2605
// a PHDRS clause.
2606
 
2607
Output_section*
2608
Output_section_definition::allocate_to_segment(String_list** phdrs_list,
2609
                                               bool* orphan)
2610
{
2611
  // Update phdrs_list even if we don't have an output section. It
2612
  // might be used by the following sections.
2613
  if (this->phdrs_ != NULL)
2614
    *phdrs_list = this->phdrs_;
2615
 
2616
  if (this->output_section_ == NULL)
2617
    return NULL;
2618
  if ((this->output_section_->flags() & elfcpp::SHF_ALLOC) == 0)
2619
    return NULL;
2620
  *orphan = false;
2621
  return this->output_section_;
2622
}
2623
 
2624
// Look for an output section by name and return the address, the load
2625
// address, the alignment, and the size.  This is used when an
2626
// expression refers to an output section which was not actually
2627
// created.  This returns true if the section was found, false
2628
// otherwise.
2629
 
2630
bool
2631
Output_section_definition::get_output_section_info(const char* name,
2632
                                                   uint64_t* address,
2633
                                                   uint64_t* load_address,
2634
                                                   uint64_t* addralign,
2635
                                                   uint64_t* size) const
2636
{
2637
  if (this->name_ != name)
2638
    return false;
2639
 
2640
  if (this->output_section_ != NULL)
2641
    {
2642
      *address = this->output_section_->address();
2643
      if (this->output_section_->has_load_address())
2644
        *load_address = this->output_section_->load_address();
2645
      else
2646
        *load_address = *address;
2647
      *addralign = this->output_section_->addralign();
2648
      *size = this->output_section_->current_data_size();
2649
    }
2650
  else
2651
    {
2652
      *address = this->evaluated_address_;
2653
      *load_address = this->evaluated_load_address_;
2654
      *addralign = this->evaluated_addralign_;
2655
      *size = 0;
2656
    }
2657
 
2658
  return true;
2659
}
2660
 
2661
// Print for debugging.
2662
 
2663
void
2664
Output_section_definition::print(FILE* f) const
2665
{
2666
  fprintf(f, "  %s ", this->name_.c_str());
2667
 
2668
  if (this->address_ != NULL)
2669
    {
2670
      this->address_->print(f);
2671
      fprintf(f, " ");
2672
    }
2673
 
2674
  if (this->script_section_type_ != SCRIPT_SECTION_TYPE_NONE)
2675
      fprintf(f, "(%s) ",
2676
              this->script_section_type_name(this->script_section_type_));
2677
 
2678
  fprintf(f, ": ");
2679
 
2680
  if (this->load_address_ != NULL)
2681
    {
2682
      fprintf(f, "AT(");
2683
      this->load_address_->print(f);
2684
      fprintf(f, ") ");
2685
    }
2686
 
2687
  if (this->align_ != NULL)
2688
    {
2689
      fprintf(f, "ALIGN(");
2690
      this->align_->print(f);
2691
      fprintf(f, ") ");
2692
    }
2693
 
2694
  if (this->subalign_ != NULL)
2695
    {
2696
      fprintf(f, "SUBALIGN(");
2697
      this->subalign_->print(f);
2698
      fprintf(f, ") ");
2699
    }
2700
 
2701
  fprintf(f, "{\n");
2702
 
2703
  for (Output_section_elements::const_iterator p = this->elements_.begin();
2704
       p != this->elements_.end();
2705
       ++p)
2706
    (*p)->print(f);
2707
 
2708
  fprintf(f, "  }");
2709
 
2710
  if (this->fill_ != NULL)
2711
    {
2712
      fprintf(f, " = ");
2713
      this->fill_->print(f);
2714
    }
2715
 
2716
  if (this->phdrs_ != NULL)
2717
    {
2718
      for (String_list::const_iterator p = this->phdrs_->begin();
2719
           p != this->phdrs_->end();
2720
           ++p)
2721
        fprintf(f, " :%s", p->c_str());
2722
    }
2723
 
2724
  fprintf(f, "\n");
2725
}
2726
 
2727
Script_sections::Section_type
2728
Output_section_definition::section_type() const
2729
{
2730
  switch (this->script_section_type_)
2731
    {
2732
    case SCRIPT_SECTION_TYPE_NONE:
2733
      return Script_sections::ST_NONE;
2734
    case SCRIPT_SECTION_TYPE_NOLOAD:
2735
      return Script_sections::ST_NOLOAD;
2736
    case SCRIPT_SECTION_TYPE_COPY:
2737
    case SCRIPT_SECTION_TYPE_DSECT:
2738
    case SCRIPT_SECTION_TYPE_INFO:
2739
    case SCRIPT_SECTION_TYPE_OVERLAY:
2740
      // There are not really support so we treat them as ST_NONE.  The
2741
      // parse should have issued errors for them already.
2742
      return Script_sections::ST_NONE;
2743
    default:
2744
      gold_unreachable();
2745
    }
2746
}
2747
 
2748
// Return the name of a script section type.
2749
 
2750
const char*
2751
Output_section_definition::script_section_type_name(
2752
    Script_section_type script_section_type)
2753
{
2754
  switch (script_section_type)
2755
    {
2756
    case SCRIPT_SECTION_TYPE_NONE:
2757
      return "NONE";
2758
    case SCRIPT_SECTION_TYPE_NOLOAD:
2759
      return "NOLOAD";
2760
    case SCRIPT_SECTION_TYPE_DSECT:
2761
      return "DSECT";
2762
    case SCRIPT_SECTION_TYPE_COPY:
2763
      return "COPY";
2764
    case SCRIPT_SECTION_TYPE_INFO:
2765
      return "INFO";
2766
    case SCRIPT_SECTION_TYPE_OVERLAY:
2767
      return "OVERLAY";
2768
    default:
2769
      gold_unreachable();
2770
    }
2771
}
2772
 
2773
void
2774
Output_section_definition::set_memory_region(Memory_region* mr, bool set_vma)
2775
{
2776
  gold_assert(mr != NULL);
2777
  // Add the current section to the specified region's list.
2778
  mr->add_section(this, set_vma);
2779
}
2780
 
2781
// An output section created to hold orphaned input sections.  These
2782
// do not actually appear in linker scripts.  However, for convenience
2783
// when setting the output section addresses, we put a marker to these
2784
// sections in the appropriate place in the list of SECTIONS elements.
2785
 
2786
class Orphan_output_section : public Sections_element
2787
{
2788
 public:
2789
  Orphan_output_section(Output_section* os)
2790
    : os_(os)
2791
  { }
2792
 
2793
  // Return whether the orphan output section is relro.  We can just
2794
  // check the output section because we always set the flag, if
2795
  // needed, just after we create the Orphan_output_section.
2796
  bool
2797
  is_relro() const
2798
  { return this->os_->is_relro(); }
2799
 
2800
  // Initialize OSP with an output section.  This should have been
2801
  // done already.
2802
  void
2803
  orphan_section_init(Orphan_section_placement*,
2804
                      Script_sections::Elements_iterator)
2805
  { gold_unreachable(); }
2806
 
2807
  // Set section addresses.
2808
  void
2809
  set_section_addresses(Symbol_table*, Layout*, uint64_t*, uint64_t*,
2810
                        uint64_t*);
2811
 
2812
  // Get the list of segments to use for an allocated section when
2813
  // using a PHDRS clause.
2814
  Output_section*
2815
  allocate_to_segment(String_list**, bool*);
2816
 
2817
  // Return the associated Output_section.
2818
  Output_section*
2819
  get_output_section() const
2820
  { return this->os_; }
2821
 
2822
  // Print for debugging.
2823
  void
2824
  print(FILE* f) const
2825
  {
2826
    fprintf(f, "  marker for orphaned output section %s\n",
2827
            this->os_->name());
2828
  }
2829
 
2830
 private:
2831
  Output_section* os_;
2832
};
2833
 
2834
// Set section addresses.
2835
 
2836
void
2837
Orphan_output_section::set_section_addresses(Symbol_table*, Layout*,
2838
                                             uint64_t* dot_value,
2839
                                             uint64_t*,
2840
                                             uint64_t* load_address)
2841
{
2842
  typedef std::list<Output_section::Input_section> Input_section_list;
2843
 
2844
  bool have_load_address = *load_address != *dot_value;
2845
 
2846
  uint64_t address = *dot_value;
2847
  address = align_address(address, this->os_->addralign());
2848
 
2849
  if ((this->os_->flags() & elfcpp::SHF_ALLOC) != 0)
2850
    {
2851
      this->os_->set_address(address);
2852
      if (have_load_address)
2853
        this->os_->set_load_address(align_address(*load_address,
2854
                                                  this->os_->addralign()));
2855
    }
2856
 
2857
  Input_section_list input_sections;
2858
  address += this->os_->get_input_sections(address, "", &input_sections);
2859
 
2860
  for (Input_section_list::iterator p = input_sections.begin();
2861
       p != input_sections.end();
2862
       ++p)
2863
    {
2864
      uint64_t addralign = p->addralign();
2865
      if (!p->is_input_section())
2866
        p->output_section_data()->finalize_data_size();
2867
      uint64_t size = p->data_size();
2868
      address = align_address(address, addralign);
2869
      this->os_->add_script_input_section(*p);
2870
      address += size;
2871
    }
2872
 
2873
  // An SHF_TLS/SHT_NOBITS section does not take up any address space.
2874
  if (this->os_ == NULL
2875
      || (this->os_->flags() & elfcpp::SHF_TLS) == 0
2876
      || this->os_->type() != elfcpp::SHT_NOBITS)
2877
    {
2878
      if (!have_load_address)
2879
        *load_address = address;
2880
      else
2881
        *load_address += address - *dot_value;
2882
 
2883
      *dot_value = address;
2884
    }
2885
}
2886
 
2887
// Get the list of segments to use for an allocated section when using
2888
// a PHDRS clause.  If this is an allocated section, return the
2889
// Output_section.  We don't change the list of segments.
2890
 
2891
Output_section*
2892
Orphan_output_section::allocate_to_segment(String_list**, bool* orphan)
2893
{
2894
  if ((this->os_->flags() & elfcpp::SHF_ALLOC) == 0)
2895
    return NULL;
2896
  *orphan = true;
2897
  return this->os_;
2898
}
2899
 
2900
// Class Phdrs_element.  A program header from a PHDRS clause.
2901
 
2902
class Phdrs_element
2903
{
2904
 public:
2905
  Phdrs_element(const char* name, size_t namelen, unsigned int type,
2906
                bool includes_filehdr, bool includes_phdrs,
2907
                bool is_flags_valid, unsigned int flags,
2908
                Expression* load_address)
2909
    : name_(name, namelen), type_(type), includes_filehdr_(includes_filehdr),
2910
      includes_phdrs_(includes_phdrs), is_flags_valid_(is_flags_valid),
2911
      flags_(flags), load_address_(load_address), load_address_value_(0),
2912
      segment_(NULL)
2913
  { }
2914
 
2915
  // Return the name of this segment.
2916
  const std::string&
2917
  name() const
2918
  { return this->name_; }
2919
 
2920
  // Return the type of the segment.
2921
  unsigned int
2922
  type() const
2923
  { return this->type_; }
2924
 
2925
  // Whether to include the file header.
2926
  bool
2927
  includes_filehdr() const
2928
  { return this->includes_filehdr_; }
2929
 
2930
  // Whether to include the program headers.
2931
  bool
2932
  includes_phdrs() const
2933
  { return this->includes_phdrs_; }
2934
 
2935
  // Return whether there is a load address.
2936
  bool
2937
  has_load_address() const
2938
  { return this->load_address_ != NULL; }
2939
 
2940
  // Evaluate the load address expression if there is one.
2941
  void
2942
  eval_load_address(Symbol_table* symtab, Layout* layout)
2943
  {
2944
    if (this->load_address_ != NULL)
2945
      this->load_address_value_ = this->load_address_->eval(symtab, layout,
2946
                                                            true);
2947
  }
2948
 
2949
  // Return the load address.
2950
  uint64_t
2951
  load_address() const
2952
  {
2953
    gold_assert(this->load_address_ != NULL);
2954
    return this->load_address_value_;
2955
  }
2956
 
2957
  // Create the segment.
2958
  Output_segment*
2959
  create_segment(Layout* layout)
2960
  {
2961
    this->segment_ = layout->make_output_segment(this->type_, this->flags_);
2962
    return this->segment_;
2963
  }
2964
 
2965
  // Return the segment.
2966
  Output_segment*
2967
  segment()
2968
  { return this->segment_; }
2969
 
2970
  // Release the segment.
2971
  void
2972
  release_segment()
2973
  { this->segment_ = NULL; }
2974
 
2975
  // Set the segment flags if appropriate.
2976
  void
2977
  set_flags_if_valid()
2978
  {
2979
    if (this->is_flags_valid_)
2980
      this->segment_->set_flags(this->flags_);
2981
  }
2982
 
2983
  // Print for debugging.
2984
  void
2985
  print(FILE*) const;
2986
 
2987
 private:
2988
  // The name used in the script.
2989
  std::string name_;
2990
  // The type of the segment (PT_LOAD, etc.).
2991
  unsigned int type_;
2992
  // Whether this segment includes the file header.
2993
  bool includes_filehdr_;
2994
  // Whether this segment includes the section headers.
2995
  bool includes_phdrs_;
2996
  // Whether the flags were explicitly specified.
2997
  bool is_flags_valid_;
2998
  // The flags for this segment (PF_R, etc.) if specified.
2999
  unsigned int flags_;
3000
  // The expression for the load address for this segment.  This may
3001
  // be NULL.
3002
  Expression* load_address_;
3003
  // The actual load address from evaluating the expression.
3004
  uint64_t load_address_value_;
3005
  // The segment itself.
3006
  Output_segment* segment_;
3007
};
3008
 
3009
// Print for debugging.
3010
 
3011
void
3012
Phdrs_element::print(FILE* f) const
3013
{
3014
  fprintf(f, "  %s 0x%x", this->name_.c_str(), this->type_);
3015
  if (this->includes_filehdr_)
3016
    fprintf(f, " FILEHDR");
3017
  if (this->includes_phdrs_)
3018
    fprintf(f, " PHDRS");
3019
  if (this->is_flags_valid_)
3020
    fprintf(f, " FLAGS(%u)", this->flags_);
3021
  if (this->load_address_ != NULL)
3022
    {
3023
      fprintf(f, " AT(");
3024
      this->load_address_->print(f);
3025
      fprintf(f, ")");
3026
    }
3027
  fprintf(f, ";\n");
3028
}
3029
 
3030
// Add a memory region.
3031
 
3032
void
3033
Script_sections::add_memory_region(const char* name, size_t namelen,
3034
                                   unsigned int attributes,
3035
                                   Expression* start, Expression* length)
3036
{
3037
  if (this->memory_regions_ == NULL)
3038
    this->memory_regions_ = new Memory_regions();
3039
  else if (this->find_memory_region(name, namelen))
3040
    {
3041
      gold_error(_("region '%.*s' already defined"), static_cast<int>(namelen),
3042
                  name);
3043
      // FIXME: Add a GOLD extension to allow multiple regions with the same
3044
      // name.  This would amount to a single region covering disjoint blocks
3045
      // of memory, which is useful for embedded devices.
3046
    }
3047
 
3048
  // FIXME: Check the length and start values.  Currently we allow
3049
  // non-constant expressions for these values, whereas LD does not.
3050
 
3051
  // FIXME: Add a GOLD extension to allow NEGATIVE LENGTHS.  This would
3052
  // describe a region that packs from the end address going down, rather
3053
  // than the start address going up.  This would be useful for embedded
3054
  // devices.
3055
 
3056
  this->memory_regions_->push_back(new Memory_region(name, namelen, attributes,
3057
                                                     start, length));
3058
}
3059
 
3060
// Find a memory region.
3061
 
3062
Memory_region*
3063
Script_sections::find_memory_region(const char* name, size_t namelen)
3064
{
3065
  if (this->memory_regions_ == NULL)
3066
    return NULL;
3067
 
3068
  for (Memory_regions::const_iterator m = this->memory_regions_->begin();
3069
       m != this->memory_regions_->end();
3070
       ++m)
3071
    if ((*m)->name_match(name, namelen))
3072
      return *m;
3073
 
3074
  return NULL;
3075
}
3076
 
3077
// Find a memory region's origin.
3078
 
3079
Expression*
3080
Script_sections::find_memory_region_origin(const char* name, size_t namelen)
3081
{
3082
  Memory_region* mr = find_memory_region(name, namelen);
3083
  if (mr == NULL)
3084
    return NULL;
3085
 
3086
  return mr->start_address();
3087
}
3088
 
3089
// Find a memory region's length.
3090
 
3091
Expression*
3092
Script_sections::find_memory_region_length(const char* name, size_t namelen)
3093
{
3094
  Memory_region* mr = find_memory_region(name, namelen);
3095
  if (mr == NULL)
3096
    return NULL;
3097
 
3098
  return mr->length();
3099
}
3100
 
3101
// Set the memory region to use for the current section.
3102
 
3103
void
3104
Script_sections::set_memory_region(Memory_region* mr, bool set_vma)
3105
{
3106
  gold_assert(!this->sections_elements_->empty());
3107
  this->sections_elements_->back()->set_memory_region(mr, set_vma);
3108
}
3109
 
3110
// Class Script_sections.
3111
 
3112
Script_sections::Script_sections()
3113
  : saw_sections_clause_(false),
3114
    in_sections_clause_(false),
3115
    sections_elements_(NULL),
3116
    output_section_(NULL),
3117
    memory_regions_(NULL),
3118
    phdrs_elements_(NULL),
3119
    orphan_section_placement_(NULL),
3120
    data_segment_align_start_(),
3121
    saw_data_segment_align_(false),
3122
    saw_relro_end_(false),
3123
    saw_segment_start_expression_(false)
3124
{
3125
}
3126
 
3127
// Start a SECTIONS clause.
3128
 
3129
void
3130
Script_sections::start_sections()
3131
{
3132
  gold_assert(!this->in_sections_clause_ && this->output_section_ == NULL);
3133
  this->saw_sections_clause_ = true;
3134
  this->in_sections_clause_ = true;
3135
  if (this->sections_elements_ == NULL)
3136
    this->sections_elements_ = new Sections_elements;
3137
}
3138
 
3139
// Finish a SECTIONS clause.
3140
 
3141
void
3142
Script_sections::finish_sections()
3143
{
3144
  gold_assert(this->in_sections_clause_ && this->output_section_ == NULL);
3145
  this->in_sections_clause_ = false;
3146
}
3147
 
3148
// Add a symbol to be defined.
3149
 
3150
void
3151
Script_sections::add_symbol_assignment(const char* name, size_t length,
3152
                                       Expression* val, bool provide,
3153
                                       bool hidden)
3154
{
3155
  if (this->output_section_ != NULL)
3156
    this->output_section_->add_symbol_assignment(name, length, val,
3157
                                                 provide, hidden);
3158
  else
3159
    {
3160
      Sections_element* p = new Sections_element_assignment(name, length,
3161
                                                            val, provide,
3162
                                                            hidden);
3163
      this->sections_elements_->push_back(p);
3164
    }
3165
}
3166
 
3167
// Add an assignment to the special dot symbol.
3168
 
3169
void
3170
Script_sections::add_dot_assignment(Expression* val)
3171
{
3172
  if (this->output_section_ != NULL)
3173
    this->output_section_->add_dot_assignment(val);
3174
  else
3175
    {
3176
      // The GNU linker permits assignments to . to appears outside of
3177
      // a SECTIONS clause, and treats it as appearing inside, so
3178
      // sections_elements_ may be NULL here.
3179
      if (this->sections_elements_ == NULL)
3180
        {
3181
          this->sections_elements_ = new Sections_elements;
3182
          this->saw_sections_clause_ = true;
3183
        }
3184
 
3185
      Sections_element* p = new Sections_element_dot_assignment(val);
3186
      this->sections_elements_->push_back(p);
3187
    }
3188
}
3189
 
3190
// Add an assertion.
3191
 
3192
void
3193
Script_sections::add_assertion(Expression* check, const char* message,
3194
                               size_t messagelen)
3195
{
3196
  if (this->output_section_ != NULL)
3197
    this->output_section_->add_assertion(check, message, messagelen);
3198
  else
3199
    {
3200
      Sections_element* p = new Sections_element_assertion(check, message,
3201
                                                           messagelen);
3202
      this->sections_elements_->push_back(p);
3203
    }
3204
}
3205
 
3206
// Start processing entries for an output section.
3207
 
3208
void
3209
Script_sections::start_output_section(
3210
    const char* name,
3211
    size_t namelen,
3212
    const Parser_output_section_header* header)
3213
{
3214
  Output_section_definition* posd = new Output_section_definition(name,
3215
                                                                  namelen,
3216
                                                                  header);
3217
  this->sections_elements_->push_back(posd);
3218
  gold_assert(this->output_section_ == NULL);
3219
  this->output_section_ = posd;
3220
}
3221
 
3222
// Stop processing entries for an output section.
3223
 
3224
void
3225
Script_sections::finish_output_section(
3226
    const Parser_output_section_trailer* trailer)
3227
{
3228
  gold_assert(this->output_section_ != NULL);
3229
  this->output_section_->finish(trailer);
3230
  this->output_section_ = NULL;
3231
}
3232
 
3233
// Add a data item to the current output section.
3234
 
3235
void
3236
Script_sections::add_data(int size, bool is_signed, Expression* val)
3237
{
3238
  gold_assert(this->output_section_ != NULL);
3239
  this->output_section_->add_data(size, is_signed, val);
3240
}
3241
 
3242
// Add a fill value setting to the current output section.
3243
 
3244
void
3245
Script_sections::add_fill(Expression* val)
3246
{
3247
  gold_assert(this->output_section_ != NULL);
3248
  this->output_section_->add_fill(val);
3249
}
3250
 
3251
// Add an input section specification to the current output section.
3252
 
3253
void
3254
Script_sections::add_input_section(const Input_section_spec* spec, bool keep)
3255
{
3256
  gold_assert(this->output_section_ != NULL);
3257
  this->output_section_->add_input_section(spec, keep);
3258
}
3259
 
3260
// This is called when we see DATA_SEGMENT_ALIGN.  It means that any
3261
// subsequent output sections may be relro.
3262
 
3263
void
3264
Script_sections::data_segment_align()
3265
{
3266
  if (this->saw_data_segment_align_)
3267
    gold_error(_("DATA_SEGMENT_ALIGN may only appear once in a linker script"));
3268
  gold_assert(!this->sections_elements_->empty());
3269
  Sections_elements::iterator p = this->sections_elements_->end();
3270
  --p;
3271
  this->data_segment_align_start_ = p;
3272
  this->saw_data_segment_align_ = true;
3273
}
3274
 
3275
// This is called when we see DATA_SEGMENT_RELRO_END.  It means that
3276
// any output sections seen since DATA_SEGMENT_ALIGN are relro.
3277
 
3278
void
3279
Script_sections::data_segment_relro_end()
3280
{
3281
  if (this->saw_relro_end_)
3282
    gold_error(_("DATA_SEGMENT_RELRO_END may only appear once "
3283
                 "in a linker script"));
3284
  this->saw_relro_end_ = true;
3285
 
3286
  if (!this->saw_data_segment_align_)
3287
    gold_error(_("DATA_SEGMENT_RELRO_END must follow DATA_SEGMENT_ALIGN"));
3288
  else
3289
    {
3290
      Sections_elements::iterator p = this->data_segment_align_start_;
3291
      for (++p; p != this->sections_elements_->end(); ++p)
3292
        (*p)->set_is_relro();
3293
    }
3294
}
3295
 
3296
// Create any required sections.
3297
 
3298
void
3299
Script_sections::create_sections(Layout* layout)
3300
{
3301
  if (!this->saw_sections_clause_)
3302
    return;
3303
  for (Sections_elements::iterator p = this->sections_elements_->begin();
3304
       p != this->sections_elements_->end();
3305
       ++p)
3306
    (*p)->create_sections(layout);
3307
}
3308
 
3309
// Add any symbols we are defining to the symbol table.
3310
 
3311
void
3312
Script_sections::add_symbols_to_table(Symbol_table* symtab)
3313
{
3314
  if (!this->saw_sections_clause_)
3315
    return;
3316
  for (Sections_elements::iterator p = this->sections_elements_->begin();
3317
       p != this->sections_elements_->end();
3318
       ++p)
3319
    (*p)->add_symbols_to_table(symtab);
3320
}
3321
 
3322
// Finalize symbols and check assertions.
3323
 
3324
void
3325
Script_sections::finalize_symbols(Symbol_table* symtab, const Layout* layout)
3326
{
3327
  if (!this->saw_sections_clause_)
3328
    return;
3329
  uint64_t dot_value = 0;
3330
  for (Sections_elements::iterator p = this->sections_elements_->begin();
3331
       p != this->sections_elements_->end();
3332
       ++p)
3333
    (*p)->finalize_symbols(symtab, layout, &dot_value);
3334
}
3335
 
3336
// Return the name of the output section to use for an input file name
3337
// and section name.
3338
 
3339
const char*
3340
Script_sections::output_section_name(
3341
    const char* file_name,
3342
    const char* section_name,
3343
    Output_section*** output_section_slot,
3344
    Script_sections::Section_type* psection_type)
3345
{
3346
  for (Sections_elements::const_iterator p = this->sections_elements_->begin();
3347
       p != this->sections_elements_->end();
3348
       ++p)
3349
    {
3350
      const char* ret = (*p)->output_section_name(file_name, section_name,
3351
                                                  output_section_slot,
3352
                                                  psection_type);
3353
 
3354
      if (ret != NULL)
3355
        {
3356
          // The special name /DISCARD/ means that the input section
3357
          // should be discarded.
3358
          if (strcmp(ret, "/DISCARD/") == 0)
3359
            {
3360
              *output_section_slot = NULL;
3361
              *psection_type = Script_sections::ST_NONE;
3362
              return NULL;
3363
            }
3364
          return ret;
3365
        }
3366
    }
3367
 
3368
  // If we couldn't find a mapping for the name, the output section
3369
  // gets the name of the input section.
3370
 
3371
  *output_section_slot = NULL;
3372
  *psection_type = Script_sections::ST_NONE;
3373
 
3374
  return section_name;
3375
}
3376
 
3377
// Place a marker for an orphan output section into the SECTIONS
3378
// clause.
3379
 
3380
void
3381
Script_sections::place_orphan(Output_section* os)
3382
{
3383
  Orphan_section_placement* osp = this->orphan_section_placement_;
3384
  if (osp == NULL)
3385
    {
3386
      // Initialize the Orphan_section_placement structure.
3387
      osp = new Orphan_section_placement();
3388
      for (Sections_elements::iterator p = this->sections_elements_->begin();
3389
           p != this->sections_elements_->end();
3390
           ++p)
3391
        (*p)->orphan_section_init(osp, p);
3392
      gold_assert(!this->sections_elements_->empty());
3393
      Sections_elements::iterator last = this->sections_elements_->end();
3394
      --last;
3395
      osp->last_init(last);
3396
      this->orphan_section_placement_ = osp;
3397
    }
3398
 
3399
  Orphan_output_section* orphan = new Orphan_output_section(os);
3400
 
3401
  // Look for where to put ORPHAN.
3402
  Sections_elements::iterator* where;
3403
  if (osp->find_place(os, &where))
3404
    {
3405
      if ((**where)->is_relro())
3406
        os->set_is_relro();
3407
      else
3408
        os->clear_is_relro();
3409
 
3410
      // We want to insert ORPHAN after *WHERE, and then update *WHERE
3411
      // so that the next one goes after this one.
3412
      Sections_elements::iterator p = *where;
3413
      gold_assert(p != this->sections_elements_->end());
3414
      ++p;
3415
      *where = this->sections_elements_->insert(p, orphan);
3416
    }
3417
  else
3418
    {
3419
      os->clear_is_relro();
3420
      // We don't have a place to put this orphan section.  Put it,
3421
      // and all other sections like it, at the end, but before the
3422
      // sections which always come at the end.
3423
      Sections_elements::iterator last = osp->last_place();
3424
      *where = this->sections_elements_->insert(last, orphan);
3425
    }
3426
}
3427
 
3428
// Set the addresses of all the output sections.  Walk through all the
3429
// elements, tracking the dot symbol.  Apply assignments which set
3430
// absolute symbol values, in case they are used when setting dot.
3431
// Fill in data statement values.  As we find output sections, set the
3432
// address, set the address of all associated input sections, and
3433
// update dot.  Return the segment which should hold the file header
3434
// and segment headers, if any.
3435
 
3436
Output_segment*
3437
Script_sections::set_section_addresses(Symbol_table* symtab, Layout* layout)
3438
{
3439
  gold_assert(this->saw_sections_clause_);
3440
 
3441
  // Implement ONLY_IF_RO/ONLY_IF_RW constraints.  These are a pain
3442
  // for our representation.
3443
  for (Sections_elements::iterator p = this->sections_elements_->begin();
3444
       p != this->sections_elements_->end();
3445
       ++p)
3446
    {
3447
      Output_section_definition* posd;
3448
      Section_constraint failed_constraint = (*p)->check_constraint(&posd);
3449
      if (failed_constraint != CONSTRAINT_NONE)
3450
        {
3451
          Sections_elements::iterator q;
3452
          for (q = this->sections_elements_->begin();
3453
               q != this->sections_elements_->end();
3454
               ++q)
3455
            {
3456
              if (q != p)
3457
                {
3458
                  if ((*q)->alternate_constraint(posd, failed_constraint))
3459
                    break;
3460
                }
3461
            }
3462
 
3463
          if (q == this->sections_elements_->end())
3464
            gold_error(_("no matching section constraint"));
3465
        }
3466
    }
3467
 
3468
  // Force the alignment of the first TLS section to be the maximum
3469
  // alignment of all TLS sections.
3470
  Output_section* first_tls = NULL;
3471
  uint64_t tls_align = 0;
3472
  for (Sections_elements::const_iterator p = this->sections_elements_->begin();
3473
       p != this->sections_elements_->end();
3474
       ++p)
3475
    {
3476
      Output_section* os = (*p)->get_output_section();
3477
      if (os != NULL && (os->flags() & elfcpp::SHF_TLS) != 0)
3478
        {
3479
          if (first_tls == NULL)
3480
            first_tls = os;
3481
          if (os->addralign() > tls_align)
3482
            tls_align = os->addralign();
3483
        }
3484
    }
3485
  if (first_tls != NULL)
3486
    first_tls->set_addralign(tls_align);
3487
 
3488
  // For a relocatable link, we implicitly set dot to zero.
3489
  uint64_t dot_value = 0;
3490
  uint64_t dot_alignment = 0;
3491
  uint64_t load_address = 0;
3492
 
3493
  // Check to see if we want to use any of -Ttext, -Tdata and -Tbss options
3494
  // to set section addresses.  If the script has any SEGMENT_START
3495
  // expression, we do not set the section addresses.
3496
  bool use_tsection_options =
3497
    (!this->saw_segment_start_expression_
3498
     && (parameters->options().user_set_Ttext()
3499
         || parameters->options().user_set_Tdata()
3500
         || parameters->options().user_set_Tbss()));
3501
 
3502
  for (Sections_elements::iterator p = this->sections_elements_->begin();
3503
       p != this->sections_elements_->end();
3504
       ++p)
3505
    {
3506
      Output_section* os = (*p)->get_output_section();
3507
 
3508
      // Handle -Ttext, -Tdata and -Tbss options.  We do this by looking for
3509
      // the special sections by names and doing dot assignments. 
3510
      if (use_tsection_options
3511
          && os != NULL
3512
          && (os->flags() & elfcpp::SHF_ALLOC) != 0)
3513
        {
3514
          uint64_t new_dot_value = dot_value;
3515
 
3516
          if (parameters->options().user_set_Ttext()
3517
              && strcmp(os->name(), ".text") == 0)
3518
            new_dot_value = parameters->options().Ttext();
3519
          else if (parameters->options().user_set_Tdata()
3520
              && strcmp(os->name(), ".data") == 0)
3521
            new_dot_value = parameters->options().Tdata();
3522
          else if (parameters->options().user_set_Tbss()
3523
              && strcmp(os->name(), ".bss") == 0)
3524
            new_dot_value = parameters->options().Tbss();
3525
 
3526
          // Update dot and load address if necessary.
3527
          if (new_dot_value < dot_value)
3528
            gold_error(_("dot may not move backward"));
3529
          else if (new_dot_value != dot_value)
3530
            {
3531
              dot_value = new_dot_value;
3532
              load_address = new_dot_value;
3533
            }
3534
        }
3535
 
3536
      (*p)->set_section_addresses(symtab, layout, &dot_value, &dot_alignment,
3537
                                  &load_address);
3538
    }
3539
 
3540
  if (this->phdrs_elements_ != NULL)
3541
    {
3542
      for (Phdrs_elements::iterator p = this->phdrs_elements_->begin();
3543
           p != this->phdrs_elements_->end();
3544
           ++p)
3545
        (*p)->eval_load_address(symtab, layout);
3546
    }
3547
 
3548
  return this->create_segments(layout, dot_alignment);
3549
}
3550
 
3551
// Sort the sections in order to put them into segments.
3552
 
3553
class Sort_output_sections
3554
{
3555
 public:
3556
  Sort_output_sections(const Script_sections::Sections_elements* elements)
3557
   : elements_(elements)
3558
  { }
3559
 
3560
  bool
3561
  operator()(const Output_section* os1, const Output_section* os2) const;
3562
 
3563
 private:
3564
  int
3565
  script_compare(const Output_section* os1, const Output_section* os2) const;
3566
 
3567
 private:
3568
  const Script_sections::Sections_elements* elements_;
3569
};
3570
 
3571
bool
3572
Sort_output_sections::operator()(const Output_section* os1,
3573
                                 const Output_section* os2) const
3574
{
3575
  // Sort first by the load address.
3576
  uint64_t lma1 = (os1->has_load_address()
3577
                   ? os1->load_address()
3578
                   : os1->address());
3579
  uint64_t lma2 = (os2->has_load_address()
3580
                   ? os2->load_address()
3581
                   : os2->address());
3582
  if (lma1 != lma2)
3583
    return lma1 < lma2;
3584
 
3585
  // Then sort by the virtual address.
3586
  if (os1->address() != os2->address())
3587
    return os1->address() < os2->address();
3588
 
3589
  // If the linker script says which of these sections is first, go
3590
  // with what it says.
3591
  int i = this->script_compare(os1, os2);
3592
  if (i != 0)
3593
    return i < 0;
3594
 
3595
  // Sort PROGBITS before NOBITS.
3596
  bool nobits1 = os1->type() == elfcpp::SHT_NOBITS;
3597
  bool nobits2 = os2->type() == elfcpp::SHT_NOBITS;
3598
  if (nobits1 != nobits2)
3599
    return nobits2;
3600
 
3601
  // Sort PROGBITS TLS sections to the end, NOBITS TLS sections to the
3602
  // beginning.
3603
  bool tls1 = (os1->flags() & elfcpp::SHF_TLS) != 0;
3604
  bool tls2 = (os2->flags() & elfcpp::SHF_TLS) != 0;
3605
  if (tls1 != tls2)
3606
    return nobits1 ? tls1 : tls2;
3607
 
3608
  // Sort non-NOLOAD before NOLOAD.
3609
  if (os1->is_noload() && !os2->is_noload())
3610
    return true;
3611
  if (!os1->is_noload() && os2->is_noload())
3612
    return true;
3613
 
3614
  // The sections seem practically identical.  Sort by name to get a
3615
  // stable sort.
3616
  return os1->name() < os2->name();
3617
}
3618
 
3619
// Return -1 if OS1 comes before OS2 in ELEMENTS_, 1 if comes after, 0
3620
// if either OS1 or OS2 is not mentioned.  This ensures that we keep
3621
// empty sections in the order in which they appear in a linker
3622
// script.
3623
 
3624
int
3625
Sort_output_sections::script_compare(const Output_section* os1,
3626
                                     const Output_section* os2) const
3627
{
3628
  if (this->elements_ == NULL)
3629
    return 0;
3630
 
3631
  bool found_os1 = false;
3632
  bool found_os2 = false;
3633
  for (Script_sections::Sections_elements::const_iterator
3634
         p = this->elements_->begin();
3635
       p != this->elements_->end();
3636
       ++p)
3637
    {
3638
      if (os2 == (*p)->get_output_section())
3639
        {
3640
          if (found_os1)
3641
            return -1;
3642
          found_os2 = true;
3643
        }
3644
      else if (os1 == (*p)->get_output_section())
3645
        {
3646
          if (found_os2)
3647
            return 1;
3648
          found_os1 = true;
3649
        }
3650
    }
3651
 
3652
  return 0;
3653
}
3654
 
3655
// Return whether OS is a BSS section.  This is a SHT_NOBITS section.
3656
// We treat a section with the SHF_TLS flag set as taking up space
3657
// even if it is SHT_NOBITS (this is true of .tbss), as we allocate
3658
// space for them in the file.
3659
 
3660
bool
3661
Script_sections::is_bss_section(const Output_section* os)
3662
{
3663
  return (os->type() == elfcpp::SHT_NOBITS
3664
          && (os->flags() & elfcpp::SHF_TLS) == 0);
3665
}
3666
 
3667
// Return the size taken by the file header and the program headers.
3668
 
3669
size_t
3670
Script_sections::total_header_size(Layout* layout) const
3671
{
3672
  size_t segment_count = layout->segment_count();
3673
  size_t file_header_size;
3674
  size_t segment_headers_size;
3675
  if (parameters->target().get_size() == 32)
3676
    {
3677
      file_header_size = elfcpp::Elf_sizes<32>::ehdr_size;
3678
      segment_headers_size = segment_count * elfcpp::Elf_sizes<32>::phdr_size;
3679
    }
3680
  else if (parameters->target().get_size() == 64)
3681
    {
3682
      file_header_size = elfcpp::Elf_sizes<64>::ehdr_size;
3683
      segment_headers_size = segment_count * elfcpp::Elf_sizes<64>::phdr_size;
3684
    }
3685
  else
3686
    gold_unreachable();
3687
 
3688
  return file_header_size + segment_headers_size;
3689
}
3690
 
3691
// Return the amount we have to subtract from the LMA to accommodate
3692
// headers of the given size.  The complication is that the file
3693
// header have to be at the start of a page, as otherwise it will not
3694
// be at the start of the file.
3695
 
3696
uint64_t
3697
Script_sections::header_size_adjustment(uint64_t lma,
3698
                                        size_t sizeof_headers) const
3699
{
3700
  const uint64_t abi_pagesize = parameters->target().abi_pagesize();
3701
  uint64_t hdr_lma = lma - sizeof_headers;
3702
  hdr_lma &= ~(abi_pagesize - 1);
3703
  return lma - hdr_lma;
3704
}
3705
 
3706
// Create the PT_LOAD segments when using a SECTIONS clause.  Returns
3707
// the segment which should hold the file header and segment headers,
3708
// if any.
3709
 
3710
Output_segment*
3711
Script_sections::create_segments(Layout* layout, uint64_t dot_alignment)
3712
{
3713
  gold_assert(this->saw_sections_clause_);
3714
 
3715
  if (parameters->options().relocatable())
3716
    return NULL;
3717
 
3718
  if (this->saw_phdrs_clause())
3719
    return create_segments_from_phdrs_clause(layout, dot_alignment);
3720
 
3721
  Layout::Section_list sections;
3722
  layout->get_allocated_sections(&sections);
3723
 
3724
  // Sort the sections by address.
3725
  std::stable_sort(sections.begin(), sections.end(),
3726
                   Sort_output_sections(this->sections_elements_));
3727
 
3728
  this->create_note_and_tls_segments(layout, &sections);
3729
 
3730
  // Walk through the sections adding them to PT_LOAD segments.
3731
  const uint64_t abi_pagesize = parameters->target().abi_pagesize();
3732
  Output_segment* first_seg = NULL;
3733
  Output_segment* current_seg = NULL;
3734
  bool is_current_seg_readonly = true;
3735
  Layout::Section_list::iterator plast = sections.end();
3736
  uint64_t last_vma = 0;
3737
  uint64_t last_lma = 0;
3738
  uint64_t last_size = 0;
3739
  for (Layout::Section_list::iterator p = sections.begin();
3740
       p != sections.end();
3741
       ++p)
3742
    {
3743
      const uint64_t vma = (*p)->address();
3744
      const uint64_t lma = ((*p)->has_load_address()
3745
                            ? (*p)->load_address()
3746
                            : vma);
3747
      const uint64_t size = (*p)->current_data_size();
3748
 
3749
      bool need_new_segment;
3750
      if (current_seg == NULL)
3751
        need_new_segment = true;
3752
      else if (lma - vma != last_lma - last_vma)
3753
        {
3754
          // This section has a different LMA relationship than the
3755
          // last one; we need a new segment.
3756
          need_new_segment = true;
3757
        }
3758
      else if (align_address(last_lma + last_size, abi_pagesize)
3759
               < align_address(lma, abi_pagesize))
3760
        {
3761
          // Putting this section in the segment would require
3762
          // skipping a page.
3763
          need_new_segment = true;
3764
        }
3765
      else if (is_bss_section(*plast) && !is_bss_section(*p))
3766
        {
3767
          // A non-BSS section can not follow a BSS section in the
3768
          // same segment.
3769
          need_new_segment = true;
3770
        }
3771
      else if (is_current_seg_readonly
3772
               && ((*p)->flags() & elfcpp::SHF_WRITE) != 0
3773
               && !parameters->options().omagic())
3774
        {
3775
          // Don't put a writable section in the same segment as a
3776
          // non-writable section.
3777
          need_new_segment = true;
3778
        }
3779
      else
3780
        {
3781
          // Otherwise, reuse the existing segment.
3782
          need_new_segment = false;
3783
        }
3784
 
3785
      elfcpp::Elf_Word seg_flags =
3786
        Layout::section_flags_to_segment((*p)->flags());
3787
 
3788
      if (need_new_segment)
3789
        {
3790
          current_seg = layout->make_output_segment(elfcpp::PT_LOAD,
3791
                                                    seg_flags);
3792
          current_seg->set_addresses(vma, lma);
3793
          current_seg->set_minimum_p_align(dot_alignment);
3794
          if (first_seg == NULL)
3795
            first_seg = current_seg;
3796
          is_current_seg_readonly = true;
3797
        }
3798
 
3799
      current_seg->add_output_section_to_load(layout, *p, seg_flags);
3800
 
3801
      if (((*p)->flags() & elfcpp::SHF_WRITE) != 0)
3802
        is_current_seg_readonly = false;
3803
 
3804
      plast = p;
3805
      last_vma = vma;
3806
      last_lma = lma;
3807
      last_size = size;
3808
    }
3809
 
3810
  // An ELF program should work even if the program headers are not in
3811
  // a PT_LOAD segment.  However, it appears that the Linux kernel
3812
  // does not set the AT_PHDR auxiliary entry in that case.  It sets
3813
  // the load address to p_vaddr - p_offset of the first PT_LOAD
3814
  // segment.  It then sets AT_PHDR to the load address plus the
3815
  // offset to the program headers, e_phoff in the file header.  This
3816
  // fails when the program headers appear in the file before the
3817
  // first PT_LOAD segment.  Therefore, we always create a PT_LOAD
3818
  // segment to hold the file header and the program headers.  This is
3819
  // effectively what the GNU linker does, and it is slightly more
3820
  // efficient in any case.  We try to use the first PT_LOAD segment
3821
  // if we can, otherwise we make a new one.
3822
 
3823
  if (first_seg == NULL)
3824
    return NULL;
3825
 
3826
  // -n or -N mean that the program is not demand paged and there is
3827
  // no need to put the program headers in a PT_LOAD segment.
3828
  if (parameters->options().nmagic() || parameters->options().omagic())
3829
    return NULL;
3830
 
3831
  size_t sizeof_headers = this->total_header_size(layout);
3832
 
3833
  uint64_t vma = first_seg->vaddr();
3834
  uint64_t lma = first_seg->paddr();
3835
 
3836
  uint64_t subtract = this->header_size_adjustment(lma, sizeof_headers);
3837
 
3838
  if ((lma & (abi_pagesize - 1)) >= sizeof_headers)
3839
    {
3840
      first_seg->set_addresses(vma - subtract, lma - subtract);
3841
      return first_seg;
3842
    }
3843
 
3844
  // If there is no room to squeeze in the headers, then punt.  The
3845
  // resulting executable probably won't run on GNU/Linux, but we
3846
  // trust that the user knows what they are doing.
3847
  if (lma < subtract || vma < subtract)
3848
    return NULL;
3849
 
3850
  // If memory regions have been specified and the address range
3851
  // we are about to use is not contained within any region then
3852
  // issue a warning message about the segment we are going to
3853
  // create.  It will be outside of any region and so possibly
3854
  // using non-existent or protected memory.  We test LMA rather
3855
  // than VMA since we assume that the headers will never be
3856
  // relocated.
3857
  if (this->memory_regions_ != NULL
3858
      && !this->block_in_region (NULL, layout, lma - subtract, subtract))
3859
    gold_warning(_("creating a segment to contain the file and program"
3860
                   " headers outside of any MEMORY region"));
3861
 
3862
  Output_segment* load_seg = layout->make_output_segment(elfcpp::PT_LOAD,
3863
                                                         elfcpp::PF_R);
3864
  load_seg->set_addresses(vma - subtract, lma - subtract);
3865
 
3866
  return load_seg;
3867
}
3868
 
3869
// Create a PT_NOTE segment for each SHT_NOTE section and a PT_TLS
3870
// segment if there are any SHT_TLS sections.
3871
 
3872
void
3873
Script_sections::create_note_and_tls_segments(
3874
    Layout* layout,
3875
    const Layout::Section_list* sections)
3876
{
3877
  gold_assert(!this->saw_phdrs_clause());
3878
 
3879
  bool saw_tls = false;
3880
  for (Layout::Section_list::const_iterator p = sections->begin();
3881
       p != sections->end();
3882
       ++p)
3883
    {
3884
      if ((*p)->type() == elfcpp::SHT_NOTE)
3885
        {
3886
          elfcpp::Elf_Word seg_flags =
3887
            Layout::section_flags_to_segment((*p)->flags());
3888
          Output_segment* oseg = layout->make_output_segment(elfcpp::PT_NOTE,
3889
                                                             seg_flags);
3890
          oseg->add_output_section_to_nonload(*p, seg_flags);
3891
 
3892
          // Incorporate any subsequent SHT_NOTE sections, in the
3893
          // hopes that the script is sensible.
3894
          Layout::Section_list::const_iterator pnext = p + 1;
3895
          while (pnext != sections->end()
3896
                 && (*pnext)->type() == elfcpp::SHT_NOTE)
3897
            {
3898
              seg_flags = Layout::section_flags_to_segment((*pnext)->flags());
3899
              oseg->add_output_section_to_nonload(*pnext, seg_flags);
3900
              p = pnext;
3901
              ++pnext;
3902
            }
3903
        }
3904
 
3905
      if (((*p)->flags() & elfcpp::SHF_TLS) != 0)
3906
        {
3907
          if (saw_tls)
3908
            gold_error(_("TLS sections are not adjacent"));
3909
 
3910
          elfcpp::Elf_Word seg_flags =
3911
            Layout::section_flags_to_segment((*p)->flags());
3912
          Output_segment* oseg = layout->make_output_segment(elfcpp::PT_TLS,
3913
                                                             seg_flags);
3914
          oseg->add_output_section_to_nonload(*p, seg_flags);
3915
 
3916
          Layout::Section_list::const_iterator pnext = p + 1;
3917
          while (pnext != sections->end()
3918
                 && ((*pnext)->flags() & elfcpp::SHF_TLS) != 0)
3919
            {
3920
              seg_flags = Layout::section_flags_to_segment((*pnext)->flags());
3921
              oseg->add_output_section_to_nonload(*pnext, seg_flags);
3922
              p = pnext;
3923
              ++pnext;
3924
            }
3925
 
3926
          saw_tls = true;
3927
        }
3928
    }
3929
}
3930
 
3931
// Add a program header.  The PHDRS clause is syntactically distinct
3932
// from the SECTIONS clause, but we implement it with the SECTIONS
3933
// support because PHDRS is useless if there is no SECTIONS clause.
3934
 
3935
void
3936
Script_sections::add_phdr(const char* name, size_t namelen, unsigned int type,
3937
                          bool includes_filehdr, bool includes_phdrs,
3938
                          bool is_flags_valid, unsigned int flags,
3939
                          Expression* load_address)
3940
{
3941
  if (this->phdrs_elements_ == NULL)
3942
    this->phdrs_elements_ = new Phdrs_elements();
3943
  this->phdrs_elements_->push_back(new Phdrs_element(name, namelen, type,
3944
                                                     includes_filehdr,
3945
                                                     includes_phdrs,
3946
                                                     is_flags_valid, flags,
3947
                                                     load_address));
3948
}
3949
 
3950
// Return the number of segments we expect to create based on the
3951
// SECTIONS clause.  This is used to implement SIZEOF_HEADERS.
3952
 
3953
size_t
3954
Script_sections::expected_segment_count(const Layout* layout) const
3955
{
3956
  if (this->saw_phdrs_clause())
3957
    return this->phdrs_elements_->size();
3958
 
3959
  Layout::Section_list sections;
3960
  layout->get_allocated_sections(&sections);
3961
 
3962
  // We assume that we will need two PT_LOAD segments.
3963
  size_t ret = 2;
3964
 
3965
  bool saw_note = false;
3966
  bool saw_tls = false;
3967
  for (Layout::Section_list::const_iterator p = sections.begin();
3968
       p != sections.end();
3969
       ++p)
3970
    {
3971
      if ((*p)->type() == elfcpp::SHT_NOTE)
3972
        {
3973
          // Assume that all note sections will fit into a single
3974
          // PT_NOTE segment.
3975
          if (!saw_note)
3976
            {
3977
              ++ret;
3978
              saw_note = true;
3979
            }
3980
        }
3981
      else if (((*p)->flags() & elfcpp::SHF_TLS) != 0)
3982
        {
3983
          // There can only be one PT_TLS segment.
3984
          if (!saw_tls)
3985
            {
3986
              ++ret;
3987
              saw_tls = true;
3988
            }
3989
        }
3990
    }
3991
 
3992
  return ret;
3993
}
3994
 
3995
// Create the segments from a PHDRS clause.  Return the segment which
3996
// should hold the file header and program headers, if any.
3997
 
3998
Output_segment*
3999
Script_sections::create_segments_from_phdrs_clause(Layout* layout,
4000
                                                   uint64_t dot_alignment)
4001
{
4002
  this->attach_sections_using_phdrs_clause(layout);
4003
  return this->set_phdrs_clause_addresses(layout, dot_alignment);
4004
}
4005
 
4006
// Create the segments from the PHDRS clause, and put the output
4007
// sections in them.
4008
 
4009
void
4010
Script_sections::attach_sections_using_phdrs_clause(Layout* layout)
4011
{
4012
  typedef std::map<std::string, Output_segment*> Name_to_segment;
4013
  Name_to_segment name_to_segment;
4014
  for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
4015
       p != this->phdrs_elements_->end();
4016
       ++p)
4017
    name_to_segment[(*p)->name()] = (*p)->create_segment(layout);
4018
 
4019
  // Walk through the output sections and attach them to segments.
4020
  // Output sections in the script which do not list segments are
4021
  // attached to the same set of segments as the immediately preceding
4022
  // output section.
4023
 
4024
  String_list* phdr_names = NULL;
4025
  bool load_segments_only = false;
4026
  for (Sections_elements::const_iterator p = this->sections_elements_->begin();
4027
       p != this->sections_elements_->end();
4028
       ++p)
4029
    {
4030
      bool orphan;
4031
      String_list* old_phdr_names = phdr_names;
4032
      Output_section* os = (*p)->allocate_to_segment(&phdr_names, &orphan);
4033
      if (os == NULL)
4034
        continue;
4035
 
4036
      if (phdr_names == NULL)
4037
        {
4038
          gold_error(_("allocated section not in any segment"));
4039
          continue;
4040
        }
4041
 
4042
      // We see a list of segments names.  Disable PT_LOAD segment only
4043
      // filtering.
4044
      if (old_phdr_names != phdr_names)
4045
        load_segments_only = false;
4046
 
4047
      // If this is an orphan section--one that was not explicitly
4048
      // mentioned in the linker script--then it should not inherit
4049
      // any segment type other than PT_LOAD.  Otherwise, e.g., the
4050
      // PT_INTERP segment will pick up following orphan sections,
4051
      // which does not make sense.  If this is not an orphan section,
4052
      // we trust the linker script.
4053
      if (orphan)
4054
        {
4055
          // Enable PT_LOAD segments only filtering until we see another
4056
          // list of segment names.
4057
          load_segments_only = true;
4058
        }
4059
 
4060
      bool in_load_segment = false;
4061
      for (String_list::const_iterator q = phdr_names->begin();
4062
           q != phdr_names->end();
4063
           ++q)
4064
        {
4065
          Name_to_segment::const_iterator r = name_to_segment.find(*q);
4066
          if (r == name_to_segment.end())
4067
            gold_error(_("no segment %s"), q->c_str());
4068
          else
4069
            {
4070
              if (load_segments_only
4071
                  && r->second->type() != elfcpp::PT_LOAD)
4072
                continue;
4073
 
4074
              elfcpp::Elf_Word seg_flags =
4075
                Layout::section_flags_to_segment(os->flags());
4076
 
4077
              if (r->second->type() != elfcpp::PT_LOAD)
4078
                r->second->add_output_section_to_nonload(os, seg_flags);
4079
              else
4080
                {
4081
                  r->second->add_output_section_to_load(layout, os, seg_flags);
4082
                  if (in_load_segment)
4083
                    gold_error(_("section in two PT_LOAD segments"));
4084
                  in_load_segment = true;
4085
                }
4086
            }
4087
        }
4088
 
4089
      if (!in_load_segment)
4090
        gold_error(_("allocated section not in any PT_LOAD segment"));
4091
    }
4092
}
4093
 
4094
// Set the addresses for segments created from a PHDRS clause.  Return
4095
// the segment which should hold the file header and program headers,
4096
// if any.
4097
 
4098
Output_segment*
4099
Script_sections::set_phdrs_clause_addresses(Layout* layout,
4100
                                            uint64_t dot_alignment)
4101
{
4102
  Output_segment* load_seg = NULL;
4103
  for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
4104
       p != this->phdrs_elements_->end();
4105
       ++p)
4106
    {
4107
      // Note that we have to set the flags after adding the output
4108
      // sections to the segment, as adding an output segment can
4109
      // change the flags.
4110
      (*p)->set_flags_if_valid();
4111
 
4112
      Output_segment* oseg = (*p)->segment();
4113
 
4114
      if (oseg->type() != elfcpp::PT_LOAD)
4115
        {
4116
          // The addresses of non-PT_LOAD segments are set from the
4117
          // PT_LOAD segments.
4118
          if ((*p)->has_load_address())
4119
            gold_error(_("may only specify load address for PT_LOAD segment"));
4120
          continue;
4121
        }
4122
 
4123
      oseg->set_minimum_p_align(dot_alignment);
4124
 
4125
      // The output sections should have addresses from the SECTIONS
4126
      // clause.  The addresses don't have to be in order, so find the
4127
      // one with the lowest load address.  Use that to set the
4128
      // address of the segment.
4129
 
4130
      Output_section* osec = oseg->section_with_lowest_load_address();
4131
      if (osec == NULL)
4132
        {
4133
          oseg->set_addresses(0, 0);
4134
          continue;
4135
        }
4136
 
4137
      uint64_t vma = osec->address();
4138
      uint64_t lma = osec->has_load_address() ? osec->load_address() : vma;
4139
 
4140
      // Override the load address of the section with the load
4141
      // address specified for the segment.
4142
      if ((*p)->has_load_address())
4143
        {
4144
          if (osec->has_load_address())
4145
            gold_warning(_("PHDRS load address overrides "
4146
                           "section %s load address"),
4147
                         osec->name());
4148
 
4149
          lma = (*p)->load_address();
4150
        }
4151
 
4152
      bool headers = (*p)->includes_filehdr() && (*p)->includes_phdrs();
4153
      if (!headers && ((*p)->includes_filehdr() || (*p)->includes_phdrs()))
4154
        {
4155
          // We could support this if we wanted to.
4156
          gold_error(_("using only one of FILEHDR and PHDRS is "
4157
                       "not currently supported"));
4158
        }
4159
      if (headers)
4160
        {
4161
          size_t sizeof_headers = this->total_header_size(layout);
4162
          uint64_t subtract = this->header_size_adjustment(lma,
4163
                                                           sizeof_headers);
4164
          if (lma >= subtract && vma >= subtract)
4165
            {
4166
              lma -= subtract;
4167
              vma -= subtract;
4168
            }
4169
          else
4170
            {
4171
              gold_error(_("sections loaded on first page without room "
4172
                           "for file and program headers "
4173
                           "are not supported"));
4174
            }
4175
 
4176
          if (load_seg != NULL)
4177
            gold_error(_("using FILEHDR and PHDRS on more than one "
4178
                         "PT_LOAD segment is not currently supported"));
4179
          load_seg = oseg;
4180
        }
4181
 
4182
      oseg->set_addresses(vma, lma);
4183
    }
4184
 
4185
  return load_seg;
4186
}
4187
 
4188
// Add the file header and segment headers to non-load segments
4189
// specified in the PHDRS clause.
4190
 
4191
void
4192
Script_sections::put_headers_in_phdrs(Output_data* file_header,
4193
                                      Output_data* segment_headers)
4194
{
4195
  gold_assert(this->saw_phdrs_clause());
4196
  for (Phdrs_elements::iterator p = this->phdrs_elements_->begin();
4197
       p != this->phdrs_elements_->end();
4198
       ++p)
4199
    {
4200
      if ((*p)->type() != elfcpp::PT_LOAD)
4201
        {
4202
          if ((*p)->includes_phdrs())
4203
            (*p)->segment()->add_initial_output_data(segment_headers);
4204
          if ((*p)->includes_filehdr())
4205
            (*p)->segment()->add_initial_output_data(file_header);
4206
        }
4207
    }
4208
}
4209
 
4210
// Look for an output section by name and return the address, the load
4211
// address, the alignment, and the size.  This is used when an
4212
// expression refers to an output section which was not actually
4213
// created.  This returns true if the section was found, false
4214
// otherwise.
4215
 
4216
bool
4217
Script_sections::get_output_section_info(const char* name, uint64_t* address,
4218
                                         uint64_t* load_address,
4219
                                         uint64_t* addralign,
4220
                                         uint64_t* size) const
4221
{
4222
  if (!this->saw_sections_clause_)
4223
    return false;
4224
  for (Sections_elements::const_iterator p = this->sections_elements_->begin();
4225
       p != this->sections_elements_->end();
4226
       ++p)
4227
    if ((*p)->get_output_section_info(name, address, load_address, addralign,
4228
                                      size))
4229
      return true;
4230
  return false;
4231
}
4232
 
4233
// Release all Output_segments.  This remove all pointers to all
4234
// Output_segments.
4235
 
4236
void
4237
Script_sections::release_segments()
4238
{
4239
  if (this->saw_phdrs_clause())
4240
    {
4241
      for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
4242
           p != this->phdrs_elements_->end();
4243
           ++p)
4244
        (*p)->release_segment();
4245
    }
4246
}
4247
 
4248
// Print the SECTIONS clause to F for debugging.
4249
 
4250
void
4251
Script_sections::print(FILE* f) const
4252
{
4253
  if (this->phdrs_elements_ != NULL)
4254
    {
4255
      fprintf(f, "PHDRS {\n");
4256
      for (Phdrs_elements::const_iterator p = this->phdrs_elements_->begin();
4257
           p != this->phdrs_elements_->end();
4258
           ++p)
4259
        (*p)->print(f);
4260
      fprintf(f, "}\n");
4261
    }
4262
 
4263
  if (this->memory_regions_ != NULL)
4264
    {
4265
      fprintf(f, "MEMORY {\n");
4266
      for (Memory_regions::const_iterator m = this->memory_regions_->begin();
4267
           m != this->memory_regions_->end();
4268
           ++m)
4269
        (*m)->print(f);
4270
      fprintf(f, "}\n");
4271
    }
4272
 
4273
  if (!this->saw_sections_clause_)
4274
    return;
4275
 
4276
  fprintf(f, "SECTIONS {\n");
4277
 
4278
  for (Sections_elements::const_iterator p = this->sections_elements_->begin();
4279
       p != this->sections_elements_->end();
4280
       ++p)
4281
    (*p)->print(f);
4282
 
4283
  fprintf(f, "}\n");
4284
}
4285
 
4286
} // End namespace gold.

powered by: WebSVN 2.1.0

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