cfi_assembler.h - mozsearch

// -*- mode: C++ -*-

// Copyright (c) 2010, Google Inc.

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>

// cfi_assembler.h: Define CFISection, a class for creating properly

// (and improperly) formatted DWARF CFI data for unit tests.

#ifndef PROCESSOR_CFI_ASSEMBLER_H_

#define PROCESSOR_CFI_ASSEMBLER_H_

#include <string>

#include "common/dwarf/dwarf2enums.h"

#include "common/test_assembler.h"

#include "common/using_std_string.h"

#include "google_breakpad/common/breakpad_types.h"

namespace google_breakpad {

using dwarf2reader::DwarfPointerEncoding;

using google_breakpad::test_assembler::Endianness;

using google_breakpad::test_assembler::Label;

using google_breakpad::test_assembler::Section;

class CFISection: public Section {

 public:

  // CFI augmentation strings beginning with 'z', defined by the

  // Linux/IA-64 C++ ABI, can specify interesting encodings for

  // addresses appearing in FDE headers and call frame instructions (and

  // for additional fields whose presence the augmentation string

  // specifies). In particular, pointers can be specified to be relative

  // to various base address: the start of the .text section, the

  // location holding the address itself, and so on. These allow the

  // frame data to be position-independent even when they live in

  // write-protected pages. These variants are specified at the

  // following two URLs:

//

  // http://refspecs.linux-foundation.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/dwarfext.html

  // http://refspecs.linux-foundation.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html

//

  // CFISection leaves the production of well-formed 'z'-augmented CIEs and

  // FDEs to the user, but does provide EncodedPointer, to emit

  // properly-encoded addresses for a given pointer encoding.

  // EncodedPointer uses an instance of this structure to find the base

  // addresses it should use; you can establish a default for all encoded

  // pointers appended to this section with SetEncodedPointerBases.

  struct EncodedPointerBases {

    EncodedPointerBases() : cfi(), text(), data() { }

    // The starting address of this CFI section in memory, for

    // DW_EH_PE_pcrel. DW_EH_PE_pcrel pointers may only be used in data

    // that has is loaded into the program's address space.

    uint64_t cfi;

    // The starting address of this file's .text section, for DW_EH_PE_textrel.

    uint64_t text;

    // The starting address of this file's .got or .eh_frame_hdr section,

    // for DW_EH_PE_datarel.

    uint64_t data;

};

  // Create a CFISection whose endianness is ENDIANNESS, and where

  // machine addresses are ADDRESS_SIZE bytes long. If EH_FRAME is

  // true, use the .eh_frame format, as described by the Linux

  // Standards Base Core Specification, instead of the DWARF CFI

  // format.

  CFISection(Endianness endianness, size_t address_size,

             bool eh_frame = false)

      : Section(endianness), address_size_(address_size), eh_frame_(eh_frame),

        pointer_encoding_(dwarf2reader::DW_EH_PE_absptr),

        encoded_pointer_bases_(), entry_length_(NULL), in_fde_(false) {

    // The 'start', 'Here', and 'Mark' members of a CFISection all refer

    // to section offsets.

    start() = 0;

  // Return this CFISection's address size.

  size_t AddressSize() const { return address_size_; }

  // Return true if this CFISection uses the .eh_frame format, or

  // false if it contains ordinary DWARF CFI data.

  bool ContainsEHFrame() const { return eh_frame_; }

  // Use ENCODING for pointers in calls to FDEHeader and EncodedPointer.

  void SetPointerEncoding(DwarfPointerEncoding encoding) {

    pointer_encoding_ = encoding;

  // Use the addresses in BASES as the base addresses for encoded

  // pointers in subsequent calls to FDEHeader or EncodedPointer.

  // This function makes a copy of BASES.

  void SetEncodedPointerBases(const EncodedPointerBases &bases) {

    encoded_pointer_bases_ = bases;

  // Append a Common Information Entry header to this section with the

  // given values. If dwarf64 is true, use the 64-bit DWARF initial

  // length format for the CIE's initial length. Return a reference to

  // this section. You should call FinishEntry after writing the last

  // instruction for the CIE.

//

  // Before calling this function, you will typically want to use Mark

  // or Here to make a label to pass to FDEHeader that refers to this

  // CIE's position in the section.

  CFISection &CIEHeader(uint64_t code_alignment_factor,

                        int data_alignment_factor,

                        unsigned return_address_register,

                        uint8_t version = 3,

                        const string &augmentation = "",

                        bool dwarf64 = false,

                        uint8_t address_size = 8,

                        uint8_t segment_size = 0);

  // Append a Frame Description Entry header to this section with the

  // given values. If dwarf64 is true, use the 64-bit DWARF initial

  // length format for the CIE's initial length. Return a reference to

  // this section. You should call FinishEntry after writing the last

  // instruction for the CIE.

//

  // This function doesn't support entries that are longer than

  // 0xffffff00 bytes. (The "initial length" is always a 32-bit

  // value.) Nor does it support .debug_frame sections longer than

  // 0xffffff00 bytes.

  CFISection &FDEHeader(Label cie_pointer,

                        uint64_t initial_location,

                        uint64_t address_range,

                        bool dwarf64 = false);

  // Note the current position as the end of the last CIE or FDE we

  // started, after padding with DW_CFA_nops for alignment. This

  // defines the label representing the entry's length, cited in the

  // entry's header. Return a reference to this section.

  CFISection &FinishEntry();

  // Append the contents of BLOCK as a DW_FORM_block value: an

  // unsigned LEB128 length, followed by that many bytes of data.

  CFISection &Block(const string &block) {

    ULEB128(block.size());

    Append(block);

    return *this;

  // Append ADDRESS to this section, in the appropriate size and

  // endianness. Return a reference to this section.

  CFISection &Address(uint64_t address) {

    Section::Append(endianness(), address_size_, address);

    return *this;

  CFISection &Address(Label address) {

    Section::Append(endianness(), address_size_, address);

    return *this;

  // Append ADDRESS to this section, using ENCODING and BASES. ENCODING

  // defaults to this section's default encoding, established by

  // SetPointerEncoding. BASES defaults to this section's bases, set by

  // SetEncodedPointerBases. If the DW_EH_PE_indirect bit is set in the

  // encoding, assume that ADDRESS is where the true address is stored.

  // Return a reference to this section.

//

  // (C++ doesn't let me use default arguments here, because I want to

  // refer to members of *this in the default argument expression.)

  CFISection &EncodedPointer(uint64_t address) {

    return EncodedPointer(address, pointer_encoding_, encoded_pointer_bases_);

  CFISection &EncodedPointer(uint64_t address, DwarfPointerEncoding encoding) {

    return EncodedPointer(address, encoding, encoded_pointer_bases_);

  CFISection &EncodedPointer(uint64_t address, DwarfPointerEncoding encoding,

                             const EncodedPointerBases &bases);

  // Restate some member functions, to keep chaining working nicely.

  CFISection &Mark(Label *label)   { Section::Mark(label); return *this; }

  CFISection &D8(uint8_t v)       { Section::D8(v);       return *this; }

  CFISection &D16(uint16_t v)     { Section::D16(v);      return *this; }

  CFISection &D16(Label v)         { Section::D16(v);      return *this; }

  CFISection &D32(uint32_t v)     { Section::D32(v);      return *this; }

  CFISection &D32(const Label &v)  { Section::D32(v);      return *this; }

  CFISection &D64(uint64_t v)     { Section::D64(v);      return *this; }

  CFISection &D64(const Label &v)  { Section::D64(v);      return *this; }

  CFISection &LEB128(long long v)  { Section::LEB128(v);   return *this; }

  CFISection &ULEB128(uint64_t v) { Section::ULEB128(v);  return *this; }

 private:

  // A length value that we've appended to the section, but is not yet

  // known. LENGTH is the appended value; START is a label referring

  // to the start of the data whose length was cited.

  struct PendingLength {

    Label length;

    Label start;

};

  // Constants used in CFI/.eh_frame data:

  // If the first four bytes of an "initial length" are this constant, then

  // the data uses the 64-bit DWARF format, and the length itself is the

  // subsequent eight bytes.

  static const uint32_t kDwarf64InitialLengthMarker = 0xffffffffU;

  // The CIE identifier for 32- and 64-bit DWARF CFI and .eh_frame data.

  static const uint32_t kDwarf32CIEIdentifier = ~(uint32_t)0;

  static const uint64_t kDwarf64CIEIdentifier = ~(uint64_t)0;

  static const uint32_t kEHFrame32CIEIdentifier = 0;

  static const uint64_t kEHFrame64CIEIdentifier = 0;

  // The size of a machine address for the data in this section.

  size_t address_size_;

  // If true, we are generating a Linux .eh_frame section, instead of

  // a standard DWARF .debug_frame section.

  bool eh_frame_;

  // The encoding to use for FDE pointers.

  DwarfPointerEncoding pointer_encoding_;

  // The base addresses to use when emitting encoded pointers.

  EncodedPointerBases encoded_pointer_bases_;

  // The length value for the current entry.

//

  // Oddly, this must be dynamically allocated. Labels never get new

  // values; they only acquire constraints on the value they already

  // have, or assert if you assign them something incompatible. So

  // each header needs truly fresh Label objects to cite in their

  // headers and track their positions. The alternative is explicit

  // destructor invocation and a placement new. Ick.

  PendingLength *entry_length_;

  // True if we are currently emitting an FDE --- that is, we have

  // called FDEHeader but have not yet called FinishEntry.

  bool in_fde_;

  // If in_fde_ is true, this is its starting address. We use this for

  // emitting DW_EH_PE_funcrel pointers.

  uint64_t fde_start_address_;

};

}  // namespace google_breakpad

#endif  // PROCESSOR_CFI_ASSEMBLER_H_

Source code

Revision control

Copy as Markdown

Other Tools