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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gold/] [layout.h] - Blame information for rev 203

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

Line No. Rev Author Line
1 27 khays
// layout.h -- lay out output file sections for gold  -*- C++ -*-
2
 
3 159 khays
// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4 27 khays
// 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
#ifndef GOLD_LAYOUT_H
24
#define GOLD_LAYOUT_H
25
 
26
#include <cstring>
27
#include <list>
28
#include <map>
29
#include <string>
30
#include <utility>
31
#include <vector>
32
 
33
#include "script.h"
34
#include "workqueue.h"
35
#include "object.h"
36
#include "dynobj.h"
37
#include "stringpool.h"
38
 
39
namespace gold
40
{
41
 
42
class General_options;
43
class Incremental_inputs;
44
class Incremental_binary;
45
class Input_objects;
46
class Mapfile;
47
class Symbol_table;
48
class Output_section_data;
49
class Output_section;
50
class Output_section_headers;
51
class Output_segment_headers;
52
class Output_file_header;
53
class Output_segment;
54
class Output_data;
55
class Output_data_reloc_generic;
56
class Output_data_dynamic;
57
class Output_symtab_xindex;
58
class Output_reduced_debug_abbrev_section;
59
class Output_reduced_debug_info_section;
60
class Eh_frame;
61
class Target;
62
struct Timespec;
63
 
64
// Return TRUE if SECNAME is the name of a compressed debug section.
65
extern bool
66
is_compressed_debug_section(const char* secname);
67
 
68
// Maintain a list of free space within a section, segment, or file.
69
// Used for incremental update links.
70
 
71
class Free_list
72
{
73
 public:
74 159 khays
  struct Free_list_node
75
  {
76
    Free_list_node(off_t start, off_t end)
77
      : start_(start), end_(end)
78
    { }
79
    off_t start_;
80
    off_t end_;
81
  };
82
  typedef std::list<Free_list_node>::const_iterator Const_iterator;
83
 
84 27 khays
  Free_list()
85 159 khays
    : list_(), last_remove_(list_.begin()), extend_(false), length_(0),
86
      min_hole_(0)
87 27 khays
  { }
88
 
89 159 khays
  // Initialize the free list for a section of length LEN.
90
  // If EXTEND is true, free space may be allocated past the end.
91 27 khays
  void
92
  init(off_t len, bool extend);
93
 
94 159 khays
  // Set the minimum hole size that is allowed when allocating
95
  // from the free list.
96 27 khays
  void
97 159 khays
  set_min_hole_size(off_t min_hole)
98
  { this->min_hole_ = min_hole; }
99
 
100
  // Remove a chunk from the free list.
101
  void
102 27 khays
  remove(off_t start, off_t end);
103
 
104 159 khays
  // Allocate a chunk of space from the free list of length LEN,
105
  // with alignment ALIGN, and minimum offset MINOFF.
106 27 khays
  off_t
107
  allocate(off_t len, uint64_t align, off_t minoff);
108
 
109 159 khays
  // Return an iterator for the beginning of the free list.
110
  Const_iterator
111
  begin() const
112
  { return this->list_.begin(); }
113
 
114
  // Return an iterator for the end of the free list.
115
  Const_iterator
116
  end() const
117
  { return this->list_.end(); }
118
 
119
  // Dump the free list (for debugging).
120 27 khays
  void
121
  dump();
122
 
123 159 khays
  // Print usage statistics.
124 27 khays
  static void
125
  print_stats();
126
 
127
 private:
128
  typedef std::list<Free_list_node>::iterator Iterator;
129
 
130
  // The free list.
131
  std::list<Free_list_node> list_;
132
 
133
  // The last node visited during a remove operation.
134
  Iterator last_remove_;
135
 
136
  // Whether we can extend past the original length.
137
  bool extend_;
138
 
139
  // The total length of the section, segment, or file.
140
  off_t length_;
141
 
142 159 khays
  // The minimum hole size allowed.  When allocating from the free list,
143
  // we must not leave a hole smaller than this.
144
  off_t min_hole_;
145
 
146 27 khays
  // Statistics:
147
  // The total number of free lists used.
148
  static unsigned int num_lists;
149
  // The total number of free list nodes used.
150
  static unsigned int num_nodes;
151
  // The total number of calls to Free_list::remove.
152
  static unsigned int num_removes;
153
  // The total number of nodes visited during calls to Free_list::remove.
154
  static unsigned int num_remove_visits;
155
  // The total number of calls to Free_list::allocate.
156
  static unsigned int num_allocates;
157
  // The total number of nodes visited during calls to Free_list::allocate.
158
  static unsigned int num_allocate_visits;
159
};
160
 
161
// This task function handles mapping the input sections to output
162
// sections and laying them out in memory.
163
 
164
class Layout_task_runner : public Task_function_runner
165
{
166
 public:
167
  // OPTIONS is the command line options, INPUT_OBJECTS is the list of
168
  // input objects, SYMTAB is the symbol table, LAYOUT is the layout
169
  // object.
170
  Layout_task_runner(const General_options& options,
171
                     const Input_objects* input_objects,
172
                     Symbol_table* symtab,
173
                     Target* target,
174
                     Layout* layout,
175
                     Mapfile* mapfile)
176
    : options_(options), input_objects_(input_objects), symtab_(symtab),
177
      target_(target), layout_(layout), mapfile_(mapfile)
178
  { }
179
 
180
  // Run the operation.
181
  void
182
  run(Workqueue*, const Task*);
183
 
184
 private:
185
  Layout_task_runner(const Layout_task_runner&);
186
  Layout_task_runner& operator=(const Layout_task_runner&);
187
 
188
  const General_options& options_;
189
  const Input_objects* input_objects_;
190
  Symbol_table* symtab_;
191
  Target* target_;
192
  Layout* layout_;
193
  Mapfile* mapfile_;
194
};
195
 
196
// This class holds information about the comdat group or
197
// .gnu.linkonce section that will be kept for a given signature.
198
 
199
class Kept_section
200
{
201
 private:
202
  // For a comdat group, we build a mapping from the name of each
203
  // section in the group to the section index and the size in object.
204
  // When we discard a group in some other object file, we use this
205
  // map to figure out which kept section the discarded section is
206
  // associated with.  We then use that mapping when processing relocs
207
  // against discarded sections.
208
  struct Comdat_section_info
209
  {
210
    // The section index.
211
    unsigned int shndx;
212
    // The section size.
213
    uint64_t size;
214
 
215
    Comdat_section_info(unsigned int a_shndx, uint64_t a_size)
216
      : shndx(a_shndx), size(a_size)
217
    { }
218
  };
219
 
220
  // Most comdat groups have only one or two sections, so we use a
221
  // std::map rather than an Unordered_map to optimize for that case
222
  // without paying too heavily for groups with more sections.
223
  typedef std::map<std::string, Comdat_section_info> Comdat_group;
224
 
225
 public:
226
  Kept_section()
227
    : object_(NULL), shndx_(0), is_comdat_(false), is_group_name_(false)
228
  { this->u_.linkonce_size = 0; }
229
 
230
  // We need to support copies for the signature map in the Layout
231
  // object, but we should never copy an object after it has been
232
  // marked as a comdat section.
233
  Kept_section(const Kept_section& k)
234
    : object_(k.object_), shndx_(k.shndx_), is_comdat_(false),
235
      is_group_name_(k.is_group_name_)
236
  {
237
    gold_assert(!k.is_comdat_);
238
    this->u_.linkonce_size = 0;
239
  }
240
 
241
  ~Kept_section()
242
  {
243
    if (this->is_comdat_)
244
      delete this->u_.group_sections;
245
  }
246
 
247
  // The object where this section lives.
248
  Relobj*
249
  object() const
250
  { return this->object_; }
251
 
252
  // Set the object.
253
  void
254
  set_object(Relobj* object)
255
  {
256
    gold_assert(this->object_ == NULL);
257
    this->object_ = object;
258
  }
259
 
260
  // The section index.
261
  unsigned int
262
  shndx() const
263
  { return this->shndx_; }
264
 
265
  // Set the section index.
266
  void
267
  set_shndx(unsigned int shndx)
268
  {
269
    gold_assert(this->shndx_ == 0);
270
    this->shndx_ = shndx;
271
  }
272
 
273
  // Whether this is a comdat group.
274
  bool
275
  is_comdat() const
276
  { return this->is_comdat_; }
277
 
278
  // Set that this is a comdat group.
279
  void
280
  set_is_comdat()
281
  {
282
    gold_assert(!this->is_comdat_);
283
    this->is_comdat_ = true;
284
    this->u_.group_sections = new Comdat_group();
285
  }
286
 
287
  // Whether this is associated with the name of a group or section
288
  // rather than the symbol name derived from a linkonce section.
289
  bool
290
  is_group_name() const
291
  { return this->is_group_name_; }
292
 
293
  // Note that this represents a comdat group rather than a single
294
  // linkonce section.
295
  void
296
  set_is_group_name()
297
  { this->is_group_name_ = true; }
298
 
299
  // Add a section to the group list.
300
  void
301
  add_comdat_section(const std::string& name, unsigned int shndx,
302
                     uint64_t size)
303
  {
304
    gold_assert(this->is_comdat_);
305
    Comdat_section_info sinfo(shndx, size);
306
    this->u_.group_sections->insert(std::make_pair(name, sinfo));
307
  }
308
 
309
  // Look for a section name in the group list, and return whether it
310
  // was found.  If found, returns the section index and size.
311
  bool
312
  find_comdat_section(const std::string& name, unsigned int* pshndx,
313
                      uint64_t* psize) const
314
  {
315
    gold_assert(this->is_comdat_);
316
    Comdat_group::const_iterator p = this->u_.group_sections->find(name);
317
    if (p == this->u_.group_sections->end())
318
      return false;
319
    *pshndx = p->second.shndx;
320
    *psize = p->second.size;
321
    return true;
322
  }
323
 
324
  // If there is only one section in the group list, return true, and
325
  // return the section index and size.
326
  bool
327
  find_single_comdat_section(unsigned int* pshndx, uint64_t* psize) const
328
  {
329
    gold_assert(this->is_comdat_);
330
    if (this->u_.group_sections->size() != 1)
331
      return false;
332
    Comdat_group::const_iterator p = this->u_.group_sections->begin();
333
    *pshndx = p->second.shndx;
334
    *psize = p->second.size;
335
    return true;
336
  }
337
 
338
  // Return the size of a linkonce section.
339
  uint64_t
340
  linkonce_size() const
341
  {
342
    gold_assert(!this->is_comdat_);
343
    return this->u_.linkonce_size;
344
  }
345
 
346
  // Set the size of a linkonce section.
347
  void
348
  set_linkonce_size(uint64_t size)
349
  {
350
    gold_assert(!this->is_comdat_);
351
    this->u_.linkonce_size = size;
352
  }
353
 
354
 private:
355
  // No assignment.
356
  Kept_section& operator=(const Kept_section&);
357
 
358
  // The object containing the comdat group or .gnu.linkonce section.
359
  Relobj* object_;
360
  // Index of the group section for comdats and the section itself for
361
  // .gnu.linkonce.
362
  unsigned int shndx_;
363
  // True if this is for a comdat group rather than a .gnu.linkonce
364
  // section.
365
  bool is_comdat_;
366
  // The Kept_sections are values of a mapping, that maps names to
367
  // them.  This field is true if this struct is associated with the
368
  // name of a comdat or .gnu.linkonce, false if it is associated with
369
  // the name of a symbol obtained from the .gnu.linkonce.* name
370
  // through some heuristics.
371
  bool is_group_name_;
372
  union
373
  {
374
    // If the is_comdat_ field is true, this holds a map from names of
375
    // the sections in the group to section indexes in object_ and to
376
    // section sizes.
377
    Comdat_group* group_sections;
378
    // If the is_comdat_ field is false, this holds the size of the
379
    // single section.
380
    uint64_t linkonce_size;
381
  } u_;
382
};
383
 
384
// The ordering for output sections.  This controls how output
385
// sections are ordered within a PT_LOAD output segment.
386
 
387
enum Output_section_order
388
{
389
  // Unspecified.  Used for non-load segments.  Also used for the file
390
  // and segment headers.
391
  ORDER_INVALID,
392
 
393
  // The PT_INTERP section should come first, so that the dynamic
394
  // linker can pick it up quickly.
395
  ORDER_INTERP,
396
 
397
  // Loadable read-only note sections come next so that the PT_NOTE
398
  // segment is on the first page of the executable.
399
  ORDER_RO_NOTE,
400
 
401
  // Put read-only sections used by the dynamic linker early in the
402
  // executable to minimize paging.
403
  ORDER_DYNAMIC_LINKER,
404
 
405
  // Put reloc sections used by the dynamic linker after other
406
  // sections used by the dynamic linker; otherwise, objcopy and strip
407
  // get confused.
408
  ORDER_DYNAMIC_RELOCS,
409
 
410
  // Put the PLT reloc section after the other dynamic relocs;
411
  // otherwise, prelink gets confused.
412
  ORDER_DYNAMIC_PLT_RELOCS,
413
 
414
  // The .init section.
415
  ORDER_INIT,
416
 
417
  // The PLT.
418
  ORDER_PLT,
419
 
420
  // The regular text sections.
421
  ORDER_TEXT,
422
 
423
  // The .fini section.
424
  ORDER_FINI,
425
 
426
  // The read-only sections.
427
  ORDER_READONLY,
428
 
429
  // The exception frame sections.
430
  ORDER_EHFRAME,
431
 
432
  // The TLS sections come first in the data section.
433
  ORDER_TLS_DATA,
434
  ORDER_TLS_BSS,
435
 
436
  // Local RELRO (read-only after relocation) sections come before
437
  // non-local RELRO sections.  This data will be fully resolved by
438
  // the prelinker.
439
  ORDER_RELRO_LOCAL,
440
 
441
  // Non-local RELRO sections are grouped together after local RELRO
442
  // sections.  All RELRO sections must be adjacent so that they can
443
  // all be put into a PT_GNU_RELRO segment.
444
  ORDER_RELRO,
445
 
446
  // We permit marking exactly one output section as the last RELRO
447
  // section.  We do this so that the read-only GOT can be adjacent to
448
  // the writable GOT.
449
  ORDER_RELRO_LAST,
450
 
451
  // Similarly, we permit marking exactly one output section as the
452
  // first non-RELRO section.
453
  ORDER_NON_RELRO_FIRST,
454
 
455
  // The regular data sections come after the RELRO sections.
456
  ORDER_DATA,
457
 
458
  // Large data sections normally go in large data segments.
459
  ORDER_LARGE_DATA,
460
 
461
  // Group writable notes so that we can have a single PT_NOTE
462
  // segment.
463
  ORDER_RW_NOTE,
464
 
465
  // The small data sections must be at the end of the data sections,
466
  // so that they can be adjacent to the small BSS sections.
467
  ORDER_SMALL_DATA,
468
 
469
  // The BSS sections start here.
470
 
471
  // The small BSS sections must be at the start of the BSS sections,
472
  // so that they can be adjacent to the small data sections.
473
  ORDER_SMALL_BSS,
474
 
475
  // The regular BSS sections.
476
  ORDER_BSS,
477
 
478
  // The large BSS sections come after the other BSS sections.
479
  ORDER_LARGE_BSS,
480
 
481
  // Maximum value.
482
  ORDER_MAX
483
};
484
 
485
// This class handles the details of laying out input sections.
486
 
487
class Layout
488
{
489
 public:
490
  Layout(int number_of_input_files, Script_options*);
491
 
492
  ~Layout()
493
  {
494
    delete this->relaxation_debug_check_;
495
    delete this->segment_states_;
496
  }
497
 
498
  // For incremental links, record the base file to be modified.
499
  void
500
  set_incremental_base(Incremental_binary* base);
501
 
502
  Incremental_binary*
503
  incremental_base()
504
  { return this->incremental_base_; }
505
 
506
  // For incremental links, record the initial fixed layout of a section
507
  // from the base file, and return a pointer to the Output_section.
508
  template<int size, bool big_endian>
509
  Output_section*
510
  init_fixed_output_section(const char*, elfcpp::Shdr<size, big_endian>&);
511
 
512
  // Given an input section SHNDX, named NAME, with data in SHDR, from
513
  // the object file OBJECT, return the output section where this
514
  // input section should go.  RELOC_SHNDX is the index of a
515
  // relocation section which applies to this section, or 0 if none,
516
  // or -1U if more than one.  RELOC_TYPE is the type of the
517
  // relocation section if there is one.  Set *OFFSET to the offset
518
  // within the output section.
519
  template<int size, bool big_endian>
520
  Output_section*
521
  layout(Sized_relobj_file<size, big_endian> *object, unsigned int shndx,
522
         const char* name, const elfcpp::Shdr<size, big_endian>& shdr,
523
         unsigned int reloc_shndx, unsigned int reloc_type, off_t* offset);
524
 
525 163 khays
  std::map<Section_id, unsigned int>*
526
  get_section_order_map()
527
  { return &this->section_order_map_; }
528
 
529 159 khays
  bool
530
  is_section_ordering_specified()
531
  { return this->section_ordering_specified_; }
532
 
533
  void
534
  set_section_ordering_specified()
535
  { this->section_ordering_specified_ = true; }
536
 
537 27 khays
  // For incremental updates, allocate a block of memory from the
538
  // free list.  Find a block starting at or after MINOFF.
539
  off_t
540
  allocate(off_t len, uint64_t align, off_t minoff)
541
  { return this->free_list_.allocate(len, align, minoff); }
542
 
543
  unsigned int
544
  find_section_order_index(const std::string&);
545
 
546 159 khays
  // Read the sequence of input sections from the file specified with
547
  // linker option --section-ordering-file.
548 27 khays
  void
549
  read_layout_from_file();
550
 
551
  // Layout an input reloc section when doing a relocatable link.  The
552
  // section is RELOC_SHNDX in OBJECT, with data in SHDR.
553
  // DATA_SECTION is the reloc section to which it refers.  RR is the
554
  // relocatable information.
555
  template<int size, bool big_endian>
556
  Output_section*
557
  layout_reloc(Sized_relobj_file<size, big_endian>* object,
558
               unsigned int reloc_shndx,
559
               const elfcpp::Shdr<size, big_endian>& shdr,
560
               Output_section* data_section,
561
               Relocatable_relocs* rr);
562
 
563
  // Layout a group section when doing a relocatable link.
564
  template<int size, bool big_endian>
565
  void
566
  layout_group(Symbol_table* symtab,
567
               Sized_relobj_file<size, big_endian>* object,
568
               unsigned int group_shndx,
569
               const char* group_section_name,
570
               const char* signature,
571
               const elfcpp::Shdr<size, big_endian>& shdr,
572
               elfcpp::Elf_Word flags,
573
               std::vector<unsigned int>* shndxes);
574
 
575
  // Like layout, only for exception frame sections.  OBJECT is an
576
  // object file.  SYMBOLS is the contents of the symbol table
577
  // section, with size SYMBOLS_SIZE.  SYMBOL_NAMES is the contents of
578
  // the symbol name section, with size SYMBOL_NAMES_SIZE.  SHNDX is a
579
  // .eh_frame section in OBJECT.  SHDR is the section header.
580
  // RELOC_SHNDX is the index of a relocation section which applies to
581
  // this section, or 0 if none, or -1U if more than one.  RELOC_TYPE
582
  // is the type of the relocation section if there is one.  This
583
  // returns the output section, and sets *OFFSET to the offset.
584
  template<int size, bool big_endian>
585
  Output_section*
586
  layout_eh_frame(Sized_relobj_file<size, big_endian>* object,
587
                  const unsigned char* symbols,
588
                  off_t symbols_size,
589
                  const unsigned char* symbol_names,
590
                  off_t symbol_names_size,
591
                  unsigned int shndx,
592
                  const elfcpp::Shdr<size, big_endian>& shdr,
593
                  unsigned int reloc_shndx, unsigned int reloc_type,
594
                  off_t* offset);
595
 
596 159 khays
  // Add .eh_frame information for a PLT.  The FDE must start with a
597
  // 4-byte PC-relative reference to the start of the PLT, followed by
598
  // a 4-byte size of PLT.
599
  void
600
  add_eh_frame_for_plt(Output_data* plt, const unsigned char* cie_data,
601
                       size_t cie_length, const unsigned char* fde_data,
602
                       size_t fde_length);
603
 
604 27 khays
  // Handle a GNU stack note.  This is called once per input object
605
  // file.  SEEN_GNU_STACK is true if the object file has a
606
  // .note.GNU-stack section.  GNU_STACK_FLAGS is the section flags
607
  // from that section if there was one.
608
  void
609
  layout_gnu_stack(bool seen_gnu_stack, uint64_t gnu_stack_flags,
610
                   const Object*);
611
 
612
  // Add an Output_section_data to the layout.  This is used for
613
  // special sections like the GOT section.  ORDER is where the
614
  // section should wind up in the output segment.  IS_RELRO is true
615
  // for relro sections.
616
  Output_section*
617
  add_output_section_data(const char* name, elfcpp::Elf_Word type,
618
                          elfcpp::Elf_Xword flags,
619
                          Output_section_data*, Output_section_order order,
620
                          bool is_relro);
621
 
622
  // Increase the size of the relro segment by this much.
623
  void
624
  increase_relro(unsigned int s)
625
  { this->increase_relro_ += s; }
626
 
627
  // Create dynamic sections if necessary.
628
  void
629
  create_initial_dynamic_sections(Symbol_table*);
630
 
631
  // Define __start and __stop symbols for output sections.
632
  void
633
  define_section_symbols(Symbol_table*);
634
 
635
  // Create automatic note sections.
636
  void
637
  create_notes();
638
 
639
  // Create sections for linker scripts.
640
  void
641
  create_script_sections()
642
  { this->script_options_->create_script_sections(this); }
643
 
644
  // Define symbols from any linker script.
645
  void
646
  define_script_symbols(Symbol_table* symtab)
647
  { this->script_options_->add_symbols_to_table(symtab); }
648
 
649
  // Define symbols for group signatures.
650
  void
651
  define_group_signatures(Symbol_table*);
652
 
653
  // Return the Stringpool used for symbol names.
654
  const Stringpool*
655
  sympool() const
656
  { return &this->sympool_; }
657
 
658
  // Return the Stringpool used for dynamic symbol names and dynamic
659
  // tags.
660
  const Stringpool*
661
  dynpool() const
662
  { return &this->dynpool_; }
663
 
664 159 khays
  // Return the .dynamic output section.  This is only valid after the
665
  // layout has been finalized.
666
  Output_section*
667
  dynamic_section() const
668
  { return this->dynamic_section_; }
669
 
670 27 khays
  // Return the symtab_xindex section used to hold large section
671
  // indexes for the normal symbol table.
672
  Output_symtab_xindex*
673
  symtab_xindex() const
674
  { return this->symtab_xindex_; }
675
 
676
  // Return the dynsym_xindex section used to hold large section
677
  // indexes for the dynamic symbol table.
678
  Output_symtab_xindex*
679
  dynsym_xindex() const
680
  { return this->dynsym_xindex_; }
681
 
682
  // Return whether a section is a .gnu.linkonce section, given the
683
  // section name.
684
  static inline bool
685
  is_linkonce(const char* name)
686
  { return strncmp(name, ".gnu.linkonce", sizeof(".gnu.linkonce") - 1) == 0; }
687
 
688
  // Whether we have added an input section.
689
  bool
690
  have_added_input_section() const
691
  { return this->have_added_input_section_; }
692
 
693
  // Return true if a section is a debugging section.
694
  static inline bool
695
  is_debug_info_section(const char* name)
696
  {
697
    // Debugging sections can only be recognized by name.
698
    return (strncmp(name, ".debug", sizeof(".debug") - 1) == 0
699
            || strncmp(name, ".zdebug", sizeof(".zdebug") - 1) == 0
700
            || strncmp(name, ".gnu.linkonce.wi.",
701
                       sizeof(".gnu.linkonce.wi.") - 1) == 0
702
            || strncmp(name, ".line", sizeof(".line") - 1) == 0
703
            || strncmp(name, ".stab", sizeof(".stab") - 1) == 0);
704
  }
705
 
706 159 khays
  // Return true if RELOBJ is an input file whose base name matches
707
  // FILE_NAME.  The base name must have an extension of ".o", and
708
  // must be exactly FILE_NAME.o or FILE_NAME, one character, ".o".
709
  static bool
710
  match_file_name(const Relobj* relobj, const char* file_name);
711
 
712
  // Return whether section SHNDX in RELOBJ is a .ctors/.dtors section
713
  // with more than one word being mapped to a .init_array/.fini_array
714
  // section.
715
  bool
716
  is_ctors_in_init_array(Relobj* relobj, unsigned int shndx) const;
717
 
718 27 khays
  // Check if a comdat group or .gnu.linkonce section with the given
719
  // NAME is selected for the link.  If there is already a section,
720
  // *KEPT_SECTION is set to point to the signature and the function
721
  // returns false.  Otherwise, OBJECT, SHNDX,IS_COMDAT, and
722
  // IS_GROUP_NAME are recorded for this NAME in the layout object,
723
  // *KEPT_SECTION is set to the internal copy and the function return
724
  // false.
725
  bool
726
  find_or_add_kept_section(const std::string& name, Relobj* object,
727
                           unsigned int shndx, bool is_comdat,
728
                           bool is_group_name, Kept_section** kept_section);
729
 
730
  // Finalize the layout after all the input sections have been added.
731
  off_t
732
  finalize(const Input_objects*, Symbol_table*, Target*, const Task*);
733
 
734
  // Return whether any sections require postprocessing.
735
  bool
736
  any_postprocessing_sections() const
737
  { return this->any_postprocessing_sections_; }
738
 
739
  // Return the size of the output file.
740
  off_t
741
  output_file_size() const
742
  { return this->output_file_size_; }
743
 
744
  // Return the TLS segment.  This will return NULL if there isn't
745
  // one.
746
  Output_segment*
747
  tls_segment() const
748
  { return this->tls_segment_; }
749
 
750
  // Return the normal symbol table.
751
  Output_section*
752
  symtab_section() const
753
  {
754
    gold_assert(this->symtab_section_ != NULL);
755
    return this->symtab_section_;
756
  }
757
 
758
  // Return the file offset of the normal symbol table.
759
  off_t
760
  symtab_section_offset() const;
761
 
762 159 khays
  // Return the section index of the normal symbol tabl.e
763
  unsigned int
764
  symtab_section_shndx() const;
765
 
766 27 khays
  // Return the dynamic symbol table.
767
  Output_section*
768
  dynsym_section() const
769
  {
770
    gold_assert(this->dynsym_section_ != NULL);
771
    return this->dynsym_section_;
772
  }
773
 
774
  // Return the dynamic tags.
775
  Output_data_dynamic*
776
  dynamic_data() const
777
  { return this->dynamic_data_; }
778
 
779
  // Write out the output sections.
780
  void
781
  write_output_sections(Output_file* of) const;
782
 
783
  // Write out data not associated with an input file or the symbol
784
  // table.
785
  void
786
  write_data(const Symbol_table*, Output_file*) const;
787
 
788
  // Write out output sections which can not be written until all the
789
  // input sections are complete.
790
  void
791
  write_sections_after_input_sections(Output_file* of);
792
 
793
  // Return an output section named NAME, or NULL if there is none.
794
  Output_section*
795
  find_output_section(const char* name) const;
796
 
797
  // Return an output segment of type TYPE, with segment flags SET set
798
  // and segment flags CLEAR clear.  Return NULL if there is none.
799
  Output_segment*
800
  find_output_segment(elfcpp::PT type, elfcpp::Elf_Word set,
801
                      elfcpp::Elf_Word clear) const;
802
 
803
  // Return the number of segments we expect to produce.
804
  size_t
805
  expected_segment_count() const;
806
 
807
  // Set a flag to indicate that an object file uses the static TLS model.
808
  void
809
  set_has_static_tls()
810
  { this->has_static_tls_ = true; }
811
 
812
  // Return true if any object file uses the static TLS model.
813
  bool
814
  has_static_tls() const
815
  { return this->has_static_tls_; }
816
 
817
  // Return the options which may be set by a linker script.
818
  Script_options*
819
  script_options()
820
  { return this->script_options_; }
821
 
822
  const Script_options*
823
  script_options() const
824
  { return this->script_options_; }
825
 
826
  // Return the object managing inputs in incremental build. NULL in
827
  // non-incremental builds.
828
  Incremental_inputs*
829
  incremental_inputs() const
830
  { return this->incremental_inputs_; }
831
 
832
  // For the target-specific code to add dynamic tags which are common
833
  // to most targets.
834
  void
835
  add_target_dynamic_tags(bool use_rel, const Output_data* plt_got,
836
                          const Output_data* plt_rel,
837
                          const Output_data_reloc_generic* dyn_rel,
838
                          bool add_debug, bool dynrel_includes_plt);
839
 
840
  // Compute and write out the build ID if needed.
841
  void
842
  write_build_id(Output_file*) const;
843
 
844
  // Rewrite output file in binary format.
845
  void
846
  write_binary(Output_file* in) const;
847
 
848
  // Print output sections to the map file.
849
  void
850
  print_to_mapfile(Mapfile*) const;
851
 
852
  // Dump statistical information to stderr.
853
  void
854
  print_stats() const;
855
 
856
  // A list of segments.
857
 
858
  typedef std::vector<Output_segment*> Segment_list;
859
 
860
  // A list of sections.
861
 
862
  typedef std::vector<Output_section*> Section_list;
863
 
864
  // The list of information to write out which is not attached to
865
  // either a section or a segment.
866
  typedef std::vector<Output_data*> Data_list;
867
 
868
  // Store the allocated sections into the section list.  This is used
869
  // by the linker script code.
870
  void
871
  get_allocated_sections(Section_list*) const;
872
 
873
  // Make a section for a linker script to hold data.
874
  Output_section*
875
  make_output_section_for_script(const char* name,
876
                                 Script_sections::Section_type section_type);
877
 
878
  // Make a segment.  This is used by the linker script code.
879
  Output_segment*
880
  make_output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags);
881
 
882
  // Return the number of segments.
883
  size_t
884
  segment_count() const
885
  { return this->segment_list_.size(); }
886
 
887
  // Map from section flags to segment flags.
888
  static elfcpp::Elf_Word
889
  section_flags_to_segment(elfcpp::Elf_Xword flags);
890
 
891
  // Attach sections to segments.
892
  void
893
  attach_sections_to_segments();
894
 
895
  // For relaxation clean up, we need to know output section data created
896
  // from a linker script.
897
  void
898
  new_output_section_data_from_script(Output_section_data* posd)
899
  {
900
    if (this->record_output_section_data_from_script_)
901
      this->script_output_section_data_list_.push_back(posd);
902
  }
903
 
904
  // Return section list.
905
  const Section_list&
906
  section_list() const
907
  { return this->section_list_; }
908
 
909
 private:
910
  Layout(const Layout&);
911
  Layout& operator=(const Layout&);
912
 
913
  // Mapping from input section names to output section names.
914
  struct Section_name_mapping
915
  {
916
    const char* from;
917
    int fromlen;
918
    const char* to;
919
    int tolen;
920
  };
921
  static const Section_name_mapping section_name_mapping[];
922
  static const int section_name_mapping_count;
923
 
924
  // During a relocatable link, a list of group sections and
925
  // signatures.
926
  struct Group_signature
927
  {
928
    // The group section.
929
    Output_section* section;
930
    // The signature.
931
    const char* signature;
932
 
933
    Group_signature()
934
      : section(NULL), signature(NULL)
935
    { }
936
 
937
    Group_signature(Output_section* sectiona, const char* signaturea)
938
      : section(sectiona), signature(signaturea)
939
    { }
940
  };
941
  typedef std::vector<Group_signature> Group_signatures;
942
 
943
  // Create a note section, filling in the header.
944
  Output_section*
945
  create_note(const char* name, int note_type, const char* section_name,
946
              size_t descsz, bool allocate, size_t* trailing_padding);
947
 
948
  // Create a note section for gold version.
949
  void
950
  create_gold_note();
951
 
952
  // Record whether the stack must be executable.
953
  void
954
  create_executable_stack_info();
955
 
956
  // Create a build ID note if needed.
957
  void
958
  create_build_id();
959
 
960
  // Link .stab and .stabstr sections.
961
  void
962
  link_stabs_sections();
963
 
964
  // Create .gnu_incremental_inputs and .gnu_incremental_strtab sections needed
965
  // for the next run of incremental linking to check what has changed.
966
  void
967
  create_incremental_info_sections(Symbol_table*);
968
 
969
  // Find the first read-only PT_LOAD segment, creating one if
970
  // necessary.
971
  Output_segment*
972
  find_first_load_seg();
973
 
974
  // Count the local symbols in the regular symbol table and the dynamic
975
  // symbol table, and build the respective string pools.
976
  void
977
  count_local_symbols(const Task*, const Input_objects*);
978
 
979
  // Create the output sections for the symbol table.
980
  void
981
  create_symtab_sections(const Input_objects*, Symbol_table*,
982
                         unsigned int, off_t*);
983
 
984
  // Create the .shstrtab section.
985
  Output_section*
986
  create_shstrtab();
987
 
988
  // Create the section header table.
989
  void
990
  create_shdrs(const Output_section* shstrtab_section, off_t*);
991
 
992
  // Create the dynamic symbol table.
993
  void
994
  create_dynamic_symtab(const Input_objects*, Symbol_table*,
995
                        Output_section** pdynstr,
996
                        unsigned int* plocal_dynamic_count,
997
                        std::vector<Symbol*>* pdynamic_symbols,
998
                        Versions* versions);
999
 
1000
  // Assign offsets to each local portion of the dynamic symbol table.
1001
  void
1002
  assign_local_dynsym_offsets(const Input_objects*);
1003
 
1004
  // Finish the .dynamic section and PT_DYNAMIC segment.
1005
  void
1006
  finish_dynamic_section(const Input_objects*, const Symbol_table*);
1007
 
1008
  // Set the size of the _DYNAMIC symbol.
1009
  void
1010
  set_dynamic_symbol_size(const Symbol_table*);
1011
 
1012
  // Create the .interp section and PT_INTERP segment.
1013
  void
1014
  create_interp(const Target* target);
1015
 
1016
  // Create the version sections.
1017
  void
1018
  create_version_sections(const Versions*,
1019
                          const Symbol_table*,
1020
                          unsigned int local_symcount,
1021
                          const std::vector<Symbol*>& dynamic_symbols,
1022
                          const Output_section* dynstr);
1023
 
1024
  template<int size, bool big_endian>
1025
  void
1026
  sized_create_version_sections(const Versions* versions,
1027
                                const Symbol_table*,
1028
                                unsigned int local_symcount,
1029
                                const std::vector<Symbol*>& dynamic_symbols,
1030
                                const Output_section* dynstr);
1031
 
1032
  // Return whether to include this section in the link.
1033
  template<int size, bool big_endian>
1034
  bool
1035
  include_section(Sized_relobj_file<size, big_endian>* object, const char* name,
1036
                  const elfcpp::Shdr<size, big_endian>&);
1037
 
1038
  // Return the output section name to use given an input section
1039
  // name.  Set *PLEN to the length of the name.  *PLEN must be
1040
  // initialized to the length of NAME.
1041
  static const char*
1042 159 khays
  output_section_name(const Relobj*, const char* name, size_t* plen);
1043 27 khays
 
1044
  // Return the number of allocated output sections.
1045
  size_t
1046
  allocated_output_section_count() const;
1047
 
1048
  // Return the output section for NAME, TYPE and FLAGS.
1049
  Output_section*
1050
  get_output_section(const char* name, Stringpool::Key name_key,
1051
                     elfcpp::Elf_Word type, elfcpp::Elf_Xword flags,
1052
                     Output_section_order order, bool is_relro);
1053
 
1054
  // Choose the output section for NAME in RELOBJ.
1055
  Output_section*
1056
  choose_output_section(const Relobj* relobj, const char* name,
1057
                        elfcpp::Elf_Word type, elfcpp::Elf_Xword flags,
1058
                        bool is_input_section, Output_section_order order,
1059
                        bool is_relro);
1060
 
1061
  // Create a new Output_section.
1062
  Output_section*
1063
  make_output_section(const char* name, elfcpp::Elf_Word type,
1064
                      elfcpp::Elf_Xword flags, Output_section_order order,
1065
                      bool is_relro);
1066
 
1067
  // Attach a section to a segment.
1068
  void
1069
  attach_section_to_segment(Output_section*);
1070
 
1071
  // Get section order.
1072
  Output_section_order
1073
  default_section_order(Output_section*, bool is_relro_local);
1074
 
1075
  // Attach an allocated section to a segment.
1076
  void
1077
  attach_allocated_section_to_segment(Output_section*);
1078
 
1079 159 khays
  // Make the .eh_frame section.
1080
  Output_section*
1081
  make_eh_frame_section(const Relobj*);
1082
 
1083 27 khays
  // Set the final file offsets of all the segments.
1084
  off_t
1085
  set_segment_offsets(const Target*, Output_segment*, unsigned int* pshndx);
1086
 
1087
  // Set the file offsets of the sections when doing a relocatable
1088
  // link.
1089
  off_t
1090
  set_relocatable_section_offsets(Output_data*, unsigned int* pshndx);
1091
 
1092
  // Set the final file offsets of all the sections not associated
1093
  // with a segment.  We set section offsets in three passes: the
1094
  // first handles all allocated sections, the second sections that
1095
  // require postprocessing, and the last the late-bound STRTAB
1096
  // sections (probably only shstrtab, which is the one we care about
1097
  // because it holds section names).
1098
  enum Section_offset_pass
1099
  {
1100
    BEFORE_INPUT_SECTIONS_PASS,
1101
    POSTPROCESSING_SECTIONS_PASS,
1102
    STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS
1103
  };
1104
  off_t
1105
  set_section_offsets(off_t, Section_offset_pass pass);
1106
 
1107
  // Set the final section indexes of all the sections not associated
1108
  // with a segment.  Returns the next unused index.
1109
  unsigned int
1110
  set_section_indexes(unsigned int pshndx);
1111
 
1112
  // Set the section addresses when using a script.
1113
  Output_segment*
1114
  set_section_addresses_from_script(Symbol_table*);
1115
 
1116
  // Find appropriate places or orphan sections in a script.
1117
  void
1118
  place_orphan_sections_in_script();
1119
 
1120
  // Return whether SEG1 comes before SEG2 in the output file.
1121 159 khays
  bool
1122 27 khays
  segment_precedes(const Output_segment* seg1, const Output_segment* seg2);
1123
 
1124
  // Use to save and restore segments during relaxation. 
1125
  typedef Unordered_map<const Output_segment*, const Output_segment*>
1126
    Segment_states;
1127
 
1128
  // Save states of current output segments.
1129
  void
1130
  save_segments(Segment_states*);
1131
 
1132
  // Restore output segment states.
1133
  void
1134
  restore_segments(const Segment_states*);
1135
 
1136
  // Clean up after relaxation so that it is possible to lay out the
1137
  // sections and segments again.
1138
  void
1139
  clean_up_after_relaxation();
1140
 
1141
  // Doing preparation work for relaxation.  This is factored out to make
1142
  // Layout::finalized a bit smaller and easier to read.
1143
  void
1144
  prepare_for_relaxation();
1145
 
1146
  // Main body of the relaxation loop, which lays out the section.
1147
  off_t
1148
  relaxation_loop_body(int, Target*, Symbol_table*, Output_segment**,
1149
                       Output_segment*, Output_segment_headers*,
1150
                       Output_file_header*, unsigned int*);
1151
 
1152
  // A mapping used for kept comdats/.gnu.linkonce group signatures.
1153
  typedef Unordered_map<std::string, Kept_section> Signatures;
1154
 
1155
  // Mapping from input section name/type/flags to output section.  We
1156
  // use canonicalized strings here.
1157
 
1158
  typedef std::pair<Stringpool::Key,
1159
                    std::pair<elfcpp::Elf_Word, elfcpp::Elf_Xword> > Key;
1160
 
1161
  struct Hash_key
1162
  {
1163
    size_t
1164
    operator()(const Key& k) const;
1165
  };
1166
 
1167
  typedef Unordered_map<Key, Output_section*, Hash_key> Section_name_map;
1168
 
1169
  // A comparison class for segments.
1170
 
1171 159 khays
  class Compare_segments
1172 27 khays
  {
1173 159 khays
   public:
1174
    Compare_segments(Layout* layout)
1175
      : layout_(layout)
1176
    { }
1177
 
1178 27 khays
    bool
1179
    operator()(const Output_segment* seg1, const Output_segment* seg2)
1180 159 khays
    { return this->layout_->segment_precedes(seg1, seg2); }
1181
 
1182
   private:
1183
    Layout* layout_;
1184 27 khays
  };
1185
 
1186
  typedef std::vector<Output_section_data*> Output_section_data_list;
1187
 
1188
  // Debug checker class.
1189
  class Relaxation_debug_check
1190
  {
1191
   public:
1192
    Relaxation_debug_check()
1193
      : section_infos_()
1194
    { }
1195
 
1196
    // Check that sections and special data are in reset states.
1197
    void
1198
    check_output_data_for_reset_values(const Layout::Section_list&,
1199
                                       const Layout::Data_list&);
1200
 
1201
    // Record information of a section list.
1202
    void
1203
    read_sections(const Layout::Section_list&);
1204
 
1205
    // Verify a section list with recorded information.
1206
    void
1207
    verify_sections(const Layout::Section_list&);
1208
 
1209
   private:
1210
    // Information we care about a section.
1211
    struct Section_info
1212
    {
1213
      // Output section described by this.
1214
      Output_section* output_section;
1215
      // Load address.
1216
      uint64_t address;
1217
      // Data size.
1218
      off_t data_size;
1219
      // File offset.
1220
      off_t offset;
1221
    };
1222
 
1223
    // Section information.
1224
    std::vector<Section_info> section_infos_;
1225
  };
1226
 
1227
  // The number of input files, for sizing tables.
1228
  int number_of_input_files_;
1229
  // Information set by scripts or by command line options.
1230
  Script_options* script_options_;
1231
  // The output section names.
1232
  Stringpool namepool_;
1233
  // The output symbol names.
1234
  Stringpool sympool_;
1235
  // The dynamic strings, if needed.
1236
  Stringpool dynpool_;
1237
  // The list of group sections and linkonce sections which we have seen.
1238
  Signatures signatures_;
1239
  // The mapping from input section name/type/flags to output sections.
1240
  Section_name_map section_name_map_;
1241
  // The list of output segments.
1242
  Segment_list segment_list_;
1243
  // The list of output sections.
1244
  Section_list section_list_;
1245
  // The list of output sections which are not attached to any output
1246
  // segment.
1247
  Section_list unattached_section_list_;
1248
  // The list of unattached Output_data objects which require special
1249
  // handling because they are not Output_sections.
1250
  Data_list special_output_list_;
1251
  // The section headers.
1252
  Output_section_headers* section_headers_;
1253
  // A pointer to the PT_TLS segment if there is one.
1254
  Output_segment* tls_segment_;
1255
  // A pointer to the PT_GNU_RELRO segment if there is one.
1256
  Output_segment* relro_segment_;
1257 159 khays
  // A pointer to the PT_INTERP segment if there is one.
1258
  Output_segment* interp_segment_;
1259 27 khays
  // A backend may increase the size of the PT_GNU_RELRO segment if
1260
  // there is one.  This is the amount to increase it by.
1261
  unsigned int increase_relro_;
1262
  // The SHT_SYMTAB output section.
1263
  Output_section* symtab_section_;
1264
  // The SHT_SYMTAB_SHNDX for the regular symbol table if there is one.
1265
  Output_symtab_xindex* symtab_xindex_;
1266
  // The SHT_DYNSYM output section if there is one.
1267
  Output_section* dynsym_section_;
1268
  // The SHT_SYMTAB_SHNDX for the dynamic symbol table if there is one.
1269
  Output_symtab_xindex* dynsym_xindex_;
1270
  // The SHT_DYNAMIC output section if there is one.
1271
  Output_section* dynamic_section_;
1272
  // The _DYNAMIC symbol if there is one.
1273
  Symbol* dynamic_symbol_;
1274
  // The dynamic data which goes into dynamic_section_.
1275
  Output_data_dynamic* dynamic_data_;
1276
  // The exception frame output section if there is one.
1277
  Output_section* eh_frame_section_;
1278
  // The exception frame data for eh_frame_section_.
1279
  Eh_frame* eh_frame_data_;
1280
  // Whether we have added eh_frame_data_ to the .eh_frame section.
1281
  bool added_eh_frame_data_;
1282
  // The exception frame header output section if there is one.
1283
  Output_section* eh_frame_hdr_section_;
1284
  // The space for the build ID checksum if there is one.
1285
  Output_section_data* build_id_note_;
1286
  // The output section containing dwarf abbreviations
1287
  Output_reduced_debug_abbrev_section* debug_abbrev_;
1288
  // The output section containing the dwarf debug info tree
1289
  Output_reduced_debug_info_section* debug_info_;
1290
  // A list of group sections and their signatures.
1291
  Group_signatures group_signatures_;
1292
  // The size of the output file.
1293
  off_t output_file_size_;
1294
  // Whether we have added an input section to an output section.
1295
  bool have_added_input_section_;
1296
  // Whether we have attached the sections to the segments.
1297
  bool sections_are_attached_;
1298
  // Whether we have seen an object file marked to require an
1299
  // executable stack.
1300
  bool input_requires_executable_stack_;
1301
  // Whether we have seen at least one object file with an executable
1302
  // stack marker.
1303
  bool input_with_gnu_stack_note_;
1304
  // Whether we have seen at least one object file without an
1305
  // executable stack marker.
1306
  bool input_without_gnu_stack_note_;
1307
  // Whether we have seen an object file that uses the static TLS model.
1308
  bool has_static_tls_;
1309
  // Whether any sections require postprocessing.
1310
  bool any_postprocessing_sections_;
1311
  // Whether we have resized the signatures_ hash table.
1312
  bool resized_signatures_;
1313
  // Whether we have created a .stab*str output section.
1314
  bool have_stabstr_section_;
1315 159 khays
  // True if the input sections in the output sections should be sorted
1316
  // as specified in a section ordering file.
1317
  bool section_ordering_specified_;
1318 27 khays
  // In incremental build, holds information check the inputs and build the
1319
  // .gnu_incremental_inputs section.
1320
  Incremental_inputs* incremental_inputs_;
1321
  // Whether we record output section data created in script
1322
  bool record_output_section_data_from_script_;
1323
  // List of output data that needs to be removed at relaxation clean up.
1324
  Output_section_data_list script_output_section_data_list_;
1325
  // Structure to save segment states before entering the relaxation loop.
1326
  Segment_states* segment_states_;
1327
  // A relaxation debug checker.  We only create one when in debugging mode.
1328
  Relaxation_debug_check* relaxation_debug_check_;
1329 163 khays
  // Plugins specify section_ordering using this map.  This is set in
1330
  // update_section_order in plugin.cc
1331
  std::map<Section_id, unsigned int> section_order_map_;
1332 27 khays
  // Hash a pattern to its position in the section ordering file.
1333
  Unordered_map<std::string, unsigned int> input_section_position_;
1334
  // Vector of glob only patterns in the section_ordering file.
1335
  std::vector<std::string> input_section_glob_;
1336
  // For incremental links, the base file to be modified.
1337
  Incremental_binary* incremental_base_;
1338
  // For incremental links, a list of free space within the file.
1339
  Free_list free_list_;
1340
};
1341
 
