replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

clang-format and restyle DWARFFormValue before working on it. NFC 

llvm-svn: 302086
This commit is contained in:
Paul Robinson 2017-05-03 21:53:21 +00:00
parent 87f033885e
commit ae2e6f37f3
2 changed files with 457 additions and 441 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

317
llvm/include/llvm/DebugInfo/DWARF/DWARFFormValue.h
View File

@ -39,20 +39,18 @@ public:
private:
struct ValueType {
ValueType() {
uval = 0;
}
ValueType() { uval = 0; }
union {
uint64_t uval;
int64_t sval;
const char* cstr;
const char *cstr;
};
const uint8_t* data = nullptr;
const uint8_t *data = nullptr;
};
dwarf::Form Form; // Form for this value.
ValueType Value; // Contains all data for the form.
dwarf::Form Form; // Form for this value.
ValueType Value; // Contains all data for the form.
const DWARFUnit *U = nullptr; // Remember the DWARFUnit at extract time.
public:
@ -84,7 +82,7 @@ public:
const DWARFUnit *U);
bool isInlinedCStr() const {
return Value.data != nullptr && Value.data == (const uint8_t*)Value.cstr;
return Value.data != nullptr && Value.data == (const uint8_t *)Value.cstr;
}
/// getAsFoo functions below return the extracted value as Foo if only
@ -135,45 +133,45 @@ public:
uint8_t AddrSize,
llvm::dwarf::DwarfFormat Format);
/// Skip a form in \p debug_info_data at offset specified by \p offset_ptr.
/// Skip a form in \p DebugInfoData at offset specified by \p OffsetPtr.
///
/// Skips the bytes for this form in the debug info and updates the offset.
///
/// \param debug_info_data the .debug_info data to use to skip the value.
/// \param offset_ptr a reference to the offset that will be updated.
/// \param DebugInfoData the .debug_info data to use to skip the value.
/// \param OffsetPtr a reference to the offset that will be updated.
/// \param U the DWARFUnit to use when skipping the form in case the form
/// size differs according to data in the DWARFUnit.
/// \returns true on success, false if the form was not skipped.
bool skipValue(DataExtractor debug_info_data, uint32_t *offset_ptr,
bool skipValue(DataExtractor DebugInfoData, uint32_t *OffsetPtr,
const DWARFUnit *U) const;
/// Skip a form in \p debug_info_data at offset specified by \p offset_ptr.
/// Skip a form in \p DebugInfoData at offset specified by \p OffsetPtr.
///
/// Skips the bytes for this form in the debug info and updates the offset.
///
/// \param form the DW_FORM enumeration that indicates the form to skip.
/// \param debug_info_data the .debug_info data to use to skip the value.
/// \param offset_ptr a reference to the offset that will be updated.
/// \param Form the DW_FORM enumeration that indicates the form to skip.
/// \param DebugInfoData the .debug_info data to use to skip the value.
/// \param OffsetPtr a reference to the offset that will be updated.
/// \param U the DWARFUnit to use when skipping the form in case the form
/// size differs according to data in the DWARFUnit.
/// \returns true on success, false if the form was not skipped.
static bool skipValue(dwarf::Form form, DataExtractor debug_info_data,
uint32_t *offset_ptr, const DWARFUnit *U);
static bool skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
uint32_t *OffsetPtr, const DWARFUnit *U);
/// Skip a form in \p debug_info_data at offset specified by \p offset_ptr.
/// Skip a form in \p DebugInfoData at offset specified by \p OffsetPtr.
///
/// Skips the bytes for this form in the debug info and updates the offset.
///
/// \param form the DW_FORM enumeration that indicates the form to skip.
/// \param debug_info_data the .debug_info data to use to skip the value.
/// \param offset_ptr a reference to the offset that will be updated.
/// \param Form the DW_FORM enumeration that indicates the form to skip.
/// \param DebugInfoData the .debug_info data to use to skip the value.
/// \param OffsetPtr a reference to the offset that will be updated.
/// \param Version DWARF version number.
/// \param AddrSize size of an address in bytes.
/// \param Format enum value from llvm::dwarf::DwarfFormat.
/// \returns true on success, false if the form was not skipped.
static bool skipValue(dwarf::Form form, DataExtractor debug_info_data,
uint32_t *offset_ptr, uint16_t Version,
uint8_t AddrSize, llvm::dwarf::DwarfFormat Format);
static bool skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
uint32_t *OffsetPtr, uint16_t Version, uint8_t AddrSize,
llvm::dwarf::DwarfFormat Format);
private:
void dumpString(raw_ostream &OS) const;
@ -181,149 +179,146 @@ private:
namespace dwarf {
/// Take an optional DWARFFormValue and try to extract a string value from it.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and was a string.
inline Optional<const char*> toString(const Optional<DWARFFormValue>& V) {
if (V)
return V->getAsCString();
return None;
}
/// Take an optional DWARFFormValue and extract a string value from it.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \param Default the default value to return in case of failure.
/// \returns the string value or Default if the V doesn't have a value or the
/// form value's encoding wasn't a string.
inline const char*
toString(const Optional<DWARFFormValue>& V, const char *Default) {
return toString(V).getValueOr(Default);
}
/// Take an optional DWARFFormValue and try to extract a string value from it.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and was a string.
inline Optional<const char *> toString(const Optional<DWARFFormValue> &V) {
if (V)
return V->getAsCString();
return None;
}
/// Take an optional DWARFFormValue and try to extract an unsigned constant.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and has a unsigned constant form.
inline Optional<uint64_t> toUnsigned(const Optional<DWARFFormValue>& V) {
if (V)
return V->getAsUnsignedConstant();
return None;
}
/// Take an optional DWARFFormValue and extract a unsigned constant.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \param Default the default value to return in case of failure.
/// \returns the extracted unsigned value or Default if the V doesn't have a
/// value or the form value's encoding wasn't an unsigned constant form.
inline uint64_t
toUnsigned(const Optional<DWARFFormValue>& V, uint64_t Default) {
return toUnsigned(V).getValueOr(Default);
}
/// Take an optional DWARFFormValue and try to extract an reference.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and has a reference form.
inline Optional<uint64_t> toReference(const Optional<DWARFFormValue>& V) {
if (V)
return V->getAsReference();
return None;
}
/// Take an optional DWARFFormValue and extract a reference.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \param Default the default value to return in case of failure.
/// \returns the extracted reference value or Default if the V doesn't have a
/// value or the form value's encoding wasn't a reference form.
inline uint64_t
toReference(const Optional<DWARFFormValue>& V, uint64_t Default) {
return toReference(V).getValueOr(Default);
}
/// Take an optional DWARFFormValue and try to extract an signed constant.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and has a signed constant form.
inline Optional<int64_t> toSigned(const Optional<DWARFFormValue>& V) {
if (V)
return V->getAsSignedConstant();
return None;
}
/// Take an optional DWARFFormValue and extract a string value from it.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \param Default the default value to return in case of failure.
/// \returns the string value or Default if the V doesn't have a value or the
/// form value's encoding wasn't a string.
inline const char *toString(const Optional<DWARFFormValue> &V,
const char *Default) {
return toString(V).getValueOr(Default);
}
/// Take an optional DWARFFormValue and extract a signed integer.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \param Default the default value to return in case of failure.
/// \returns the extracted signed integer value or Default if the V doesn't
/// have a value or the form value's encoding wasn't a signed integer form.
inline int64_t
toSigned(const Optional<DWARFFormValue>& V, int64_t Default) {
return toSigned(V).getValueOr(Default);
}
/// Take an optional DWARFFormValue and try to extract an unsigned constant.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and has a unsigned constant form.
inline Optional<uint64_t> toUnsigned(const Optional<DWARFFormValue> &V) {
if (V)
return V->getAsUnsignedConstant();
return None;
}
/// Take an optional DWARFFormValue and try to extract an address.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and has a address form.
inline Optional<uint64_t> toAddress(const Optional<DWARFFormValue>& V) {
if (V)
return V->getAsAddress();
return None;
}
/// Take an optional DWARFFormValue and extract a unsigned constant.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \param Default the default value to return in case of failure.
/// \returns the extracted unsigned value or Default if the V doesn't have a
/// value or the form value's encoding wasn't an unsigned constant form.
inline uint64_t toUnsigned(const Optional<DWARFFormValue> &V,
uint64_t Default) {
return toUnsigned(V).getValueOr(Default);
}
/// Take an optional DWARFFormValue and extract a address.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \param Default the default value to return in case of failure.
/// \returns the extracted address value or Default if the V doesn't have a
/// value or the form value's encoding wasn't an address form.
inline uint64_t
toAddress(const Optional<DWARFFormValue>& V, uint64_t Default) {
return toAddress(V).getValueOr(Default);
}
/// Take an optional DWARFFormValue and try to extract an reference.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and has a reference form.
inline Optional<uint64_t> toReference(const Optional<DWARFFormValue> &V) {
if (V)
return V->getAsReference();
return None;
}
/// Take an optional DWARFFormValue and try to extract an section offset.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and has a section offset form.
inline Optional<uint64_t> toSectionOffset(const Optional<DWARFFormValue>& V) {
if (V)
return V->getAsSectionOffset();
return None;
}
/// Take an optional DWARFFormValue and extract a reference.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \param Default the default value to return in case of failure.
/// \returns the extracted reference value or Default if the V doesn't have a
/// value or the form value's encoding wasn't a reference form.
inline uint64_t toReference(const Optional<DWARFFormValue> &V,
uint64_t Default) {
return toReference(V).getValueOr(Default);
}
/// Take an optional DWARFFormValue and extract a section offset.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \param Default the default value to return in case of failure.
/// \returns the extracted section offset value or Default if the V doesn't
/// have a value or the form value's encoding wasn't a section offset form.
inline uint64_t
toSectionOffset(const Optional<DWARFFormValue>& V, uint64_t Default) {
return toSectionOffset(V).getValueOr(Default);
}
/// Take an optional DWARFFormValue and try to extract an signed constant.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and has a signed constant form.
inline Optional<int64_t> toSigned(const Optional<DWARFFormValue> &V) {
if (V)
return V->getAsSignedConstant();
return None;
}
/// Take an optional DWARFFormValue and try to extract block data.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and has a block form.
inline Optional<ArrayRef<uint8_t>>
toBlock(const Optional<DWARFFormValue>& V) {
if (V)
return V->getAsBlock();
return None;
}
/// Take an optional DWARFFormValue and extract a signed integer.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \param Default the default value to return in case of failure.
/// \returns the extracted signed integer value or Default if the V doesn't
/// have a value or the form value's encoding wasn't a signed integer form.
inline int64_t toSigned(const Optional<DWARFFormValue> &V, int64_t Default) {
return toSigned(V).getValueOr(Default);
}
/// Take an optional DWARFFormValue and try to extract an address.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and has a address form.
inline Optional<uint64_t> toAddress(const Optional<DWARFFormValue> &V) {
if (V)
return V->getAsAddress();
return None;
}
/// Take an optional DWARFFormValue and extract a address.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \param Default the default value to return in case of failure.
/// \returns the extracted address value or Default if the V doesn't have a
/// value or the form value's encoding wasn't an address form.
inline uint64_t toAddress(const Optional<DWARFFormValue> &V, uint64_t Default) {
return toAddress(V).getValueOr(Default);
}
/// Take an optional DWARFFormValue and try to extract an section offset.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and has a section offset form.
inline Optional<uint64_t> toSectionOffset(const Optional<DWARFFormValue> &V) {
if (V)
return V->getAsSectionOffset();
return None;
}
/// Take an optional DWARFFormValue and extract a section offset.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \param Default the default value to return in case of failure.
/// \returns the extracted section offset value or Default if the V doesn't
/// have a value or the form value's encoding wasn't a section offset form.
inline uint64_t toSectionOffset(const Optional<DWARFFormValue> &V,
uint64_t Default) {
return toSectionOffset(V).getValueOr(Default);
}
/// Take an optional DWARFFormValue and try to extract block data.
///
/// \param V and optional DWARFFormValue to attempt to extract the value from.
/// \returns an optional value that contains a value if the form value
/// was valid and has a block form.
inline Optional<ArrayRef<uint8_t>> toBlock(const Optional<DWARFFormValue> &V) {
if (V)
return V->getAsBlock();
return None;
}
} // end namespace dwarf

