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