1342
// This task handles writing out data in output sections which is not
1343
// part of an input section, or which requires special handling.  When
1344
// this is done, it unblocks both output_sections_blocker and
1345
// final_blocker.
1346
 
1347
class Write_sections_task : public Task
1348
{
1349
 public:
1350
  Write_sections_task(const Layout* layout, Output_file* of,
1351
                      Task_token* output_sections_blocker,
1352
                      Task_token* final_blocker)
1353
    : layout_(layout), of_(of),
1354
      output_sections_blocker_(output_sections_blocker),
1355
      final_blocker_(final_blocker)
1356
  { }
1357
 
1358
  // The standard Task methods.
1359
 
1360
  Task_token*
1361
  is_runnable();
1362
 
1363
  void
1364
  locks(Task_locker*);
1365
 
1366
  void
1367
  run(Workqueue*);
1368
 
1369
  std::string
1370
  get_name() const
1371
  { return "Write_sections_task"; }
1372
 
1373
 private:
1374
  class Write_sections_locker;
1375
 
1376
  const Layout* layout_;
1377
  Output_file* of_;
1378
  Task_token* output_sections_blocker_;
1379
  Task_token* final_blocker_;
1380
};
1381
 
1382
// This task handles writing out data which is not part of a section
1383
// or segment.
1384
 
1385
class Write_data_task : public Task
1386
{
1387
 public:
1388
  Write_data_task(const Layout* layout, const Symbol_table* symtab,
1389
                  Output_file* of, Task_token* final_blocker)
1390
    : layout_(layout), symtab_(symtab), of_(of), final_blocker_(final_blocker)
1391
  { }
1392
 
1393
  // The standard Task methods.
1394
 
1395
  Task_token*
1396
  is_runnable();
1397
 
1398
  void
1399
  locks(Task_locker*);
1400
 
1401
  void
1402
  run(Workqueue*);
1403
 
1404
  std::string
1405
  get_name() const
1406
  { return "Write_data_task"; }
1407
 
1408
 private:
1409
  const Layout* layout_;
1410
  const Symbol_table* symtab_;
1411
  Output_file* of_;
1412
  Task_token* final_blocker_;
1413
};
1414
 
1415
// This task handles writing out the global symbols.
1416
 
1417
class Write_symbols_task : public Task
1418
{
1419
 public:
1420
  Write_symbols_task(const Layout* layout, const Symbol_table* symtab,
1421
                     const Input_objects* input_objects,
1422
                     const Stringpool* sympool, const Stringpool* dynpool,
1423
                     Output_file* of, Task_token* final_blocker)
1424
    : layout_(layout), symtab_(symtab), input_objects_(input_objects),
1425
      sympool_(sympool), dynpool_(dynpool), of_(of),
1426
      final_blocker_(final_blocker)
1427
  { }
1428
 
1429
  // The standard Task methods.
1430
 
1431
  Task_token*
1432
  is_runnable();
1433
 
1434
  void
1435
  locks(Task_locker*);
1436
 
1437
  void
1438
  run(Workqueue*);
1439
 
1440
  std::string
1441
  get_name() const
1442
  { return "Write_symbols_task"; }
1443
 
1444
 private:
1445
  const Layout* layout_;
1446
  const Symbol_table* symtab_;
1447
  const Input_objects* input_objects_;
1448
  const Stringpool* sympool_;
1449
  const Stringpool* dynpool_;
1450
  Output_file* of_;
1451
  Task_token* final_blocker_;
1452
};
1453
 