581
llvm/lib/DebugInfo/DWARF/DWARFFormValue.cpp
View File

@ -7,13 +7,13 @@
//
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
#include "SyntaxHighlighting.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/None.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
#include "llvm/Support/Dwarf.h"
@ -29,34 +29,34 @@ using namespace dwarf;
using namespace syntax;
static const DWARFFormValue::FormClass DWARF4FormClasses[] = {
DWARFFormValue::FC_Unknown, // 0x0
DWARFFormValue::FC_Address, // 0x01 DW_FORM_addr
DWARFFormValue::FC_Unknown, // 0x02 unused
DWARFFormValue::FC_Block, // 0x03 DW_FORM_block2
DWARFFormValue::FC_Block, // 0x04 DW_FORM_block4
DWARFFormValue::FC_Constant, // 0x05 DW_FORM_data2
// --- These can be FC_SectionOffset in DWARF3 and below:
DWARFFormValue::FC_Constant, // 0x06 DW_FORM_data4
DWARFFormValue::FC_Constant, // 0x07 DW_FORM_data8
// ---
DWARFFormValue::FC_String, // 0x08 DW_FORM_string
DWARFFormValue::FC_Block, // 0x09 DW_FORM_block
DWARFFormValue::FC_Block, // 0x0a DW_FORM_block1
DWARFFormValue::FC_Constant, // 0x0b DW_FORM_data1
DWARFFormValue::FC_Flag, // 0x0c DW_FORM_flag
DWARFFormValue::FC_Constant, // 0x0d DW_FORM_sdata
DWARFFormValue::FC_String, // 0x0e DW_FORM_strp
DWARFFormValue::FC_Constant, // 0x0f DW_FORM_udata
DWARFFormValue::FC_Reference, // 0x10 DW_FORM_ref_addr
DWARFFormValue::FC_Reference, // 0x11 DW_FORM_ref1
DWARFFormValue::FC_Reference, // 0x12 DW_FORM_ref2
DWARFFormValue::FC_Reference, // 0x13 DW_FORM_ref4
DWARFFormValue::FC_Reference, // 0x14 DW_FORM_ref8
DWARFFormValue::FC_Reference, // 0x15 DW_FORM_ref_udata
DWARFFormValue::FC_Indirect, // 0x16 DW_FORM_indirect
DWARFFormValue::FC_SectionOffset, // 0x17 DW_FORM_sec_offset
DWARFFormValue::FC_Exprloc, // 0x18 DW_FORM_exprloc
DWARFFormValue::FC_Flag, // 0x19 DW_FORM_flag_present
DWARFFormValue::FC_Unknown, // 0x0
DWARFFormValue::FC_Address, // 0x01 DW_FORM_addr
DWARFFormValue::FC_Unknown, // 0x02 unused
DWARFFormValue::FC_Block, // 0x03 DW_FORM_block2
DWARFFormValue::FC_Block, // 0x04 DW_FORM_block4
DWARFFormValue::FC_Constant, // 0x05 DW_FORM_data2
// --- These can be FC_SectionOffset in DWARF3 and below:
DWARFFormValue::FC_Constant, // 0x06 DW_FORM_data4
DWARFFormValue::FC_Constant, // 0x07 DW_FORM_data8
// ---
DWARFFormValue::FC_String, // 0x08 DW_FORM_string
DWARFFormValue::FC_Block, // 0x09 DW_FORM_block
DWARFFormValue::FC_Block, // 0x0a DW_FORM_block1
DWARFFormValue::FC_Constant, // 0x0b DW_FORM_data1
DWARFFormValue::FC_Flag, // 0x0c DW_FORM_flag
DWARFFormValue::FC_Constant, // 0x0d DW_FORM_sdata
DWARFFormValue::FC_String, // 0x0e DW_FORM_strp
DWARFFormValue::FC_Constant, // 0x0f DW_FORM_udata
DWARFFormValue::FC_Reference, // 0x10 DW_FORM_ref_addr
DWARFFormValue::FC_Reference, // 0x11 DW_FORM_ref1
DWARFFormValue::FC_Reference, // 0x12 DW_FORM_ref2
DWARFFormValue::FC_Reference, // 0x13 DW_FORM_ref4
DWARFFormValue::FC_Reference, // 0x14 DW_FORM_ref8
DWARFFormValue::FC_Reference, // 0x15 DW_FORM_ref_udata
DWARFFormValue::FC_Indirect, // 0x16 DW_FORM_indirect
DWARFFormValue::FC_SectionOffset, // 0x17 DW_FORM_sec_offset
DWARFFormValue::FC_Exprloc, // 0x18 DW_FORM_exprloc
DWARFFormValue::FC_Flag, // 0x19 DW_FORM_flag_present
};
namespace {
@ -83,10 +83,10 @@ public:
uint8_t getDwarfOffsetByteSize() const {
switch (Format) {
case dwarf::DwarfFormat::DWARF32:
return 4;
case dwarf::DwarfFormat::DWARF64:
return 8;
case dwarf::DwarfFormat::DWARF32:
return 4;
case dwarf::DwarfFormat::DWARF64:
return 8;
}
llvm_unreachable("Invalid Format value");
}
@ -97,83 +97,83 @@ public:
template <class T>
static Optional<uint8_t> getFixedByteSize(dwarf::Form Form, const T *U) {
switch (Form) {
case DW_FORM_addr:
if (U)
return U->getAddressByteSize();
return None;
case DW_FORM_addr:
if (U)
return U->getAddressByteSize();
return None;
case DW_FORM_block: // ULEB128 length L followed by L bytes.
case DW_FORM_block1: // 1 byte length L followed by L bytes.
case DW_FORM_block2: // 2 byte length L followed by L bytes.
case DW_FORM_block4: // 4 byte length L followed by L bytes.
case DW_FORM_string: // C-string with null terminator.
case DW_FORM_sdata: // SLEB128.
case DW_FORM_udata: // ULEB128.
case DW_FORM_ref_udata: // ULEB128.
case DW_FORM_indirect: // ULEB128.
case DW_FORM_exprloc: // ULEB128 length L followed by L bytes.
case DW_FORM_strx: // ULEB128.
case DW_FORM_addrx: // ULEB128.
case DW_FORM_loclistx: // ULEB128.
case DW_FORM_rnglistx: // ULEB128.
case DW_FORM_GNU_addr_index: // ULEB128.
case DW_FORM_GNU_str_index: // ULEB128.
return None;
case DW_FORM_block: // ULEB128 length L followed by L bytes.
case DW_FORM_block1: // 1 byte length L followed by L bytes.
case DW_FORM_block2: // 2 byte length L followed by L bytes.
case DW_FORM_block4: // 4 byte length L followed by L bytes.
case DW_FORM_string: // C-string with null terminator.
case DW_FORM_sdata: // SLEB128.
case DW_FORM_udata: // ULEB128.
case DW_FORM_ref_udata: // ULEB128.
case DW_FORM_indirect: // ULEB128.
case DW_FORM_exprloc: // ULEB128 length L followed by L bytes.
case DW_FORM_strx: // ULEB128.
case DW_FORM_addrx: // ULEB128.
case DW_FORM_loclistx: // ULEB128.
case DW_FORM_rnglistx: // ULEB128.
case DW_FORM_GNU_addr_index: // ULEB128.
case DW_FORM_GNU_str_index: // ULEB128.
return None;
case DW_FORM_ref_addr:
if (U)
return U->getRefAddrByteSize();
return None;
case DW_FORM_ref_addr:
if (U)
return U->getRefAddrByteSize();
return None;
case DW_FORM_flag:
case DW_FORM_data1:
case DW_FORM_ref1:
case DW_FORM_strx1:
case DW_FORM_addrx1:
return 1;
case DW_FORM_flag:
case DW_FORM_data1:
case DW_FORM_ref1:
case DW_FORM_strx1:
case DW_FORM_addrx1:
return 1;
case DW_FORM_data2:
case DW_FORM_ref2:
case DW_FORM_strx2:
case DW_FORM_addrx2:
return 2;
case DW_FORM_data2:
case DW_FORM_ref2:
case DW_FORM_strx2:
case DW_FORM_addrx2:
return 2;
case DW_FORM_data4:
case DW_FORM_ref4:
case DW_FORM_ref_sup4:
case DW_FORM_strx4:
case DW_FORM_addrx4:
return 4;
case DW_FORM_data4:
case DW_FORM_ref4:
case DW_FORM_ref_sup4:
case DW_FORM_strx4:
case DW_FORM_addrx4:
return 4;
case DW_FORM_strp:
case DW_FORM_GNU_ref_alt:
case DW_FORM_GNU_strp_alt:
case DW_FORM_line_strp:
case DW_FORM_sec_offset:
case DW_FORM_strp_sup:
if (U)
return U->getDwarfOffsetByteSize();
return None;
case DW_FORM_strp:
case DW_FORM_GNU_ref_alt:
case DW_FORM_GNU_strp_alt:
case DW_FORM_line_strp:
case DW_FORM_sec_offset:
case DW_FORM_strp_sup:
if (U)
return U->getDwarfOffsetByteSize();
return None;
case DW_FORM_data8:
case DW_FORM_ref8:
case DW_FORM_ref_sig8:
case DW_FORM_ref_sup8:
return 8;
case DW_FORM_data8:
case DW_FORM_ref8:
case DW_FORM_ref_sig8:
case DW_FORM_ref_sup8:
return 8;
case DW_FORM_flag_present:
return 0;
case DW_FORM_flag_present:
return 0;
case DW_FORM_data16:
return 16;
case DW_FORM_data16:
return 16;
case DW_FORM_implicit_const:
// The implicit value is stored in the abbreviation as a SLEB128, and
// there no data in debug info.
return 0;
case DW_FORM_implicit_const:
// The implicit value is stored in the abbreviation as a SLEB128, and
// there no data in debug info.
return 0;
default:
llvm_unreachable("Handle this form in this switch statement");
default:
llvm_unreachable("Handle this form in this switch statement");
}
return None;
}
@ -184,91 +184,91 @@ static bool skipFormValue(dwarf::Form Form, const DataExtractor &DebugInfoData,
bool Indirect = false;
do {
switch (Form) {
// Blocks of inlined data that have a length field and the data bytes
// inlined in the .debug_info.
case DW_FORM_exprloc:
case DW_FORM_block: {
uint64_t size = DebugInfoData.getULEB128(OffsetPtr);
*OffsetPtr += size;
return true;
}
case DW_FORM_block1: {
uint8_t size = DebugInfoData.getU8(OffsetPtr);
*OffsetPtr += size;
return true;
}
case DW_FORM_block2: {
uint16_t size = DebugInfoData.getU16(OffsetPtr);
*OffsetPtr += size;
return true;
}
case DW_FORM_block4: {
uint32_t size = DebugInfoData.getU32(OffsetPtr);
*OffsetPtr += size;
// Blocks of inlined data that have a length field and the data bytes
// inlined in the .debug_info.
case DW_FORM_exprloc:
case DW_FORM_block: {
uint64_t size = DebugInfoData.getULEB128(OffsetPtr);
*OffsetPtr += size;
return true;
}
case DW_FORM_block1: {
uint8_t size = DebugInfoData.getU8(OffsetPtr);
*OffsetPtr += size;
return true;
}
case DW_FORM_block2: {
uint16_t size = DebugInfoData.getU16(OffsetPtr);
*OffsetPtr += size;
return true;
}
case DW_FORM_block4: {
uint32_t size = DebugInfoData.getU32(OffsetPtr);
*OffsetPtr += size;
return true;
}
// Inlined NULL terminated C-strings.
case DW_FORM_string:
DebugInfoData.getCStr(OffsetPtr);
return true;
case DW_FORM_addr:
case DW_FORM_ref_addr:
case DW_FORM_flag_present:
case DW_FORM_data1:
case DW_FORM_data2:
case DW_FORM_data4:
case DW_FORM_data8:
case DW_FORM_flag:
case DW_FORM_ref1:
case DW_FORM_ref2:
case DW_FORM_ref4:
case DW_FORM_ref8:
case DW_FORM_ref_sig8:
case DW_FORM_ref_sup4:
case DW_FORM_ref_sup8:
case DW_FORM_strx1:
case DW_FORM_strx2:
case DW_FORM_strx4:
case DW_FORM_addrx1:
case DW_FORM_addrx2:
case DW_FORM_addrx4:
case DW_FORM_sec_offset:
case DW_FORM_strp:
case DW_FORM_strp_sup:
case DW_FORM_line_strp:
case DW_FORM_GNU_ref_alt:
case DW_FORM_GNU_strp_alt:
if (Optional<uint8_t> FixedSize = ::getFixedByteSize(Form, U)) {
*OffsetPtr += *FixedSize;
return true;
}
return false;
// Inlined NULL terminated C-strings.
case DW_FORM_string:
DebugInfoData.getCStr(OffsetPtr);
return true;
// signed or unsigned LEB 128 values.
case DW_FORM_sdata:
DebugInfoData.getSLEB128(OffsetPtr);
return true;
case DW_FORM_addr:
case DW_FORM_ref_addr:
case DW_FORM_flag_present:
case DW_FORM_data1:
case DW_FORM_data2:
case DW_FORM_data4:
case DW_FORM_data8:
case DW_FORM_flag:
case DW_FORM_ref1:
case DW_FORM_ref2:
case DW_FORM_ref4:
case DW_FORM_ref8:
case DW_FORM_ref_sig8:
case DW_FORM_ref_sup4:
case DW_FORM_ref_sup8:
case DW_FORM_strx1:
case DW_FORM_strx2:
case DW_FORM_strx4:
case DW_FORM_addrx1:
case DW_FORM_addrx2:
case DW_FORM_addrx4:
case DW_FORM_sec_offset:
case DW_FORM_strp:
case DW_FORM_strp_sup:
case DW_FORM_line_strp:
case DW_FORM_GNU_ref_alt:
case DW_FORM_GNU_strp_alt:
if (Optional<uint8_t> FixedSize = ::getFixedByteSize(Form, U)) {
*OffsetPtr += *FixedSize;
return true;
}
return false;
case DW_FORM_udata:
case DW_FORM_ref_udata:
case DW_FORM_strx:
case DW_FORM_addrx:
case DW_FORM_loclistx:
case DW_FORM_rnglistx:
case DW_FORM_GNU_addr_index:
case DW_FORM_GNU_str_index:
DebugInfoData.getULEB128(OffsetPtr);
return true;
// signed or unsigned LEB 128 values.
case DW_FORM_sdata:
DebugInfoData.getSLEB128(OffsetPtr);
return true;
case DW_FORM_indirect:
Indirect = true;
Form = static_cast<dwarf::Form>(DebugInfoData.getULEB128(OffsetPtr));
break;
case DW_FORM_udata:
case DW_FORM_ref_udata:
case DW_FORM_strx:
case DW_FORM_addrx:
case DW_FORM_loclistx:
case DW_FORM_rnglistx:
case DW_FORM_GNU_addr_index:
case DW_FORM_GNU_str_index:
DebugInfoData.getULEB128(OffsetPtr);
return true;
case DW_FORM_indirect:
Indirect = true;
Form = static_cast<dwarf::Form>(DebugInfoData.getULEB128(OffsetPtr));
break;
default:
return false;
default:
return false;
}
} while (Indirect);
return true;
@ -316,87 +316,84 @@ bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
FC == FC_SectionOffset;
}
bool DWARFFormValue::extractValue(const DataExtractor &data,
uint32_t *offset_ptr,
const DWARFUnit *cu) {
U = cu;
bool indirect = false;
bool is_block = false;
bool DWARFFormValue::extractValue(const DataExtractor &Data,
uint32_t *OffsetPtr, const DWARFUnit *CU) {
U = CU;
bool Indirect = false;
bool IsBlock = false;
Value.data = nullptr;
// Read the value for the form into value and follow and DW_FORM_indirect
// instances we run into
do {
indirect = false;
Indirect = false;
switch (Form) {
case DW_FORM_addr:
case DW_FORM_ref_addr: {
if (!U)
return false;
uint16_t AddrSize =
(Form == DW_FORM_addr)
? U->getAddressByteSize()
: U->getRefAddrByteSize();
uint16_t AddrSize = (Form == DW_FORM_addr) ? U->getAddressByteSize()
: U->getRefAddrByteSize();
Value.uval =
getRelocatedValue(data, AddrSize, offset_ptr, U->getRelocMap());
getRelocatedValue(Data, AddrSize, OffsetPtr, U->getRelocMap());
break;
}
case DW_FORM_exprloc:
case DW_FORM_block:
Value.uval = data.getULEB128(offset_ptr);
is_block = true;
Value.uval = Data.getULEB128(OffsetPtr);
IsBlock = true;
break;
case DW_FORM_block1:
Value.uval = data.getU8(offset_ptr);
is_block = true;
Value.uval = Data.getU8(OffsetPtr);
IsBlock = true;
break;
case DW_FORM_block2:
Value.uval = data.getU16(offset_ptr);
is_block = true;
Value.uval = Data.getU16(OffsetPtr);
IsBlock = true;
break;
case DW_FORM_block4:
Value.uval = data.getU32(offset_ptr);
is_block = true;
Value.uval = Data.getU32(OffsetPtr);
IsBlock = true;
break;
case DW_FORM_data1:
case DW_FORM_ref1:
case DW_FORM_flag:
case DW_FORM_strx1:
case DW_FORM_addrx1:
Value.uval = data.getU8(offset_ptr);
Value.uval = Data.getU8(OffsetPtr);
break;
case DW_FORM_data2:
case DW_FORM_ref2:
case DW_FORM_strx2:
case DW_FORM_addrx2:
Value.uval = data.getU16(offset_ptr);
Value.uval = Data.getU16(OffsetPtr);
break;
case DW_FORM_data4:
case DW_FORM_ref4:
case DW_FORM_ref_sup4:
case DW_FORM_strx4:
case DW_FORM_addrx4: {
const RelocAddrMap* RelocMap = U ? U->getRelocMap() : nullptr;
Value.uval = getRelocatedValue(data, 4, offset_ptr, RelocMap);
const RelocAddrMap *RelocMap = U ? U->getRelocMap() : nullptr;
Value.uval = getRelocatedValue(Data, 4, OffsetPtr, RelocMap);
break;
}
case DW_FORM_data8:
case DW_FORM_ref8:
case DW_FORM_ref_sup8:
Value.uval = data.getU64(offset_ptr);
Value.uval = Data.getU64(OffsetPtr);
break;
case DW_FORM_sdata:
Value.sval = data.getSLEB128(offset_ptr);
Value.sval = Data.getSLEB128(OffsetPtr);
break;
case DW_FORM_udata:
case DW_FORM_ref_udata:
Value.uval = data.getULEB128(offset_ptr);
Value.uval = Data.getULEB128(OffsetPtr);
break;
case DW_FORM_string:
Value.cstr = data.getCStr(offset_ptr);
Value.cstr = Data.getCStr(OffsetPtr);
break;
case DW_FORM_indirect:
Form = static_cast<dwarf::Form>(data.getULEB128(offset_ptr));
indirect = true;
Form = static_cast<dwarf::Form>(Data.getULEB128(OffsetPtr));
Indirect = true;
break;
case DW_FORM_strp:
case DW_FORM_sec_offset:
@ -406,82 +403,93 @@ bool DWARFFormValue::extractValue(const DataExtractor &data,
case DW_FORM_strp_sup: {
if (!U)
return false;
Value.uval = getRelocatedValue(data, U->getDwarfOffsetByteSize(),
offset_ptr, U->getRelocMap());
Value.uval = getRelocatedValue(Data, U->getDwarfOffsetByteSize(),
OffsetPtr, U->getRelocMap());
break;
}
case DW_FORM_flag_present:
Value.uval = 1;
break;
case DW_FORM_ref_sig8:
Value.uval = data.getU64(offset_ptr);
Value.uval = Data.getU64(OffsetPtr);
break;
case DW_FORM_GNU_addr_index:
case DW_FORM_GNU_str_index:
Value.uval = data.getULEB128(offset_ptr);
Value.uval = Data.getULEB128(OffsetPtr);
break;
default:
// DWARFFormValue::skipValue() will have caught this and caused all
// DWARF DIEs to fail to be parsed, so this code is not be reachable.
llvm_unreachable("unsupported form");
}
} while (indirect);
} while (Indirect);
if (is_block) {
StringRef str = data.getData().substr(*offset_ptr, Value.uval);
if (IsBlock) {
StringRef Str = Data.getData().substr(*OffsetPtr, Value.uval);
Value.data = nullptr;
if (!str.empty()) {
Value.data = reinterpret_cast<const uint8_t *>(str.data());
*offset_ptr += Value.uval;
if (!Str.empty()) {
Value.data = reinterpret_cast<const uint8_t *>(Str.data());
*OffsetPtr += Value.uval;
}
}
return true;
}
bool DWARFFormValue::skipValue(DataExtractor DebugInfoData,
uint32_t *offset_ptr, const DWARFUnit *U) const {
return DWARFFormValue::skipValue(Form, DebugInfoData, offset_ptr, U);
bool DWARFFormValue::skipValue(DataExtractor DebugInfoData, uint32_t *OffsetPtr,
const DWARFUnit *U) const {
return DWARFFormValue::skipValue(Form, DebugInfoData, OffsetPtr, U);
}
bool DWARFFormValue::skipValue(dwarf::Form form, DataExtractor DebugInfoData,
uint32_t *offset_ptr, const DWARFUnit *U) {
return skipFormValue(form, DebugInfoData, offset_ptr, U);
bool DWARFFormValue::skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
uint32_t *OffsetPtr, const DWARFUnit *U) {
return skipFormValue(Form, DebugInfoData, OffsetPtr, U);
}
bool DWARFFormValue::skipValue(dwarf::Form form, DataExtractor DebugInfoData,
uint32_t *offset_ptr, uint16_t Version,
bool DWARFFormValue::skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
uint32_t *OffsetPtr, uint16_t Version,
uint8_t AddrSize,
llvm::dwarf::DwarfFormat Format) {
FormSizeHelper FSH(Version, AddrSize, Format);
return skipFormValue(form, DebugInfoData, offset_ptr, &FSH);
return skipFormValue(Form, DebugInfoData, OffsetPtr, &FSH);
}
void
DWARFFormValue::dump(raw_ostream &OS) const {
uint64_t uvalue = Value.uval;
bool cu_relative_offset = false;
void DWARFFormValue::dump(raw_ostream &OS) const {
uint64_t UValue = Value.uval;
bool CURelativeOffset = false;
switch (Form) {
case DW_FORM_addr: OS << format("0x%016" PRIx64, uvalue); break;
case DW_FORM_addr:
OS << format("0x%016" PRIx64, UValue);
break;
case DW_FORM_GNU_addr_index: {
OS << format(" indexed (%8.8x) address = ", (uint32_t)uvalue);
OS << format(" indexed (%8.8x) address = ", (uint32_t)UValue);
uint64_t Address;
if (U == nullptr)
OS << "<invalid dwarf unit>";
else if (U->getAddrOffsetSectionItem(uvalue, Address))
else if (U->getAddrOffsetSectionItem(UValue, Address))
OS << format("0x%016" PRIx64, Address);
else
OS << "<no .debug_addr section>";
break;
}
case DW_FORM_flag_present: OS << "true"; break;
case DW_FORM_flag_present:
OS << "true";
break;
case DW_FORM_flag:
case DW_FORM_data1: OS << format("0x%02x", (uint8_t)uvalue); break;
case DW_FORM_data2: OS << format("0x%04x", (uint16_t)uvalue); break;
case DW_FORM_data4: OS << format("0x%08x", (uint32_t)uvalue); break;
case DW_FORM_data1:
OS << format("0x%02x", (uint8_t)UValue);
break;
case DW_FORM_data2:
OS << format("0x%04x", (uint16_t)UValue);
break;
case DW_FORM_data4:
OS << format("0x%08x", (uint32_t)UValue);
break;
case DW_FORM_ref_sig8:
case DW_FORM_data8: OS << format("0x%016" PRIx64, uvalue); break;
case DW_FORM_data8:
OS << format("0x%016" PRIx64, UValue);
break;
case DW_FORM_string:
OS << '"';
OS.write_escaped(Value.cstr);
@ -492,80 +500,92 @@ DWARFFormValue::dump(raw_ostream &OS) const {
case DW_FORM_block1:
case DW_FORM_block2:
case DW_FORM_block4:
if (uvalue > 0) {
if (UValue > 0) {
switch (Form) {
case DW_FORM_exprloc:
case DW_FORM_block: OS << format("<0x%" PRIx64 "> ", uvalue); break;
case DW_FORM_block1: OS << format("<0x%2.2x> ", (uint8_t)uvalue); break;
case DW_FORM_block2: OS << format("<0x%4.4x> ", (uint16_t)uvalue); break;
case DW_FORM_block4: OS << format("<0x%8.8x> ", (uint32_t)uvalue); break;
default: break;
case DW_FORM_block:
OS << format("<0x%" PRIx64 "> ", UValue);
break;
case DW_FORM_block1:
OS << format("<0x%2.2x> ", (uint8_t)UValue);
break;
case DW_FORM_block2:
OS << format("<0x%4.4x> ", (uint16_t)UValue);
break;
case DW_FORM_block4:
OS << format("<0x%8.8x> ", (uint32_t)UValue);
break;
default:
break;
}
const uint8_t* data_ptr = Value.data;
if (data_ptr) {
// uvalue contains size of block
const uint8_t* end_data_ptr = data_ptr + uvalue;
while (data_ptr < end_data_ptr) {
OS << format("%2.2x ", *data_ptr);
++data_ptr;
const uint8_t *DataPtr = Value.data;
if (DataPtr) {
// UValue contains size of block
const uint8_t *EndDataPtr = DataPtr + UValue;
while (DataPtr < EndDataPtr) {
OS << format("%2.2x ", *DataPtr);
++DataPtr;
}
}
else
} else
OS << "NULL";
}
break;
case DW_FORM_sdata: OS << Value.sval; break;
case DW_FORM_udata: OS << Value.uval; break;
case DW_FORM_sdata:
OS << Value.sval;
break;
case DW_FORM_udata:
OS << Value.uval;
break;
case DW_FORM_strp:
OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)uvalue);
OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)UValue);
dumpString(OS);
break;
case DW_FORM_GNU_str_index:
OS << format(" indexed (%8.8x) string = ", (uint32_t)uvalue);
OS << format(" indexed (%8.8x) string = ", (uint32_t)UValue);
dumpString(OS);
break;
case DW_FORM_GNU_strp_alt:
OS << format("alt indirect string, offset: 0x%" PRIx64 "", uvalue);
OS << format("alt indirect string, offset: 0x%" PRIx64 "", UValue);
dumpString(OS);
break;
case DW_FORM_ref_addr:
OS << format("0x%016" PRIx64, uvalue);
OS << format("0x%016" PRIx64, UValue);
break;
case DW_FORM_ref1:
cu_relative_offset = true;
OS << format("cu + 0x%2.2x", (uint8_t)uvalue);
CURelativeOffset = true;
OS << format("cu + 0x%2.2x", (uint8_t)UValue);
break;
case DW_FORM_ref2:
cu_relative_offset = true;
OS << format("cu + 0x%4.4x", (uint16_t)uvalue);
CURelativeOffset = true;
OS << format("cu + 0x%4.4x", (uint16_t)UValue);
break;
case DW_FORM_ref4:
cu_relative_offset = true;
OS << format("cu + 0x%4.4x", (uint32_t)uvalue);
CURelativeOffset = true;
OS << format("cu + 0x%4.4x", (uint32_t)UValue);
break;
case DW_FORM_ref8:
cu_relative_offset = true;
OS << format("cu + 0x%8.8" PRIx64, uvalue);
CURelativeOffset = true;
OS << format("cu + 0x%8.8" PRIx64, UValue);
break;
case DW_FORM_ref_udata:
cu_relative_offset = true;
OS << format("cu + 0x%" PRIx64, uvalue);
CURelativeOffset = true;
OS << format("cu + 0x%" PRIx64, UValue);
break;
case DW_FORM_GNU_ref_alt:
OS << format("<alt 0x%" PRIx64 ">", uvalue);
OS << format("<alt 0x%" PRIx64 ">", UValue);
break;
// All DW_FORM_indirect attributes should be resolved prior to calling
// this function
// All DW_FORM_indirect attributes should be resolved prior to calling
// this function
case DW_FORM_indirect:
OS << "DW_FORM_indirect";
break;
// Should be formatted to 64-bit for DWARF64.
// Should be formatted to 64-bit for DWARF64.
case DW_FORM_sec_offset:
OS << format("0x%08x", (uint32_t)uvalue);
OS << format("0x%08x", (uint32_t)UValue);
break;
default:
@ -573,10 +593,10 @@ DWARFFormValue::dump(raw_ostream &OS) const {
break;
}
if (cu_relative_offset) {
if (CURelativeOffset) {
OS << " => {";
WithColor(OS, syntax::Address).get()
<< format("0x%8.8" PRIx64, uvalue + (U ? U->getOffset() : 0));
<< format("0x%8.8" PRIx64, UValue + (U ? U->getOffset() : 0));
OS << "}";
}
}
@ -653,15 +673,16 @@ Optional<uint64_t> DWARFFormValue::getAsSectionOffset() const {
}
Optional<uint64_t> DWARFFormValue::getAsUnsignedConstant() const {
if ((!isFormClass(FC_Constant) && !isFormClass(FC_Flag))
|| Form == DW_FORM_sdata)
if ((!isFormClass(FC_Constant) && !isFormClass(FC_Flag)) ||
Form == DW_FORM_sdata)
return None;
return Value.uval;
}
Optional<int64_t> DWARFFormValue::getAsSignedConstant() const {
if ((!isFormClass(FC_Constant) && !isFormClass(FC_Flag)) ||
(Form == DW_FORM_udata && uint64_t(std::numeric_limits<int64_t>::max()) < Value.uval))
(Form == DW_FORM_udata &&
uint64_t(std::numeric_limits<int64_t>::max()) < Value.uval))
return None;
switch (Form) {
case DW_FORM_data4: