mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-25 12:12:47 +01:00
fa59d7afc5
Supporting this form in .debug_line.dwo will be done as a follow-up. Differential Revision: https://reviews.llvm.org/D33155 llvm-svn: 317607
665 lines
19 KiB
C++
665 lines
19 KiB
C++
//===- DWARFFormValue.cpp -------------------------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#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/BinaryFormat/Dwarf.h"
|
|
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
|
|
#include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
|
|
#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/Format.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <cinttypes>
|
|
#include <cstdint>
|
|
#include <limits>
|
|
|
|
using namespace llvm;
|
|
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
|
|
};
|
|
|
|
Optional<uint8_t>
|
|
DWARFFormValue::getFixedByteSize(dwarf::Form Form,
|
|
const DWARFFormParams Params) {
|
|
switch (Form) {
|
|
case DW_FORM_addr:
|
|
assert(Params.Version && Params.AddrSize && "Invalid Params for form");
|
|
return Params.AddrSize;
|
|
|
|
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:
|
|
assert(Params.Version && Params.AddrSize && "Invalid Params for form");
|
|
return Params.getRefAddrByteSize();
|
|
|
|
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_strx3:
|
|
return 3;
|
|
|
|
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:
|
|
assert(Params.Version && Params.AddrSize && "Invalid Params for form");
|
|
return Params.getDwarfOffsetByteSize();
|
|
|
|
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_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;
|
|
|
|
default:
|
|
llvm_unreachable("Handle this form in this switch statement");
|
|
}
|
|
return None;
|
|
}
|
|
|
|
bool DWARFFormValue::skipValue(dwarf::Form Form, DataExtractor DebugInfoData,
|
|
uint32_t *OffsetPtr,
|
|
const DWARFFormParams Params) {
|
|
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;
|
|
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 =
|
|
DWARFFormValue::getFixedByteSize(Form, Params)) {
|
|
*OffsetPtr += *FixedSize;
|
|
return true;
|
|
}
|
|
return false;
|
|
|
|
// signed or unsigned LEB 128 values.
|
|
case DW_FORM_sdata:
|
|
DebugInfoData.getSLEB128(OffsetPtr);
|
|
return true;
|
|
|
|
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;
|
|
}
|
|
} while (Indirect);
|
|
return true;
|
|
}
|
|
|
|
bool DWARFFormValue::isFormClass(DWARFFormValue::FormClass FC) const {
|
|
// First, check DWARF4 form classes.
|
|
if (Form < makeArrayRef(DWARF4FormClasses).size() &&
|
|
DWARF4FormClasses[Form] == FC)
|
|
return true;
|
|
// Check more forms from DWARF4 and DWARF5 proposals.
|
|
switch (Form) {
|
|
case DW_FORM_ref_sig8:
|
|
case DW_FORM_GNU_ref_alt:
|
|
return (FC == FC_Reference);
|
|
case DW_FORM_GNU_addr_index:
|
|
return (FC == FC_Address);
|
|
case DW_FORM_GNU_str_index:
|
|
case DW_FORM_GNU_strp_alt:
|
|
case DW_FORM_strx:
|
|
case DW_FORM_strx1:
|
|
case DW_FORM_strx2:
|
|
case DW_FORM_strx3:
|
|
case DW_FORM_strx4:
|
|
return (FC == FC_String);
|
|
case DW_FORM_implicit_const:
|
|
return (FC == FC_Constant);
|
|
default:
|
|
break;
|
|
}
|
|
// In DWARF3 DW_FORM_data4 and DW_FORM_data8 served also as a section offset.
|
|
// Don't check for DWARF version here, as some producers may still do this
|
|
// by mistake. Also accept DW_FORM_strp since this is .debug_str section
|
|
// offset.
|
|
return (Form == DW_FORM_data4 || Form == DW_FORM_data8 ||
|
|
Form == DW_FORM_strp) &&
|
|
FC == FC_SectionOffset;
|
|
}
|
|
|
|
bool DWARFFormValue::extractValue(const DWARFDataExtractor &Data,
|
|
uint32_t *OffsetPtr, DWARFFormParams FP,
|
|
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;
|
|
switch (Form) {
|
|
case DW_FORM_addr:
|
|
case DW_FORM_ref_addr: {
|
|
uint16_t Size =
|
|
(Form == DW_FORM_addr) ? FP.AddrSize : FP.getRefAddrByteSize();
|
|
Value.uval = Data.getRelocatedValue(Size, OffsetPtr, &Value.SectionIndex);
|
|
break;
|
|
}
|
|
case DW_FORM_exprloc:
|
|
case DW_FORM_block:
|
|
Value.uval = Data.getULEB128(OffsetPtr);
|
|
IsBlock = true;
|
|
break;
|
|
case DW_FORM_block1:
|
|
Value.uval = Data.getU8(OffsetPtr);
|
|
IsBlock = true;
|
|
break;
|
|
case DW_FORM_block2:
|
|
Value.uval = Data.getU16(OffsetPtr);
|
|
IsBlock = true;
|
|
break;
|
|
case DW_FORM_block4:
|
|
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(OffsetPtr);
|
|
break;
|
|
case DW_FORM_data2:
|
|
case DW_FORM_ref2:
|
|
case DW_FORM_strx2:
|
|
case DW_FORM_addrx2:
|
|
Value.uval = Data.getU16(OffsetPtr);
|
|
break;
|
|
case DW_FORM_strx3:
|
|
Value.uval = Data.getU24(OffsetPtr);
|
|
break;
|
|
case DW_FORM_data4:
|
|
case DW_FORM_ref4:
|
|
case DW_FORM_ref_sup4:
|
|
case DW_FORM_strx4:
|
|
case DW_FORM_addrx4:
|
|
Value.uval = Data.getRelocatedValue(4, OffsetPtr);
|
|
break;
|
|
case DW_FORM_data8:
|
|
case DW_FORM_ref8:
|
|
case DW_FORM_ref_sup8:
|
|
Value.uval = Data.getU64(OffsetPtr);
|
|
break;
|
|
case DW_FORM_sdata:
|
|
Value.sval = Data.getSLEB128(OffsetPtr);
|
|
break;
|
|
case DW_FORM_udata:
|
|
case DW_FORM_ref_udata:
|
|
Value.uval = Data.getULEB128(OffsetPtr);
|
|
break;
|
|
case DW_FORM_string:
|
|
Value.cstr = Data.getCStr(OffsetPtr);
|
|
break;
|
|
case DW_FORM_indirect:
|
|
Form = static_cast<dwarf::Form>(Data.getULEB128(OffsetPtr));
|
|
Indirect = true;
|
|
break;
|
|
case DW_FORM_strp:
|
|
case DW_FORM_sec_offset:
|
|
case DW_FORM_GNU_ref_alt:
|
|
case DW_FORM_GNU_strp_alt:
|
|
case DW_FORM_line_strp:
|
|
case DW_FORM_strp_sup: {
|
|
Value.uval =
|
|
Data.getRelocatedValue(FP.getDwarfOffsetByteSize(), OffsetPtr);
|
|
break;
|
|
}
|
|
case DW_FORM_flag_present:
|
|
Value.uval = 1;
|
|
break;
|
|
case DW_FORM_ref_sig8:
|
|
Value.uval = Data.getU64(OffsetPtr);
|
|
break;
|
|
case DW_FORM_GNU_addr_index:
|
|
case DW_FORM_GNU_str_index:
|
|
case DW_FORM_strx:
|
|
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);
|
|
|
|
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());
|
|
*OffsetPtr += Value.uval;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void DWARFFormValue::dump(raw_ostream &OS, DIDumpOptions DumpOpts) 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_GNU_addr_index: {
|
|
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))
|
|
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:
|
|
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_string:
|
|
OS << '"';
|
|
OS.write_escaped(Value.cstr);
|
|
OS << '"';
|
|
break;
|
|
case DW_FORM_exprloc:
|
|
case DW_FORM_block:
|
|
case DW_FORM_block1:
|
|
case DW_FORM_block2:
|
|
case DW_FORM_block4:
|
|
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;
|
|
}
|
|
|
|
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
|
|
OS << "NULL";
|
|
}
|
|
break;
|
|
|
|
case DW_FORM_sdata:
|
|
OS << Value.sval;
|
|
break;
|
|
case DW_FORM_udata:
|
|
OS << Value.uval;
|
|
break;
|
|
case DW_FORM_strp:
|
|
if (DumpOpts.Verbose)
|
|
OS << format(" .debug_str[0x%8.8x] = ", (uint32_t)UValue);
|
|
dumpString(OS);
|
|
break;
|
|
case DW_FORM_strx:
|
|
case DW_FORM_strx1:
|
|
case DW_FORM_strx2:
|
|
case DW_FORM_strx3:
|
|
case DW_FORM_strx4:
|
|
case DW_FORM_GNU_str_index:
|
|
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);
|
|
dumpString(OS);
|
|
break;
|
|
case DW_FORM_ref_addr:
|
|
OS << format("0x%016" PRIx64, UValue);
|
|
break;
|
|
case DW_FORM_ref1:
|
|
CURelativeOffset = true;
|
|
OS << format("cu + 0x%2.2x", (uint8_t)UValue);
|
|
break;
|
|
case DW_FORM_ref2:
|
|
CURelativeOffset = true;
|
|
OS << format("cu + 0x%4.4x", (uint16_t)UValue);
|
|
break;
|
|
case DW_FORM_ref4:
|
|
CURelativeOffset = true;
|
|
OS << format("cu + 0x%4.4x", (uint32_t)UValue);
|
|
break;
|
|
case DW_FORM_ref8:
|
|
CURelativeOffset = true;
|
|
OS << format("cu + 0x%8.8" PRIx64, UValue);
|
|
break;
|
|
case DW_FORM_ref_udata:
|
|
CURelativeOffset = true;
|
|
OS << format("cu + 0x%" PRIx64, UValue);
|
|
break;
|
|
case DW_FORM_GNU_ref_alt:
|
|
OS << format("<alt 0x%" PRIx64 ">", UValue);
|
|
break;
|
|
|
|
// 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.
|
|
case DW_FORM_sec_offset:
|
|
OS << format("0x%08x", (uint32_t)UValue);
|
|
break;
|
|
|
|
default:
|
|
OS << format("DW_FORM(0x%4.4x)", Form);
|
|
break;
|
|
}
|
|
|
|
if (CURelativeOffset && DumpOpts.Verbose) {
|
|
OS << " => {";
|
|
WithColor(OS, syntax::Address).get()
|
|
<< format("0x%8.8" PRIx64, UValue + (U ? U->getOffset() : 0));
|
|
OS << "}";
|
|
}
|
|
}
|
|
|
|
void DWARFFormValue::dumpString(raw_ostream &OS) const {
|
|
Optional<const char *> DbgStr = getAsCString();
|
|
if (DbgStr.hasValue()) {
|
|
raw_ostream &COS = WithColor(OS, syntax::String);
|
|
COS << '"';
|
|
COS.write_escaped(DbgStr.getValue());
|
|
COS << '"';
|
|
}
|
|
}
|
|
|
|
Optional<const char *> DWARFFormValue::getAsCString() const {
|
|
if (!isFormClass(FC_String))
|
|
return None;
|
|
if (Form == DW_FORM_string)
|
|
return Value.cstr;
|
|
// FIXME: Add support for DW_FORM_GNU_strp_alt
|
|
if (Form == DW_FORM_GNU_strp_alt || U == nullptr)
|
|
return None;
|
|
uint32_t Offset = Value.uval;
|
|
if (Form == DW_FORM_GNU_str_index || Form == DW_FORM_strx ||
|
|
Form == DW_FORM_strx1 || Form == DW_FORM_strx2 || Form == DW_FORM_strx3 ||
|
|
Form == DW_FORM_strx4) {
|
|
uint64_t StrOffset;
|
|
if (!U->getStringOffsetSectionItem(Offset, StrOffset))
|
|
return None;
|
|
Offset = StrOffset;
|
|
}
|
|
if (const char *Str = U->getStringExtractor().getCStr(&Offset)) {
|
|
return Str;
|
|
}
|
|
return None;
|
|
}
|
|
|
|
Optional<uint64_t> DWARFFormValue::getAsAddress() const {
|
|
if (!isFormClass(FC_Address))
|
|
return None;
|
|
if (Form == DW_FORM_GNU_addr_index) {
|
|
uint32_t Index = Value.uval;
|
|
uint64_t Result;
|
|
if (!U || !U->getAddrOffsetSectionItem(Index, Result))
|
|
return None;
|
|
return Result;
|
|
}
|
|
return Value.uval;
|
|
}
|
|
|
|
Optional<uint64_t> DWARFFormValue::getAsReference() const {
|
|
if (!isFormClass(FC_Reference))
|
|
return None;
|
|
switch (Form) {
|
|
case DW_FORM_ref1:
|
|
case DW_FORM_ref2:
|
|
case DW_FORM_ref4:
|
|
case DW_FORM_ref8:
|
|
case DW_FORM_ref_udata:
|
|
if (!U)
|
|
return None;
|
|
return Value.uval + U->getOffset();
|
|
case DW_FORM_ref_addr:
|
|
case DW_FORM_ref_sig8:
|
|
case DW_FORM_GNU_ref_alt:
|
|
return Value.uval;
|
|
default:
|
|
return None;
|
|
}
|
|
}
|
|
|
|
Optional<uint64_t> DWARFFormValue::getAsSectionOffset() const {
|
|
if (!isFormClass(FC_SectionOffset))
|
|
return None;
|
|
return Value.uval;
|
|
}
|
|
|
|
Optional<uint64_t> DWARFFormValue::getAsUnsignedConstant() const {
|
|
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))
|
|
return None;
|
|
switch (Form) {
|
|
case DW_FORM_data4:
|
|
return int32_t(Value.uval);
|
|
case DW_FORM_data2:
|
|
return int16_t(Value.uval);
|
|
case DW_FORM_data1:
|
|
return int8_t(Value.uval);
|
|
case DW_FORM_sdata:
|
|
case DW_FORM_data8:
|
|
default:
|
|
return Value.sval;
|
|
}
|
|
}
|
|
|
|
Optional<ArrayRef<uint8_t>> DWARFFormValue::getAsBlock() const {
|
|
if (!isFormClass(FC_Block) && !isFormClass(FC_Exprloc))
|
|
return None;
|
|
return makeArrayRef(Value.data, Value.uval);
|
|
}
|
|
|
|
Optional<uint64_t> DWARFFormValue::getAsCStringOffset() const {
|
|
if (!isFormClass(FC_String) && Form == DW_FORM_string)
|
|
return None;
|
|
return Value.uval;
|
|
}
|
|
|
|
Optional<uint64_t> DWARFFormValue::getAsReferenceUVal() const {
|
|
if (!isFormClass(FC_Reference))
|
|
return None;
|
|
return Value.uval;
|
|
}
|