1454
// This task handles writing out data in output sections which can't
1455
// be written out until all the input sections have been handled.
1456
// This is for sections whose contents is based on the contents of
1457
// other output sections.
1458
 
1459
class Write_after_input_sections_task : public Task
1460
{
1461
 public:
1462
  Write_after_input_sections_task(Layout* layout, Output_file* of,
1463
                                  Task_token* input_sections_blocker,
1464
                                  Task_token* final_blocker)
1465
    : layout_(layout), of_(of),
1466
      input_sections_blocker_(input_sections_blocker),
1467
      final_blocker_(final_blocker)
1468
  { }
1469
 
1470
  // The standard Task methods.
1471
 
1472
  Task_token*
1473
  is_runnable();
1474
 
1475
  void
1476
  locks(Task_locker*);
1477
 
1478
  void
1479
  run(Workqueue*);
1480
 
1481
  std::string
1482
  get_name() const
1483
  { return "Write_after_input_sections_task"; }
1484
 
1485
 private:
1486
  Layout* layout_;
1487
  Output_file* of_;
1488
  Task_token* input_sections_blocker_;
1489
  Task_token* final_blocker_;
1490
};
1491
 
1492
// This task function handles closing the file.
1493
 
1494
class Close_task_runner : public Task_function_runner
1495
{
1496
 public:
1497
  Close_task_runner(const General_options* options, const Layout* layout,
1498
                    Output_file* of)
1499
    : options_(options), layout_(layout), of_(of)
1500
  { }
1501
 
1502
  // Run the operation.
1503
  void
1504
  run(Workqueue*, const Task*);
1505
 
1506
 private:
1507
  const General_options* options_;
1508
  const Layout* layout_;
1509
  Output_file* of_;
1510
};
1511
 
1512
// A small helper function to align an address.
1513
 
1514
inline uint64_t
1515
align_address(uint64_t address, uint64_t addralign)
1516
{
1517
  if (addralign != 0)
1518
    address = (address + addralign - 1) &~ (addralign - 1);
1519
  return address;
1520
}
1521
 
1522
} // End namespace gold.
1523
 
1524
#endif // !defined(GOLD_LAYOUT_H)

powered by: WebSVN 2.1.0

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