1 // layout.cc -- lay out output file sections for gold
3 // Copyright 2006, 2007 Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of gold.
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.
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.
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.
30 #include "parameters.h"
40 // Layout_task_runner methods.
42 // Lay out the sections. This is called after all the input objects
46 Layout_task_runner::run(Workqueue* workqueue)
48 off_t file_size = this->layout_->finalize(this->input_objects_,
51 // Now we know the final size of the output file and we know where
52 // each piece of information goes.
53 Output_file* of = new Output_file(this->options_,
54 this->input_objects_->target());
57 // Queue up the final set of tasks.
58 gold::queue_final_tasks(this->options_, this->input_objects_,
59 this->symtab_, this->layout_, workqueue, of);
64 Layout::Layout(const General_options& options)
65 : options_(options), namepool_(), sympool_(), dynpool_(), signatures_(),
66 section_name_map_(), segment_list_(), section_list_(),
67 unattached_section_list_(), special_output_list_(),
68 tls_segment_(NULL), symtab_section_(NULL),
69 dynsym_section_(NULL), dynamic_section_(NULL), dynamic_data_(NULL),
70 eh_frame_section_(NULL), output_file_size_(-1),
71 input_requires_executable_stack_(false),
72 input_with_gnu_stack_note_(false),
73 input_without_gnu_stack_note_(false),
76 // Make space for more than enough segments for a typical file.
77 // This is just for efficiency--it's OK if we wind up needing more.
78 this->segment_list_.reserve(12);
80 // We expect three unattached Output_data objects: the file header,
81 // the segment headers, and the section headers.
82 this->special_output_list_.reserve(3);
85 // Hash a key we use to look up an output section mapping.
88 Layout::Hash_key::operator()(const Layout::Key& k) const
90 return k.first + k.second.first + k.second.second;
93 // Return whether PREFIX is a prefix of STR.
96 is_prefix_of(const char* prefix, const char* str)
98 return strncmp(prefix, str, strlen(prefix)) == 0;
101 // Whether to include this section in the link.
103 template<int size, bool big_endian>
105 Layout::include_section(Sized_relobj<size, big_endian>*, const char* name,
106 const elfcpp::Shdr<size, big_endian>& shdr)
108 // Some section types are never linked. Some are only linked when
109 // doing a relocateable link.
110 switch (shdr.get_sh_type())
112 case elfcpp::SHT_NULL:
113 case elfcpp::SHT_SYMTAB:
114 case elfcpp::SHT_DYNSYM:
115 case elfcpp::SHT_STRTAB:
116 case elfcpp::SHT_HASH:
117 case elfcpp::SHT_DYNAMIC:
118 case elfcpp::SHT_SYMTAB_SHNDX:
121 case elfcpp::SHT_RELA:
122 case elfcpp::SHT_REL:
123 case elfcpp::SHT_GROUP:
124 return parameters->output_is_object();
126 case elfcpp::SHT_PROGBITS:
127 if (parameters->strip_debug()
128 && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
130 // Debugging sections can only be recognized by name.
131 if (is_prefix_of(".debug", name)
132 || is_prefix_of(".gnu.linkonce.wi.", name)
133 || is_prefix_of(".line", name)
134 || is_prefix_of(".stab", name))
144 // Return an output section named NAME, or NULL if there is none.
147 Layout::find_output_section(const char* name) const
149 for (Section_name_map::const_iterator p = this->section_name_map_.begin();
150 p != this->section_name_map_.end();
152 if (strcmp(p->second->name(), name) == 0)
157 // Return an output segment of type TYPE, with segment flags SET set
158 // and segment flags CLEAR clear. Return NULL if there is none.
161 Layout::find_output_segment(elfcpp::PT type, elfcpp::Elf_Word set,
162 elfcpp::Elf_Word clear) const
164 for (Segment_list::const_iterator p = this->segment_list_.begin();
165 p != this->segment_list_.end();
167 if (static_cast<elfcpp::PT>((*p)->type()) == type
168 && ((*p)->flags() & set) == set
169 && ((*p)->flags() & clear) == 0)
174 // Return the output section to use for section NAME with type TYPE
175 // and section flags FLAGS.
178 Layout::get_output_section(const char* name, Stringpool::Key name_key,
179 elfcpp::Elf_Word type, elfcpp::Elf_Xword flags)
181 // We should ignore some flags.
182 flags &= ~ (elfcpp::SHF_INFO_LINK
183 | elfcpp::SHF_LINK_ORDER
186 | elfcpp::SHF_STRINGS);
188 const Key key(name_key, std::make_pair(type, flags));
189 const std::pair<Key, Output_section*> v(key, NULL);
190 std::pair<Section_name_map::iterator, bool> ins(
191 this->section_name_map_.insert(v));
194 return ins.first->second;
197 // This is the first time we've seen this name/type/flags
199 Output_section* os = this->make_output_section(name, type, flags);
200 ins.first->second = os;
205 // Return the output section to use for input section SHNDX, with name
206 // NAME, with header HEADER, from object OBJECT. RELOC_SHNDX is the
207 // index of a relocation section which applies to this section, or 0
208 // if none, or -1U if more than one. RELOC_TYPE is the type of the
209 // relocation section if there is one. Set *OFF to the offset of this
210 // input section without the output section. Return NULL if the
211 // section should be discarded. Set *OFF to -1 if the section
212 // contents should not be written directly to the output file, but
213 // will instead receive special handling.
215 template<int size, bool big_endian>
217 Layout::layout(Sized_relobj<size, big_endian>* object, unsigned int shndx,
218 const char* name, const elfcpp::Shdr<size, big_endian>& shdr,
219 unsigned int reloc_shndx, unsigned int, off_t* off)
221 if (!this->include_section(object, name, shdr))
224 // If we are not doing a relocateable link, choose the name to use
225 // for the output section.
226 size_t len = strlen(name);
227 if (!parameters->output_is_object())
228 name = Layout::output_section_name(name, &len);
230 // FIXME: Handle SHF_OS_NONCONFORMING here.
232 // Canonicalize the section name.
233 Stringpool::Key name_key;
234 name = this->namepool_.add_prefix(name, len, &name_key);
236 // Find the output section. The output section is selected based on
237 // the section name, type, and flags.
238 Output_section* os = this->get_output_section(name, name_key,
240 shdr.get_sh_flags());
242 // FIXME: Handle SHF_LINK_ORDER somewhere.
244 *off = os->add_input_section(object, shndx, name, shdr, reloc_shndx);
249 // Special GNU handling of sections name .eh_frame. They will
250 // normally hold exception frame data as defined by the C++ ABI
251 // (http://codesourcery.com/cxx-abi/).
253 template<int size, bool big_endian>
255 Layout::layout_eh_frame(Sized_relobj<size, big_endian>* object,
256 const unsigned char* symbols,
258 const unsigned char* symbol_names,
259 off_t symbol_names_size,
261 const elfcpp::Shdr<size, big_endian>& shdr,
262 unsigned int reloc_shndx, unsigned int reloc_type,
265 gold_assert(shdr.get_sh_type() == elfcpp::SHT_PROGBITS);
266 gold_assert(shdr.get_sh_flags() == elfcpp::SHF_ALLOC);
268 Stringpool::Key name_key;
269 const char* name = this->namepool_.add(".eh_frame", false, &name_key);
271 Output_section* os = this->get_output_section(name, name_key,
272 elfcpp::SHT_PROGBITS,
275 if (this->eh_frame_section_ == NULL)
277 this->eh_frame_section_ = os;
278 this->eh_frame_data_ = new Eh_frame();
279 os->add_output_section_data(this->eh_frame_data_);
281 if (this->options_.create_eh_frame_hdr())
283 Stringpool::Key hdr_name_key;
284 const char* hdr_name = this->namepool_.add(".eh_frame_hdr",
287 Output_section* hdr_os =
288 this->get_output_section(hdr_name, hdr_name_key,
289 elfcpp::SHT_PROGBITS,
292 Eh_frame_hdr* hdr_posd = new Eh_frame_hdr(os, this->eh_frame_data_);
293 hdr_os->add_output_section_data(hdr_posd);
295 hdr_os->set_after_input_sections();
297 Output_segment* hdr_oseg =
298 new Output_segment(elfcpp::PT_GNU_EH_FRAME, elfcpp::PF_R);
299 this->segment_list_.push_back(hdr_oseg);
300 hdr_oseg->add_output_section(hdr_os, elfcpp::PF_R);
302 this->eh_frame_data_->set_eh_frame_hdr(hdr_posd);
306 gold_assert(this->eh_frame_section_ == os);
308 if (this->eh_frame_data_->add_ehframe_input_section(object,
319 // We couldn't handle this .eh_frame section for some reason.
320 // Add it as a normal section.
321 *off = os->add_input_section(object, shndx, name, shdr, reloc_shndx);
327 // Add POSD to an output section using NAME, TYPE, and FLAGS.
330 Layout::add_output_section_data(const char* name, elfcpp::Elf_Word type,
331 elfcpp::Elf_Xword flags,
332 Output_section_data* posd)
334 // Canonicalize the name.
335 Stringpool::Key name_key;
336 name = this->namepool_.add(name, true, &name_key);
338 Output_section* os = this->get_output_section(name, name_key, type, flags);
339 os->add_output_section_data(posd);
342 // Map section flags to segment flags.
345 Layout::section_flags_to_segment(elfcpp::Elf_Xword flags)
347 elfcpp::Elf_Word ret = elfcpp::PF_R;
348 if ((flags & elfcpp::SHF_WRITE) != 0)
350 if ((flags & elfcpp::SHF_EXECINSTR) != 0)
355 // Make a new Output_section, and attach it to segments as
359 Layout::make_output_section(const char* name, elfcpp::Elf_Word type,
360 elfcpp::Elf_Xword flags)
362 Output_section* os = new Output_section(name, type, flags);
363 this->section_list_.push_back(os);
365 if ((flags & elfcpp::SHF_ALLOC) == 0)
366 this->unattached_section_list_.push_back(os);
369 // This output section goes into a PT_LOAD segment.
371 elfcpp::Elf_Word seg_flags = Layout::section_flags_to_segment(flags);
373 // The only thing we really care about for PT_LOAD segments is
374 // whether or not they are writable, so that is how we search
375 // for them. People who need segments sorted on some other
376 // basis will have to wait until we implement a mechanism for
377 // them to describe the segments they want.
379 Segment_list::const_iterator p;
380 for (p = this->segment_list_.begin();
381 p != this->segment_list_.end();
384 if ((*p)->type() == elfcpp::PT_LOAD
385 && ((*p)->flags() & elfcpp::PF_W) == (seg_flags & elfcpp::PF_W))
387 (*p)->add_output_section(os, seg_flags);
392 if (p == this->segment_list_.end())
394 Output_segment* oseg = new Output_segment(elfcpp::PT_LOAD,
396 this->segment_list_.push_back(oseg);
397 oseg->add_output_section(os, seg_flags);
400 // If we see a loadable SHT_NOTE section, we create a PT_NOTE
402 if (type == elfcpp::SHT_NOTE)
404 // See if we already have an equivalent PT_NOTE segment.
405 for (p = this->segment_list_.begin();
406 p != segment_list_.end();
409 if ((*p)->type() == elfcpp::PT_NOTE
410 && (((*p)->flags() & elfcpp::PF_W)
411 == (seg_flags & elfcpp::PF_W)))
413 (*p)->add_output_section(os, seg_flags);
418 if (p == this->segment_list_.end())
420 Output_segment* oseg = new Output_segment(elfcpp::PT_NOTE,
422 this->segment_list_.push_back(oseg);
423 oseg->add_output_section(os, seg_flags);
427 // If we see a loadable SHF_TLS section, we create a PT_TLS
428 // segment. There can only be one such segment.
429 if ((flags & elfcpp::SHF_TLS) != 0)
431 if (this->tls_segment_ == NULL)
433 this->tls_segment_ = new Output_segment(elfcpp::PT_TLS,
435 this->segment_list_.push_back(this->tls_segment_);
437 this->tls_segment_->add_output_section(os, seg_flags);
444 // Handle the .note.GNU-stack section at layout time. SEEN_GNU_STACK
445 // is whether we saw a .note.GNU-stack section in the object file.
446 // GNU_STACK_FLAGS is the section flags. The flags give the
447 // protection required for stack memory. We record this in an
448 // executable as a PT_GNU_STACK segment. If an object file does not
449 // have a .note.GNU-stack segment, we must assume that it is an old
450 // object. On some targets that will force an executable stack.
453 Layout::layout_gnu_stack(bool seen_gnu_stack, uint64_t gnu_stack_flags)
456 this->input_without_gnu_stack_note_ = true;
459 this->input_with_gnu_stack_note_ = true;
460 if ((gnu_stack_flags & elfcpp::SHF_EXECINSTR) != 0)
461 this->input_requires_executable_stack_ = true;
465 // Create the dynamic sections which are needed before we read the
469 Layout::create_initial_dynamic_sections(const Input_objects* input_objects,
470 Symbol_table* symtab)
472 if (parameters->doing_static_link())
475 const char* dynamic_name = this->namepool_.add(".dynamic", false, NULL);
476 this->dynamic_section_ = this->make_output_section(dynamic_name,
479 | elfcpp::SHF_WRITE));
481 symtab->define_in_output_data(input_objects->target(), "_DYNAMIC", NULL,
482 this->dynamic_section_, 0, 0,
483 elfcpp::STT_OBJECT, elfcpp::STB_LOCAL,
484 elfcpp::STV_HIDDEN, 0, false, false);
486 this->dynamic_data_ = new Output_data_dynamic(&this->dynpool_);
488 this->dynamic_section_->add_output_section_data(this->dynamic_data_);
491 // For each output section whose name can be represented as C symbol,
492 // define __start and __stop symbols for the section. This is a GNU
496 Layout::define_section_symbols(Symbol_table* symtab, const Target* target)
498 for (Section_list::const_iterator p = this->section_list_.begin();
499 p != this->section_list_.end();
502 const char* const name = (*p)->name();
503 if (name[strspn(name,
505 "ABCDEFGHIJKLMNOPWRSTUVWXYZ"
506 "abcdefghijklmnopqrstuvwxyz"
510 const std::string name_string(name);
511 const std::string start_name("__start_" + name_string);
512 const std::string stop_name("__stop_" + name_string);
514 symtab->define_in_output_data(target,
524 false, // offset_is_from_end
525 false); // only_if_ref
527 symtab->define_in_output_data(target,
537 true, // offset_is_from_end
538 false); // only_if_ref
543 // Find the first read-only PT_LOAD segment, creating one if
547 Layout::find_first_load_seg()
549 for (Segment_list::const_iterator p = this->segment_list_.begin();
550 p != this->segment_list_.end();
553 if ((*p)->type() == elfcpp::PT_LOAD
554 && ((*p)->flags() & elfcpp::PF_R) != 0
555 && ((*p)->flags() & elfcpp::PF_W) == 0)
559 Output_segment* load_seg = new Output_segment(elfcpp::PT_LOAD, elfcpp::PF_R);
560 this->segment_list_.push_back(load_seg);
564 // Finalize the layout. When this is called, we have created all the
565 // output sections and all the output segments which are based on
566 // input sections. We have several things to do, and we have to do
567 // them in the right order, so that we get the right results correctly
570 // 1) Finalize the list of output segments and create the segment
573 // 2) Finalize the dynamic symbol table and associated sections.
575 // 3) Determine the final file offset of all the output segments.
577 // 4) Determine the final file offset of all the SHF_ALLOC output
580 // 5) Create the symbol table sections and the section name table
583 // 6) Finalize the symbol table: set symbol values to their final
584 // value and make a final determination of which symbols are going
585 // into the output symbol table.
587 // 7) Create the section table header.
589 // 8) Determine the final file offset of all the output sections which
590 // are not SHF_ALLOC, including the section table header.
592 // 9) Finalize the ELF file header.
594 // This function returns the size of the output file.
597 Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab)
599 Target* const target = input_objects->target();
601 target->finalize_sections(this);
603 this->create_gold_note();
604 this->create_executable_stack_info(target);
606 Output_segment* phdr_seg = NULL;
607 if (!parameters->doing_static_link())
609 // There was a dynamic object in the link. We need to create
610 // some information for the dynamic linker.
612 // Create the PT_PHDR segment which will hold the program
614 phdr_seg = new Output_segment(elfcpp::PT_PHDR, elfcpp::PF_R);
615 this->segment_list_.push_back(phdr_seg);
617 // Create the dynamic symbol table, including the hash table.
618 Output_section* dynstr;
619 std::vector<Symbol*> dynamic_symbols;
620 unsigned int local_dynamic_count;
622 this->create_dynamic_symtab(target, symtab, &dynstr,
623 &local_dynamic_count, &dynamic_symbols,
626 // Create the .interp section to hold the name of the
627 // interpreter, and put it in a PT_INTERP segment.
628 if (!parameters->output_is_shared())
629 this->create_interp(target);
631 // Finish the .dynamic section to hold the dynamic data, and put
632 // it in a PT_DYNAMIC segment.
633 this->finish_dynamic_section(input_objects, symtab);
635 // We should have added everything we need to the dynamic string
637 this->dynpool_.set_string_offsets();
639 // Create the version sections. We can't do this until the
640 // dynamic string table is complete.
641 this->create_version_sections(&versions, symtab, local_dynamic_count,
642 dynamic_symbols, dynstr);
645 // FIXME: Handle PT_GNU_STACK.
647 Output_segment* load_seg = this->find_first_load_seg();
649 // Lay out the segment headers.
650 Output_segment_headers* segment_headers;
651 segment_headers = new Output_segment_headers(this->segment_list_);
652 load_seg->add_initial_output_data(segment_headers);
653 this->special_output_list_.push_back(segment_headers);
654 if (phdr_seg != NULL)
655 phdr_seg->add_initial_output_data(segment_headers);
657 // Lay out the file header.
658 Output_file_header* file_header;
659 file_header = new Output_file_header(target, symtab, segment_headers);
660 load_seg->add_initial_output_data(file_header);
661 this->special_output_list_.push_back(file_header);
663 // We set the output section indexes in set_segment_offsets and
664 // set_section_offsets.
665 unsigned int shndx = 1;
667 // Set the file offsets of all the segments, and all the sections
669 off_t off = this->set_segment_offsets(target, load_seg, &shndx);
671 // Set the file offsets of all the data sections not associated with
672 // segments. This makes sure that debug sections have their offsets
673 // before symbols are finalized.
674 off = this->set_section_offsets(off, true);
676 // Create the symbol table sections.
677 this->create_symtab_sections(input_objects, symtab, &off);
679 // Create the .shstrtab section.
680 Output_section* shstrtab_section = this->create_shstrtab();
682 // Set the file offsets of all the non-data sections not associated with
684 off = this->set_section_offsets(off, false);
686 // Now that all sections have been created, set the section indexes.
687 shndx = this->set_section_indexes(shndx);
689 // Create the section table header.
690 Output_section_headers* oshdrs = this->create_shdrs(&off);
692 file_header->set_section_info(oshdrs, shstrtab_section);
694 // Now we know exactly where everything goes in the output file.
695 Output_data::layout_complete();
697 this->output_file_size_ = off;
702 // Create a .note section for an executable or shared library. This
703 // records the version of gold used to create the binary.
706 Layout::create_gold_note()
708 if (parameters->output_is_object())
711 // Authorities all agree that the values in a .note field should
712 // be aligned on 4-byte boundaries for 32-bit binaries. However,
713 // they differ on what the alignment is for 64-bit binaries.
714 // The GABI says unambiguously they take 8-byte alignment:
715 // http://sco.com/developers/gabi/latest/ch5.pheader.html#note_section
716 // Other documentation says alignment should always be 4 bytes:
717 // http://www.netbsd.org/docs/kernel/elf-notes.html#note-format
718 // GNU ld and GNU readelf both support the latter (at least as of
719 // version 2.16.91), and glibc always generates the latter for
720 // .note.ABI-tag (as of version 1.6), so that's the one we go with
722 #ifdef GABI_FORMAT_FOR_DOTNOTE_SECTION // This is not defined by default.
723 const int size = parameters->get_size();
728 // The contents of the .note section.
729 const char* name = "GNU";
730 std::string desc(std::string("gold ") + gold::get_version_string());
731 size_t namesz = strlen(name) + 1;
732 size_t aligned_namesz = align_address(namesz, size / 8);
733 size_t descsz = desc.length() + 1;
734 size_t aligned_descsz = align_address(descsz, size / 8);
735 const int note_type = 4;
737 size_t notesz = 3 * (size / 8) + aligned_namesz + aligned_descsz;
739 unsigned char buffer[128];
740 gold_assert(sizeof buffer >= notesz);
741 memset(buffer, 0, notesz);
743 bool is_big_endian = parameters->is_big_endian();
749 elfcpp::Swap<32, false>::writeval(buffer, namesz);
750 elfcpp::Swap<32, false>::writeval(buffer + 4, descsz);
751 elfcpp::Swap<32, false>::writeval(buffer + 8, note_type);
755 elfcpp::Swap<32, true>::writeval(buffer, namesz);
756 elfcpp::Swap<32, true>::writeval(buffer + 4, descsz);
757 elfcpp::Swap<32, true>::writeval(buffer + 8, note_type);
764 elfcpp::Swap<64, false>::writeval(buffer, namesz);
765 elfcpp::Swap<64, false>::writeval(buffer + 8, descsz);
766 elfcpp::Swap<64, false>::writeval(buffer + 16, note_type);
770 elfcpp::Swap<64, true>::writeval(buffer, namesz);
771 elfcpp::Swap<64, true>::writeval(buffer + 8, descsz);
772 elfcpp::Swap<64, true>::writeval(buffer + 16, note_type);
778 memcpy(buffer + 3 * (size / 8), name, namesz);
779 memcpy(buffer + 3 * (size / 8) + aligned_namesz, desc.data(), descsz);
781 const char* note_name = this->namepool_.add(".note", false, NULL);
782 Output_section* os = this->make_output_section(note_name,
785 Output_section_data* posd = new Output_data_const(buffer, notesz,
787 os->add_output_section_data(posd);
790 // Record whether the stack should be executable. This can be set
791 // from the command line using the -z execstack or -z noexecstack
792 // options. Otherwise, if any input file has a .note.GNU-stack
793 // section with the SHF_EXECINSTR flag set, the stack should be
794 // executable. Otherwise, if at least one input file a
795 // .note.GNU-stack section, and some input file has no .note.GNU-stack
796 // section, we use the target default for whether the stack should be
797 // executable. Otherwise, we don't generate a stack note. When
798 // generating a object file, we create a .note.GNU-stack section with
799 // the appropriate marking. When generating an executable or shared
800 // library, we create a PT_GNU_STACK segment.
803 Layout::create_executable_stack_info(const Target* target)
805 bool is_stack_executable;
806 if (this->options_.is_execstack_set())
807 is_stack_executable = this->options_.is_stack_executable();
808 else if (!this->input_with_gnu_stack_note_)
812 if (this->input_requires_executable_stack_)
813 is_stack_executable = true;
814 else if (this->input_without_gnu_stack_note_)
815 is_stack_executable = target->is_default_stack_executable();
817 is_stack_executable = false;
820 if (parameters->output_is_object())
822 const char* name = this->namepool_.add(".note.GNU-stack", false, NULL);
823 elfcpp::Elf_Xword flags = 0;
824 if (is_stack_executable)
825 flags |= elfcpp::SHF_EXECINSTR;
826 this->make_output_section(name, elfcpp::SHT_PROGBITS, flags);
830 int flags = elfcpp::PF_R | elfcpp::PF_W;
831 if (is_stack_executable)
832 flags |= elfcpp::PF_X;
833 Output_segment* oseg = new Output_segment(elfcpp::PT_GNU_STACK, flags);
834 this->segment_list_.push_back(oseg);
838 // Return whether SEG1 should be before SEG2 in the output file. This
839 // is based entirely on the segment type and flags. When this is
840 // called the segment addresses has normally not yet been set.
843 Layout::segment_precedes(const Output_segment* seg1,
844 const Output_segment* seg2)
846 elfcpp::Elf_Word type1 = seg1->type();
847 elfcpp::Elf_Word type2 = seg2->type();
849 // The single PT_PHDR segment is required to precede any loadable
850 // segment. We simply make it always first.
851 if (type1 == elfcpp::PT_PHDR)
853 gold_assert(type2 != elfcpp::PT_PHDR);
856 if (type2 == elfcpp::PT_PHDR)
859 // The single PT_INTERP segment is required to precede any loadable
860 // segment. We simply make it always second.
861 if (type1 == elfcpp::PT_INTERP)
863 gold_assert(type2 != elfcpp::PT_INTERP);
866 if (type2 == elfcpp::PT_INTERP)
869 // We then put PT_LOAD segments before any other segments.
870 if (type1 == elfcpp::PT_LOAD && type2 != elfcpp::PT_LOAD)
872 if (type2 == elfcpp::PT_LOAD && type1 != elfcpp::PT_LOAD)
875 // We put the PT_TLS segment last, because that is where the dynamic
876 // linker expects to find it (this is just for efficiency; other
877 // positions would also work correctly).
878 if (type1 == elfcpp::PT_TLS && type2 != elfcpp::PT_TLS)
880 if (type2 == elfcpp::PT_TLS && type1 != elfcpp::PT_TLS)
883 const elfcpp::Elf_Word flags1 = seg1->flags();
884 const elfcpp::Elf_Word flags2 = seg2->flags();
886 // The order of non-PT_LOAD segments is unimportant. We simply sort
887 // by the numeric segment type and flags values. There should not
888 // be more than one segment with the same type and flags.
889 if (type1 != elfcpp::PT_LOAD)
892 return type1 < type2;
893 gold_assert(flags1 != flags2);
894 return flags1 < flags2;
897 // We sort PT_LOAD segments based on the flags. Readonly segments
898 // come before writable segments. Then executable segments come
899 // before non-executable segments. Then the unlikely case of a
900 // non-readable segment comes before the normal case of a readable
901 // segment. If there are multiple segments with the same type and
902 // flags, we require that the address be set, and we sort by
903 // virtual address and then physical address.
904 if ((flags1 & elfcpp::PF_W) != (flags2 & elfcpp::PF_W))
905 return (flags1 & elfcpp::PF_W) == 0;
906 if ((flags1 & elfcpp::PF_X) != (flags2 & elfcpp::PF_X))
907 return (flags1 & elfcpp::PF_X) != 0;
908 if ((flags1 & elfcpp::PF_R) != (flags2 & elfcpp::PF_R))
909 return (flags1 & elfcpp::PF_R) == 0;
911 uint64_t vaddr1 = seg1->vaddr();
912 uint64_t vaddr2 = seg2->vaddr();
913 if (vaddr1 != vaddr2)
914 return vaddr1 < vaddr2;
916 uint64_t paddr1 = seg1->paddr();
917 uint64_t paddr2 = seg2->paddr();
918 gold_assert(paddr1 != paddr2);
919 return paddr1 < paddr2;
922 // Set the file offsets of all the segments, and all the sections they
923 // contain. They have all been created. LOAD_SEG must be be laid out
924 // first. Return the offset of the data to follow.
927 Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
928 unsigned int *pshndx)
930 // Sort them into the final order.
931 std::sort(this->segment_list_.begin(), this->segment_list_.end(),
932 Layout::Compare_segments());
934 // Find the PT_LOAD segments, and set their addresses and offsets
935 // and their section's addresses and offsets.
937 if (options_.user_set_text_segment_address())
938 addr = options_.text_segment_address();
940 addr = target->default_text_segment_address();
942 bool was_readonly = false;
943 for (Segment_list::iterator p = this->segment_list_.begin();
944 p != this->segment_list_.end();
947 if ((*p)->type() == elfcpp::PT_LOAD)
949 if (load_seg != NULL && load_seg != *p)
953 // If the last segment was readonly, and this one is not,
954 // then skip the address forward one page, maintaining the
955 // same position within the page. This lets us store both
956 // segments overlapping on a single page in the file, but
957 // the loader will put them on different pages in memory.
959 uint64_t orig_addr = addr;
960 uint64_t orig_off = off;
962 uint64_t aligned_addr = addr;
963 uint64_t abi_pagesize = target->abi_pagesize();
965 // FIXME: This should depend on the -n and -N options.
966 (*p)->set_minimum_addralign(target->common_pagesize());
968 if (was_readonly && ((*p)->flags() & elfcpp::PF_W) != 0)
970 uint64_t align = (*p)->addralign();
972 addr = align_address(addr, align);
974 if ((addr & (abi_pagesize - 1)) != 0)
975 addr = addr + abi_pagesize;
978 unsigned int shndx_hold = *pshndx;
979 off = orig_off + ((addr - orig_addr) & (abi_pagesize - 1));
980 uint64_t new_addr = (*p)->set_section_addresses(addr, &off, pshndx);
982 // Now that we know the size of this segment, we may be able
983 // to save a page in memory, at the cost of wasting some
984 // file space, by instead aligning to the start of a new
985 // page. Here we use the real machine page size rather than
986 // the ABI mandated page size.
988 if (aligned_addr != addr)
990 uint64_t common_pagesize = target->common_pagesize();
991 uint64_t first_off = (common_pagesize
993 & (common_pagesize - 1)));
994 uint64_t last_off = new_addr & (common_pagesize - 1);
997 && ((aligned_addr & ~ (common_pagesize - 1))
998 != (new_addr & ~ (common_pagesize - 1)))
999 && first_off + last_off <= common_pagesize)
1001 *pshndx = shndx_hold;
1002 addr = align_address(aligned_addr, common_pagesize);
1003 off = orig_off + ((addr - orig_addr) & (abi_pagesize - 1));
1004 new_addr = (*p)->set_section_addresses(addr, &off, pshndx);
1010 if (((*p)->flags() & elfcpp::PF_W) == 0)
1011 was_readonly = true;
1015 // Handle the non-PT_LOAD segments, setting their offsets from their
1016 // section's offsets.
1017 for (Segment_list::iterator p = this->segment_list_.begin();
1018 p != this->segment_list_.end();
1021 if ((*p)->type() != elfcpp::PT_LOAD)
1028 // Set the file offset of all the sections not associated with a
1032 Layout::set_section_offsets(off_t off,
1033 bool do_bits_sections)
1035 for (Section_list::iterator p = this->unattached_section_list_.begin();
1036 p != this->unattached_section_list_.end();
1039 bool is_bits_section = ((*p)->type() == elfcpp::SHT_PROGBITS
1040 || (*p)->type() == elfcpp::SHT_NOBITS);
1041 if (is_bits_section != do_bits_sections)
1043 if ((*p)->offset() != -1)
1045 off = align_address(off, (*p)->addralign());
1046 (*p)->set_address(0, off);
1047 off += (*p)->data_size();
1052 // Set the section indexes of all the sections not associated with a
1056 Layout::set_section_indexes(unsigned int shndx)
1058 for (Section_list::iterator p = this->unattached_section_list_.begin();
1059 p != this->unattached_section_list_.end();
1062 (*p)->set_out_shndx(shndx);
1068 // Create the symbol table sections. Here we also set the final
1069 // values of the symbols. At this point all the loadable sections are
1073 Layout::create_symtab_sections(const Input_objects* input_objects,
1074 Symbol_table* symtab,
1079 if (parameters->get_size() == 32)
1081 symsize = elfcpp::Elf_sizes<32>::sym_size;
1084 else if (parameters->get_size() == 64)
1086 symsize = elfcpp::Elf_sizes<64>::sym_size;
1093 off = align_address(off, align);
1094 off_t startoff = off;
1096 // Save space for the dummy symbol at the start of the section. We
1097 // never bother to write this out--it will just be left as zero.
1099 unsigned int local_symbol_index = 1;
1101 // Add STT_SECTION symbols for each Output section which needs one.
1102 for (Section_list::iterator p = this->section_list_.begin();
1103 p != this->section_list_.end();
1106 if (!(*p)->needs_symtab_index())
1107 (*p)->set_symtab_index(-1U);
1110 (*p)->set_symtab_index(local_symbol_index);
1111 ++local_symbol_index;
1116 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
1117 p != input_objects->relobj_end();
1120 Task_lock_obj<Object> tlo(**p);
1121 unsigned int index = (*p)->finalize_local_symbols(local_symbol_index,
1124 off += (index - local_symbol_index) * symsize;
1125 local_symbol_index = index;
1128 unsigned int local_symcount = local_symbol_index;
1129 gold_assert(local_symcount * symsize == off - startoff);
1132 size_t dyn_global_index;
1134 if (this->dynsym_section_ == NULL)
1137 dyn_global_index = 0;
1142 dyn_global_index = this->dynsym_section_->info();
1143 off_t locsize = dyn_global_index * this->dynsym_section_->entsize();
1144 dynoff = this->dynsym_section_->offset() + locsize;
1145 dyncount = (this->dynsym_section_->data_size() - locsize) / symsize;
1146 gold_assert(static_cast<off_t>(dyncount * symsize)
1147 == this->dynsym_section_->data_size() - locsize);
1150 off = symtab->finalize(local_symcount, off, dynoff, dyn_global_index,
1151 dyncount, &this->sympool_);
1153 if (!parameters->strip_all())
1155 this->sympool_.set_string_offsets();
1157 const char* symtab_name = this->namepool_.add(".symtab", false, NULL);
1158 Output_section* osymtab = this->make_output_section(symtab_name,
1161 this->symtab_section_ = osymtab;
1163 Output_section_data* pos = new Output_data_space(off - startoff,
1165 osymtab->add_output_section_data(pos);
1167 const char* strtab_name = this->namepool_.add(".strtab", false, NULL);
1168 Output_section* ostrtab = this->make_output_section(strtab_name,
1172 Output_section_data* pstr = new Output_data_strtab(&this->sympool_);
1173 ostrtab->add_output_section_data(pstr);
1175 osymtab->set_address(0, startoff);
1176 osymtab->set_link_section(ostrtab);
1177 osymtab->set_info(local_symcount);
1178 osymtab->set_entsize(symsize);
1184 // Create the .shstrtab section, which holds the names of the
1185 // sections. At the time this is called, we have created all the
1186 // output sections except .shstrtab itself.
1189 Layout::create_shstrtab()
1191 // FIXME: We don't need to create a .shstrtab section if we are
1192 // stripping everything.
1194 const char* name = this->namepool_.add(".shstrtab", false, NULL);
1196 this->namepool_.set_string_offsets();
1198 Output_section* os = this->make_output_section(name, elfcpp::SHT_STRTAB, 0);
1200 Output_section_data* posd = new Output_data_strtab(&this->namepool_);
1201 os->add_output_section_data(posd);
1206 // Create the section headers. SIZE is 32 or 64. OFF is the file
1209 Output_section_headers*
1210 Layout::create_shdrs(off_t* poff)
1212 Output_section_headers* oshdrs;
1213 oshdrs = new Output_section_headers(this,
1214 &this->segment_list_,
1215 &this->unattached_section_list_,
1217 off_t off = align_address(*poff, oshdrs->addralign());
1218 oshdrs->set_address(0, off);
1219 off += oshdrs->data_size();
1221 this->special_output_list_.push_back(oshdrs);
1225 // Create the dynamic symbol table.
1228 Layout::create_dynamic_symtab(const Target* target, Symbol_table* symtab,
1229 Output_section **pdynstr,
1230 unsigned int* plocal_dynamic_count,
1231 std::vector<Symbol*>* pdynamic_symbols,
1232 Versions* pversions)
1234 // Count all the symbols in the dynamic symbol table, and set the
1235 // dynamic symbol indexes.
1237 // Skip symbol 0, which is always all zeroes.
1238 unsigned int index = 1;
1240 // Add STT_SECTION symbols for each Output section which needs one.
1241 for (Section_list::iterator p = this->section_list_.begin();
1242 p != this->section_list_.end();
1245 if (!(*p)->needs_dynsym_index())
1246 (*p)->set_dynsym_index(-1U);
1249 (*p)->set_dynsym_index(index);
1254 // FIXME: Some targets apparently require local symbols in the
1255 // dynamic symbol table. Here is where we will have to count them,
1256 // and set the dynamic symbol indexes, and add the names to
1259 unsigned int local_symcount = index;
1260 *plocal_dynamic_count = local_symcount;
1262 // FIXME: We have to tell set_dynsym_indexes whether the
1263 // -E/--export-dynamic option was used.
1264 index = symtab->set_dynsym_indexes(target, index, pdynamic_symbols,
1265 &this->dynpool_, pversions);
1269 const int size = parameters->get_size();
1272 symsize = elfcpp::Elf_sizes<32>::sym_size;
1275 else if (size == 64)
1277 symsize = elfcpp::Elf_sizes<64>::sym_size;
1283 // Create the dynamic symbol table section.
1285 const char* dynsym_name = this->namepool_.add(".dynsym", false, NULL);
1286 Output_section* dynsym = this->make_output_section(dynsym_name,
1290 Output_section_data* odata = new Output_data_space(index * symsize,
1292 dynsym->add_output_section_data(odata);
1294 dynsym->set_info(local_symcount);
1295 dynsym->set_entsize(symsize);
1296 dynsym->set_addralign(align);
1298 this->dynsym_section_ = dynsym;
1300 Output_data_dynamic* const odyn = this->dynamic_data_;
1301 odyn->add_section_address(elfcpp::DT_SYMTAB, dynsym);
1302 odyn->add_constant(elfcpp::DT_SYMENT, symsize);
1304 // Create the dynamic string table section.
1306 const char* dynstr_name = this->namepool_.add(".dynstr", false, NULL);
1307 Output_section* dynstr = this->make_output_section(dynstr_name,
1311 Output_section_data* strdata = new Output_data_strtab(&this->dynpool_);
1312 dynstr->add_output_section_data(strdata);
1314 dynsym->set_link_section(dynstr);
1315 this->dynamic_section_->set_link_section(dynstr);
1317 odyn->add_section_address(elfcpp::DT_STRTAB, dynstr);
1318 odyn->add_section_size(elfcpp::DT_STRSZ, dynstr);
1322 // Create the hash tables.
1324 // FIXME: We need an option to create a GNU hash table.
1326 unsigned char* phash;
1327 unsigned int hashlen;
1328 Dynobj::create_elf_hash_table(*pdynamic_symbols, local_symcount,
1331 const char* hash_name = this->namepool_.add(".hash", false, NULL);
1332 Output_section* hashsec = this->make_output_section(hash_name,
1336 Output_section_data* hashdata = new Output_data_const_buffer(phash,
1339 hashsec->add_output_section_data(hashdata);
1341 hashsec->set_link_section(dynsym);
1342 hashsec->set_entsize(4);
1344 odyn->add_section_address(elfcpp::DT_HASH, hashsec);
1347 // Create the version sections.
1350 Layout::create_version_sections(const Versions* versions,
1351 const Symbol_table* symtab,
1352 unsigned int local_symcount,
1353 const std::vector<Symbol*>& dynamic_symbols,
1354 const Output_section* dynstr)
1356 if (!versions->any_defs() && !versions->any_needs())
1359 if (parameters->get_size() == 32)
1361 if (parameters->is_big_endian())
1363 #ifdef HAVE_TARGET_32_BIG
1364 this->sized_create_version_sections
1365 SELECT_SIZE_ENDIAN_NAME(32, true)(
1366 versions, symtab, local_symcount, dynamic_symbols, dynstr
1367 SELECT_SIZE_ENDIAN(32, true));
1374 #ifdef HAVE_TARGET_32_LITTLE
1375 this->sized_create_version_sections
1376 SELECT_SIZE_ENDIAN_NAME(32, false)(
1377 versions, symtab, local_symcount, dynamic_symbols, dynstr
1378 SELECT_SIZE_ENDIAN(32, false));
1384 else if (parameters->get_size() == 64)
1386 if (parameters->is_big_endian())
1388 #ifdef HAVE_TARGET_64_BIG
1389 this->sized_create_version_sections
1390 SELECT_SIZE_ENDIAN_NAME(64, true)(
1391 versions, symtab, local_symcount, dynamic_symbols, dynstr
1392 SELECT_SIZE_ENDIAN(64, true));
1399 #ifdef HAVE_TARGET_64_LITTLE
1400 this->sized_create_version_sections
1401 SELECT_SIZE_ENDIAN_NAME(64, false)(
1402 versions, symtab, local_symcount, dynamic_symbols, dynstr
1403 SELECT_SIZE_ENDIAN(64, false));
1413 // Create the version sections, sized version.
1415 template<int size, bool big_endian>
1417 Layout::sized_create_version_sections(
1418 const Versions* versions,
1419 const Symbol_table* symtab,
1420 unsigned int local_symcount,
1421 const std::vector<Symbol*>& dynamic_symbols,
1422 const Output_section* dynstr
1425 const char* vname = this->namepool_.add(".gnu.version", false, NULL);
1426 Output_section* vsec = this->make_output_section(vname,
1427 elfcpp::SHT_GNU_versym,
1430 unsigned char* vbuf;
1432 versions->symbol_section_contents SELECT_SIZE_ENDIAN_NAME(size, big_endian)(
1433 symtab, &this->dynpool_, local_symcount, dynamic_symbols, &vbuf, &vsize
1434 SELECT_SIZE_ENDIAN(size, big_endian));
1436 Output_section_data* vdata = new Output_data_const_buffer(vbuf, vsize, 2);
1438 vsec->add_output_section_data(vdata);
1439 vsec->set_entsize(2);
1440 vsec->set_link_section(this->dynsym_section_);
1442 Output_data_dynamic* const odyn = this->dynamic_data_;
1443 odyn->add_section_address(elfcpp::DT_VERSYM, vsec);
1445 if (versions->any_defs())
1447 const char* vdname = this->namepool_.add(".gnu.version_d", false, NULL);
1448 Output_section *vdsec;
1449 vdsec = this->make_output_section(vdname, elfcpp::SHT_GNU_verdef,
1452 unsigned char* vdbuf;
1453 unsigned int vdsize;
1454 unsigned int vdentries;
1455 versions->def_section_contents SELECT_SIZE_ENDIAN_NAME(size, big_endian)(
1456 &this->dynpool_, &vdbuf, &vdsize, &vdentries
1457 SELECT_SIZE_ENDIAN(size, big_endian));
1459 Output_section_data* vddata = new Output_data_const_buffer(vdbuf,
1463 vdsec->add_output_section_data(vddata);
1464 vdsec->set_link_section(dynstr);
1465 vdsec->set_info(vdentries);
1467 odyn->add_section_address(elfcpp::DT_VERDEF, vdsec);
1468 odyn->add_constant(elfcpp::DT_VERDEFNUM, vdentries);
1471 if (versions->any_needs())
1473 const char* vnname = this->namepool_.add(".gnu.version_r", false, NULL);
1474 Output_section* vnsec;
1475 vnsec = this->make_output_section(vnname, elfcpp::SHT_GNU_verneed,
1478 unsigned char* vnbuf;
1479 unsigned int vnsize;
1480 unsigned int vnentries;
1481 versions->need_section_contents SELECT_SIZE_ENDIAN_NAME(size, big_endian)
1482 (&this->dynpool_, &vnbuf, &vnsize, &vnentries
1483 SELECT_SIZE_ENDIAN(size, big_endian));
1485 Output_section_data* vndata = new Output_data_const_buffer(vnbuf,
1489 vnsec->add_output_section_data(vndata);
1490 vnsec->set_link_section(dynstr);
1491 vnsec->set_info(vnentries);
1493 odyn->add_section_address(elfcpp::DT_VERNEED, vnsec);
1494 odyn->add_constant(elfcpp::DT_VERNEEDNUM, vnentries);
1498 // Create the .interp section and PT_INTERP segment.
1501 Layout::create_interp(const Target* target)
1503 const char* interp = this->options_.dynamic_linker();
1506 interp = target->dynamic_linker();
1507 gold_assert(interp != NULL);
1510 size_t len = strlen(interp) + 1;
1512 Output_section_data* odata = new Output_data_const(interp, len, 1);
1514 const char* interp_name = this->namepool_.add(".interp", false, NULL);
1515 Output_section* osec = this->make_output_section(interp_name,
1516 elfcpp::SHT_PROGBITS,
1518 osec->add_output_section_data(odata);
1520 Output_segment* oseg = new Output_segment(elfcpp::PT_INTERP, elfcpp::PF_R);
1521 this->segment_list_.push_back(oseg);
1522 oseg->add_initial_output_section(osec, elfcpp::PF_R);
1525 // Finish the .dynamic section and PT_DYNAMIC segment.
1528 Layout::finish_dynamic_section(const Input_objects* input_objects,
1529 const Symbol_table* symtab)
1531 Output_segment* oseg = new Output_segment(elfcpp::PT_DYNAMIC,
1532 elfcpp::PF_R | elfcpp::PF_W);
1533 this->segment_list_.push_back(oseg);
1534 oseg->add_initial_output_section(this->dynamic_section_,
1535 elfcpp::PF_R | elfcpp::PF_W);
1537 Output_data_dynamic* const odyn = this->dynamic_data_;
1539 for (Input_objects::Dynobj_iterator p = input_objects->dynobj_begin();
1540 p != input_objects->dynobj_end();
1543 // FIXME: Handle --as-needed.
1544 odyn->add_string(elfcpp::DT_NEEDED, (*p)->soname());
1547 // FIXME: Support --init and --fini.
1548 Symbol* sym = symtab->lookup("_init");
1549 if (sym != NULL && sym->is_defined() && !sym->is_from_dynobj())
1550 odyn->add_symbol(elfcpp::DT_INIT, sym);
1552 sym = symtab->lookup("_fini");
1553 if (sym != NULL && sym->is_defined() && !sym->is_from_dynobj())
1554 odyn->add_symbol(elfcpp::DT_FINI, sym);
1556 // FIXME: Support DT_INIT_ARRAY and DT_FINI_ARRAY.
1558 // Add a DT_RPATH entry if needed.
1559 const General_options::Dir_list& rpath(this->options_.rpath());
1562 std::string rpath_val;
1563 for (General_options::Dir_list::const_iterator p = rpath.begin();
1567 if (rpath_val.empty())
1568 rpath_val = p->name();
1571 // Eliminate duplicates.
1572 General_options::Dir_list::const_iterator q;
1573 for (q = rpath.begin(); q != p; ++q)
1574 if (q->name() == p->name())
1579 rpath_val += p->name();
1584 odyn->add_string(elfcpp::DT_RPATH, rpath_val);
1587 // Add a DT_FLAGS entry. We add it even if no flags are set so that
1588 // post-link tools can easily modify these flags if desired.
1589 unsigned int flags = 0;
1590 if (this->have_textrel_)
1591 flags |= elfcpp::DF_TEXTREL;
1592 odyn->add_constant(elfcpp::DT_FLAGS, flags);
1595 // The mapping of .gnu.linkonce section names to real section names.
1597 #define MAPPING_INIT(f, t) { f, sizeof(f) - 1, t, sizeof(t) - 1 }
1598 const Layout::Linkonce_mapping Layout::linkonce_mapping[] =
1600 MAPPING_INIT("d.rel.ro", ".data.rel.ro"), // Must be before "d".
1601 MAPPING_INIT("t", ".text"),
1602 MAPPING_INIT("r", ".rodata"),
1603 MAPPING_INIT("d", ".data"),
1604 MAPPING_INIT("b", ".bss"),
1605 MAPPING_INIT("s", ".sdata"),
1606 MAPPING_INIT("sb", ".sbss"),
1607 MAPPING_INIT("s2", ".sdata2"),
1608 MAPPING_INIT("sb2", ".sbss2"),
1609 MAPPING_INIT("wi", ".debug_info"),
1610 MAPPING_INIT("td", ".tdata"),
1611 MAPPING_INIT("tb", ".tbss"),
1612 MAPPING_INIT("lr", ".lrodata"),
1613 MAPPING_INIT("l", ".ldata"),
1614 MAPPING_INIT("lb", ".lbss"),
1618 const int Layout::linkonce_mapping_count =
1619 sizeof(Layout::linkonce_mapping) / sizeof(Layout::linkonce_mapping[0]);
1621 // Return the name of the output section to use for a .gnu.linkonce
1622 // section. This is based on the default ELF linker script of the old
1623 // GNU linker. For example, we map a name like ".gnu.linkonce.t.foo"
1624 // to ".text". Set *PLEN to the length of the name. *PLEN is
1625 // initialized to the length of NAME.
1628 Layout::linkonce_output_name(const char* name, size_t *plen)
1630 const char* s = name + sizeof(".gnu.linkonce") - 1;
1634 const Linkonce_mapping* plm = linkonce_mapping;
1635 for (int i = 0; i < linkonce_mapping_count; ++i, ++plm)
1637 if (strncmp(s, plm->from, plm->fromlen) == 0 && s[plm->fromlen] == '.')
1646 // Choose the output section name to use given an input section name.
1647 // Set *PLEN to the length of the name. *PLEN is initialized to the
1651 Layout::output_section_name(const char* name, size_t* plen)
1653 if (Layout::is_linkonce(name))
1655 // .gnu.linkonce sections are laid out as though they were named
1656 // for the sections are placed into.
1657 return Layout::linkonce_output_name(name, plen);
1660 // gcc 4.3 generates the following sorts of section names when it
1661 // needs a section name specific to a function:
1667 // .data.rel.local.FN
1669 // .data.rel.ro.local.FN
1676 // The GNU linker maps all of those to the part before the .FN,
1677 // except that .data.rel.local.FN is mapped to .data, and
1678 // .data.rel.ro.local.FN is mapped to .data.rel.ro. The sections
1679 // beginning with .data.rel.ro.local are grouped together.
1681 // For an anonymous namespace, the string FN can contain a '.'.
1683 // Also of interest: .rodata.strN.N, .rodata.cstN, both of which the
1684 // GNU linker maps to .rodata.
1686 // The .data.rel.ro sections enable a security feature triggered by
1687 // the -z relro option. Section which need to be relocated at
1688 // program startup time but which may be readonly after startup are
1689 // grouped into .data.rel.ro. They are then put into a PT_GNU_RELRO
1690 // segment. The dynamic linker will make that segment writable,
1691 // perform relocations, and then make it read-only. FIXME: We do
1692 // not yet implement this optimization.
1694 // It is hard to handle this in a principled way.
1696 // These are the rules we follow:
1698 // If the section name has no initial '.', or no dot other than an
1699 // initial '.', we use the name unchanged (i.e., "mysection" and
1700 // ".text" are unchanged).
1702 // If the name starts with ".data.rel.ro" we use ".data.rel.ro".
1704 // Otherwise, we drop the second '.' and everything that comes after
1705 // it (i.e., ".text.XXX" becomes ".text").
1707 const char* s = name;
1711 const char* sdot = strchr(s, '.');
1715 const char* const data_rel_ro = ".data.rel.ro";
1716 if (strncmp(name, data_rel_ro, strlen(data_rel_ro)) == 0)
1718 *plen = strlen(data_rel_ro);
1722 *plen = sdot - name;
1726 // Record the signature of a comdat section, and return whether to
1727 // include it in the link. If GROUP is true, this is a regular
1728 // section group. If GROUP is false, this is a group signature
1729 // derived from the name of a linkonce section. We want linkonce
1730 // signatures and group signatures to block each other, but we don't
1731 // want a linkonce signature to block another linkonce signature.
1734 Layout::add_comdat(const char* signature, bool group)
1736 std::string sig(signature);
1737 std::pair<Signatures::iterator, bool> ins(
1738 this->signatures_.insert(std::make_pair(sig, group)));
1742 // This is the first time we've seen this signature.
1746 if (ins.first->second)
1748 // We've already seen a real section group with this signature.
1753 // This is a real section group, and we've already seen a
1754 // linkonce section with this signature. Record that we've seen
1755 // a section group, and don't include this section group.
1756 ins.first->second = true;
1761 // We've already seen a linkonce section and this is a linkonce
1762 // section. These don't block each other--this may be the same
1763 // symbol name with different section types.
1768 // Write out the Output_sections. Most won't have anything to write,
1769 // since most of the data will come from input sections which are
1770 // handled elsewhere. But some Output_sections do have Output_data.
1773 Layout::write_output_sections(Output_file* of) const
1775 for (Section_list::const_iterator p = this->section_list_.begin();
1776 p != this->section_list_.end();
1779 if (!(*p)->after_input_sections())
1784 // Write out data not associated with a section or the symbol table.
1787 Layout::write_data(const Symbol_table* symtab, Output_file* of) const
1789 if (!parameters->strip_all())
1791 const Output_section* symtab_section = this->symtab_section_;
1792 for (Section_list::const_iterator p = this->section_list_.begin();
1793 p != this->section_list_.end();
1796 if ((*p)->needs_symtab_index())
1798 gold_assert(symtab_section != NULL);
1799 unsigned int index = (*p)->symtab_index();
1800 gold_assert(index > 0 && index != -1U);
1801 off_t off = (symtab_section->offset()
1802 + index * symtab_section->entsize());
1803 symtab->write_section_symbol(*p, of, off);
1808 const Output_section* dynsym_section = this->dynsym_section_;
1809 for (Section_list::const_iterator p = this->section_list_.begin();
1810 p != this->section_list_.end();
1813 if ((*p)->needs_dynsym_index())
1815 gold_assert(dynsym_section != NULL);
1816 unsigned int index = (*p)->dynsym_index();
1817 gold_assert(index > 0 && index != -1U);
1818 off_t off = (dynsym_section->offset()
1819 + index * dynsym_section->entsize());
1820 symtab->write_section_symbol(*p, of, off);
1824 // Write out the Output_data which are not in an Output_section.
1825 for (Data_list::const_iterator p = this->special_output_list_.begin();
1826 p != this->special_output_list_.end();
1831 // Write out the Output_sections which can only be written after the
1832 // input sections are complete.
1835 Layout::write_sections_after_input_sections(Output_file* of) const
1837 for (Section_list::const_iterator p = this->section_list_.begin();
1838 p != this->section_list_.end();
1841 if ((*p)->after_input_sections())
1846 // Write_sections_task methods.
1848 // We can always run this task.
1850 Task::Is_runnable_type
1851 Write_sections_task::is_runnable(Workqueue*)
1856 // We need to unlock both OUTPUT_SECTIONS_BLOCKER and FINAL_BLOCKER
1859 class Write_sections_task::Write_sections_locker : public Task_locker
1862 Write_sections_locker(Task_token& output_sections_blocker,
1863 Task_token& final_blocker,
1864 Workqueue* workqueue)
1865 : output_sections_block_(output_sections_blocker, workqueue),
1866 final_block_(final_blocker, workqueue)
1870 Task_block_token output_sections_block_;
1871 Task_block_token final_block_;
1875 Write_sections_task::locks(Workqueue* workqueue)
1877 return new Write_sections_locker(*this->output_sections_blocker_,
1878 *this->final_blocker_,
1882 // Run the task--write out the data.
1885 Write_sections_task::run(Workqueue*)
1887 this->layout_->write_output_sections(this->of_);
1890 // Write_data_task methods.
1892 // We can always run this task.
1894 Task::Is_runnable_type
1895 Write_data_task::is_runnable(Workqueue*)
1900 // We need to unlock FINAL_BLOCKER when finished.
1903 Write_data_task::locks(Workqueue* workqueue)
1905 return new Task_locker_block(*this->final_blocker_, workqueue);
1908 // Run the task--write out the data.
1911 Write_data_task::run(Workqueue*)
1913 this->layout_->write_data(this->symtab_, this->of_);
1916 // Write_symbols_task methods.
1918 // We can always run this task.
1920 Task::Is_runnable_type
1921 Write_symbols_task::is_runnable(Workqueue*)
1926 // We need to unlock FINAL_BLOCKER when finished.
1929 Write_symbols_task::locks(Workqueue* workqueue)
1931 return new Task_locker_block(*this->final_blocker_, workqueue);
1934 // Run the task--write out the symbols.
1937 Write_symbols_task::run(Workqueue*)
1939 this->symtab_->write_globals(this->input_objects_, this->sympool_,
1940 this->dynpool_, this->of_);
1943 // Write_after_input_sections_task methods.
1945 // We can only run this task after the input sections have completed.
1947 Task::Is_runnable_type
1948 Write_after_input_sections_task::is_runnable(Workqueue*)
1950 if (this->input_sections_blocker_->is_blocked())
1955 // We need to unlock FINAL_BLOCKER when finished.
1958 Write_after_input_sections_task::locks(Workqueue* workqueue)
1960 return new Task_locker_block(*this->final_blocker_, workqueue);
1966 Write_after_input_sections_task::run(Workqueue*)
1968 this->layout_->write_sections_after_input_sections(this->of_);
1971 // Close_task_runner methods.
1973 // Run the task--close the file.
1976 Close_task_runner::run(Workqueue*)
1981 // Instantiate the templates we need. We could use the configure
1982 // script to restrict this to only the ones for implemented targets.
1984 #ifdef HAVE_TARGET_32_LITTLE
1987 Layout::layout<32, false>(Sized_relobj<32, false>* object, unsigned int shndx,
1989 const elfcpp::Shdr<32, false>& shdr,
1990 unsigned int, unsigned int, off_t*);
1993 #ifdef HAVE_TARGET_32_BIG
1996 Layout::layout<32, true>(Sized_relobj<32, true>* object, unsigned int shndx,
1998 const elfcpp::Shdr<32, true>& shdr,
1999 unsigned int, unsigned int, off_t*);
2002 #ifdef HAVE_TARGET_64_LITTLE
2005 Layout::layout<64, false>(Sized_relobj<64, false>* object, unsigned int shndx,
2007 const elfcpp::Shdr<64, false>& shdr,
2008 unsigned int, unsigned int, off_t*);
2011 #ifdef HAVE_TARGET_64_BIG
2014 Layout::layout<64, true>(Sized_relobj<64, true>* object, unsigned int shndx,
2016 const elfcpp::Shdr<64, true>& shdr,
2017 unsigned int, unsigned int, off_t*);
2020 #ifdef HAVE_TARGET_32_LITTLE
2023 Layout::layout_eh_frame<32, false>(Sized_relobj<32, false>* object,
2024 const unsigned char* symbols,
2026 const unsigned char* symbol_names,
2027 off_t symbol_names_size,
2029 const elfcpp::Shdr<32, false>& shdr,
2030 unsigned int reloc_shndx,
2031 unsigned int reloc_type,
2035 #ifdef HAVE_TARGET_32_BIG
2038 Layout::layout_eh_frame<32, true>(Sized_relobj<32, true>* object,
2039 const unsigned char* symbols,
2041 const unsigned char* symbol_names,
2042 off_t symbol_names_size,
2044 const elfcpp::Shdr<32, true>& shdr,
2045 unsigned int reloc_shndx,
2046 unsigned int reloc_type,
2050 #ifdef HAVE_TARGET_64_LITTLE
2053 Layout::layout_eh_frame<64, false>(Sized_relobj<64, false>* object,
2054 const unsigned char* symbols,
2056 const unsigned char* symbol_names,
2057 off_t symbol_names_size,
2059 const elfcpp::Shdr<64, false>& shdr,
2060 unsigned int reloc_shndx,
2061 unsigned int reloc_type,
2065 #ifdef HAVE_TARGET_64_BIG
2068 Layout::layout_eh_frame<64, true>(Sized_relobj<64, true>* object,
2069 const unsigned char* symbols,
2071 const unsigned char* symbol_names,
2072 off_t symbol_names_size,
2074 const elfcpp::Shdr<64, true>& shdr,
2075 unsigned int reloc_shndx,
2076 unsigned int reloc_type,
2080 } // End namespace gold.