*** empty log message ***
[deliverable/binutils-gdb.git] / gold / layout.cc
CommitLineData
a2fb1b05
ILT
1// layout.cc -- lay out output file sections for gold
2
e5756efb 3// Copyright 2006, 2007, 2008 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#include "gold.h"
24
8ed814a9 25#include <cerrno>
a2fb1b05 26#include <cstring>
54dc6425 27#include <algorithm>
a2fb1b05
ILT
28#include <iostream>
29#include <utility>
8ed814a9
ILT
30#include <fcntl.h>
31#include <unistd.h>
32#include "libiberty.h"
33#include "md5.h"
34#include "sha1.h"
a2fb1b05 35
7e1edb90 36#include "parameters.h"
14144f39 37#include "options.h"
7d9e3d98 38#include "mapfile.h"
a445fddf
ILT
39#include "script.h"
40#include "script-sections.h"
a2fb1b05 41#include "output.h"
f6ce93d6 42#include "symtab.h"
a3ad94ed 43#include "dynobj.h"
3151305a 44#include "ehframe.h"
96803768 45#include "compressed_output.h"
62b01cb5 46#include "reduced_debug_output.h"
6a74a719 47#include "reloc.h"
a2fb1b05
ILT
48#include "layout.h"
49
50namespace gold
51{
52
92e059d8 53// Layout_task_runner methods.
a2fb1b05
ILT
54
55// Lay out the sections. This is called after all the input objects
56// have been read.
57
58void
17a1d0a9 59Layout_task_runner::run(Workqueue* workqueue, const Task* task)
a2fb1b05 60{
12e14209 61 off_t file_size = this->layout_->finalize(this->input_objects_,
17a1d0a9 62 this->symtab_,
8851ecca 63 this->target_,
17a1d0a9 64 task);
61ba1cf9
ILT
65
66 // Now we know the final size of the output file and we know where
67 // each piece of information goes.
7d9e3d98
ILT
68
69 if (this->mapfile_ != NULL)
70 {
71 this->mapfile_->print_discarded_sections(this->input_objects_);
72 this->layout_->print_to_mapfile(this->mapfile_);
73 }
74
8851ecca 75 Output_file* of = new Output_file(parameters->options().output_file_name());
7cc619c3 76 if (this->options_.oformat_enum() != General_options::OBJECT_FORMAT_ELF)
516cb3d0 77 of->set_is_temporary();
61ba1cf9
ILT
78 of->open(file_size);
79
80 // Queue up the final set of tasks.
81 gold::queue_final_tasks(this->options_, this->input_objects_,
12e14209 82 this->symtab_, this->layout_, workqueue, of);
a2fb1b05
ILT
83}
84
85// Layout methods.
86
e5756efb 87Layout::Layout(const General_options& options, Script_options* script_options)
d491d34e
ILT
88 : options_(options),
89 script_options_(script_options),
90 namepool_(),
91 sympool_(),
92 dynpool_(),
93 signatures_(),
94 section_name_map_(),
95 segment_list_(),
96 section_list_(),
97 unattached_section_list_(),
98 sections_are_attached_(false),
99 special_output_list_(),
100 section_headers_(NULL),
101 tls_segment_(NULL),
9f1d377b 102 relro_segment_(NULL),
d491d34e
ILT
103 symtab_section_(NULL),
104 symtab_xindex_(NULL),
105 dynsym_section_(NULL),
106 dynsym_xindex_(NULL),
107 dynamic_section_(NULL),
108 dynamic_data_(NULL),
109 eh_frame_section_(NULL),
110 eh_frame_data_(NULL),
111 added_eh_frame_data_(false),
112 eh_frame_hdr_section_(NULL),
113 build_id_note_(NULL),
62b01cb5
ILT
114 debug_abbrev_(NULL),
115 debug_info_(NULL),
d491d34e
ILT
116 group_signatures_(),
117 output_file_size_(-1),
35cdfc9a
ILT
118 input_requires_executable_stack_(false),
119 input_with_gnu_stack_note_(false),
535890bb 120 input_without_gnu_stack_note_(false),
17a1d0a9
ILT
121 has_static_tls_(false),
122 any_postprocessing_sections_(false)
54dc6425
ILT
123{
124 // Make space for more than enough segments for a typical file.
125 // This is just for efficiency--it's OK if we wind up needing more.
a3ad94ed
ILT
126 this->segment_list_.reserve(12);
127
27bc2bce
ILT
128 // We expect two unattached Output_data objects: the file header and
129 // the segment headers.
130 this->special_output_list_.reserve(2);
54dc6425
ILT
131}
132
a2fb1b05
ILT
133// Hash a key we use to look up an output section mapping.
134
135size_t
136Layout::Hash_key::operator()(const Layout::Key& k) const
137{
f0641a0b 138 return k.first + k.second.first + k.second.second;
a2fb1b05
ILT
139}
140
9e2dcb77
ILT
141// Return whether PREFIX is a prefix of STR.
142
143static inline bool
144is_prefix_of(const char* prefix, const char* str)
145{
146 return strncmp(prefix, str, strlen(prefix)) == 0;
147}
148
02d2ba74
ILT
149// Returns whether the given section is in the list of
150// debug-sections-used-by-some-version-of-gdb. Currently,
151// we've checked versions of gdb up to and including 6.7.1.
152
153static const char* gdb_sections[] =
154{ ".debug_abbrev",
155 // ".debug_aranges", // not used by gdb as of 6.7.1
156 ".debug_frame",
157 ".debug_info",
158 ".debug_line",
159 ".debug_loc",
160 ".debug_macinfo",
161 // ".debug_pubnames", // not used by gdb as of 6.7.1
162 ".debug_ranges",
163 ".debug_str",
164};
165
62b01cb5
ILT
166static const char* lines_only_debug_sections[] =
167{ ".debug_abbrev",
168 // ".debug_aranges", // not used by gdb as of 6.7.1
169 // ".debug_frame",
170 ".debug_info",
171 ".debug_line",
172 // ".debug_loc",
173 // ".debug_macinfo",
174 // ".debug_pubnames", // not used by gdb as of 6.7.1
175 // ".debug_ranges",
176 ".debug_str",
177};
178
02d2ba74
ILT
179static inline bool
180is_gdb_debug_section(const char* str)
181{
182 // We can do this faster: binary search or a hashtable. But why bother?
183 for (size_t i = 0; i < sizeof(gdb_sections)/sizeof(*gdb_sections); ++i)
184 if (strcmp(str, gdb_sections[i]) == 0)
185 return true;
186 return false;
187}
188
62b01cb5
ILT
189static inline bool
190is_lines_only_debug_section(const char* str)
191{
192 // We can do this faster: binary search or a hashtable. But why bother?
193 for (size_t i = 0;
194 i < sizeof(lines_only_debug_sections)/sizeof(*lines_only_debug_sections);
195 ++i)
196 if (strcmp(str, lines_only_debug_sections[i]) == 0)
197 return true;
198 return false;
199}
200
a2fb1b05
ILT
201// Whether to include this section in the link.
202
203template<int size, bool big_endian>
204bool
730cdc88 205Layout::include_section(Sized_relobj<size, big_endian>*, const char* name,
a2fb1b05
ILT
206 const elfcpp::Shdr<size, big_endian>& shdr)
207{
a2fb1b05
ILT
208 switch (shdr.get_sh_type())
209 {
210 case elfcpp::SHT_NULL:
211 case elfcpp::SHT_SYMTAB:
212 case elfcpp::SHT_DYNSYM:
a2fb1b05
ILT
213 case elfcpp::SHT_HASH:
214 case elfcpp::SHT_DYNAMIC:
215 case elfcpp::SHT_SYMTAB_SHNDX:
216 return false;
217
5cb66f97
ILT
218 case elfcpp::SHT_STRTAB:
219 // Discard the sections which have special meanings in the ELF
220 // ABI. Keep others (e.g., .stabstr). We could also do this by
221 // checking the sh_link fields of the appropriate sections.
222 return (strcmp(name, ".dynstr") != 0
223 && strcmp(name, ".strtab") != 0
224 && strcmp(name, ".shstrtab") != 0);
225
a2fb1b05
ILT
226 case elfcpp::SHT_RELA:
227 case elfcpp::SHT_REL:
228 case elfcpp::SHT_GROUP:
7019cd25
ILT
229 // If we are emitting relocations these should be handled
230 // elsewhere.
8851ecca
ILT
231 gold_assert(!parameters->options().relocatable()
232 && !parameters->options().emit_relocs());
6a74a719 233 return false;
a2fb1b05 234
9e2dcb77 235 case elfcpp::SHT_PROGBITS:
8851ecca 236 if (parameters->options().strip_debug()
9e2dcb77
ILT
237 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
238 {
e94cf127 239 if (is_debug_info_section(name))
9e2dcb77
ILT
240 return false;
241 }
62b01cb5
ILT
242 if (parameters->options().strip_debug_non_line()
243 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
244 {
245 // Debugging sections can only be recognized by name.
246 if (is_prefix_of(".debug", name)
247 && !is_lines_only_debug_section(name))
248 return false;
249 }
8851ecca 250 if (parameters->options().strip_debug_gdb()
02d2ba74
ILT
251 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
252 {
253 // Debugging sections can only be recognized by name.
254 if (is_prefix_of(".debug", name)
255 && !is_gdb_debug_section(name))
256 return false;
257 }
9e2dcb77
ILT
258 return true;
259
a2fb1b05 260 default:
a2fb1b05
ILT
261 return true;
262 }
263}
264
ead1e424 265// Return an output section named NAME, or NULL if there is none.
a2fb1b05 266
a2fb1b05 267Output_section*
ead1e424 268Layout::find_output_section(const char* name) const
a2fb1b05 269{
a445fddf
ILT
270 for (Section_list::const_iterator p = this->section_list_.begin();
271 p != this->section_list_.end();
ead1e424 272 ++p)
a445fddf
ILT
273 if (strcmp((*p)->name(), name) == 0)
274 return *p;
ead1e424
ILT
275 return NULL;
276}
a2fb1b05 277
ead1e424
ILT
278// Return an output segment of type TYPE, with segment flags SET set
279// and segment flags CLEAR clear. Return NULL if there is none.
a2fb1b05 280
ead1e424
ILT
281Output_segment*
282Layout::find_output_segment(elfcpp::PT type, elfcpp::Elf_Word set,
283 elfcpp::Elf_Word clear) const
284{
285 for (Segment_list::const_iterator p = this->segment_list_.begin();
286 p != this->segment_list_.end();
287 ++p)
288 if (static_cast<elfcpp::PT>((*p)->type()) == type
289 && ((*p)->flags() & set) == set
290 && ((*p)->flags() & clear) == 0)
291 return *p;
292 return NULL;
293}
a2fb1b05 294
ead1e424 295// Return the output section to use for section NAME with type TYPE
a445fddf
ILT
296// and section flags FLAGS. NAME must be canonicalized in the string
297// pool, and NAME_KEY is the key.
a2fb1b05 298
ead1e424 299Output_section*
f0641a0b
ILT
300Layout::get_output_section(const char* name, Stringpool::Key name_key,
301 elfcpp::Elf_Word type, elfcpp::Elf_Xword flags)
ead1e424 302{
154e0e9a
ILT
303 elfcpp::Elf_Xword lookup_flags = flags;
304
305 // Ignoring SHF_WRITE and SHF_EXECINSTR here means that we combine
306 // read-write with read-only sections. Some other ELF linkers do
307 // not do this. FIXME: Perhaps there should be an option
308 // controlling this.
309 lookup_flags &= ~(elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR);
310
311 const Key key(name_key, std::make_pair(type, lookup_flags));
a2fb1b05
ILT
312 const std::pair<Key, Output_section*> v(key, NULL);
313 std::pair<Section_name_map::iterator, bool> ins(
314 this->section_name_map_.insert(v));
315
a2fb1b05 316 if (!ins.second)
ead1e424 317 return ins.first->second;
a2fb1b05
ILT
318 else
319 {
320 // This is the first time we've seen this name/type/flags
4e2b1697
ILT
321 // combination. For compatibility with the GNU linker, we
322 // combine sections with contents and zero flags with sections
323 // with non-zero flags. This is a workaround for cases where
324 // assembler code forgets to set section flags. FIXME: Perhaps
325 // there should be an option to control this.
15cf077e 326 Output_section* os = NULL;
4e2b1697
ILT
327
328 if (type == elfcpp::SHT_PROGBITS)
15cf077e 329 {
4e2b1697
ILT
330 if (flags == 0)
331 {
332 Output_section* same_name = this->find_output_section(name);
333 if (same_name != NULL
334 && same_name->type() == elfcpp::SHT_PROGBITS
335 && (same_name->flags() & elfcpp::SHF_TLS) == 0)
336 os = same_name;
337 }
338 else if ((flags & elfcpp::SHF_TLS) == 0)
339 {
340 elfcpp::Elf_Xword zero_flags = 0;
341 const Key zero_key(name_key, std::make_pair(type, zero_flags));
342 Section_name_map::iterator p =
343 this->section_name_map_.find(zero_key);
344 if (p != this->section_name_map_.end())
154e0e9a 345 os = p->second;
4e2b1697 346 }
15cf077e 347 }
4e2b1697 348
15cf077e
ILT
349 if (os == NULL)
350 os = this->make_output_section(name, type, flags);
a2fb1b05 351 ins.first->second = os;
ead1e424 352 return os;
a2fb1b05 353 }
ead1e424
ILT
354}
355
a445fddf
ILT
356// Pick the output section to use for section NAME, in input file
357// RELOBJ, with type TYPE and flags FLAGS. RELOBJ may be NULL for a
154e0e9a
ILT
358// linker created section. IS_INPUT_SECTION is true if we are
359// choosing an output section for an input section found in a input
360// file. This will return NULL if the input section should be
361// discarded.
a445fddf
ILT
362
363Output_section*
364Layout::choose_output_section(const Relobj* relobj, const char* name,
365 elfcpp::Elf_Word type, elfcpp::Elf_Xword flags,
154e0e9a 366 bool is_input_section)
a445fddf 367{
154e0e9a
ILT
368 // We should not see any input sections after we have attached
369 // sections to segments.
370 gold_assert(!is_input_section || !this->sections_are_attached_);
371
372 // Some flags in the input section should not be automatically
373 // copied to the output section.
a445fddf
ILT
374 flags &= ~ (elfcpp::SHF_INFO_LINK
375 | elfcpp::SHF_LINK_ORDER
376 | elfcpp::SHF_GROUP
377 | elfcpp::SHF_MERGE
378 | elfcpp::SHF_STRINGS);
379
380 if (this->script_options_->saw_sections_clause())
381 {
382 // We are using a SECTIONS clause, so the output section is
383 // chosen based only on the name.
384
385 Script_sections* ss = this->script_options_->script_sections();
386 const char* file_name = relobj == NULL ? NULL : relobj->name().c_str();
387 Output_section** output_section_slot;
388 name = ss->output_section_name(file_name, name, &output_section_slot);
389 if (name == NULL)
390 {
391 // The SECTIONS clause says to discard this input section.
392 return NULL;
393 }
394
395 // If this is an orphan section--one not mentioned in the linker
396 // script--then OUTPUT_SECTION_SLOT will be NULL, and we do the
397 // default processing below.
398
399 if (output_section_slot != NULL)
400 {
401 if (*output_section_slot != NULL)
154e0e9a 402 return *output_section_slot;
a445fddf
ILT
403
404 // We don't put sections found in the linker script into
405 // SECTION_NAME_MAP_. That keeps us from getting confused
406 // if an orphan section is mapped to a section with the same
407 // name as one in the linker script.
408
409 name = this->namepool_.add(name, false, NULL);
410
411 Output_section* os = this->make_output_section(name, type, flags);
412 os->set_found_in_sections_clause();
413 *output_section_slot = os;
414 return os;
415 }
416 }
417
418 // FIXME: Handle SHF_OS_NONCONFORMING somewhere.
419
420 // Turn NAME from the name of the input section into the name of the
421 // output section.
422
423 size_t len = strlen(name);
154e0e9a 424 if (is_input_section && !parameters->options().relocatable())
a445fddf
ILT
425 name = Layout::output_section_name(name, &len);
426
427 Stringpool::Key name_key;
428 name = this->namepool_.add_with_length(name, len, true, &name_key);
429
430 // Find or make the output section. The output section is selected
431 // based on the section name, type, and flags.
432 return this->get_output_section(name, name_key, type, flags);
433}
434
ead1e424 435// Return the output section to use for input section SHNDX, with name
730cdc88
ILT
436// NAME, with header HEADER, from object OBJECT. RELOC_SHNDX is the
437// index of a relocation section which applies to this section, or 0
438// if none, or -1U if more than one. RELOC_TYPE is the type of the
439// relocation section if there is one. Set *OFF to the offset of this
440// input section without the output section. Return NULL if the
441// section should be discarded. Set *OFF to -1 if the section
442// contents should not be written directly to the output file, but
443// will instead receive special handling.
ead1e424
ILT
444
445template<int size, bool big_endian>
446Output_section*
730cdc88
ILT
447Layout::layout(Sized_relobj<size, big_endian>* object, unsigned int shndx,
448 const char* name, const elfcpp::Shdr<size, big_endian>& shdr,
449 unsigned int reloc_shndx, unsigned int, off_t* off)
ead1e424 450{
ef9beddf
ILT
451 *off = 0;
452
ead1e424
ILT
453 if (!this->include_section(object, name, shdr))
454 return NULL;
455
6a74a719
ILT
456 Output_section* os;
457
458 // In a relocatable link a grouped section must not be combined with
459 // any other sections.
8851ecca 460 if (parameters->options().relocatable()
6a74a719
ILT
461 && (shdr.get_sh_flags() & elfcpp::SHF_GROUP) != 0)
462 {
463 name = this->namepool_.add(name, true, NULL);
464 os = this->make_output_section(name, shdr.get_sh_type(),
465 shdr.get_sh_flags());
466 }
467 else
468 {
469 os = this->choose_output_section(object, name, shdr.get_sh_type(),
470 shdr.get_sh_flags(), true);
471 if (os == NULL)
472 return NULL;
473 }
a2fb1b05 474
2fd32231
ILT
475 // By default the GNU linker sorts input sections whose names match
476 // .ctor.*, .dtor.*, .init_array.*, or .fini_array.*. The sections
477 // are sorted by name. This is used to implement constructor
478 // priority ordering. We are compatible.
479 if (!this->script_options_->saw_sections_clause()
480 && (is_prefix_of(".ctors.", name)
481 || is_prefix_of(".dtors.", name)
482 || is_prefix_of(".init_array.", name)
483 || is_prefix_of(".fini_array.", name)))
484 os->set_must_sort_attached_input_sections();
485
a2fb1b05
ILT
486 // FIXME: Handle SHF_LINK_ORDER somewhere.
487
a445fddf
ILT
488 *off = os->add_input_section(object, shndx, name, shdr, reloc_shndx,
489 this->script_options_->saw_sections_clause());
a2fb1b05
ILT
490
491 return os;
492}
493
6a74a719
ILT
494// Handle a relocation section when doing a relocatable link.
495
496template<int size, bool big_endian>
497Output_section*
498Layout::layout_reloc(Sized_relobj<size, big_endian>* object,
499 unsigned int,
500 const elfcpp::Shdr<size, big_endian>& shdr,
501 Output_section* data_section,
502 Relocatable_relocs* rr)
503{
8851ecca
ILT
504 gold_assert(parameters->options().relocatable()
505 || parameters->options().emit_relocs());
6a74a719
ILT
506
507 int sh_type = shdr.get_sh_type();
508
509 std::string name;
510 if (sh_type == elfcpp::SHT_REL)
511 name = ".rel";
512 else if (sh_type == elfcpp::SHT_RELA)
513 name = ".rela";
514 else
515 gold_unreachable();
516 name += data_section->name();
517
518 Output_section* os = this->choose_output_section(object, name.c_str(),
519 sh_type,
520 shdr.get_sh_flags(),
521 false);
522
523 os->set_should_link_to_symtab();
524 os->set_info_section(data_section);
525
526 Output_section_data* posd;
527 if (sh_type == elfcpp::SHT_REL)
528 {
529 os->set_entsize(elfcpp::Elf_sizes<size>::rel_size);
530 posd = new Output_relocatable_relocs<elfcpp::SHT_REL,
531 size,
532 big_endian>(rr);
533 }
534 else if (sh_type == elfcpp::SHT_RELA)
535 {
536 os->set_entsize(elfcpp::Elf_sizes<size>::rela_size);
537 posd = new Output_relocatable_relocs<elfcpp::SHT_RELA,
538 size,
539 big_endian>(rr);
540 }
541 else
542 gold_unreachable();
543
544 os->add_output_section_data(posd);
545 rr->set_output_data(posd);
546
547 return os;
548}
549
550// Handle a group section when doing a relocatable link.
551
552template<int size, bool big_endian>
553void
554Layout::layout_group(Symbol_table* symtab,
555 Sized_relobj<size, big_endian>* object,
556 unsigned int,
557 const char* group_section_name,
558 const char* signature,
559 const elfcpp::Shdr<size, big_endian>& shdr,
8825ac63
ILT
560 elfcpp::Elf_Word flags,
561 std::vector<unsigned int>* shndxes)
6a74a719 562{
8851ecca 563 gold_assert(parameters->options().relocatable());
6a74a719
ILT
564 gold_assert(shdr.get_sh_type() == elfcpp::SHT_GROUP);
565 group_section_name = this->namepool_.add(group_section_name, true, NULL);
566 Output_section* os = this->make_output_section(group_section_name,
567 elfcpp::SHT_GROUP,
568 shdr.get_sh_flags());
569
570 // We need to find a symbol with the signature in the symbol table.
755ab8af 571 // If we don't find one now, we need to look again later.
6a74a719 572 Symbol* sym = symtab->lookup(signature, NULL);
755ab8af
ILT
573 if (sym != NULL)
574 os->set_info_symndx(sym);
575 else
576 {
577 // We will wind up using a symbol whose name is the signature.
578 // So just put the signature in the symbol name pool to save it.
579 signature = symtab->canonicalize_name(signature);
580 this->group_signatures_.push_back(Group_signature(os, signature));
581 }
6a74a719
ILT
582
583 os->set_should_link_to_symtab();
6a74a719
ILT
584 os->set_entsize(4);
585
586 section_size_type entry_count =
587 convert_to_section_size_type(shdr.get_sh_size() / 4);
588 Output_section_data* posd =
8825ac63
ILT
589 new Output_data_group<size, big_endian>(object, entry_count, flags,
590 shndxes);
6a74a719
ILT
591 os->add_output_section_data(posd);
592}
593
730cdc88
ILT
594// Special GNU handling of sections name .eh_frame. They will
595// normally hold exception frame data as defined by the C++ ABI
596// (http://codesourcery.com/cxx-abi/).
3151305a
ILT
597
598template<int size, bool big_endian>
730cdc88
ILT
599Output_section*
600Layout::layout_eh_frame(Sized_relobj<size, big_endian>* object,
601 const unsigned char* symbols,
602 off_t symbols_size,
603 const unsigned char* symbol_names,
604 off_t symbol_names_size,
3151305a 605 unsigned int shndx,
3151305a 606 const elfcpp::Shdr<size, big_endian>& shdr,
730cdc88
ILT
607 unsigned int reloc_shndx, unsigned int reloc_type,
608 off_t* off)
3151305a 609{
730cdc88 610 gold_assert(shdr.get_sh_type() == elfcpp::SHT_PROGBITS);
1650c4ff 611 gold_assert((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0);
730cdc88 612
a445fddf
ILT
613 const char* const name = ".eh_frame";
614 Output_section* os = this->choose_output_section(object,
615 name,
616 elfcpp::SHT_PROGBITS,
617 elfcpp::SHF_ALLOC,
618 false);
619 if (os == NULL)
620 return NULL;
730cdc88 621
3151305a
ILT
622 if (this->eh_frame_section_ == NULL)
623 {
624 this->eh_frame_section_ = os;
730cdc88 625 this->eh_frame_data_ = new Eh_frame();
3151305a 626
45aa233b 627 if (this->options_.eh_frame_hdr())
3151305a 628 {
3151305a 629 Output_section* hdr_os =
a445fddf
ILT
630 this->choose_output_section(NULL,
631 ".eh_frame_hdr",
632 elfcpp::SHT_PROGBITS,
633 elfcpp::SHF_ALLOC,
634 false);
3151305a 635
a445fddf
ILT
636 if (hdr_os != NULL)
637 {
638 Eh_frame_hdr* hdr_posd = new Eh_frame_hdr(os,
639 this->eh_frame_data_);
640 hdr_os->add_output_section_data(hdr_posd);
3151305a 641
a445fddf 642 hdr_os->set_after_input_sections();
730cdc88 643
1c4f3631
ILT
644 if (!this->script_options_->saw_phdrs_clause())
645 {
646 Output_segment* hdr_oseg;
647 hdr_oseg = this->make_output_segment(elfcpp::PT_GNU_EH_FRAME,
648 elfcpp::PF_R);
649 hdr_oseg->add_output_section(hdr_os, elfcpp::PF_R);
650 }
730cdc88 651
a445fddf
ILT
652 this->eh_frame_data_->set_eh_frame_hdr(hdr_posd);
653 }
3151305a
ILT
654 }
655 }
656
657 gold_assert(this->eh_frame_section_ == os);
658
730cdc88
ILT
659 if (this->eh_frame_data_->add_ehframe_input_section(object,
660 symbols,
661 symbols_size,
662 symbol_names,
663 symbol_names_size,
664 shndx,
665 reloc_shndx,
666 reloc_type))
2c38906f 667 {
154e0e9a
ILT
668 os->update_flags_for_input_section(shdr.get_sh_flags());
669
2c38906f
ILT
670 // We found a .eh_frame section we are going to optimize, so now
671 // we can add the set of optimized sections to the output
672 // section. We need to postpone adding this until we've found a
673 // section we can optimize so that the .eh_frame section in
674 // crtbegin.o winds up at the start of the output section.
675 if (!this->added_eh_frame_data_)
676 {
677 os->add_output_section_data(this->eh_frame_data_);
678 this->added_eh_frame_data_ = true;
679 }
680 *off = -1;
681 }
730cdc88
ILT
682 else
683 {
684 // We couldn't handle this .eh_frame section for some reason.
685 // Add it as a normal section.
a445fddf
ILT
686 bool saw_sections_clause = this->script_options_->saw_sections_clause();
687 *off = os->add_input_section(object, shndx, name, shdr, reloc_shndx,
688 saw_sections_clause);
730cdc88
ILT
689 }
690
691 return os;
3151305a
ILT
692}
693
9f1d377b
ILT
694// Add POSD to an output section using NAME, TYPE, and FLAGS. Return
695// the output section.
ead1e424 696
9f1d377b 697Output_section*
ead1e424
ILT
698Layout::add_output_section_data(const char* name, elfcpp::Elf_Word type,
699 elfcpp::Elf_Xword flags,
700 Output_section_data* posd)
701{
a445fddf
ILT
702 Output_section* os = this->choose_output_section(NULL, name, type, flags,
703 false);
704 if (os != NULL)
705 os->add_output_section_data(posd);
9f1d377b 706 return os;
ead1e424
ILT
707}
708
a2fb1b05
ILT
709// Map section flags to segment flags.
710
711elfcpp::Elf_Word
712Layout::section_flags_to_segment(elfcpp::Elf_Xword flags)
713{
714 elfcpp::Elf_Word ret = elfcpp::PF_R;
715 if ((flags & elfcpp::SHF_WRITE) != 0)
716 ret |= elfcpp::PF_W;
717 if ((flags & elfcpp::SHF_EXECINSTR) != 0)
718 ret |= elfcpp::PF_X;
719 return ret;
720}
721
96803768
ILT
722// Sometimes we compress sections. This is typically done for
723// sections that are not part of normal program execution (such as
724// .debug_* sections), and where the readers of these sections know
725// how to deal with compressed sections. (To make it easier for them,
726// we will rename the ouput section in such cases from .foo to
727// .foo.zlib.nnnn, where nnnn is the uncompressed size.) This routine
728// doesn't say for certain whether we'll compress -- it depends on
729// commandline options as well -- just whether this section is a
730// candidate for compression.
731
732static bool
733is_compressible_debug_section(const char* secname)
734{
735 return (strncmp(secname, ".debug", sizeof(".debug") - 1) == 0);
736}
737
a2fb1b05
ILT
738// Make a new Output_section, and attach it to segments as
739// appropriate.
740
741Output_section*
742Layout::make_output_section(const char* name, elfcpp::Elf_Word type,
743 elfcpp::Elf_Xword flags)
744{
96803768
ILT
745 Output_section* os;
746 if ((flags & elfcpp::SHF_ALLOC) == 0
ee1fe73e 747 && strcmp(this->options_.compress_debug_sections(), "none") != 0
96803768
ILT
748 && is_compressible_debug_section(name))
749 os = new Output_compressed_section(&this->options_, name, type, flags);
62b01cb5
ILT
750
751 else if ((flags & elfcpp::SHF_ALLOC) == 0
752 && this->options_.strip_debug_non_line()
753 && strcmp(".debug_abbrev", name) == 0)
754 {
755 os = this->debug_abbrev_ = new Output_reduced_debug_abbrev_section(
756 name, type, flags);
757 if (this->debug_info_)
758 this->debug_info_->set_abbreviations(this->debug_abbrev_);
759 }
760 else if ((flags & elfcpp::SHF_ALLOC) == 0
761 && this->options_.strip_debug_non_line()
762 && strcmp(".debug_info", name) == 0)
763 {
764 os = this->debug_info_ = new Output_reduced_debug_info_section(
765 name, type, flags);
766 if (this->debug_abbrev_)
767 this->debug_info_->set_abbreviations(this->debug_abbrev_);
768 }
769 else
96803768
ILT
770 os = new Output_section(name, type, flags);
771
a3ad94ed 772 this->section_list_.push_back(os);
a2fb1b05 773
2fd32231
ILT
774 // The GNU linker by default sorts some sections by priority, so we
775 // do the same. We need to know that this might happen before we
776 // attach any input sections.
777 if (!this->script_options_->saw_sections_clause()
778 && (strcmp(name, ".ctors") == 0
779 || strcmp(name, ".dtors") == 0
780 || strcmp(name, ".init_array") == 0
781 || strcmp(name, ".fini_array") == 0))
782 os->set_may_sort_attached_input_sections();
783
9f1d377b
ILT
784 // With -z relro, we have to recognize the special sections by name.
785 // There is no other way.
786 if (!this->script_options_->saw_sections_clause()
787 && parameters->options().relro()
788 && type == elfcpp::SHT_PROGBITS
789 && (flags & elfcpp::SHF_ALLOC) != 0
790 && (flags & elfcpp::SHF_WRITE) != 0)
791 {
792 if (strcmp(name, ".data.rel.ro") == 0)
793 os->set_is_relro();
794 else if (strcmp(name, ".data.rel.ro.local") == 0)
795 {
796 os->set_is_relro();
797 os->set_is_relro_local();
798 }
799 }
800
154e0e9a
ILT
801 // If we have already attached the sections to segments, then we
802 // need to attach this one now. This happens for sections created
803 // directly by the linker.
804 if (this->sections_are_attached_)
805 this->attach_section_to_segment(os);
806
4e2b1697
ILT
807 return os;
808}
a445fddf 809
154e0e9a
ILT
810// Attach output sections to segments. This is called after we have
811// seen all the input sections.
812
813void
814Layout::attach_sections_to_segments()
815{
816 for (Section_list::iterator p = this->section_list_.begin();
817 p != this->section_list_.end();
818 ++p)
819 this->attach_section_to_segment(*p);
820
821 this->sections_are_attached_ = true;
822}
823
824// Attach an output section to a segment.
825
826void
827Layout::attach_section_to_segment(Output_section* os)
828{
829 if ((os->flags() & elfcpp::SHF_ALLOC) == 0)
830 this->unattached_section_list_.push_back(os);
831 else
832 this->attach_allocated_section_to_segment(os);
833}
834
4e2b1697 835// Attach an allocated output section to a segment.
1c4f3631 836
4e2b1697 837void
154e0e9a 838Layout::attach_allocated_section_to_segment(Output_section* os)
4e2b1697 839{
154e0e9a 840 elfcpp::Elf_Xword flags = os->flags();
4e2b1697 841 gold_assert((flags & elfcpp::SHF_ALLOC) != 0);
a2fb1b05 842
4e2b1697
ILT
843 if (parameters->options().relocatable())
844 return;
a2fb1b05 845
4e2b1697
ILT
846 // If we have a SECTIONS clause, we can't handle the attachment to
847 // segments until after we've seen all the sections.
848 if (this->script_options_->saw_sections_clause())
849 return;
a2fb1b05 850
4e2b1697 851 gold_assert(!this->script_options_->saw_phdrs_clause());
756ac4a8 852
4e2b1697 853 // This output section goes into a PT_LOAD segment.
a2fb1b05 854
4e2b1697 855 elfcpp::Elf_Word seg_flags = Layout::section_flags_to_segment(flags);
a2fb1b05 856
4e2b1697
ILT
857 // In general the only thing we really care about for PT_LOAD
858 // segments is whether or not they are writable, so that is how we
859 // search for them. People who need segments sorted on some other
860 // basis will have to use a linker script.
a2fb1b05 861
4e2b1697
ILT
862 Segment_list::const_iterator p;
863 for (p = this->segment_list_.begin();
864 p != this->segment_list_.end();
865 ++p)
866 {
867 if ((*p)->type() == elfcpp::PT_LOAD
af6156ef
ILT
868 && (parameters->options().omagic()
869 || ((*p)->flags() & elfcpp::PF_W) == (seg_flags & elfcpp::PF_W)))
4e2b1697
ILT
870 {
871 // If -Tbss was specified, we need to separate the data
872 // and BSS segments.
873 if (this->options_.user_set_Tbss())
874 {
875 if ((os->type() == elfcpp::SHT_NOBITS)
876 == (*p)->has_any_data_sections())
877 continue;
878 }
879
880 (*p)->add_output_section(os, seg_flags);
881 break;
882 }
883 }
54dc6425 884
4e2b1697
ILT
885 if (p == this->segment_list_.end())
886 {
887 Output_segment* oseg = this->make_output_segment(elfcpp::PT_LOAD,
888 seg_flags);
889 oseg->add_output_section(os, seg_flags);
a2fb1b05
ILT
890 }
891
4e2b1697
ILT
892 // If we see a loadable SHT_NOTE section, we create a PT_NOTE
893 // segment.
894 if (os->type() == elfcpp::SHT_NOTE)
895 {
896 // See if we already have an equivalent PT_NOTE segment.
897 for (p = this->segment_list_.begin();
898 p != segment_list_.end();
899 ++p)
900 {
901 if ((*p)->type() == elfcpp::PT_NOTE
902 && (((*p)->flags() & elfcpp::PF_W)
903 == (seg_flags & elfcpp::PF_W)))
904 {
905 (*p)->add_output_section(os, seg_flags);
906 break;
907 }
908 }
909
910 if (p == this->segment_list_.end())
911 {
912 Output_segment* oseg = this->make_output_segment(elfcpp::PT_NOTE,
913 seg_flags);
914 oseg->add_output_section(os, seg_flags);
915 }
916 }
917
918 // If we see a loadable SHF_TLS section, we create a PT_TLS
919 // segment. There can only be one such segment.
920 if ((flags & elfcpp::SHF_TLS) != 0)
921 {
922 if (this->tls_segment_ == NULL)
923 this->tls_segment_ = this->make_output_segment(elfcpp::PT_TLS,
924 seg_flags);
925 this->tls_segment_->add_output_section(os, seg_flags);
926 }
9f1d377b
ILT
927
928 // If -z relro is in effect, and we see a relro section, we create a
929 // PT_GNU_RELRO segment. There can only be one such segment.
930 if (os->is_relro() && parameters->options().relro())
931 {
932 gold_assert(seg_flags == (elfcpp::PF_R | elfcpp::PF_W));
933 if (this->relro_segment_ == NULL)
934 this->relro_segment_ = this->make_output_segment(elfcpp::PT_GNU_RELRO,
935 seg_flags);
936 this->relro_segment_->add_output_section(os, seg_flags);
937 }
a2fb1b05
ILT
938}
939
919ed24c
ILT
940// Make an output section for a script.
941
942Output_section*
943Layout::make_output_section_for_script(const char* name)
944{
945 name = this->namepool_.add(name, false, NULL);
946 Output_section* os = this->make_output_section(name, elfcpp::SHT_PROGBITS,
947 elfcpp::SHF_ALLOC);
948 os->set_found_in_sections_clause();
949 return os;
950}
951
3802b2dd
ILT
952// Return the number of segments we expect to see.
953
954size_t
955Layout::expected_segment_count() const
956{
957 size_t ret = this->segment_list_.size();
958
959 // If we didn't see a SECTIONS clause in a linker script, we should
960 // already have the complete list of segments. Otherwise we ask the
961 // SECTIONS clause how many segments it expects, and add in the ones
962 // we already have (PT_GNU_STACK, PT_GNU_EH_FRAME, etc.)
963
964 if (!this->script_options_->saw_sections_clause())
965 return ret;
966 else
967 {
968 const Script_sections* ss = this->script_options_->script_sections();
969 return ret + ss->expected_segment_count(this);
970 }
971}
972
35cdfc9a
ILT
973// Handle the .note.GNU-stack section at layout time. SEEN_GNU_STACK
974// is whether we saw a .note.GNU-stack section in the object file.
975// GNU_STACK_FLAGS is the section flags. The flags give the
976// protection required for stack memory. We record this in an
977// executable as a PT_GNU_STACK segment. If an object file does not
978// have a .note.GNU-stack segment, we must assume that it is an old
979// object. On some targets that will force an executable stack.
980
981void
982Layout::layout_gnu_stack(bool seen_gnu_stack, uint64_t gnu_stack_flags)
983{
984 if (!seen_gnu_stack)
985 this->input_without_gnu_stack_note_ = true;
986 else
987 {
988 this->input_with_gnu_stack_note_ = true;
989 if ((gnu_stack_flags & elfcpp::SHF_EXECINSTR) != 0)
990 this->input_requires_executable_stack_ = true;
991 }
992}
993
a3ad94ed
ILT
994// Create the dynamic sections which are needed before we read the
995// relocs.
996
997void
9b07f471 998Layout::create_initial_dynamic_sections(Symbol_table* symtab)
a3ad94ed 999{
436ca963 1000 if (parameters->doing_static_link())
a3ad94ed
ILT
1001 return;
1002
3802b2dd
ILT
1003 this->dynamic_section_ = this->choose_output_section(NULL, ".dynamic",
1004 elfcpp::SHT_DYNAMIC,
1005 (elfcpp::SHF_ALLOC
1006 | elfcpp::SHF_WRITE),
1007 false);
9f1d377b 1008 this->dynamic_section_->set_is_relro();
a3ad94ed 1009
9b07f471 1010 symtab->define_in_output_data("_DYNAMIC", NULL, this->dynamic_section_, 0, 0,
a3ad94ed
ILT
1011 elfcpp::STT_OBJECT, elfcpp::STB_LOCAL,
1012 elfcpp::STV_HIDDEN, 0, false, false);
16649710 1013
9025d29d 1014 this->dynamic_data_ = new Output_data_dynamic(&this->dynpool_);
16649710
ILT
1015
1016 this->dynamic_section_->add_output_section_data(this->dynamic_data_);
a3ad94ed
ILT
1017}
1018
bfd58944
ILT
1019// For each output section whose name can be represented as C symbol,
1020// define __start and __stop symbols for the section. This is a GNU
1021// extension.
1022
1023void
9b07f471 1024Layout::define_section_symbols(Symbol_table* symtab)
bfd58944
ILT
1025{
1026 for (Section_list::const_iterator p = this->section_list_.begin();
1027 p != this->section_list_.end();
1028 ++p)
1029 {
1030 const char* const name = (*p)->name();
1031 if (name[strspn(name,
1032 ("0123456789"
1033 "ABCDEFGHIJKLMNOPWRSTUVWXYZ"
1034 "abcdefghijklmnopqrstuvwxyz"
1035 "_"))]
1036 == '\0')
1037 {
1038 const std::string name_string(name);
1039 const std::string start_name("__start_" + name_string);
1040 const std::string stop_name("__stop_" + name_string);
1041
9b07f471 1042 symtab->define_in_output_data(start_name.c_str(),
bfd58944
ILT
1043 NULL, // version
1044 *p,
1045 0, // value
1046 0, // symsize
1047 elfcpp::STT_NOTYPE,
1048 elfcpp::STB_GLOBAL,
1049 elfcpp::STV_DEFAULT,
1050 0, // nonvis
1051 false, // offset_is_from_end
a445fddf 1052 true); // only_if_ref
bfd58944 1053
9b07f471 1054 symtab->define_in_output_data(stop_name.c_str(),
bfd58944
ILT
1055 NULL, // version
1056 *p,
1057 0, // value
1058 0, // symsize
1059 elfcpp::STT_NOTYPE,
1060 elfcpp::STB_GLOBAL,
1061 elfcpp::STV_DEFAULT,
1062 0, // nonvis
1063 true, // offset_is_from_end
a445fddf 1064 true); // only_if_ref
bfd58944
ILT
1065 }
1066 }
1067}
1068
755ab8af
ILT
1069// Define symbols for group signatures.
1070
1071void
1072Layout::define_group_signatures(Symbol_table* symtab)
1073{
1074 for (Group_signatures::iterator p = this->group_signatures_.begin();
1075 p != this->group_signatures_.end();
1076 ++p)
1077 {
1078 Symbol* sym = symtab->lookup(p->signature, NULL);
1079 if (sym != NULL)
1080 p->section->set_info_symndx(sym);
1081 else
1082 {
1083 // Force the name of the group section to the group
1084 // signature, and use the group's section symbol as the
1085 // signature symbol.
1086 if (strcmp(p->section->name(), p->signature) != 0)
1087 {
1088 const char* name = this->namepool_.add(p->signature,
1089 true, NULL);
1090 p->section->set_name(name);
1091 }
1092 p->section->set_needs_symtab_index();
1093 p->section->set_info_section_symndx(p->section);
1094 }
1095 }
1096
1097 this->group_signatures_.clear();
1098}
1099
75f65a3e
ILT
1100// Find the first read-only PT_LOAD segment, creating one if
1101// necessary.
54dc6425 1102
75f65a3e
ILT
1103Output_segment*
1104Layout::find_first_load_seg()
54dc6425 1105{
75f65a3e
ILT
1106 for (Segment_list::const_iterator p = this->segment_list_.begin();
1107 p != this->segment_list_.end();
1108 ++p)
1109 {
1110 if ((*p)->type() == elfcpp::PT_LOAD
1111 && ((*p)->flags() & elfcpp::PF_R) != 0
af6156ef
ILT
1112 && (parameters->options().omagic()
1113 || ((*p)->flags() & elfcpp::PF_W) == 0))
75f65a3e
ILT
1114 return *p;
1115 }
1116
1c4f3631
ILT
1117 gold_assert(!this->script_options_->saw_phdrs_clause());
1118
3802b2dd
ILT
1119 Output_segment* load_seg = this->make_output_segment(elfcpp::PT_LOAD,
1120 elfcpp::PF_R);
75f65a3e 1121 return load_seg;
54dc6425
ILT
1122}
1123
1124// Finalize the layout. When this is called, we have created all the
1125// output sections and all the output segments which are based on
1126// input sections. We have several things to do, and we have to do
1127// them in the right order, so that we get the right results correctly
1128// and efficiently.
1129
1130// 1) Finalize the list of output segments and create the segment
1131// table header.
1132
1133// 2) Finalize the dynamic symbol table and associated sections.
1134
1135// 3) Determine the final file offset of all the output segments.
1136
1137// 4) Determine the final file offset of all the SHF_ALLOC output
1138// sections.
1139
75f65a3e
ILT
1140// 5) Create the symbol table sections and the section name table
1141// section.
1142
1143// 6) Finalize the symbol table: set symbol values to their final
54dc6425
ILT
1144// value and make a final determination of which symbols are going
1145// into the output symbol table.
1146
54dc6425
ILT
1147// 7) Create the section table header.
1148
1149// 8) Determine the final file offset of all the output sections which
1150// are not SHF_ALLOC, including the section table header.
1151
1152// 9) Finalize the ELF file header.
1153
75f65a3e
ILT
1154// This function returns the size of the output file.
1155
1156off_t
17a1d0a9 1157Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab,
8851ecca 1158 Target* target, const Task* task)
54dc6425 1159{
7e1edb90 1160 target->finalize_sections(this);
5a6f7e2d 1161
17a1d0a9 1162 this->count_local_symbols(task, input_objects);
7bf1f802 1163
35cdfc9a
ILT
1164 this->create_gold_note();
1165 this->create_executable_stack_info(target);
8ed814a9 1166 this->create_build_id();
4f211c8b 1167
3802b2dd 1168 Output_segment* phdr_seg = NULL;
8851ecca 1169 if (!parameters->options().relocatable() && !parameters->doing_static_link())
54dc6425 1170 {
dbe717ef
ILT
1171 // There was a dynamic object in the link. We need to create
1172 // some information for the dynamic linker.
1173
3802b2dd
ILT
1174 // Create the PT_PHDR segment which will hold the program
1175 // headers.
1c4f3631
ILT
1176 if (!this->script_options_->saw_phdrs_clause())
1177 phdr_seg = this->make_output_segment(elfcpp::PT_PHDR, elfcpp::PF_R);
3802b2dd 1178
14b31740
ILT
1179 // Create the dynamic symbol table, including the hash table.
1180 Output_section* dynstr;
1181 std::vector<Symbol*> dynamic_symbols;
1182 unsigned int local_dynamic_count;
a5dc0706
ILT
1183 Versions versions(*this->script_options()->version_script_info(),
1184 &this->dynpool_);
9b07f471 1185 this->create_dynamic_symtab(input_objects, symtab, &dynstr,
14b31740
ILT
1186 &local_dynamic_count, &dynamic_symbols,
1187 &versions);
dbe717ef
ILT
1188
1189 // Create the .interp section to hold the name of the
1190 // interpreter, and put it in a PT_INTERP segment.
8851ecca 1191 if (!parameters->options().shared())
96f2030e 1192 this->create_interp(target);
a3ad94ed
ILT
1193
1194 // Finish the .dynamic section to hold the dynamic data, and put
1195 // it in a PT_DYNAMIC segment.
16649710 1196 this->finish_dynamic_section(input_objects, symtab);
14b31740
ILT
1197
1198 // We should have added everything we need to the dynamic string
1199 // table.
1200 this->dynpool_.set_string_offsets();
1201
1202 // Create the version sections. We can't do this until the
1203 // dynamic string table is complete.
46fe1623 1204 this->create_version_sections(&versions, symtab, local_dynamic_count,
14b31740 1205 dynamic_symbols, dynstr);
54dc6425
ILT
1206 }
1207
a445fddf
ILT
1208 // If there is a SECTIONS clause, put all the input sections into
1209 // the required order.
1210 Output_segment* load_seg;
88dd47ac 1211 if (this->script_options_->saw_sections_clause())
a445fddf 1212 load_seg = this->set_section_addresses_from_script(symtab);
8851ecca 1213 else if (parameters->options().relocatable())
88dd47ac 1214 load_seg = NULL;
a445fddf
ILT
1215 else
1216 load_seg = this->find_first_load_seg();
54dc6425 1217
7cc619c3 1218 if (this->options_.oformat_enum() != General_options::OBJECT_FORMAT_ELF)
516cb3d0
ILT
1219 load_seg = NULL;
1220
3802b2dd 1221 gold_assert(phdr_seg == NULL || load_seg != NULL);
75f65a3e
ILT
1222
1223 // Lay out the segment headers.
75f65a3e 1224 Output_segment_headers* segment_headers;
8851ecca 1225 if (parameters->options().relocatable())
6a74a719
ILT
1226 segment_headers = NULL;
1227 else
1228 {
1229 segment_headers = new Output_segment_headers(this->segment_list_);
1230 if (load_seg != NULL)
1231 load_seg->add_initial_output_data(segment_headers);
1232 if (phdr_seg != NULL)
1233 phdr_seg->add_initial_output_data(segment_headers);
1234 }
75f65a3e
ILT
1235
1236 // Lay out the file header.
1237 Output_file_header* file_header;
d391083d 1238 file_header = new Output_file_header(target, symtab, segment_headers,
a5dc0706 1239 this->options_.entry());
a445fddf
ILT
1240 if (load_seg != NULL)
1241 load_seg->add_initial_output_data(file_header);
1242
61ba1cf9 1243 this->special_output_list_.push_back(file_header);
6a74a719
ILT
1244 if (segment_headers != NULL)
1245 this->special_output_list_.push_back(segment_headers);
75f65a3e 1246
6a74a719 1247 if (this->script_options_->saw_phdrs_clause()
8851ecca 1248 && !parameters->options().relocatable())
1c4f3631
ILT
1249 {
1250 // Support use of FILEHDRS and PHDRS attachments in a PHDRS
1251 // clause in a linker script.
1252 Script_sections* ss = this->script_options_->script_sections();
1253 ss->put_headers_in_phdrs(file_header, segment_headers);
1254 }
1255
ead1e424 1256 // We set the output section indexes in set_segment_offsets and
27bc2bce 1257 // set_section_indexes.
ead1e424
ILT
1258 unsigned int shndx = 1;
1259
1260 // Set the file offsets of all the segments, and all the sections
1261 // they contain.
6a74a719 1262 off_t off;
8851ecca 1263 if (!parameters->options().relocatable())
6a74a719
ILT
1264 off = this->set_segment_offsets(target, load_seg, &shndx);
1265 else
1266 off = this->set_relocatable_section_offsets(file_header, &shndx);
75f65a3e 1267
a9a60db6
ILT
1268 // Set the file offsets of all the non-data sections we've seen so
1269 // far which don't have to wait for the input sections. We need
1270 // this in order to finalize local symbols in non-allocated
1271 // sections.
1272 off = this->set_section_offsets(off, BEFORE_INPUT_SECTIONS_PASS);
1273
d491d34e
ILT
1274 // Set the section indexes of all unallocated sections seen so far,
1275 // in case any of them are somehow referenced by a symbol.
1276 shndx = this->set_section_indexes(shndx);
1277
75f65a3e 1278 // Create the symbol table sections.
d491d34e 1279 this->create_symtab_sections(input_objects, symtab, shndx, &off);
7bf1f802
ILT
1280 if (!parameters->doing_static_link())
1281 this->assign_local_dynsym_offsets(input_objects);
75f65a3e 1282
e5756efb
ILT
1283 // Process any symbol assignments from a linker script. This must
1284 // be called after the symbol table has been finalized.
1285 this->script_options_->finalize_symbols(symtab, this);
1286
75f65a3e
ILT
1287 // Create the .shstrtab section.
1288 Output_section* shstrtab_section = this->create_shstrtab();
1289
a9a60db6
ILT
1290 // Set the file offsets of the rest of the non-data sections which
1291 // don't have to wait for the input sections.
9a0910c3 1292 off = this->set_section_offsets(off, BEFORE_INPUT_SECTIONS_PASS);
86887060 1293
d491d34e
ILT
1294 // Now that all sections have been created, set the section indexes
1295 // for any sections which haven't been done yet.
86887060 1296 shndx = this->set_section_indexes(shndx);
ead1e424 1297
75f65a3e 1298 // Create the section table header.
d491d34e 1299 this->create_shdrs(shstrtab_section, &off);
75f65a3e 1300
17a1d0a9
ILT
1301 // If there are no sections which require postprocessing, we can
1302 // handle the section names now, and avoid a resize later.
1303 if (!this->any_postprocessing_sections_)
1304 off = this->set_section_offsets(off,
1305 STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS);
1306
27bc2bce 1307 file_header->set_section_info(this->section_headers_, shstrtab_section);
75f65a3e 1308
27bc2bce
ILT
1309 // Now we know exactly where everything goes in the output file
1310 // (except for non-allocated sections which require postprocessing).
a3ad94ed 1311 Output_data::layout_complete();
75f65a3e 1312
e44fcf3b
ILT
1313 this->output_file_size_ = off;
1314
75f65a3e
ILT
1315 return off;
1316}
1317
8ed814a9
ILT
1318// Create a note header following the format defined in the ELF ABI.
1319// NAME is the name, NOTE_TYPE is the type, DESCSZ is the size of the
1320// descriptor. ALLOCATE is true if the section should be allocated in
1321// memory. This returns the new note section. It sets
1322// *TRAILING_PADDING to the number of trailing zero bytes required.
4f211c8b 1323
8ed814a9
ILT
1324Output_section*
1325Layout::create_note(const char* name, int note_type, size_t descsz,
1326 bool allocate, size_t* trailing_padding)
4f211c8b 1327{
e2305dc0
ILT
1328 // Authorities all agree that the values in a .note field should
1329 // be aligned on 4-byte boundaries for 32-bit binaries. However,
1330 // they differ on what the alignment is for 64-bit binaries.
1331 // The GABI says unambiguously they take 8-byte alignment:
1332 // http://sco.com/developers/gabi/latest/ch5.pheader.html#note_section
1333 // Other documentation says alignment should always be 4 bytes:
1334 // http://www.netbsd.org/docs/kernel/elf-notes.html#note-format
1335 // GNU ld and GNU readelf both support the latter (at least as of
1336 // version 2.16.91), and glibc always generates the latter for
1337 // .note.ABI-tag (as of version 1.6), so that's the one we go with
1338 // here.
35cdfc9a 1339#ifdef GABI_FORMAT_FOR_DOTNOTE_SECTION // This is not defined by default.
8851ecca 1340 const int size = parameters->target().get_size();
e2305dc0
ILT
1341#else
1342 const int size = 32;
1343#endif
4f211c8b
ILT
1344
1345 // The contents of the .note section.
4f211c8b
ILT
1346 size_t namesz = strlen(name) + 1;
1347 size_t aligned_namesz = align_address(namesz, size / 8);
4f211c8b 1348 size_t aligned_descsz = align_address(descsz, size / 8);
4f211c8b 1349
8ed814a9 1350 size_t notehdrsz = 3 * (size / 8) + aligned_namesz;
4f211c8b 1351
8ed814a9
ILT
1352 unsigned char* buffer = new unsigned char[notehdrsz];
1353 memset(buffer, 0, notehdrsz);
4f211c8b 1354
8851ecca 1355 bool is_big_endian = parameters->target().is_big_endian();
4f211c8b
ILT
1356
1357 if (size == 32)
1358 {
1359 if (!is_big_endian)
1360 {
1361 elfcpp::Swap<32, false>::writeval(buffer, namesz);
1362 elfcpp::Swap<32, false>::writeval(buffer + 4, descsz);
1363 elfcpp::Swap<32, false>::writeval(buffer + 8, note_type);
1364 }
1365 else
1366 {
1367 elfcpp::Swap<32, true>::writeval(buffer, namesz);
1368 elfcpp::Swap<32, true>::writeval(buffer + 4, descsz);
1369 elfcpp::Swap<32, true>::writeval(buffer + 8, note_type);
1370 }
1371 }
1372 else if (size == 64)
1373 {
1374 if (!is_big_endian)
1375 {
1376 elfcpp::Swap<64, false>::writeval(buffer, namesz);
1377 elfcpp::Swap<64, false>::writeval(buffer + 8, descsz);
1378 elfcpp::Swap<64, false>::writeval(buffer + 16, note_type);
1379 }
1380 else
1381 {
1382 elfcpp::Swap<64, true>::writeval(buffer, namesz);
1383 elfcpp::Swap<64, true>::writeval(buffer + 8, descsz);
1384 elfcpp::Swap<64, true>::writeval(buffer + 16, note_type);
1385 }
1386 }
1387 else
1388 gold_unreachable();
1389
1390 memcpy(buffer + 3 * (size / 8), name, namesz);
4f211c8b 1391
cfd73a4e 1392 const char* note_name = this->namepool_.add(".note", false, NULL);
8ed814a9
ILT
1393 elfcpp::Elf_Xword flags = 0;
1394 if (allocate)
1395 flags = elfcpp::SHF_ALLOC;
4f211c8b
ILT
1396 Output_section* os = this->make_output_section(note_name,
1397 elfcpp::SHT_NOTE,
8ed814a9
ILT
1398 flags);
1399 Output_section_data* posd = new Output_data_const_buffer(buffer, notehdrsz,
7d9e3d98
ILT
1400 size / 8,
1401 "** note header");
8ed814a9
ILT
1402 os->add_output_section_data(posd);
1403
1404 *trailing_padding = aligned_descsz - descsz;
1405
1406 return os;
1407}
1408
1409// For an executable or shared library, create a note to record the
1410// version of gold used to create the binary.
1411
1412void
1413Layout::create_gold_note()
1414{
1415 if (parameters->options().relocatable())
1416 return;
1417
1418 std::string desc = std::string("gold ") + gold::get_version_string();
1419
1420 size_t trailing_padding;
1421 Output_section *os = this->create_note("GNU", elfcpp::NT_GNU_GOLD_VERSION,
1422 desc.size(), false, &trailing_padding);
1423
1424 Output_section_data* posd = new Output_data_const(desc, 4);
4f211c8b 1425 os->add_output_section_data(posd);
8ed814a9
ILT
1426
1427 if (trailing_padding > 0)
1428 {
7d9e3d98 1429 posd = new Output_data_zero_fill(trailing_padding, 0);
8ed814a9
ILT
1430 os->add_output_section_data(posd);
1431 }
4f211c8b
ILT
1432}
1433
35cdfc9a
ILT
1434// Record whether the stack should be executable. This can be set
1435// from the command line using the -z execstack or -z noexecstack
1436// options. Otherwise, if any input file has a .note.GNU-stack
1437// section with the SHF_EXECINSTR flag set, the stack should be
1438// executable. Otherwise, if at least one input file a
1439// .note.GNU-stack section, and some input file has no .note.GNU-stack
1440// section, we use the target default for whether the stack should be
1441// executable. Otherwise, we don't generate a stack note. When
1442// generating a object file, we create a .note.GNU-stack section with
1443// the appropriate marking. When generating an executable or shared
1444// library, we create a PT_GNU_STACK segment.
1445
1446void
1447Layout::create_executable_stack_info(const Target* target)
1448{
1449 bool is_stack_executable;
1450 if (this->options_.is_execstack_set())
1451 is_stack_executable = this->options_.is_stack_executable();
1452 else if (!this->input_with_gnu_stack_note_)
1453 return;
1454 else
1455 {
1456 if (this->input_requires_executable_stack_)
1457 is_stack_executable = true;
1458 else if (this->input_without_gnu_stack_note_)
1459 is_stack_executable = target->is_default_stack_executable();
1460 else
1461 is_stack_executable = false;
1462 }
1463
8851ecca 1464 if (parameters->options().relocatable())
35cdfc9a
ILT
1465 {
1466 const char* name = this->namepool_.add(".note.GNU-stack", false, NULL);
1467 elfcpp::Elf_Xword flags = 0;
1468 if (is_stack_executable)
1469 flags |= elfcpp::SHF_EXECINSTR;
1470 this->make_output_section(name, elfcpp::SHT_PROGBITS, flags);
1471 }
1472 else
1473 {
1c4f3631
ILT
1474 if (this->script_options_->saw_phdrs_clause())
1475 return;
35cdfc9a
ILT
1476 int flags = elfcpp::PF_R | elfcpp::PF_W;
1477 if (is_stack_executable)
1478 flags |= elfcpp::PF_X;
3802b2dd 1479 this->make_output_segment(elfcpp::PT_GNU_STACK, flags);
35cdfc9a
ILT
1480 }
1481}
1482
8ed814a9
ILT
1483// If --build-id was used, set up the build ID note.
1484
1485void
1486Layout::create_build_id()
1487{
1488 if (!parameters->options().user_set_build_id())
1489 return;
1490
1491 const char* style = parameters->options().build_id();
1492 if (strcmp(style, "none") == 0)
1493 return;
1494
1495 // Set DESCSZ to the size of the note descriptor. When possible,
1496 // set DESC to the note descriptor contents.
1497 size_t descsz;
1498 std::string desc;
1499 if (strcmp(style, "md5") == 0)
1500 descsz = 128 / 8;
1501 else if (strcmp(style, "sha1") == 0)
1502 descsz = 160 / 8;
1503 else if (strcmp(style, "uuid") == 0)
1504 {
1505 const size_t uuidsz = 128 / 8;
1506
1507 char buffer[uuidsz];
1508 memset(buffer, 0, uuidsz);
1509
1510 int descriptor = ::open("/dev/urandom", O_RDONLY);
1511 if (descriptor < 0)
1512 gold_error(_("--build-id=uuid failed: could not open /dev/urandom: %s"),
1513 strerror(errno));
1514 else
1515 {
1516 ssize_t got = ::read(descriptor, buffer, uuidsz);
1517 ::close(descriptor);
1518 if (got < 0)
1519 gold_error(_("/dev/urandom: read failed: %s"), strerror(errno));
1520 else if (static_cast<size_t>(got) != uuidsz)
1521 gold_error(_("/dev/urandom: expected %zu bytes, got %zd bytes"),
1522 uuidsz, got);
1523 }
1524
1525 desc.assign(buffer, uuidsz);
1526 descsz = uuidsz;
1527 }
1528 else if (strncmp(style, "0x", 2) == 0)
1529 {
1530 hex_init();
1531 const char* p = style + 2;
1532 while (*p != '\0')
1533 {
1534 if (hex_p(p[0]) && hex_p(p[1]))
1535 {
1536 char c = (hex_value(p[0]) << 4) | hex_value(p[1]);
1537 desc += c;
1538 p += 2;
1539 }
1540 else if (*p == '-' || *p == ':')
1541 ++p;
1542 else
1543 gold_fatal(_("--build-id argument '%s' not a valid hex number"),
1544 style);
1545 }
1546 descsz = desc.size();
1547 }
1548 else
1549 gold_fatal(_("unrecognized --build-id argument '%s'"), style);
1550
1551 // Create the note.
1552 size_t trailing_padding;
1553 Output_section* os = this->create_note("GNU", elfcpp::NT_GNU_BUILD_ID,
1554 descsz, true, &trailing_padding);
1555
1556 if (!desc.empty())
1557 {
1558 // We know the value already, so we fill it in now.
1559 gold_assert(desc.size() == descsz);
1560
1561 Output_section_data* posd = new Output_data_const(desc, 4);
1562 os->add_output_section_data(posd);
1563
1564 if (trailing_padding != 0)
1565 {
7d9e3d98 1566 posd = new Output_data_zero_fill(trailing_padding, 0);
8ed814a9
ILT
1567 os->add_output_section_data(posd);
1568 }
1569 }
1570 else
1571 {
1572 // We need to compute a checksum after we have completed the
1573 // link.
1574 gold_assert(trailing_padding == 0);
7d9e3d98 1575 this->build_id_note_ = new Output_data_zero_fill(descsz, 4);
8ed814a9
ILT
1576 os->add_output_section_data(this->build_id_note_);
1577 os->set_after_input_sections();
1578 }
1579}
1580
75f65a3e
ILT
1581// Return whether SEG1 should be before SEG2 in the output file. This
1582// is based entirely on the segment type and flags. When this is
1583// called the segment addresses has normally not yet been set.
1584
1585bool
1586Layout::segment_precedes(const Output_segment* seg1,
1587 const Output_segment* seg2)
1588{
1589 elfcpp::Elf_Word type1 = seg1->type();
1590 elfcpp::Elf_Word type2 = seg2->type();
1591
1592 // The single PT_PHDR segment is required to precede any loadable
1593 // segment. We simply make it always first.
1594 if (type1 == elfcpp::PT_PHDR)
1595 {
a3ad94ed 1596 gold_assert(type2 != elfcpp::PT_PHDR);
75f65a3e
ILT
1597 return true;
1598 }
1599 if (type2 == elfcpp::PT_PHDR)
1600 return false;
1601
1602 // The single PT_INTERP segment is required to precede any loadable
1603 // segment. We simply make it always second.
1604 if (type1 == elfcpp::PT_INTERP)
1605 {
a3ad94ed 1606 gold_assert(type2 != elfcpp::PT_INTERP);
75f65a3e
ILT
1607 return true;
1608 }
1609 if (type2 == elfcpp::PT_INTERP)
1610 return false;
1611
1612 // We then put PT_LOAD segments before any other segments.
1613 if (type1 == elfcpp::PT_LOAD && type2 != elfcpp::PT_LOAD)
1614 return true;
1615 if (type2 == elfcpp::PT_LOAD && type1 != elfcpp::PT_LOAD)
1616 return false;
1617
9f1d377b
ILT
1618 // We put the PT_TLS segment last except for the PT_GNU_RELRO
1619 // segment, because that is where the dynamic linker expects to find
1620 // it (this is just for efficiency; other positions would also work
1621 // correctly).
1622 if (type1 == elfcpp::PT_TLS
1623 && type2 != elfcpp::PT_TLS
1624 && type2 != elfcpp::PT_GNU_RELRO)
1625 return false;
1626 if (type2 == elfcpp::PT_TLS
1627 && type1 != elfcpp::PT_TLS
1628 && type1 != elfcpp::PT_GNU_RELRO)
1629 return true;
1630
1631 // We put the PT_GNU_RELRO segment last, because that is where the
1632 // dynamic linker expects to find it (as with PT_TLS, this is just
1633 // for efficiency).
1634 if (type1 == elfcpp::PT_GNU_RELRO && type2 != elfcpp::PT_GNU_RELRO)
92e059d8 1635 return false;
9f1d377b 1636 if (type2 == elfcpp::PT_GNU_RELRO && type1 != elfcpp::PT_GNU_RELRO)
92e059d8
ILT
1637 return true;
1638
75f65a3e
ILT
1639 const elfcpp::Elf_Word flags1 = seg1->flags();
1640 const elfcpp::Elf_Word flags2 = seg2->flags();
1641
1642 // The order of non-PT_LOAD segments is unimportant. We simply sort
1643 // by the numeric segment type and flags values. There should not
1644 // be more than one segment with the same type and flags.
1645 if (type1 != elfcpp::PT_LOAD)
1646 {
1647 if (type1 != type2)
1648 return type1 < type2;
a3ad94ed 1649 gold_assert(flags1 != flags2);
75f65a3e
ILT
1650 return flags1 < flags2;
1651 }
1652
a445fddf
ILT
1653 // If the addresses are set already, sort by load address.
1654 if (seg1->are_addresses_set())
1655 {
1656 if (!seg2->are_addresses_set())
1657 return true;
1658
1659 unsigned int section_count1 = seg1->output_section_count();
1660 unsigned int section_count2 = seg2->output_section_count();
1661 if (section_count1 == 0 && section_count2 > 0)
1662 return true;
1663 if (section_count1 > 0 && section_count2 == 0)
1664 return false;
1665
1666 uint64_t paddr1 = seg1->first_section_load_address();
1667 uint64_t paddr2 = seg2->first_section_load_address();
1668 if (paddr1 != paddr2)
1669 return paddr1 < paddr2;
1670 }
1671 else if (seg2->are_addresses_set())
1672 return false;
1673
75f65a3e 1674 // We sort PT_LOAD segments based on the flags. Readonly segments
756ac4a8
ILT
1675 // come before writable segments. Then writable segments with data
1676 // come before writable segments without data. Then executable
1677 // segments come before non-executable segments. Then the unlikely
1678 // case of a non-readable segment comes before the normal case of a
1679 // readable segment. If there are multiple segments with the same
1680 // type and flags, we require that the address be set, and we sort
1681 // by virtual address and then physical address.
75f65a3e
ILT
1682 if ((flags1 & elfcpp::PF_W) != (flags2 & elfcpp::PF_W))
1683 return (flags1 & elfcpp::PF_W) == 0;
756ac4a8
ILT
1684 if ((flags1 & elfcpp::PF_W) != 0
1685 && seg1->has_any_data_sections() != seg2->has_any_data_sections())
1686 return seg1->has_any_data_sections();
75f65a3e
ILT
1687 if ((flags1 & elfcpp::PF_X) != (flags2 & elfcpp::PF_X))
1688 return (flags1 & elfcpp::PF_X) != 0;
1689 if ((flags1 & elfcpp::PF_R) != (flags2 & elfcpp::PF_R))
1690 return (flags1 & elfcpp::PF_R) == 0;
1691
a445fddf
ILT
1692 // We shouldn't get here--we shouldn't create segments which we
1693 // can't distinguish.
1694 gold_unreachable();
75f65a3e
ILT
1695}
1696
ead1e424
ILT
1697// Set the file offsets of all the segments, and all the sections they
1698// contain. They have all been created. LOAD_SEG must be be laid out
1699// first. Return the offset of the data to follow.
75f65a3e
ILT
1700
1701off_t
ead1e424
ILT
1702Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
1703 unsigned int *pshndx)
75f65a3e
ILT
1704{
1705 // Sort them into the final order.
54dc6425
ILT
1706 std::sort(this->segment_list_.begin(), this->segment_list_.end(),
1707 Layout::Compare_segments());
1708
75f65a3e
ILT
1709 // Find the PT_LOAD segments, and set their addresses and offsets
1710 // and their section's addresses and offsets.
0c5e9c22 1711 uint64_t addr;
45aa233b
ILT
1712 if (this->options_.user_set_Ttext())
1713 addr = this->options_.Ttext();
8851ecca 1714 else if (parameters->options().shared())
a445fddf 1715 addr = 0;
0c5e9c22
ILT
1716 else
1717 addr = target->default_text_segment_address();
75f65a3e 1718 off_t off = 0;
a445fddf
ILT
1719
1720 // If LOAD_SEG is NULL, then the file header and segment headers
1721 // will not be loadable. But they still need to be at offset 0 in
1722 // the file. Set their offsets now.
1723 if (load_seg == NULL)
1724 {
1725 for (Data_list::iterator p = this->special_output_list_.begin();
1726 p != this->special_output_list_.end();
1727 ++p)
1728 {
1729 off = align_address(off, (*p)->addralign());
1730 (*p)->set_address_and_file_offset(0, off);
1731 off += (*p)->data_size();
1732 }
1733 }
1734
34810851
ILT
1735 const bool check_sections = parameters->options().check_sections();
1736 Output_segment* last_load_segment = NULL;
1737
75f65a3e
ILT
1738 bool was_readonly = false;
1739 for (Segment_list::iterator p = this->segment_list_.begin();
1740 p != this->segment_list_.end();
1741 ++p)
1742 {
1743 if ((*p)->type() == elfcpp::PT_LOAD)
1744 {
1745 if (load_seg != NULL && load_seg != *p)
a3ad94ed 1746 gold_unreachable();
75f65a3e
ILT
1747 load_seg = NULL;
1748
756ac4a8
ILT
1749 bool are_addresses_set = (*p)->are_addresses_set();
1750 if (are_addresses_set)
1751 {
1752 // When it comes to setting file offsets, we care about
1753 // the physical address.
1754 addr = (*p)->paddr();
1755 }
45aa233b 1756 else if (this->options_.user_set_Tdata()
756ac4a8 1757 && ((*p)->flags() & elfcpp::PF_W) != 0
45aa233b 1758 && (!this->options_.user_set_Tbss()
756ac4a8
ILT
1759 || (*p)->has_any_data_sections()))
1760 {
45aa233b 1761 addr = this->options_.Tdata();
756ac4a8
ILT
1762 are_addresses_set = true;
1763 }
45aa233b 1764 else if (this->options_.user_set_Tbss()
756ac4a8
ILT
1765 && ((*p)->flags() & elfcpp::PF_W) != 0
1766 && !(*p)->has_any_data_sections())
1767 {
45aa233b 1768 addr = this->options_.Tbss();
756ac4a8
ILT
1769 are_addresses_set = true;
1770 }
1771
75f65a3e
ILT
1772 uint64_t orig_addr = addr;
1773 uint64_t orig_off = off;
1774
a445fddf 1775 uint64_t aligned_addr = 0;
75f65a3e 1776 uint64_t abi_pagesize = target->abi_pagesize();
af6156ef 1777 uint64_t common_pagesize = target->common_pagesize();
0496d5e5 1778
af6156ef
ILT
1779 if (!parameters->options().nmagic()
1780 && !parameters->options().omagic())
1781 (*p)->set_minimum_p_align(common_pagesize);
0496d5e5 1782
a445fddf 1783 if (are_addresses_set)
75f65a3e 1784 {
af6156ef
ILT
1785 if (!parameters->options().nmagic()
1786 && !parameters->options().omagic())
1787 {
1788 // Adjust the file offset to the same address modulo
1789 // the page size.
1790 uint64_t unsigned_off = off;
1791 uint64_t aligned_off = ((unsigned_off & ~(abi_pagesize - 1))
1792 | (addr & (abi_pagesize - 1)));
1793 if (aligned_off < unsigned_off)
1794 aligned_off += abi_pagesize;
1795 off = aligned_off;
1796 }
a445fddf
ILT
1797 }
1798 else
1799 {
1800 // If the last segment was readonly, and this one is
1801 // not, then skip the address forward one page,
1802 // maintaining the same position within the page. This
1803 // lets us store both segments overlapping on a single
1804 // page in the file, but the loader will put them on
1805 // different pages in memory.
1806
1807 addr = align_address(addr, (*p)->maximum_alignment());
75f65a3e 1808 aligned_addr = addr;
a445fddf
ILT
1809
1810 if (was_readonly && ((*p)->flags() & elfcpp::PF_W) != 0)
1811 {
1812 if ((addr & (abi_pagesize - 1)) != 0)
1813 addr = addr + abi_pagesize;
1814 }
1815
1816 off = orig_off + ((addr - orig_addr) & (abi_pagesize - 1));
75f65a3e
ILT
1817 }
1818
ead1e424 1819 unsigned int shndx_hold = *pshndx;
96a2b4e4
ILT
1820 uint64_t new_addr = (*p)->set_section_addresses(this, false, addr,
1821 &off, pshndx);
75f65a3e
ILT
1822
1823 // Now that we know the size of this segment, we may be able
1824 // to save a page in memory, at the cost of wasting some
1825 // file space, by instead aligning to the start of a new
1826 // page. Here we use the real machine page size rather than
1827 // the ABI mandated page size.
1828
a445fddf 1829 if (!are_addresses_set && aligned_addr != addr)
75f65a3e 1830 {
75f65a3e
ILT
1831 uint64_t first_off = (common_pagesize
1832 - (aligned_addr
1833 & (common_pagesize - 1)));
1834 uint64_t last_off = new_addr & (common_pagesize - 1);
1835 if (first_off > 0
1836 && last_off > 0
1837 && ((aligned_addr & ~ (common_pagesize - 1))
1838 != (new_addr & ~ (common_pagesize - 1)))
1839 && first_off + last_off <= common_pagesize)
1840 {
ead1e424
ILT
1841 *pshndx = shndx_hold;
1842 addr = align_address(aligned_addr, common_pagesize);
a445fddf 1843 addr = align_address(addr, (*p)->maximum_alignment());
75f65a3e 1844 off = orig_off + ((addr - orig_addr) & (abi_pagesize - 1));
96a2b4e4
ILT
1845 new_addr = (*p)->set_section_addresses(this, true, addr,
1846 &off, pshndx);
75f65a3e
ILT
1847 }
1848 }
1849
1850 addr = new_addr;
1851
1852 if (((*p)->flags() & elfcpp::PF_W) == 0)
1853 was_readonly = true;
34810851
ILT
1854
1855 // Implement --check-sections. We know that the segments
1856 // are sorted by LMA.
1857 if (check_sections && last_load_segment != NULL)
1858 {
1859 gold_assert(last_load_segment->paddr() <= (*p)->paddr());
1860 if (last_load_segment->paddr() + last_load_segment->memsz()
1861 > (*p)->paddr())
1862 {
1863 unsigned long long lb1 = last_load_segment->paddr();
1864 unsigned long long le1 = lb1 + last_load_segment->memsz();
1865 unsigned long long lb2 = (*p)->paddr();
1866 unsigned long long le2 = lb2 + (*p)->memsz();
1867 gold_error(_("load segment overlap [0x%llx -> 0x%llx] and "
1868 "[0x%llx -> 0x%llx]"),
1869 lb1, le1, lb2, le2);
1870 }
1871 }
1872 last_load_segment = *p;
75f65a3e
ILT
1873 }
1874 }
1875
1876 // Handle the non-PT_LOAD segments, setting their offsets from their
1877 // section's offsets.
1878 for (Segment_list::iterator p = this->segment_list_.begin();
1879 p != this->segment_list_.end();
1880 ++p)
1881 {
1882 if ((*p)->type() != elfcpp::PT_LOAD)
1883 (*p)->set_offset();
1884 }
1885
7bf1f802
ILT
1886 // Set the TLS offsets for each section in the PT_TLS segment.
1887 if (this->tls_segment_ != NULL)
1888 this->tls_segment_->set_tls_offsets();
1889
75f65a3e
ILT
1890 return off;
1891}
1892
6a74a719
ILT
1893// Set the offsets of all the allocated sections when doing a
1894// relocatable link. This does the same jobs as set_segment_offsets,
1895// only for a relocatable link.
1896
1897off_t
1898Layout::set_relocatable_section_offsets(Output_data* file_header,
1899 unsigned int *pshndx)
1900{
1901 off_t off = 0;
1902
1903 file_header->set_address_and_file_offset(0, 0);
1904 off += file_header->data_size();
1905
1906 for (Section_list::iterator p = this->section_list_.begin();
1907 p != this->section_list_.end();
1908 ++p)
1909 {
1910 // We skip unallocated sections here, except that group sections
1911 // have to come first.
1912 if (((*p)->flags() & elfcpp::SHF_ALLOC) == 0
1913 && (*p)->type() != elfcpp::SHT_GROUP)
1914 continue;
1915
1916 off = align_address(off, (*p)->addralign());
1917
1918 // The linker script might have set the address.
1919 if (!(*p)->is_address_valid())
1920 (*p)->set_address(0);
1921 (*p)->set_file_offset(off);
1922 (*p)->finalize_data_size();
1923 off += (*p)->data_size();
1924
1925 (*p)->set_out_shndx(*pshndx);
1926 ++*pshndx;
1927 }
1928
1929 return off;
1930}
1931
75f65a3e
ILT
1932// Set the file offset of all the sections not associated with a
1933// segment.
1934
1935off_t
9a0910c3 1936Layout::set_section_offsets(off_t off, Layout::Section_offset_pass pass)
75f65a3e 1937{
a3ad94ed
ILT
1938 for (Section_list::iterator p = this->unattached_section_list_.begin();
1939 p != this->unattached_section_list_.end();
75f65a3e
ILT
1940 ++p)
1941 {
27bc2bce
ILT
1942 // The symtab section is handled in create_symtab_sections.
1943 if (*p == this->symtab_section_)
61ba1cf9 1944 continue;
27bc2bce 1945
a9a60db6
ILT
1946 // If we've already set the data size, don't set it again.
1947 if ((*p)->is_offset_valid() && (*p)->is_data_size_valid())
1948 continue;
1949
96803768
ILT
1950 if (pass == BEFORE_INPUT_SECTIONS_PASS
1951 && (*p)->requires_postprocessing())
17a1d0a9
ILT
1952 {
1953 (*p)->create_postprocessing_buffer();
1954 this->any_postprocessing_sections_ = true;
1955 }
96803768 1956
9a0910c3
ILT
1957 if (pass == BEFORE_INPUT_SECTIONS_PASS
1958 && (*p)->after_input_sections())
1959 continue;
17a1d0a9 1960 else if (pass == POSTPROCESSING_SECTIONS_PASS
9a0910c3
ILT
1961 && (!(*p)->after_input_sections()
1962 || (*p)->type() == elfcpp::SHT_STRTAB))
1963 continue;
17a1d0a9 1964 else if (pass == STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS
9a0910c3
ILT
1965 && (!(*p)->after_input_sections()
1966 || (*p)->type() != elfcpp::SHT_STRTAB))
1967 continue;
27bc2bce 1968
ead1e424 1969 off = align_address(off, (*p)->addralign());
27bc2bce
ILT
1970 (*p)->set_file_offset(off);
1971 (*p)->finalize_data_size();
75f65a3e 1972 off += (*p)->data_size();
96803768
ILT
1973
1974 // At this point the name must be set.
17a1d0a9 1975 if (pass != STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS)
96803768 1976 this->namepool_.add((*p)->name(), false, NULL);
75f65a3e
ILT
1977 }
1978 return off;
1979}
1980
86887060
ILT
1981// Set the section indexes of all the sections not associated with a
1982// segment.
1983
1984unsigned int
1985Layout::set_section_indexes(unsigned int shndx)
1986{
1987 for (Section_list::iterator p = this->unattached_section_list_.begin();
1988 p != this->unattached_section_list_.end();
1989 ++p)
1990 {
d491d34e
ILT
1991 if (!(*p)->has_out_shndx())
1992 {
1993 (*p)->set_out_shndx(shndx);
1994 ++shndx;
1995 }
86887060
ILT
1996 }
1997 return shndx;
1998}
1999
a445fddf
ILT
2000// Set the section addresses according to the linker script. This is
2001// only called when we see a SECTIONS clause. This returns the
2002// program segment which should hold the file header and segment
2003// headers, if any. It will return NULL if they should not be in a
2004// segment.
2005
2006Output_segment*
2007Layout::set_section_addresses_from_script(Symbol_table* symtab)
2008{
2009 Script_sections* ss = this->script_options_->script_sections();
2010 gold_assert(ss->saw_sections_clause());
2011
2012 // Place each orphaned output section in the script.
2013 for (Section_list::iterator p = this->section_list_.begin();
2014 p != this->section_list_.end();
2015 ++p)
2016 {
2017 if (!(*p)->found_in_sections_clause())
2018 ss->place_orphan(*p);
2019 }
2020
2021 return this->script_options_->set_section_addresses(symtab, this);
2022}
2023
7bf1f802
ILT
2024// Count the local symbols in the regular symbol table and the dynamic
2025// symbol table, and build the respective string pools.
2026
2027void
17a1d0a9
ILT
2028Layout::count_local_symbols(const Task* task,
2029 const Input_objects* input_objects)
7bf1f802 2030{
6d013333
ILT
2031 // First, figure out an upper bound on the number of symbols we'll
2032 // be inserting into each pool. This helps us create the pools with
2033 // the right size, to avoid unnecessary hashtable resizing.
2034 unsigned int symbol_count = 0;
2035 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
2036 p != input_objects->relobj_end();
2037 ++p)
2038 symbol_count += (*p)->local_symbol_count();
2039
2040 // Go from "upper bound" to "estimate." We overcount for two
2041 // reasons: we double-count symbols that occur in more than one
2042 // object file, and we count symbols that are dropped from the
2043 // output. Add it all together and assume we overcount by 100%.
2044 symbol_count /= 2;
2045
2046 // We assume all symbols will go into both the sympool and dynpool.
2047 this->sympool_.reserve(symbol_count);
2048 this->dynpool_.reserve(symbol_count);
2049
7bf1f802
ILT
2050 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
2051 p != input_objects->relobj_end();
2052 ++p)
2053 {
17a1d0a9 2054 Task_lock_obj<Object> tlo(task, *p);
7bf1f802
ILT
2055 (*p)->count_local_symbols(&this->sympool_, &this->dynpool_);
2056 }
2057}
2058
b8e6aad9
ILT
2059// Create the symbol table sections. Here we also set the final
2060// values of the symbols. At this point all the loadable sections are
d491d34e 2061// fully laid out. SHNUM is the number of sections so far.
75f65a3e
ILT
2062
2063void
9025d29d 2064Layout::create_symtab_sections(const Input_objects* input_objects,
75f65a3e 2065 Symbol_table* symtab,
d491d34e 2066 unsigned int shnum,
16649710 2067 off_t* poff)
75f65a3e 2068{
61ba1cf9
ILT
2069 int symsize;
2070 unsigned int align;
8851ecca 2071 if (parameters->target().get_size() == 32)
61ba1cf9
ILT
2072 {
2073 symsize = elfcpp::Elf_sizes<32>::sym_size;
2074 align = 4;
2075 }
8851ecca 2076 else if (parameters->target().get_size() == 64)
61ba1cf9
ILT
2077 {
2078 symsize = elfcpp::Elf_sizes<64>::sym_size;
2079 align = 8;
2080 }
2081 else
a3ad94ed 2082 gold_unreachable();
61ba1cf9
ILT
2083
2084 off_t off = *poff;
ead1e424 2085 off = align_address(off, align);
61ba1cf9
ILT
2086 off_t startoff = off;
2087
2088 // Save space for the dummy symbol at the start of the section. We
2089 // never bother to write this out--it will just be left as zero.
2090 off += symsize;
c06b7b0b 2091 unsigned int local_symbol_index = 1;
61ba1cf9 2092
a3ad94ed
ILT
2093 // Add STT_SECTION symbols for each Output section which needs one.
2094 for (Section_list::iterator p = this->section_list_.begin();
2095 p != this->section_list_.end();
2096 ++p)
2097 {
2098 if (!(*p)->needs_symtab_index())
2099 (*p)->set_symtab_index(-1U);
2100 else
2101 {
2102 (*p)->set_symtab_index(local_symbol_index);
2103 ++local_symbol_index;
2104 off += symsize;
2105 }
2106 }
2107
f6ce93d6
ILT
2108 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
2109 p != input_objects->relobj_end();
75f65a3e
ILT
2110 ++p)
2111 {
c06b7b0b 2112 unsigned int index = (*p)->finalize_local_symbols(local_symbol_index,
7bf1f802 2113 off);
c06b7b0b
ILT
2114 off += (index - local_symbol_index) * symsize;
2115 local_symbol_index = index;
75f65a3e
ILT
2116 }
2117
c06b7b0b 2118 unsigned int local_symcount = local_symbol_index;
a3ad94ed 2119 gold_assert(local_symcount * symsize == off - startoff);
61ba1cf9 2120
16649710
ILT
2121 off_t dynoff;
2122 size_t dyn_global_index;
2123 size_t dyncount;
2124 if (this->dynsym_section_ == NULL)
2125 {
2126 dynoff = 0;
2127 dyn_global_index = 0;
2128 dyncount = 0;
2129 }
2130 else
2131 {
2132 dyn_global_index = this->dynsym_section_->info();
2133 off_t locsize = dyn_global_index * this->dynsym_section_->entsize();
2134 dynoff = this->dynsym_section_->offset() + locsize;
2135 dyncount = (this->dynsym_section_->data_size() - locsize) / symsize;
f5c3f225 2136 gold_assert(static_cast<off_t>(dyncount * symsize)
16649710
ILT
2137 == this->dynsym_section_->data_size() - locsize);
2138 }
2139
55a93433
ILT
2140 off = symtab->finalize(off, dynoff, dyn_global_index, dyncount,
2141 &this->sympool_, &local_symcount);
75f65a3e 2142
8851ecca 2143 if (!parameters->options().strip_all())
9e2dcb77
ILT
2144 {
2145 this->sympool_.set_string_offsets();
61ba1cf9 2146
cfd73a4e 2147 const char* symtab_name = this->namepool_.add(".symtab", false, NULL);
9e2dcb77
ILT
2148 Output_section* osymtab = this->make_output_section(symtab_name,
2149 elfcpp::SHT_SYMTAB,
2150 0);
2151 this->symtab_section_ = osymtab;
a3ad94ed 2152
27bc2bce 2153 Output_section_data* pos = new Output_data_fixed_space(off - startoff,
7d9e3d98
ILT
2154 align,
2155 "** symtab");
9e2dcb77 2156 osymtab->add_output_section_data(pos);
61ba1cf9 2157
d491d34e
ILT
2158 // We generate a .symtab_shndx section if we have more than
2159 // SHN_LORESERVE sections. Technically it is possible that we
2160 // don't need one, because it is possible that there are no
2161 // symbols in any of sections with indexes larger than
2162 // SHN_LORESERVE. That is probably unusual, though, and it is
2163 // easier to always create one than to compute section indexes
2164 // twice (once here, once when writing out the symbols).
2165 if (shnum >= elfcpp::SHN_LORESERVE)
2166 {
2167 const char* symtab_xindex_name = this->namepool_.add(".symtab_shndx",
2168 false, NULL);
2169 Output_section* osymtab_xindex =
2170 this->make_output_section(symtab_xindex_name,
2171 elfcpp::SHT_SYMTAB_SHNDX, 0);
2172
2173 size_t symcount = (off - startoff) / symsize;
2174 this->symtab_xindex_ = new Output_symtab_xindex(symcount);
2175
2176 osymtab_xindex->add_output_section_data(this->symtab_xindex_);
2177
2178 osymtab_xindex->set_link_section(osymtab);
2179 osymtab_xindex->set_addralign(4);
2180 osymtab_xindex->set_entsize(4);
2181
2182 osymtab_xindex->set_after_input_sections();
2183
2184 // This tells the driver code to wait until the symbol table
2185 // has written out before writing out the postprocessing
2186 // sections, including the .symtab_shndx section.
2187 this->any_postprocessing_sections_ = true;
2188 }
2189
cfd73a4e 2190 const char* strtab_name = this->namepool_.add(".strtab", false, NULL);
9e2dcb77
ILT
2191 Output_section* ostrtab = this->make_output_section(strtab_name,
2192 elfcpp::SHT_STRTAB,
2193 0);
a3ad94ed 2194
9e2dcb77
ILT
2195 Output_section_data* pstr = new Output_data_strtab(&this->sympool_);
2196 ostrtab->add_output_section_data(pstr);
61ba1cf9 2197
27bc2bce
ILT
2198 osymtab->set_file_offset(startoff);
2199 osymtab->finalize_data_size();
9e2dcb77
ILT
2200 osymtab->set_link_section(ostrtab);
2201 osymtab->set_info(local_symcount);
2202 osymtab->set_entsize(symsize);
61ba1cf9 2203
9e2dcb77
ILT
2204 *poff = off;
2205 }
75f65a3e
ILT
2206}
2207
2208// Create the .shstrtab section, which holds the names of the
2209// sections. At the time this is called, we have created all the
2210// output sections except .shstrtab itself.
2211
2212Output_section*
2213Layout::create_shstrtab()
2214{
2215 // FIXME: We don't need to create a .shstrtab section if we are
2216 // stripping everything.
2217
cfd73a4e 2218 const char* name = this->namepool_.add(".shstrtab", false, NULL);
75f65a3e 2219
a3ad94ed 2220 Output_section* os = this->make_output_section(name, elfcpp::SHT_STRTAB, 0);
75f65a3e 2221
27bc2bce
ILT
2222 // We can't write out this section until we've set all the section
2223 // names, and we don't set the names of compressed output sections
2224 // until relocations are complete.
2225 os->set_after_input_sections();
2226
a3ad94ed
ILT
2227 Output_section_data* posd = new Output_data_strtab(&this->namepool_);
2228 os->add_output_section_data(posd);
75f65a3e
ILT
2229
2230 return os;
2231}
2232
2233// Create the section headers. SIZE is 32 or 64. OFF is the file
2234// offset.
2235
27bc2bce 2236void
d491d34e 2237Layout::create_shdrs(const Output_section* shstrtab_section, off_t* poff)
75f65a3e
ILT
2238{
2239 Output_section_headers* oshdrs;
9025d29d 2240 oshdrs = new Output_section_headers(this,
16649710 2241 &this->segment_list_,
6a74a719 2242 &this->section_list_,
16649710 2243 &this->unattached_section_list_,
d491d34e
ILT
2244 &this->namepool_,
2245 shstrtab_section);
ead1e424 2246 off_t off = align_address(*poff, oshdrs->addralign());
27bc2bce 2247 oshdrs->set_address_and_file_offset(0, off);
61ba1cf9
ILT
2248 off += oshdrs->data_size();
2249 *poff = off;
27bc2bce 2250 this->section_headers_ = oshdrs;
54dc6425
ILT
2251}
2252
d491d34e
ILT
2253// Count the allocated sections.
2254
2255size_t
2256Layout::allocated_output_section_count() const
2257{
2258 size_t section_count = 0;
2259 for (Segment_list::const_iterator p = this->segment_list_.begin();
2260 p != this->segment_list_.end();
2261 ++p)
2262 section_count += (*p)->output_section_count();
2263 return section_count;
2264}
2265
dbe717ef
ILT
2266// Create the dynamic symbol table.
2267
2268void
7bf1f802 2269Layout::create_dynamic_symtab(const Input_objects* input_objects,
9b07f471 2270 Symbol_table* symtab,
14b31740
ILT
2271 Output_section **pdynstr,
2272 unsigned int* plocal_dynamic_count,
2273 std::vector<Symbol*>* pdynamic_symbols,
2274 Versions* pversions)
dbe717ef 2275{
a3ad94ed
ILT
2276 // Count all the symbols in the dynamic symbol table, and set the
2277 // dynamic symbol indexes.
dbe717ef 2278
a3ad94ed
ILT
2279 // Skip symbol 0, which is always all zeroes.
2280 unsigned int index = 1;
dbe717ef 2281
a3ad94ed
ILT
2282 // Add STT_SECTION symbols for each Output section which needs one.
2283 for (Section_list::iterator p = this->section_list_.begin();
2284 p != this->section_list_.end();
2285 ++p)
2286 {
2287 if (!(*p)->needs_dynsym_index())
2288 (*p)->set_dynsym_index(-1U);
2289 else
2290 {
2291 (*p)->set_dynsym_index(index);
2292 ++index;
2293 }
2294 }
2295
7bf1f802
ILT
2296 // Count the local symbols that need to go in the dynamic symbol table,
2297 // and set the dynamic symbol indexes.
2298 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
2299 p != input_objects->relobj_end();
2300 ++p)
2301 {
2302 unsigned int new_index = (*p)->set_local_dynsym_indexes(index);
2303 index = new_index;
2304 }
a3ad94ed
ILT
2305
2306 unsigned int local_symcount = index;
14b31740 2307 *plocal_dynamic_count = local_symcount;
a3ad94ed 2308
9b07f471 2309 index = symtab->set_dynsym_indexes(index, pdynamic_symbols,
35cdfc9a 2310 &this->dynpool_, pversions);
a3ad94ed
ILT
2311
2312 int symsize;
2313 unsigned int align;
8851ecca 2314 const int size = parameters->target().get_size();
a3ad94ed
ILT
2315 if (size == 32)
2316 {
2317 symsize = elfcpp::Elf_sizes<32>::sym_size;
2318 align = 4;
2319 }
2320 else if (size == 64)
2321 {
2322 symsize = elfcpp::Elf_sizes<64>::sym_size;
2323 align = 8;
2324 }
2325 else
2326 gold_unreachable();
2327
14b31740
ILT
2328 // Create the dynamic symbol table section.
2329
3802b2dd
ILT
2330 Output_section* dynsym = this->choose_output_section(NULL, ".dynsym",
2331 elfcpp::SHT_DYNSYM,
2332 elfcpp::SHF_ALLOC,
2333 false);
a3ad94ed 2334
27bc2bce 2335 Output_section_data* odata = new Output_data_fixed_space(index * symsize,
7d9e3d98
ILT
2336 align,
2337 "** dynsym");
a3ad94ed
ILT
2338 dynsym->add_output_section_data(odata);
2339
2340 dynsym->set_info(local_symcount);
2341 dynsym->set_entsize(symsize);
2342 dynsym->set_addralign(align);
2343
2344 this->dynsym_section_ = dynsym;
2345
16649710 2346 Output_data_dynamic* const odyn = this->dynamic_data_;
a3ad94ed
ILT
2347 odyn->add_section_address(elfcpp::DT_SYMTAB, dynsym);
2348 odyn->add_constant(elfcpp::DT_SYMENT, symsize);
2349
d491d34e
ILT
2350 // If there are more than SHN_LORESERVE allocated sections, we
2351 // create a .dynsym_shndx section. It is possible that we don't
2352 // need one, because it is possible that there are no dynamic
2353 // symbols in any of the sections with indexes larger than
2354 // SHN_LORESERVE. This is probably unusual, though, and at this
2355 // time we don't know the actual section indexes so it is
2356 // inconvenient to check.
2357 if (this->allocated_output_section_count() >= elfcpp::SHN_LORESERVE)
2358 {
2359 Output_section* dynsym_xindex =
2360 this->choose_output_section(NULL, ".dynsym_shndx",
2361 elfcpp::SHT_SYMTAB_SHNDX,
2362 elfcpp::SHF_ALLOC,
2363 false);
2364
2365 this->dynsym_xindex_ = new Output_symtab_xindex(index);
2366
2367 dynsym_xindex->add_output_section_data(this->dynsym_xindex_);
2368
2369 dynsym_xindex->set_link_section(dynsym);
2370 dynsym_xindex->set_addralign(4);
2371 dynsym_xindex->set_entsize(4);
2372
2373 dynsym_xindex->set_after_input_sections();
2374
2375 // This tells the driver code to wait until the symbol table has
2376 // written out before writing out the postprocessing sections,
2377 // including the .dynsym_shndx section.
2378 this->any_postprocessing_sections_ = true;
2379 }
2380
14b31740
ILT
2381 // Create the dynamic string table section.
2382
3802b2dd
ILT
2383 Output_section* dynstr = this->choose_output_section(NULL, ".dynstr",
2384 elfcpp::SHT_STRTAB,
2385 elfcpp::SHF_ALLOC,
2386 false);
a3ad94ed
ILT
2387
2388 Output_section_data* strdata = new Output_data_strtab(&this->dynpool_);
2389 dynstr->add_output_section_data(strdata);
2390
16649710
ILT
2391 dynsym->set_link_section(dynstr);
2392 this->dynamic_section_->set_link_section(dynstr);
2393
a3ad94ed
ILT
2394 odyn->add_section_address(elfcpp::DT_STRTAB, dynstr);
2395 odyn->add_section_size(elfcpp::DT_STRSZ, dynstr);
2396
14b31740
ILT
2397 *pdynstr = dynstr;
2398
2399 // Create the hash tables.
2400
13670ee6
ILT
2401 if (strcmp(parameters->options().hash_style(), "sysv") == 0
2402 || strcmp(parameters->options().hash_style(), "both") == 0)
2403 {
2404 unsigned char* phash;
2405 unsigned int hashlen;
2406 Dynobj::create_elf_hash_table(*pdynamic_symbols, local_symcount,
2407 &phash, &hashlen);
2408
2409 Output_section* hashsec = this->choose_output_section(NULL, ".hash",
2410 elfcpp::SHT_HASH,
2411 elfcpp::SHF_ALLOC,
2412 false);
2413
2414 Output_section_data* hashdata = new Output_data_const_buffer(phash,
2415 hashlen,
7d9e3d98
ILT
2416 align,
2417 "** hash");
13670ee6
ILT
2418 hashsec->add_output_section_data(hashdata);
2419
2420 hashsec->set_link_section(dynsym);
2421 hashsec->set_entsize(4);
a3ad94ed 2422
13670ee6
ILT
2423 odyn->add_section_address(elfcpp::DT_HASH, hashsec);
2424 }
2425
2426 if (strcmp(parameters->options().hash_style(), "gnu") == 0
2427 || strcmp(parameters->options().hash_style(), "both") == 0)
2428 {
2429 unsigned char* phash;
2430 unsigned int hashlen;
2431 Dynobj::create_gnu_hash_table(*pdynamic_symbols, local_symcount,
2432 &phash, &hashlen);
a3ad94ed 2433
13670ee6
ILT
2434 Output_section* hashsec = this->choose_output_section(NULL, ".gnu.hash",
2435 elfcpp::SHT_GNU_HASH,
2436 elfcpp::SHF_ALLOC,
2437 false);
a3ad94ed 2438
13670ee6
ILT
2439 Output_section_data* hashdata = new Output_data_const_buffer(phash,
2440 hashlen,
7d9e3d98
ILT
2441 align,
2442 "** hash");
13670ee6 2443 hashsec->add_output_section_data(hashdata);
a3ad94ed 2444
13670ee6
ILT
2445 hashsec->set_link_section(dynsym);
2446 hashsec->set_entsize(4);
a3ad94ed 2447
13670ee6
ILT
2448 odyn->add_section_address(elfcpp::DT_GNU_HASH, hashsec);
2449 }
dbe717ef
ILT
2450}
2451
7bf1f802
ILT
2452// Assign offsets to each local portion of the dynamic symbol table.
2453
2454void
2455Layout::assign_local_dynsym_offsets(const Input_objects* input_objects)
2456{
2457 Output_section* dynsym = this->dynsym_section_;
2458 gold_assert(dynsym != NULL);
2459
2460 off_t off = dynsym->offset();
2461
2462 // Skip the dummy symbol at the start of the section.
2463 off += dynsym->entsize();
2464
2465 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
2466 p != input_objects->relobj_end();
2467 ++p)
2468 {
2469 unsigned int count = (*p)->set_local_dynsym_offset(off);
2470 off += count * dynsym->entsize();
2471 }
2472}
2473
14b31740
ILT
2474// Create the version sections.
2475
2476void
9025d29d 2477Layout::create_version_sections(const Versions* versions,
46fe1623 2478 const Symbol_table* symtab,
14b31740
ILT
2479 unsigned int local_symcount,
2480 const std::vector<Symbol*>& dynamic_symbols,
2481 const Output_section* dynstr)
2482{
2483 if (!versions->any_defs() && !versions->any_needs())
2484 return;
2485
8851ecca 2486 switch (parameters->size_and_endianness())
14b31740 2487 {
193a53d9 2488#ifdef HAVE_TARGET_32_LITTLE
8851ecca 2489 case Parameters::TARGET_32_LITTLE:
7d1a9ebb
ILT
2490 this->sized_create_version_sections<32, false>(versions, symtab,
2491 local_symcount,
2492 dynamic_symbols, dynstr);
8851ecca 2493 break;
193a53d9 2494#endif
8851ecca
ILT
2495#ifdef HAVE_TARGET_32_BIG
2496 case Parameters::TARGET_32_BIG:
7d1a9ebb
ILT
2497 this->sized_create_version_sections<32, true>(versions, symtab,
2498 local_symcount,
2499 dynamic_symbols, dynstr);
8851ecca 2500 break;
193a53d9 2501#endif
193a53d9 2502#ifdef HAVE_TARGET_64_LITTLE
8851ecca 2503 case Parameters::TARGET_64_LITTLE:
7d1a9ebb
ILT
2504 this->sized_create_version_sections<64, false>(versions, symtab,
2505 local_symcount,
2506 dynamic_symbols, dynstr);
8851ecca 2507 break;
193a53d9 2508#endif
8851ecca
ILT
2509#ifdef HAVE_TARGET_64_BIG
2510 case Parameters::TARGET_64_BIG:
7d1a9ebb
ILT
2511 this->sized_create_version_sections<64, true>(versions, symtab,
2512 local_symcount,
2513 dynamic_symbols, dynstr);
8851ecca
ILT
2514 break;
2515#endif
2516 default:
2517 gold_unreachable();
14b31740 2518 }
14b31740
ILT
2519}
2520
2521// Create the version sections, sized version.
2522
2523template<int size, bool big_endian>
2524void
2525Layout::sized_create_version_sections(
2526 const Versions* versions,
46fe1623 2527 const Symbol_table* symtab,
14b31740
ILT
2528 unsigned int local_symcount,
2529 const std::vector<Symbol*>& dynamic_symbols,
7d1a9ebb 2530 const Output_section* dynstr)
14b31740 2531{
3802b2dd
ILT
2532 Output_section* vsec = this->choose_output_section(NULL, ".gnu.version",
2533 elfcpp::SHT_GNU_versym,
2534 elfcpp::SHF_ALLOC,
2535 false);
14b31740
ILT
2536
2537 unsigned char* vbuf;
2538 unsigned int vsize;
7d1a9ebb
ILT
2539 versions->symbol_section_contents<size, big_endian>(symtab, &this->dynpool_,
2540 local_symcount,
2541 dynamic_symbols,
2542 &vbuf, &vsize);
14b31740 2543
7d9e3d98
ILT
2544 Output_section_data* vdata = new Output_data_const_buffer(vbuf, vsize, 2,
2545 "** versions");
14b31740
ILT
2546
2547 vsec->add_output_section_data(vdata);
2548 vsec->set_entsize(2);
2549 vsec->set_link_section(this->dynsym_section_);
2550
2551 Output_data_dynamic* const odyn = this->dynamic_data_;
2552 odyn->add_section_address(elfcpp::DT_VERSYM, vsec);
2553
2554 if (versions->any_defs())
2555 {
3802b2dd
ILT
2556 Output_section* vdsec;
2557 vdsec= this->choose_output_section(NULL, ".gnu.version_d",
2558 elfcpp::SHT_GNU_verdef,
2559 elfcpp::SHF_ALLOC,
2560 false);
14b31740
ILT
2561
2562 unsigned char* vdbuf;
2563 unsigned int vdsize;
2564 unsigned int vdentries;
7d1a9ebb
ILT
2565 versions->def_section_contents<size, big_endian>(&this->dynpool_, &vdbuf,
2566 &vdsize, &vdentries);
14b31740 2567
7d9e3d98
ILT
2568 Output_section_data* vddata =
2569 new Output_data_const_buffer(vdbuf, vdsize, 4, "** version defs");
14b31740
ILT
2570
2571 vdsec->add_output_section_data(vddata);
2572 vdsec->set_link_section(dynstr);
2573 vdsec->set_info(vdentries);
2574
2575 odyn->add_section_address(elfcpp::DT_VERDEF, vdsec);
2576 odyn->add_constant(elfcpp::DT_VERDEFNUM, vdentries);
2577 }
2578
2579 if (versions->any_needs())
2580 {
14b31740 2581 Output_section* vnsec;
3802b2dd
ILT
2582 vnsec = this->choose_output_section(NULL, ".gnu.version_r",
2583 elfcpp::SHT_GNU_verneed,
2584 elfcpp::SHF_ALLOC,
2585 false);
14b31740
ILT
2586
2587 unsigned char* vnbuf;
2588 unsigned int vnsize;
2589 unsigned int vnentries;
7d1a9ebb
ILT
2590 versions->need_section_contents<size, big_endian>(&this->dynpool_,
2591 &vnbuf, &vnsize,
2592 &vnentries);
14b31740 2593
7d9e3d98
ILT
2594 Output_section_data* vndata =
2595 new Output_data_const_buffer(vnbuf, vnsize, 4, "** version refs");
14b31740
ILT
2596
2597 vnsec->add_output_section_data(vndata);
2598 vnsec->set_link_section(dynstr);
2599 vnsec->set_info(vnentries);
2600
2601 odyn->add_section_address(elfcpp::DT_VERNEED, vnsec);
2602 odyn->add_constant(elfcpp::DT_VERNEEDNUM, vnentries);
2603 }
2604}
2605
dbe717ef
ILT
2606// Create the .interp section and PT_INTERP segment.
2607
2608void
2609Layout::create_interp(const Target* target)
2610{
2611 const char* interp = this->options_.dynamic_linker();
2612 if (interp == NULL)
2613 {
2614 interp = target->dynamic_linker();
a3ad94ed 2615 gold_assert(interp != NULL);
dbe717ef
ILT
2616 }
2617
2618 size_t len = strlen(interp) + 1;
2619
2620 Output_section_data* odata = new Output_data_const(interp, len, 1);
2621
3802b2dd
ILT
2622 Output_section* osec = this->choose_output_section(NULL, ".interp",
2623 elfcpp::SHT_PROGBITS,
2624 elfcpp::SHF_ALLOC,
2625 false);
dbe717ef
ILT
2626 osec->add_output_section_data(odata);
2627
1c4f3631
ILT
2628 if (!this->script_options_->saw_phdrs_clause())
2629 {
2630 Output_segment* oseg = this->make_output_segment(elfcpp::PT_INTERP,
2631 elfcpp::PF_R);
01676dcd 2632 oseg->add_output_section(osec, elfcpp::PF_R);
1c4f3631 2633 }
dbe717ef
ILT
2634}
2635
a3ad94ed
ILT
2636// Finish the .dynamic section and PT_DYNAMIC segment.
2637
2638void
2639Layout::finish_dynamic_section(const Input_objects* input_objects,
16649710 2640 const Symbol_table* symtab)
a3ad94ed 2641{
1c4f3631
ILT
2642 if (!this->script_options_->saw_phdrs_clause())
2643 {
2644 Output_segment* oseg = this->make_output_segment(elfcpp::PT_DYNAMIC,
2645 (elfcpp::PF_R
2646 | elfcpp::PF_W));
01676dcd
ILT
2647 oseg->add_output_section(this->dynamic_section_,
2648 elfcpp::PF_R | elfcpp::PF_W);
1c4f3631 2649 }
a3ad94ed 2650
16649710
ILT
2651 Output_data_dynamic* const odyn = this->dynamic_data_;
2652
a3ad94ed
ILT
2653 for (Input_objects::Dynobj_iterator p = input_objects->dynobj_begin();
2654 p != input_objects->dynobj_end();
2655 ++p)
2656 {
2657 // FIXME: Handle --as-needed.
2658 odyn->add_string(elfcpp::DT_NEEDED, (*p)->soname());
2659 }
2660
8851ecca 2661 if (parameters->options().shared())
fced7afd
ILT
2662 {
2663 const char* soname = this->options_.soname();
2664 if (soname != NULL)
2665 odyn->add_string(elfcpp::DT_SONAME, soname);
2666 }
2667
a3ad94ed
ILT
2668 // FIXME: Support --init and --fini.
2669 Symbol* sym = symtab->lookup("_init");
14b31740 2670 if (sym != NULL && sym->is_defined() && !sym->is_from_dynobj())
a3ad94ed
ILT
2671 odyn->add_symbol(elfcpp::DT_INIT, sym);
2672
2673 sym = symtab->lookup("_fini");
14b31740 2674 if (sym != NULL && sym->is_defined() && !sym->is_from_dynobj())
a3ad94ed
ILT
2675 odyn->add_symbol(elfcpp::DT_FINI, sym);
2676
2677 // FIXME: Support DT_INIT_ARRAY and DT_FINI_ARRAY.
41f542e7
ILT
2678
2679 // Add a DT_RPATH entry if needed.
2680 const General_options::Dir_list& rpath(this->options_.rpath());
2681 if (!rpath.empty())
2682 {
2683 std::string rpath_val;
2684 for (General_options::Dir_list::const_iterator p = rpath.begin();
2685 p != rpath.end();
2686 ++p)
2687 {
2688 if (rpath_val.empty())
ad2d6943 2689 rpath_val = p->name();
41f542e7
ILT
2690 else
2691 {
2692 // Eliminate duplicates.
2693 General_options::Dir_list::const_iterator q;
2694 for (q = rpath.begin(); q != p; ++q)
ad2d6943 2695 if (q->name() == p->name())
41f542e7
ILT
2696 break;
2697 if (q == p)
2698 {
2699 rpath_val += ':';
ad2d6943 2700 rpath_val += p->name();
41f542e7
ILT
2701 }
2702 }
2703 }
2704
2705 odyn->add_string(elfcpp::DT_RPATH, rpath_val);
7c414435
DM
2706 if (parameters->options().enable_new_dtags())
2707 odyn->add_string(elfcpp::DT_RUNPATH, rpath_val);
41f542e7 2708 }
4f4c5f80
ILT
2709
2710 // Look for text segments that have dynamic relocations.
2711 bool have_textrel = false;
4e8fe71f 2712 if (!this->script_options_->saw_sections_clause())
4f4c5f80 2713 {
4e8fe71f
ILT
2714 for (Segment_list::const_iterator p = this->segment_list_.begin();
2715 p != this->segment_list_.end();
2716 ++p)
2717 {
2718 if (((*p)->flags() & elfcpp::PF_W) == 0
2719 && (*p)->dynamic_reloc_count() > 0)
2720 {
2721 have_textrel = true;
2722 break;
2723 }
2724 }
2725 }
2726 else
2727 {
2728 // We don't know the section -> segment mapping, so we are
2729 // conservative and just look for readonly sections with
2730 // relocations. If those sections wind up in writable segments,
2731 // then we have created an unnecessary DT_TEXTREL entry.
2732 for (Section_list::const_iterator p = this->section_list_.begin();
2733 p != this->section_list_.end();
2734 ++p)
2735 {
2736 if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0
2737 && ((*p)->flags() & elfcpp::SHF_WRITE) == 0
2738 && ((*p)->dynamic_reloc_count() > 0))
2739 {
2740 have_textrel = true;
2741 break;
2742 }
2743 }
4f4c5f80
ILT
2744 }
2745
2746 // Add a DT_FLAGS entry. We add it even if no flags are set so that
2747 // post-link tools can easily modify these flags if desired.
2748 unsigned int flags = 0;
2749 if (have_textrel)
6a41d30b
ILT
2750 {
2751 // Add a DT_TEXTREL for compatibility with older loaders.
2752 odyn->add_constant(elfcpp::DT_TEXTREL, 0);
2753 flags |= elfcpp::DF_TEXTREL;
2754 }
8851ecca 2755 if (parameters->options().shared() && this->has_static_tls())
535890bb 2756 flags |= elfcpp::DF_STATIC_TLS;
4f4c5f80 2757 odyn->add_constant(elfcpp::DT_FLAGS, flags);
7c414435
DM
2758
2759 flags = 0;
2760 if (parameters->options().initfirst())
2761 flags |= elfcpp::DF_1_INITFIRST;
2762 if (parameters->options().interpose())
2763 flags |= elfcpp::DF_1_INTERPOSE;
2764 if (parameters->options().loadfltr())
2765 flags |= elfcpp::DF_1_LOADFLTR;
2766 if (parameters->options().nodefaultlib())
2767 flags |= elfcpp::DF_1_NODEFLIB;
2768 if (parameters->options().nodelete())
2769 flags |= elfcpp::DF_1_NODELETE;
2770 if (parameters->options().nodlopen())
2771 flags |= elfcpp::DF_1_NOOPEN;
2772 if (parameters->options().nodump())
2773 flags |= elfcpp::DF_1_NODUMP;
2774 if (!parameters->options().shared())
2775 flags &= ~(elfcpp::DF_1_INITFIRST
2776 | elfcpp::DF_1_NODELETE
2777 | elfcpp::DF_1_NOOPEN);
2778 if (flags)
2779 odyn->add_constant(elfcpp::DT_FLAGS_1, flags);
a3ad94ed
ILT
2780}
2781
a2fb1b05
ILT
2782// The mapping of .gnu.linkonce section names to real section names.
2783
ead1e424 2784#define MAPPING_INIT(f, t) { f, sizeof(f) - 1, t, sizeof(t) - 1 }
a2fb1b05
ILT
2785const Layout::Linkonce_mapping Layout::linkonce_mapping[] =
2786{
9f1d377b
ILT
2787 MAPPING_INIT("d.rel.ro.local", ".data.rel.ro.local"), // Before "d.rel.ro".
2788 MAPPING_INIT("d.rel.ro", ".data.rel.ro"), // Before "d".
a2fb1b05
ILT
2789 MAPPING_INIT("t", ".text"),
2790 MAPPING_INIT("r", ".rodata"),
2791 MAPPING_INIT("d", ".data"),
2792 MAPPING_INIT("b", ".bss"),
2793 MAPPING_INIT("s", ".sdata"),
2794 MAPPING_INIT("sb", ".sbss"),
2795 MAPPING_INIT("s2", ".sdata2"),
2796 MAPPING_INIT("sb2", ".sbss2"),
2797 MAPPING_INIT("wi", ".debug_info"),
2798 MAPPING_INIT("td", ".tdata"),
2799 MAPPING_INIT("tb", ".tbss"),
2800 MAPPING_INIT("lr", ".lrodata"),
2801 MAPPING_INIT("l", ".ldata"),
2802 MAPPING_INIT("lb", ".lbss"),
2803};
2804#undef MAPPING_INIT
2805
2806const int Layout::linkonce_mapping_count =
2807 sizeof(Layout::linkonce_mapping) / sizeof(Layout::linkonce_mapping[0]);
2808
2809// Return the name of the output section to use for a .gnu.linkonce
2810// section. This is based on the default ELF linker script of the old
2811// GNU linker. For example, we map a name like ".gnu.linkonce.t.foo"
ead1e424
ILT
2812// to ".text". Set *PLEN to the length of the name. *PLEN is
2813// initialized to the length of NAME.
a2fb1b05
ILT
2814
2815const char*
ead1e424 2816Layout::linkonce_output_name(const char* name, size_t *plen)
a2fb1b05
ILT
2817{
2818 const char* s = name + sizeof(".gnu.linkonce") - 1;
2819 if (*s != '.')
2820 return name;
2821 ++s;
2822 const Linkonce_mapping* plm = linkonce_mapping;
2823 for (int i = 0; i < linkonce_mapping_count; ++i, ++plm)
2824 {
2825 if (strncmp(s, plm->from, plm->fromlen) == 0 && s[plm->fromlen] == '.')
ead1e424
ILT
2826 {
2827 *plen = plm->tolen;
2828 return plm->to;
2829 }
a2fb1b05
ILT
2830 }
2831 return name;
2832}
2833
ead1e424
ILT
2834// Choose the output section name to use given an input section name.
2835// Set *PLEN to the length of the name. *PLEN is initialized to the
2836// length of NAME.
2837
2838const char*
2839Layout::output_section_name(const char* name, size_t* plen)
2840{
2841 if (Layout::is_linkonce(name))
2842 {
2843 // .gnu.linkonce sections are laid out as though they were named
2844 // for the sections are placed into.
2845 return Layout::linkonce_output_name(name, plen);
2846 }
2847
af4a8a83
ILT
2848 // gcc 4.3 generates the following sorts of section names when it
2849 // needs a section name specific to a function:
2850 // .text.FN
2851 // .rodata.FN
2852 // .sdata2.FN
2853 // .data.FN
2854 // .data.rel.FN
2855 // .data.rel.local.FN
2856 // .data.rel.ro.FN
2857 // .data.rel.ro.local.FN
2858 // .sdata.FN
2859 // .bss.FN
2860 // .sbss.FN
2861 // .tdata.FN
2862 // .tbss.FN
2863
2864 // The GNU linker maps all of those to the part before the .FN,
2865 // except that .data.rel.local.FN is mapped to .data, and
2866 // .data.rel.ro.local.FN is mapped to .data.rel.ro. The sections
2867 // beginning with .data.rel.ro.local are grouped together.
2868
2869 // For an anonymous namespace, the string FN can contain a '.'.
2870
2871 // Also of interest: .rodata.strN.N, .rodata.cstN, both of which the
2872 // GNU linker maps to .rodata.
2873
2874 // The .data.rel.ro sections enable a security feature triggered by
2875 // the -z relro option. Section which need to be relocated at
2876 // program startup time but which may be readonly after startup are
2877 // grouped into .data.rel.ro. They are then put into a PT_GNU_RELRO
2878 // segment. The dynamic linker will make that segment writable,
2879 // perform relocations, and then make it read-only. FIXME: We do
2880 // not yet implement this optimization.
2881
2882 // It is hard to handle this in a principled way.
2883
2884 // These are the rules we follow:
2885
2886 // If the section name has no initial '.', or no dot other than an
2887 // initial '.', we use the name unchanged (i.e., "mysection" and
2888 // ".text" are unchanged).
2889
9f1d377b
ILT
2890 // If the name starts with ".data.rel.ro.local" we use
2891 // ".data.rel.ro.local".
2892
af4a8a83
ILT
2893 // If the name starts with ".data.rel.ro" we use ".data.rel.ro".
2894
2895 // Otherwise, we drop the second '.' and everything that comes after
2896 // it (i.e., ".text.XXX" becomes ".text").
ead1e424
ILT
2897
2898 const char* s = name;
af4a8a83
ILT
2899 if (*s != '.')
2900 return name;
2901 ++s;
ead1e424
ILT
2902 const char* sdot = strchr(s, '.');
2903 if (sdot == NULL)
2904 return name;
2905
9f1d377b
ILT
2906 const char* const data_rel_ro_local = ".data.rel.ro.local";
2907 if (strncmp(name, data_rel_ro_local, strlen(data_rel_ro_local)) == 0)
2908 {
2909 *plen = strlen(data_rel_ro_local);
2910 return data_rel_ro_local;
2911 }
2912
af4a8a83
ILT
2913 const char* const data_rel_ro = ".data.rel.ro";
2914 if (strncmp(name, data_rel_ro, strlen(data_rel_ro)) == 0)
ead1e424 2915 {
af4a8a83
ILT
2916 *plen = strlen(data_rel_ro);
2917 return data_rel_ro;
ead1e424
ILT
2918 }
2919
ead1e424
ILT
2920 *plen = sdot - name;
2921 return name;
2922}
2923
a2fb1b05
ILT
2924// Record the signature of a comdat section, and return whether to
2925// include it in the link. If GROUP is true, this is a regular
2926// section group. If GROUP is false, this is a group signature
2927// derived from the name of a linkonce section. We want linkonce
2928// signatures and group signatures to block each other, but we don't
2929// want a linkonce signature to block another linkonce signature.
2930
2931bool
e94cf127
CC
2932Layout::add_comdat(Relobj* object, unsigned int shndx,
2933 const std::string& signature, bool group)
a2fb1b05 2934{
e94cf127 2935 Kept_section kept(object, shndx, group);
a2fb1b05 2936 std::pair<Signatures::iterator, bool> ins(
e94cf127 2937 this->signatures_.insert(std::make_pair(signature, kept)));
a2fb1b05
ILT
2938
2939 if (ins.second)
2940 {
2941 // This is the first time we've seen this signature.
2942 return true;
2943 }
2944
e94cf127 2945 if (ins.first->second.group_)
a2fb1b05
ILT
2946 {
2947 // We've already seen a real section group with this signature.
2948 return false;
2949 }
2950 else if (group)
2951 {
2952 // This is a real section group, and we've already seen a
a0fa0c07 2953 // linkonce section with this signature. Record that we've seen
a2fb1b05 2954 // a section group, and don't include this section group.
e94cf127 2955 ins.first->second.group_ = true;
a2fb1b05
ILT
2956 return false;
2957 }
2958 else
2959 {
2960 // We've already seen a linkonce section and this is a linkonce
2961 // section. These don't block each other--this may be the same
2962 // symbol name with different section types.
2963 return true;
2964 }
2965}
2966
e94cf127
CC
2967// Find the given comdat signature, and return the object and section
2968// index of the kept group.
2969Relobj*
2970Layout::find_kept_object(const std::string& signature,
2971 unsigned int* pshndx) const
2972{
2973 Signatures::const_iterator p = this->signatures_.find(signature);
2974 if (p == this->signatures_.end())
2975 return NULL;
2976 if (pshndx != NULL)
2977 *pshndx = p->second.shndx_;
2978 return p->second.object_;
2979}
2980
a445fddf
ILT
2981// Store the allocated sections into the section list.
2982
2983void
2984Layout::get_allocated_sections(Section_list* section_list) const
2985{
2986 for (Section_list::const_iterator p = this->section_list_.begin();
2987 p != this->section_list_.end();
2988 ++p)
2989 if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0)
2990 section_list->push_back(*p);
2991}
2992
2993// Create an output segment.
2994
2995Output_segment*
2996Layout::make_output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
2997{
8851ecca 2998 gold_assert(!parameters->options().relocatable());
a445fddf
ILT
2999 Output_segment* oseg = new Output_segment(type, flags);
3000 this->segment_list_.push_back(oseg);
3001 return oseg;
3002}
3003
730cdc88
ILT
3004// Write out the Output_sections. Most won't have anything to write,
3005// since most of the data will come from input sections which are
3006// handled elsewhere. But some Output_sections do have Output_data.
3007
3008void
3009Layout::write_output_sections(Output_file* of) const
3010{
3011 for (Section_list::const_iterator p = this->section_list_.begin();
3012 p != this->section_list_.end();
3013 ++p)
3014 {
3015 if (!(*p)->after_input_sections())
3016 (*p)->write(of);
3017 }
3018}
3019
61ba1cf9
ILT
3020// Write out data not associated with a section or the symbol table.
3021
3022void
9025d29d 3023Layout::write_data(const Symbol_table* symtab, Output_file* of) const
61ba1cf9 3024{
8851ecca 3025 if (!parameters->options().strip_all())
a3ad94ed 3026 {
9e2dcb77
ILT
3027 const Output_section* symtab_section = this->symtab_section_;
3028 for (Section_list::const_iterator p = this->section_list_.begin();
3029 p != this->section_list_.end();
3030 ++p)
a3ad94ed 3031 {
9e2dcb77
ILT
3032 if ((*p)->needs_symtab_index())
3033 {
3034 gold_assert(symtab_section != NULL);
3035 unsigned int index = (*p)->symtab_index();
3036 gold_assert(index > 0 && index != -1U);
3037 off_t off = (symtab_section->offset()
3038 + index * symtab_section->entsize());
d491d34e 3039 symtab->write_section_symbol(*p, this->symtab_xindex_, of, off);
9e2dcb77 3040 }
a3ad94ed
ILT
3041 }
3042 }
3043
3044 const Output_section* dynsym_section = this->dynsym_section_;
3045 for (Section_list::const_iterator p = this->section_list_.begin();
3046 p != this->section_list_.end();
3047 ++p)
3048 {
3049 if ((*p)->needs_dynsym_index())
3050 {
3051 gold_assert(dynsym_section != NULL);
3052 unsigned int index = (*p)->dynsym_index();
3053 gold_assert(index > 0 && index != -1U);
3054 off_t off = (dynsym_section->offset()
3055 + index * dynsym_section->entsize());
d491d34e 3056 symtab->write_section_symbol(*p, this->dynsym_xindex_, of, off);
a3ad94ed
ILT
3057 }
3058 }
3059
a3ad94ed 3060 // Write out the Output_data which are not in an Output_section.
61ba1cf9
ILT
3061 for (Data_list::const_iterator p = this->special_output_list_.begin();
3062 p != this->special_output_list_.end();
3063 ++p)
3064 (*p)->write(of);
3065}
3066
730cdc88
ILT
3067// Write out the Output_sections which can only be written after the
3068// input sections are complete.
3069
3070void
27bc2bce 3071Layout::write_sections_after_input_sections(Output_file* of)
730cdc88 3072{
27bc2bce 3073 // Determine the final section offsets, and thus the final output
9a0910c3
ILT
3074 // file size. Note we finalize the .shstrab last, to allow the
3075 // after_input_section sections to modify their section-names before
3076 // writing.
17a1d0a9 3077 if (this->any_postprocessing_sections_)
27bc2bce 3078 {
17a1d0a9
ILT
3079 off_t off = this->output_file_size_;
3080 off = this->set_section_offsets(off, POSTPROCESSING_SECTIONS_PASS);
3081
3082 // Now that we've finalized the names, we can finalize the shstrab.
3083 off =
3084 this->set_section_offsets(off,
3085 STRTAB_AFTER_POSTPROCESSING_SECTIONS_PASS);
3086
3087 if (off > this->output_file_size_)
3088 {
3089 of->resize(off);
3090 this->output_file_size_ = off;
3091 }
27bc2bce
ILT
3092 }
3093
730cdc88
ILT
3094 for (Section_list::const_iterator p = this->section_list_.begin();
3095 p != this->section_list_.end();
3096 ++p)
3097 {
3098 if ((*p)->after_input_sections())
3099 (*p)->write(of);
3100 }
27bc2bce 3101
27bc2bce 3102 this->section_headers_->write(of);
730cdc88
ILT
3103}
3104
8ed814a9
ILT
3105// If the build ID requires computing a checksum, do so here, and
3106// write it out. We compute a checksum over the entire file because
3107// that is simplest.
3108
3109void
3110Layout::write_build_id(Output_file* of) const
3111{
3112 if (this->build_id_note_ == NULL)
3113 return;
3114
3115 const unsigned char* iv = of->get_input_view(0, this->output_file_size_);
3116
3117 unsigned char* ov = of->get_output_view(this->build_id_note_->offset(),
3118 this->build_id_note_->data_size());
3119
3120 const char* style = parameters->options().build_id();
3121 if (strcmp(style, "sha1") == 0)
3122 {
3123 sha1_ctx ctx;
3124 sha1_init_ctx(&ctx);
3125 sha1_process_bytes(iv, this->output_file_size_, &ctx);
3126 sha1_finish_ctx(&ctx, ov);
3127 }
3128 else if (strcmp(style, "md5") == 0)
3129 {
3130 md5_ctx ctx;
3131 md5_init_ctx(&ctx);
3132 md5_process_bytes(iv, this->output_file_size_, &ctx);
3133 md5_finish_ctx(&ctx, ov);
3134 }
3135 else
3136 gold_unreachable();
3137
3138 of->write_output_view(this->build_id_note_->offset(),
3139 this->build_id_note_->data_size(),
3140 ov);
3141
3142 of->free_input_view(0, this->output_file_size_, iv);
3143}
3144
516cb3d0
ILT
3145// Write out a binary file. This is called after the link is
3146// complete. IN is the temporary output file we used to generate the
3147// ELF code. We simply walk through the segments, read them from
3148// their file offset in IN, and write them to their load address in
3149// the output file. FIXME: with a bit more work, we could support
3150// S-records and/or Intel hex format here.
3151
3152void
3153Layout::write_binary(Output_file* in) const
3154{
7cc619c3 3155 gold_assert(this->options_.oformat_enum()
bc644c6c 3156 == General_options::OBJECT_FORMAT_BINARY);
516cb3d0
ILT
3157
3158 // Get the size of the binary file.
3159 uint64_t max_load_address = 0;
3160 for (Segment_list::const_iterator p = this->segment_list_.begin();
3161 p != this->segment_list_.end();
3162 ++p)
3163 {
3164 if ((*p)->type() == elfcpp::PT_LOAD && (*p)->filesz() > 0)
3165 {
3166 uint64_t max_paddr = (*p)->paddr() + (*p)->filesz();
3167 if (max_paddr > max_load_address)
3168 max_load_address = max_paddr;
3169 }
3170 }
3171
8851ecca 3172 Output_file out(parameters->options().output_file_name());
516cb3d0
ILT
3173 out.open(max_load_address);
3174
3175 for (Segment_list::const_iterator p = this->segment_list_.begin();
3176 p != this->segment_list_.end();
3177 ++p)
3178 {
3179 if ((*p)->type() == elfcpp::PT_LOAD && (*p)->filesz() > 0)
3180 {
3181 const unsigned char* vin = in->get_input_view((*p)->offset(),
3182 (*p)->filesz());
3183 unsigned char* vout = out.get_output_view((*p)->paddr(),
3184 (*p)->filesz());
3185 memcpy(vout, vin, (*p)->filesz());
3186 out.write_output_view((*p)->paddr(), (*p)->filesz(), vout);
3187 in->free_input_view((*p)->offset(), (*p)->filesz(), vin);
3188 }
3189 }
3190
3191 out.close();
3192}
3193
7d9e3d98
ILT
3194// Print the output sections to the map file.
3195
3196void
3197Layout::print_to_mapfile(Mapfile* mapfile) const
3198{
3199 for (Segment_list::const_iterator p = this->segment_list_.begin();
3200 p != this->segment_list_.end();
3201 ++p)
3202 (*p)->print_sections_to_mapfile(mapfile);
3203}
3204
ad8f37d1
ILT
3205// Print statistical information to stderr. This is used for --stats.
3206
3207void
3208Layout::print_stats() const
3209{
3210 this->namepool_.print_stats("section name pool");
3211 this->sympool_.print_stats("output symbol name pool");
3212 this->dynpool_.print_stats("dynamic name pool");
38c5e8b4
ILT
3213
3214 for (Section_list::const_iterator p = this->section_list_.begin();
3215 p != this->section_list_.end();
3216 ++p)
3217 (*p)->print_merge_stats();
ad8f37d1
ILT
3218}
3219
730cdc88
ILT
3220// Write_sections_task methods.
3221
3222// We can always run this task.
3223
17a1d0a9
ILT
3224Task_token*
3225Write_sections_task::is_runnable()
730cdc88 3226{
17a1d0a9 3227 return NULL;
730cdc88
ILT
3228}
3229
3230// We need to unlock both OUTPUT_SECTIONS_BLOCKER and FINAL_BLOCKER
3231// when finished.
3232
17a1d0a9
ILT
3233void
3234Write_sections_task::locks(Task_locker* tl)
730cdc88 3235{
17a1d0a9
ILT
3236 tl->add(this, this->output_sections_blocker_);
3237 tl->add(this, this->final_blocker_);
730cdc88
ILT
3238}
3239
3240// Run the task--write out the data.
3241
3242void
3243Write_sections_task::run(Workqueue*)
3244{
3245 this->layout_->write_output_sections(this->of_);
3246}
3247
61ba1cf9
ILT
3248// Write_data_task methods.
3249
3250// We can always run this task.
3251
17a1d0a9
ILT
3252Task_token*
3253Write_data_task::is_runnable()
61ba1cf9 3254{
17a1d0a9 3255 return NULL;
61ba1cf9
ILT
3256}
3257
3258// We need to unlock FINAL_BLOCKER when finished.
3259
17a1d0a9
ILT
3260void
3261Write_data_task::locks(Task_locker* tl)
61ba1cf9 3262{
17a1d0a9 3263 tl->add(this, this->final_blocker_);
61ba1cf9
ILT
3264}
3265
3266// Run the task--write out the data.
3267
3268void
3269Write_data_task::run(Workqueue*)
3270{
9025d29d 3271 this->layout_->write_data(this->symtab_, this->of_);
61ba1cf9
ILT
3272}
3273
3274// Write_symbols_task methods.
3275
3276// We can always run this task.
3277
17a1d0a9
ILT
3278Task_token*
3279Write_symbols_task::is_runnable()
61ba1cf9 3280{
17a1d0a9 3281 return NULL;
61ba1cf9
ILT
3282}
3283
3284// We need to unlock FINAL_BLOCKER when finished.
3285
17a1d0a9
ILT
3286void
3287Write_symbols_task::locks(Task_locker* tl)
61ba1cf9 3288{
17a1d0a9 3289 tl->add(this, this->final_blocker_);
61ba1cf9
ILT
3290}
3291
3292// Run the task--write out the symbols.
3293
3294void
3295Write_symbols_task::run(Workqueue*)
3296{
9a2d6984 3297 this->symtab_->write_globals(this->input_objects_, this->sympool_,
d491d34e
ILT
3298 this->dynpool_, this->layout_->symtab_xindex(),
3299 this->layout_->dynsym_xindex(), this->of_);
61ba1cf9
ILT
3300}
3301
730cdc88
ILT
3302// Write_after_input_sections_task methods.
3303
3304// We can only run this task after the input sections have completed.
3305
17a1d0a9
ILT
3306Task_token*
3307Write_after_input_sections_task::is_runnable()
730cdc88
ILT
3308{
3309 if (this->input_sections_blocker_->is_blocked())
17a1d0a9
ILT
3310 return this->input_sections_blocker_;
3311 return NULL;
730cdc88
ILT
3312}
3313
3314// We need to unlock FINAL_BLOCKER when finished.
3315
17a1d0a9
ILT
3316void
3317Write_after_input_sections_task::locks(Task_locker* tl)
730cdc88 3318{
17a1d0a9 3319 tl->add(this, this->final_blocker_);
730cdc88
ILT
3320}
3321
3322// Run the task.
3323
3324void
3325Write_after_input_sections_task::run(Workqueue*)
3326{
3327 this->layout_->write_sections_after_input_sections(this->of_);
3328}
3329
92e059d8 3330// Close_task_runner methods.
61ba1cf9
ILT
3331
3332// Run the task--close the file.
3333
3334void
17a1d0a9 3335Close_task_runner::run(Workqueue*, const Task*)
61ba1cf9 3336{
8ed814a9
ILT
3337 // If we need to compute a checksum for the BUILD if, we do so here.
3338 this->layout_->write_build_id(this->of_);
3339
516cb3d0 3340 // If we've been asked to create a binary file, we do so here.
7cc619c3 3341 if (this->options_->oformat_enum() != General_options::OBJECT_FORMAT_ELF)
516cb3d0
ILT
3342 this->layout_->write_binary(this->of_);
3343
61ba1cf9
ILT
3344 this->of_->close();
3345}
3346
a2fb1b05
ILT
3347// Instantiate the templates we need. We could use the configure
3348// script to restrict this to only the ones for implemented targets.
3349
193a53d9 3350#ifdef HAVE_TARGET_32_LITTLE
a2fb1b05
ILT
3351template
3352Output_section*
730cdc88
ILT
3353Layout::layout<32, false>(Sized_relobj<32, false>* object, unsigned int shndx,
3354 const char* name,
3355 const elfcpp::Shdr<32, false>& shdr,
3356 unsigned int, unsigned int, off_t*);
193a53d9 3357#endif
a2fb1b05 3358
193a53d9 3359#ifdef HAVE_TARGET_32_BIG
a2fb1b05
ILT
3360template
3361Output_section*
730cdc88
ILT
3362Layout::layout<32, true>(Sized_relobj<32, true>* object, unsigned int shndx,
3363 const char* name,
3364 const elfcpp::Shdr<32, true>& shdr,
3365 unsigned int, unsigned int, off_t*);
193a53d9 3366#endif
a2fb1b05 3367
193a53d9 3368#ifdef HAVE_TARGET_64_LITTLE
a2fb1b05
ILT
3369template
3370Output_section*
730cdc88
ILT
3371Layout::layout<64, false>(Sized_relobj<64, false>* object, unsigned int shndx,
3372 const char* name,
3373 const elfcpp::Shdr<64, false>& shdr,
3374 unsigned int, unsigned int, off_t*);
193a53d9 3375#endif
a2fb1b05 3376
193a53d9 3377#ifdef HAVE_TARGET_64_BIG
a2fb1b05
ILT
3378template
3379Output_section*
730cdc88
ILT
3380Layout::layout<64, true>(Sized_relobj<64, true>* object, unsigned int shndx,
3381 const char* name,
3382 const elfcpp::Shdr<64, true>& shdr,
3383 unsigned int, unsigned int, off_t*);
193a53d9 3384#endif
a2fb1b05 3385
6a74a719
ILT
3386#ifdef HAVE_TARGET_32_LITTLE
3387template
3388Output_section*
3389Layout::layout_reloc<32, false>(Sized_relobj<32, false>* object,
3390 unsigned int reloc_shndx,
3391 const elfcpp::Shdr<32, false>& shdr,
3392 Output_section* data_section,
3393 Relocatable_relocs* rr);
3394#endif
3395
3396#ifdef HAVE_TARGET_32_BIG
3397template
3398Output_section*
3399Layout::layout_reloc<32, true>(Sized_relobj<32, true>* object,
3400 unsigned int reloc_shndx,
3401 const elfcpp::Shdr<32, true>& shdr,
3402 Output_section* data_section,
3403 Relocatable_relocs* rr);
3404#endif
3405
3406#ifdef HAVE_TARGET_64_LITTLE
3407template
3408Output_section*
3409Layout::layout_reloc<64, false>(Sized_relobj<64, false>* object,
3410 unsigned int reloc_shndx,
3411 const elfcpp::Shdr<64, false>& shdr,
3412 Output_section* data_section,
3413 Relocatable_relocs* rr);
3414#endif
3415
3416#ifdef HAVE_TARGET_64_BIG
3417template
3418Output_section*
3419Layout::layout_reloc<64, true>(Sized_relobj<64, true>* object,
3420 unsigned int reloc_shndx,
3421 const elfcpp::Shdr<64, true>& shdr,
3422 Output_section* data_section,
3423 Relocatable_relocs* rr);
3424#endif
3425
3426#ifdef HAVE_TARGET_32_LITTLE
3427template
3428void
3429Layout::layout_group<32, false>(Symbol_table* symtab,
3430 Sized_relobj<32, false>* object,
3431 unsigned int,
3432 const char* group_section_name,
3433 const char* signature,
3434 const elfcpp::Shdr<32, false>& shdr,
8825ac63
ILT
3435 elfcpp::Elf_Word flags,
3436 std::vector<unsigned int>* shndxes);
6a74a719
ILT
3437#endif
3438
3439#ifdef HAVE_TARGET_32_BIG
3440template
3441void
3442Layout::layout_group<32, true>(Symbol_table* symtab,
3443 Sized_relobj<32, true>* object,
3444 unsigned int,
3445 const char* group_section_name,
3446 const char* signature,
3447 const elfcpp::Shdr<32, true>& shdr,
8825ac63
ILT
3448 elfcpp::Elf_Word flags,
3449 std::vector<unsigned int>* shndxes);
6a74a719
ILT
3450#endif
3451
3452#ifdef HAVE_TARGET_64_LITTLE
3453template
3454void
3455Layout::layout_group<64, false>(Symbol_table* symtab,
3456 Sized_relobj<64, false>* object,
3457 unsigned int,
3458 const char* group_section_name,
3459 const char* signature,
3460 const elfcpp::Shdr<64, false>& shdr,
8825ac63
ILT
3461 elfcpp::Elf_Word flags,
3462 std::vector<unsigned int>* shndxes);
6a74a719
ILT
3463#endif
3464
3465#ifdef HAVE_TARGET_64_BIG
3466template
3467void
3468Layout::layout_group<64, true>(Symbol_table* symtab,
3469 Sized_relobj<64, true>* object,
3470 unsigned int,
3471 const char* group_section_name,
3472 const char* signature,
3473 const elfcpp::Shdr<64, true>& shdr,
8825ac63
ILT
3474 elfcpp::Elf_Word flags,
3475 std::vector<unsigned int>* shndxes);
6a74a719
ILT
3476#endif
3477
730cdc88
ILT
3478#ifdef HAVE_TARGET_32_LITTLE
3479template
3480Output_section*
3481Layout::layout_eh_frame<32, false>(Sized_relobj<32, false>* object,
3482 const unsigned char* symbols,
3483 off_t symbols_size,
3484 const unsigned char* symbol_names,
3485 off_t symbol_names_size,
3486 unsigned int shndx,
3487 const elfcpp::Shdr<32, false>& shdr,
3488 unsigned int reloc_shndx,
3489 unsigned int reloc_type,
3490 off_t* off);
3491#endif
3492
3493#ifdef HAVE_TARGET_32_BIG
3494template
3495Output_section*
3496Layout::layout_eh_frame<32, true>(Sized_relobj<32, true>* object,
3497 const unsigned char* symbols,
3498 off_t symbols_size,
3499 const unsigned char* symbol_names,
3500 off_t symbol_names_size,
3501 unsigned int shndx,
3502 const elfcpp::Shdr<32, true>& shdr,
3503 unsigned int reloc_shndx,
3504 unsigned int reloc_type,
3505 off_t* off);
3506#endif
3507
3508#ifdef HAVE_TARGET_64_LITTLE
3509template
3510Output_section*
3511Layout::layout_eh_frame<64, false>(Sized_relobj<64, false>* object,
3512 const unsigned char* symbols,
3513 off_t symbols_size,
3514 const unsigned char* symbol_names,
3515 off_t symbol_names_size,
3516 unsigned int shndx,
3517 const elfcpp::Shdr<64, false>& shdr,
3518 unsigned int reloc_shndx,
3519 unsigned int reloc_type,
3520 off_t* off);
3521#endif
3522
3523#ifdef HAVE_TARGET_64_BIG
3524template
3525Output_section*
3526Layout::layout_eh_frame<64, true>(Sized_relobj<64, true>* object,
3527 const unsigned char* symbols,
3528 off_t symbols_size,
3529 const unsigned char* symbol_names,
3530 off_t symbol_names_size,
3531 unsigned int shndx,
3532 const elfcpp::Shdr<64, true>& shdr,
3533 unsigned int reloc_shndx,
3534 unsigned int reloc_type,
3535 off_t* off);
3536#endif
a2fb1b05
ILT
3537
3538} // End namespace gold.
This page took 0.29297 seconds and 4 git commands to generate.