// ehframe.h -- handle exception frame sections for gold -*- C++ -*-
-// Copyright 2006, 2007 Free Software Foundation, Inc.
+// Copyright (C) 2006-2020 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
#ifndef GOLD_EHFRAME_H
#define GOLD_EHFRAME_H
+#include <map>
+#include <set>
+#include <vector>
+
#include "output.h"
+#include "merge.h"
namespace gold
{
+template<int size, bool big_endian>
+class Track_relocs;
+
+class Eh_frame;
+
// This class manages the .eh_frame_hdr section, which holds the data
// for the PT_GNU_EH_FRAME segment. gcc's unwind support code uses
// the PT_GNU_EH_FRAME segment to find the list of FDEs. This saves
// time and when a shared object is loaded, and the time required to
// deregister the exception handlers when a shared object is unloaded.
-// FIXME: gcc supports using storing a sorted lookup table for the
-// FDEs in the PT_GNU_EH_FRAME segment, but we do not yet generate
-// that.
-
class Eh_frame_hdr : public Output_section_data
{
public:
- Eh_frame_hdr(Output_section* eh_frame_section);
+ Eh_frame_hdr(Output_section* eh_frame_section, const Eh_frame*);
+ // Record that we found an unrecognized .eh_frame section.
+ void
+ found_unrecognized_eh_frame_section()
+ { this->any_unrecognized_eh_frame_sections_ = true; }
+
+ // Record an FDE.
+ void
+ record_fde(section_offset_type fde_offset, unsigned char fde_encoding)
+ {
+ if (!this->any_unrecognized_eh_frame_sections_)
+ this->fde_offsets_.push_back(std::make_pair(fde_offset, fde_encoding));
+ }
+
+ protected:
// Set the final data size.
void
- do_set_address(uint64_t address, off_t offset);
+ set_final_data_size();
// Write the data to the file.
void
do_write(Output_file*);
+ // Write to a map file.
+ void
+ do_print_to_mapfile(Mapfile* mapfile) const
+ { mapfile->print_output_data(this, _("** eh_frame_hdr")); }
+
private:
+ // Write the data to the file with the right endianness.
+ template<int size, bool big_endian>
+ void
+ do_sized_write(Output_file*);
+
+ // The data we record for one FDE: the offset of the FDE within the
+ // .eh_frame section, and the FDE encoding.
+ typedef std::pair<section_offset_type, unsigned char> Fde_offset;
+
+ // The list of information we record for an FDE.
+ typedef std::vector<Fde_offset> Fde_offsets;
+
+ // When writing out the header, we convert the FDE offsets into FDE
+ // addresses. This is a list of pairs of the offset from the header
+ // to the FDE PC and to the FDE itself.
+ template<int size>
+ class Fde_addresses
+ {
+ public:
+ typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
+ typedef typename std::pair<Address, Address> Fde_address;
+ typedef typename std::vector<Fde_address> Fde_address_list;
+ typedef typename Fde_address_list::iterator iterator;
+
+ Fde_addresses(unsigned int reserve)
+ : fde_addresses_()
+ { this->fde_addresses_.reserve(reserve); }
+
+ void
+ push_back(Address pc_address, Address fde_address)
+ {
+ this->fde_addresses_.push_back(std::make_pair(pc_address, fde_address));
+ }
+
+ iterator
+ begin()
+ { return this->fde_addresses_.begin(); }
+
+ iterator
+ end()
+ { return this->fde_addresses_.end(); }
+
+ private:
+ Fde_address_list fde_addresses_;
+ };
+
+ // Compare Fde_address objects.
+ template<int size>
+ struct Fde_address_compare
+ {
+ bool
+ operator()(const typename Fde_addresses<size>::Fde_address& f1,
+ const typename Fde_addresses<size>::Fde_address& f2) const
+ { return f1.first < f2.first; }
+ };
+
+ // Return the PC to which an FDE refers.
+ template<int size, bool big_endian>
+ typename elfcpp::Elf_types<size>::Elf_Addr
+ get_fde_pc(typename elfcpp::Elf_types<size>::Elf_Addr eh_frame_address,
+ const unsigned char* eh_frame_contents,
+ section_offset_type fde_offset, unsigned char fde_encoding);
+
+ // Convert Fde_offsets to Fde_addresses.
+ template<int size, bool big_endian>
+ void
+ get_fde_addresses(Output_file* of,
+ const Fde_offsets* fde_offsets,
+ Fde_addresses<size>* fde_addresses);
+
// The .eh_frame section.
Output_section* eh_frame_section_;
+ // The .eh_frame section data.
+ const Eh_frame* eh_frame_data_;
+ // Data from the FDEs in the .eh_frame sections.
+ Fde_offsets fde_offsets_;
+ // Whether we found any .eh_frame sections which we could not
+ // process.
+ bool any_unrecognized_eh_frame_sections_;
+};
+
+// This class holds an FDE.
+
+class Fde
+{
+ public:
+ Fde(Relobj* object, unsigned int shndx, section_offset_type input_offset,
+ const unsigned char* contents, size_t length)
+ : object_(object),
+ contents_(reinterpret_cast<const char*>(contents), length)
+ {
+ this->u_.from_object.shndx = shndx;
+ this->u_.from_object.input_offset = input_offset;
+ }
+
+ // Create an FDE associated with a PLT.
+ Fde(Output_data* plt, const unsigned char* contents, size_t length,
+ bool post_map)
+ : object_(NULL),
+ contents_(reinterpret_cast<const char*>(contents), length)
+ {
+ this->u_.from_linker.plt = plt;
+ this->u_.from_linker.post_map = post_map;
+ }
+
+ // Return the length of this FDE. Add 4 for the length and 4 for
+ // the offset to the CIE.
+ size_t
+ length() const
+ { return this->contents_.length() + 8; }
+
+ // Add a mapping for this FDE to MERGE_MAP, so that relocations
+ // against the FDE are applied to right part of the output file.
+ void
+ add_mapping(section_offset_type output_offset,
+ Output_section_data* output_data) const
+ {
+ if (this->object_ != NULL)
+ this->object_->add_merge_mapping(output_data, this->u_.from_object.shndx,
+ this->u_.from_object.input_offset, this->length(),
+ output_offset);
+ }
+
+ // Return whether this FDE was added after merge mapping.
+ bool
+ post_map() const
+ { return this->object_ == NULL && this->u_.from_linker.post_map; }
+
+ // Return whether this FDE was added for the PLT after merge mapping.
+ bool
+ post_map(const Output_data* plt) const
+ { return this->post_map() && this->u_.from_linker.plt == plt; }
+
+ // Write the FDE to OVIEW starting at OFFSET. FDE_ENCODING is the
+ // encoding, from the CIE. Round up the bytes to ADDRALIGN if
+ // necessary. ADDRESS is the virtual address of OVIEW. Record the
+ // FDE in EH_FRAME_HDR. Return the new offset.
+ template<int size, bool big_endian>
+ section_offset_type
+ write(unsigned char* oview, section_offset_type output_section_offset,
+ section_offset_type offset, uint64_t address, unsigned int addralign,
+ section_offset_type cie_offset, unsigned char fde_encoding,
+ Eh_frame_hdr* eh_frame_hdr);
+
+ private:
+ // The object in which this FDE was seen. This will be NULL for a
+ // linker generated FDE.
+ Relobj* object_;
+ union
+ {
+ // These fields are used if the FDE is from an input object (the
+ // object_ field is not NULL).
+ struct
+ {
+ // Input section index for this FDE.
+ unsigned int shndx;
+ // Offset within the input section for this FDE.
+ section_offset_type input_offset;
+ } from_object;
+ // This field is used if the FDE is generated by the linker (the
+ // object_ field is NULL).
+ struct
+ {
+ // The only linker generated FDEs are for PLT sections, and this
+ // points to the PLT section.
+ Output_data* plt;
+ // Set if the FDE was added after merge mapping.
+ bool post_map;
+ } from_linker;
+ } u_;
+ // FDE data.
+ std::string contents_;
+};
+
+// A FDE plus some info from a CIE to allow later writing of the FDE.
+
+struct Post_fde
+{
+ Post_fde(Fde* f, section_offset_type cie_off, unsigned char encoding)
+ : fde(f), cie_offset(cie_off), fde_encoding(encoding)
+ { }
+
+ Fde* fde;
+ section_offset_type cie_offset;
+ unsigned char fde_encoding;
+};
+
+typedef std::vector<Post_fde> Post_fdes;
+
+// This class holds a CIE.
+
+class Cie
+{
+ public:
+ Cie(Relobj* object, unsigned int shndx, section_offset_type input_offset,
+ unsigned char fde_encoding, const char* personality_name,
+ const unsigned char* contents, size_t length)
+ : object_(object),
+ shndx_(shndx),
+ input_offset_(input_offset),
+ fde_encoding_(fde_encoding),
+ personality_name_(personality_name),
+ fdes_(),
+ contents_(reinterpret_cast<const char*>(contents), length)
+ { }
+
+ ~Cie();
+
+ // We permit copying a CIE when there are no FDEs. This is
+ // convenient in the code which creates them.
+ Cie(const Cie& cie)
+ : object_(cie.object_),
+ shndx_(cie.shndx_),
+ input_offset_(cie.input_offset_),
+ fde_encoding_(cie.fde_encoding_),
+ personality_name_(cie.personality_name_),
+ fdes_(),
+ contents_(cie.contents_)
+ { gold_assert(cie.fdes_.empty()); }
+
+ // Add an FDE associated with this CIE.
+ void
+ add_fde(Fde* fde)
+ { this->fdes_.push_back(fde); }
+
+ // Remove the last FDE associated with this CIE.
+ void
+ remove_fde()
+ { this->fdes_.pop_back(); }
+
+ // Access the last FDE associated with this CIE.
+ const Fde*
+ last_fde() const
+ { return this->fdes_.back(); }
+
+ // Return the number of FDEs.
+ unsigned int
+ fde_count() const
+ { return this->fdes_.size(); }
+
+ // Set the output offset of this CIE to OUTPUT_OFFSET. It will be
+ // followed by all its FDEs. ADDRALIGN is the required address
+ // alignment, typically 4 or 8. This updates MERGE_MAP with the
+ // mapping. It returns the new output offset.
+ section_offset_type
+ set_output_offset(section_offset_type output_offset, unsigned int addralign,
+ Output_section_data*);
+
+ // Write the CIE to OVIEW starting at OFFSET. Round up the bytes to
+ // ADDRALIGN. ADDRESS is the virtual address of OVIEW.
+ // EH_FRAME_HDR is the exception frame header for FDE recording.
+ // POST_FDES stashes FDEs created after mappings were done, for later
+ // writing. Return the new offset.
+ template<int size, bool big_endian>
+ section_offset_type
+ write(unsigned char* oview, section_offset_type output_section_offset,
+ section_offset_type offset, uint64_t address,
+ unsigned int addralign, Eh_frame_hdr* eh_frame_hdr,
+ Post_fdes* post_fdes);
+
+ // Return the FDE encoding.
+ unsigned char
+ fde_encoding() const
+ { return this->fde_encoding_; }
+
+ friend bool operator<(const Cie&, const Cie&);
+ friend bool operator==(const Cie&, const Cie&);
+
+ private:
+ // The class is not assignable.
+ Cie& operator=(const Cie&);
+
+ // The object in which this CIE was first seen. This will be NULL
+ // for a linker generated CIE.
+ Relobj* object_;
+ // Input section index for this CIE. This will be 0 for a linker
+ // generated CIE.
+ unsigned int shndx_;
+ // Offset within the input section for this CIE. This will be 0 for
+ // a linker generated CIE.
+ section_offset_type input_offset_;
+ // The encoding of the FDE. This is a DW_EH_PE code.
+ unsigned char fde_encoding_;
+ // The name of the personality routine. This will be the name of a
+ // global symbol, or will be the empty string.
+ std::string personality_name_;
+ // List of FDEs.
+ std::vector<Fde*> fdes_;
+ // CIE data.
+ std::string contents_;
+};
+
+extern bool operator<(const Cie&, const Cie&);
+extern bool operator==(const Cie&, const Cie&);
+
+// This class manages .eh_frame sections. It discards duplicate
+// exception information.
+
+class Eh_frame : public Output_section_data
+{
+ public:
+ enum Eh_frame_section_disposition
+ {
+ EH_EMPTY_SECTION,
+ EH_UNRECOGNIZED_SECTION,
+ EH_OPTIMIZABLE_SECTION,
+ EH_END_MARKER_SECTION
+ };
+
+ Eh_frame();
+
+ // Record the associated Eh_frame_hdr, if any.
+ void
+ set_eh_frame_hdr(Eh_frame_hdr* hdr)
+ { this->eh_frame_hdr_ = hdr; }
+
+ // Add the input section SHNDX in OBJECT. SYMBOLS is the contents
+ // of the symbol table section (size SYMBOLS_SIZE), SYMBOL_NAMES is
+ // the symbol names section (size SYMBOL_NAMES_SIZE). RELOC_SHNDX
+ // is the relocation section if any (0 for none, -1U for multiple).
+ // RELOC_TYPE is the type of the relocation section if any. This
+ // returns whether the section was incorporated into the .eh_frame
+ // data.
+ template<int size, bool big_endian>
+ Eh_frame_section_disposition
+ add_ehframe_input_section(Sized_relobj_file<size, big_endian>* object,
+ const unsigned char* symbols,
+ section_size_type symbols_size,
+ const unsigned char* symbol_names,
+ section_size_type symbol_names_size,
+ unsigned int shndx, unsigned int reloc_shndx,
+ unsigned int reloc_type);
+
+ // Add a CIE and an FDE for a PLT section, to permit unwinding
+ // through a PLT. The FDE data should start with 8 bytes of zero,
+ // which will be replaced by a 4 byte PC relative reference to the
+ // address of PLT and a 4 byte size of PLT.
+ void
+ add_ehframe_for_plt(Output_data* plt, const unsigned char* cie_data,
+ size_t cie_length, const unsigned char* fde_data,
+ size_t fde_length);
+
+ // Remove all post-map unwind information for a PLT.
+ void
+ remove_ehframe_for_plt(Output_data* plt, const unsigned char* cie_data,
+ size_t cie_length);
+
+ // Return the number of FDEs.
+ unsigned int
+ fde_count() const;
+
+ protected:
+ // Set the final data size.
+ void
+ set_final_data_size();
+
+ // Return the output address for an input address.
+ bool
+ do_output_offset(const Relobj*, unsigned int shndx,
+ section_offset_type offset,
+ section_offset_type* poutput) const;
+
+ // Write the data to the file.
+ void
+ do_write(Output_file*);
+
+ // Write to a map file.
+ void
+ do_print_to_mapfile(Mapfile* mapfile) const
+ { mapfile->print_output_data(this, _("** eh_frame")); }
+
+ private:
+ // The comparison routine for the CIE map.
+ struct Cie_less
+ {
+ bool
+ operator()(const Cie* cie1, const Cie* cie2) const
+ { return *cie1 < *cie2; }
+ };
+
+ // A set of unique CIEs.
+ typedef std::set<Cie*, Cie_less> Cie_offsets;
+
+ // A list of unmergeable CIEs.
+ typedef std::vector<Cie*> Unmergeable_cie_offsets;
+
+ // A mapping from offsets to CIEs. This is used while reading an
+ // input section.
+ typedef std::map<uint64_t, Cie*> Offsets_to_cie;
+
+ // A list of CIEs, and a bool indicating whether the CIE is
+ // mergeable.
+ typedef std::vector<std::pair<Cie*, bool> > New_cies;
+
+ // Skip an LEB128.
+ static bool
+ skip_leb128(const unsigned char**, const unsigned char*);
+
+ // The implementation of add_ehframe_input_section.
+ template<int size, bool big_endian>
+ bool
+ do_add_ehframe_input_section(Sized_relobj_file<size, big_endian>* object,
+ const unsigned char* symbols,
+ section_size_type symbols_size,
+ const unsigned char* symbol_names,
+ section_size_type symbol_names_size,
+ unsigned int shndx,
+ unsigned int reloc_shndx,
+ unsigned int reloc_type,
+ const unsigned char* pcontents,
+ section_size_type contents_len,
+ New_cies*);
+
+ // Read a CIE.
+ template<int size, bool big_endian>
+ bool
+ read_cie(Sized_relobj_file<size, big_endian>* object,
+ unsigned int shndx,
+ const unsigned char* symbols,
+ section_size_type symbols_size,
+ const unsigned char* symbol_names,
+ section_size_type symbol_names_size,
+ const unsigned char* pcontents,
+ const unsigned char* pcie,
+ const unsigned char* pcieend,
+ Track_relocs<size, big_endian>* relocs,
+ Offsets_to_cie* cies,
+ New_cies* new_cies);
+
+ // Read an FDE.
+ template<int size, bool big_endian>
+ bool
+ read_fde(Sized_relobj_file<size, big_endian>* object,
+ unsigned int shndx,
+ const unsigned char* symbols,
+ section_size_type symbols_size,
+ const unsigned char* pcontents,
+ unsigned int offset,
+ const unsigned char* pfde,
+ const unsigned char* pfdeend,
+ Track_relocs<size, big_endian>* relocs,
+ Offsets_to_cie* cies);
+
+ // Template version of write function.
+ template<int size, bool big_endian>
+ void
+ do_sized_write(unsigned char* oview);
+
+ // The exception frame header, if any.
+ Eh_frame_hdr* eh_frame_hdr_;
+ // A mapping from all unique CIEs to their offset in the output
+ // file.
+ Cie_offsets cie_offsets_;
+ // A mapping from unmergeable CIEs to their offset in the output
+ // file.
+ Unmergeable_cie_offsets unmergeable_cie_offsets_;
+ // Whether we have created the mappings to the output section.
+ bool mappings_are_done_;
+ // The final data size. This is only set if mappings_are_done_ is
+ // true.
+ section_size_type final_data_size_;
};
} // End namespace gold.
projects / deliverable / binutils-gdb.git / blobdiff