LLDB mainline
Namespaces | Macros | Typedefs | Functions
FormatterBytecode.cpp File Reference
#include "lldb/DataFormatters/FormatterBytecode.h"
#include "lldb/Symbol/CompilerType.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/ValueObject/ValueObject.h"
#include "lldb/ValueObject/ValueObjectConstResult.h"
#include "lldb/lldb-forward.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/DataExtractor.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/ErrorExtras.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/FormatProviders.h"
#include "llvm/Support/FormatVariadicDetails.h"
#include <type_traits>
#include "lldb/DataFormatters/FormatterBytecode.def"

Go to the source code of this file.

Namespaces

namespace  lldb_private
 A class that represents a running process on the host machine.
namespace  lldb_private::FormatterBytecode

Macros

#define DEFINE_OPCODE(OP, MNEMONIC, NAME)
#define DEFINE_SELECTOR(ID, NAME)
#define DEFINE_SIGNATURE(ID, NAME)
#define TYPE_CHECK(...)
#define BINOP_IMPL(OP, CHECK_ZERO)
#define BINOP(OP)
#define BINOP_CHECKZERO(OP)
#define CMPOP(OP)
#define BITOP(OP)
#define SHIFTOP(OP, LEFT)
#define POP_VALOBJ(VALOBJ)

Typedefs

template<typename T>
using lldb_private::FormatterBytecode::EnableIfSigned
template<typename T>
using lldb_private::FormatterBytecode::EnableIfUnsigned

Functions

std::string lldb_private::toString (FormatterBytecode::OpCodes op)
std::string lldb_private::toString (FormatterBytecode::Selectors sel)
std::string lldb_private::toString (FormatterBytecode::Signatures sig)
std::string lldb_private::toString (const FormatterBytecode::DataStack &data)
static llvm::Expected< std::string > lldb_private::FormatterBytecode::SanitizeFormatString (llvm::StringRef fmt)
 Check a format string, and remove the layout and options of each replacement.
static llvm::Error lldb_private::FormatterBytecode::FormatImpl (DataStack &data, uint32_t version)
 Implement the @format function.
static llvm::Error lldb_private::FormatterBytecode::TypeCheck (llvm::ArrayRef< DataStackElement > data, DataType type)
static llvm::Error lldb_private::FormatterBytecode::TypeCheck (llvm::ArrayRef< DataStackElement > data, DataType type1, DataType type2)
static llvm::Error lldb_private::FormatterBytecode::TypeCheck (llvm::ArrayRef< DataStackElement > data, DataType type1, DataType type2, DataType type3)
static llvm::Error lldb_private::FormatterBytecode::TypeCheck (llvm::ArrayRef< DataStackElement > data, DataType type1, DataType type2, DataType type3, DataType type4)
template<typename T>
static DataStackElement lldb_private::FormatterBytecode::WrapAPSIntResult (T result, unsigned bit_width, bool is_unsigned)
 Wrap the result of a binary operator applied to two APSInts back into a DataStackElement.
static bool lldb_private::FormatterBytecode::Reaches (const Dictionary *from, const Dictionary *target)
 Returns true if target is transitively reachable via from.
template<typename T, EnableIfSigned< T > = 0>
static DataStackElement lldb_private::FormatterBytecode::MakeInt (T value, uint32_t version)
template<typename T, EnableIfUnsigned< T > = 0>
static DataStackElement lldb_private::FormatterBytecode::MakeInt (T value, uint32_t version)
llvm::Error lldb_private::FormatterBytecode::Interpret (ControlStack &control, DataStack &data, Signatures sig, uint32_t version)
 Interpret the bytecode on control.

Macro Definition Documentation

◆ BINOP

#define BINOP ( OP)
Value:
BINOP_IMPL(OP, false)
BINOP_IMPL
#define BINOP_IMPL(OP, CHECK_ZERO)

Referenced by lldb_private::FormatterBytecode::Interpret().

◆ BINOP_CHECKZERO

#define BINOP_CHECKZERO ( OP)
Value:
BINOP_IMPL(OP, true)

Referenced by lldb_private::FormatterBytecode::Interpret().

◆ BINOP_IMPL

#define BINOP_IMPL ( OP,
CHECK_ZERO )
Value:
{ \
TYPE_CHECK(Any, Any); \
auto y = data.PopAny(); \
if (std::holds_alternative<uint64_t>(y)) { \
if (CHECK_ZERO && !std::get<uint64_t>(y)) \
return error(#OP " by zero"); \
TYPE_CHECK(UInt); \
data.Push((uint64_t)(data.Pop<uint64_t>() OP std::get<uint64_t>(y))); \
} else if (std::holds_alternative<int64_t>(y)) { \
if (CHECK_ZERO && !std::get<int64_t>(y)) \
return error(#OP " by zero"); \
TYPE_CHECK(Int); \
data.Push((int64_t)(data.Pop<int64_t>() OP std::get<int64_t>(y))); \
} else if (std::holds_alternative<llvm::APSInt>(y)) { \
TYPE_CHECK(Integer); \
llvm::APSInt rhs = std::get<llvm::APSInt>(y); \
llvm::APSInt lhs = data.Pop<llvm::APSInt>(); \
if (lhs.isUnsigned() || rhs.isUnsigned()) \
return error("unsupported unsigned value"); \
unsigned width = std::max(lhs.getBitWidth(), rhs.getBitWidth()); \
lhs = lhs.extend(width); \
rhs = rhs.extend(width); \
if (CHECK_ZERO && rhs.isZero()) \
return error(#OP " by zero"); \
data.Push(WrapAPSIntResult(lhs OP rhs, width, lhs.isUnsigned())); \
} else \
return error("unsupported data types"); \
}
error
static llvm::raw_ostream & error(Stream &strm)
Definition CommandReturnObject.cpp:18
UInt
#define UInt(x)
Definition EmulateInstructionARM64.cpp:71
lldb_private::FormatterBytecode::WrapAPSIntResult
static DataStackElement WrapAPSIntResult(T result, unsigned bit_width, bool is_unsigned)
Wrap the result of a binary operator applied to two APSInts back into a DataStackElement.
Definition FormatterBytecode.cpp:279

◆ BITOP

#define BITOP ( OP)
Value:
{ \
TYPE_CHECK(Any, Any); \
auto y = data.PopAny(); \
if (std::holds_alternative<uint64_t>(y)) { \
TYPE_CHECK(UInt); \
data.Push((uint64_t)(data.Pop<uint64_t>() OP std::get<uint64_t>(y))); \
} else if (std::holds_alternative<int64_t>(y)) { \
TYPE_CHECK(Int); \
data.Push((int64_t)(data.Pop<int64_t>() OP std::get<int64_t>(y))); \
} else if (std::holds_alternative<llvm::APSInt>(y)) { \
TYPE_CHECK(Integer); \
llvm::APSInt rhs = std::get<llvm::APSInt>(y); \
llvm::APSInt lhs = data.Pop<llvm::APSInt>(); \
unsigned width = std::max(lhs.getBitWidth(), rhs.getBitWidth()); \
llvm::APInt lhs_bits = \
static_cast<const llvm::APInt &>(lhs).zext(width); \
llvm::APInt rhs_bits = \
static_cast<const llvm::APInt &>(rhs).zext(width); \
llvm::APInt bits = lhs_bits OP rhs_bits; \
data.Push(llvm::APSInt(std::move(bits), /*isUnsigned=*/false)); \
} else \
return error("unsupported data types"); \
}

Referenced by lldb_private::FormatterBytecode::Interpret().

◆ CMPOP

#define CMPOP ( OP)
Value:
{ \
TYPE_CHECK(Any, Any); \
auto y = data.PopAny(); \
if (std::holds_alternative<uint64_t>(y)) { \
TYPE_CHECK(UInt); \
data.Push((uint64_t)(data.Pop<uint64_t>() OP std::get<uint64_t>(y))); \
} else if (std::holds_alternative<int64_t>(y)) { \
TYPE_CHECK(Int); \
data.Push((int64_t)(data.Pop<int64_t>() OP std::get<int64_t>(y))); \
} else if (std::holds_alternative<llvm::APSInt>(y)) { \
TYPE_CHECK(Integer); \
llvm::APSInt rhs = std::get<llvm::APSInt>(y); \
llvm::APSInt lhs = data.Pop<llvm::APSInt>(); \
if (lhs.isUnsigned() || rhs.isUnsigned()) \
return error("unsupported unsigned value"); \
unsigned width = std::max(lhs.getBitWidth(), rhs.getBitWidth()); \
lhs = lhs.extend(width); \
rhs = rhs.extend(width); \
data.Push(WrapAPSIntResult(lhs OP rhs, width, lhs.isUnsigned())); \
} else \
return error("unsupported data types"); \
}

Referenced by lldb_private::FormatterBytecode::Interpret().

◆ DEFINE_OPCODE

#define DEFINE_OPCODE ( OP,
MNEMONIC,
NAME )
Value:
case OP: { \
const char *s = MNEMONIC; \
return s ? s : #NAME; \
}

◆ DEFINE_SELECTOR

#define DEFINE_SELECTOR ( ID,
NAME )
Value:
case ID: \
return "@" #NAME;
ID
static char ID
Definition IRDynamicChecks.cpp:34

◆ DEFINE_SIGNATURE

#define DEFINE_SIGNATURE ( ID,
NAME )
Value:
case ID: \
return "@" #NAME;

◆ POP_VALOBJ

#define POP_VALOBJ ( VALOBJ)
Value:
auto VALOBJ = data.Pop<ValueObjectSP>(); \
if (!VALOBJ) \
return error("null object");
lldb::ValueObjectSP
std::shared_ptr< lldb_private::ValueObject > ValueObjectSP
Definition lldb-forward.h:529

Referenced by lldb_private::FormatterBytecode::Interpret().

◆ SHIFTOP

#define SHIFTOP ( OP,
LEFT )
Value:
{ \
TYPE_CHECK(Any, UInt); \
uint64_t y = data.Pop<uint64_t>(); \
if (y > 64) \
return error("shift out of bounds"); \
if (std::holds_alternative<uint64_t>(data.back())) { \
uint64_t x = data.Pop<uint64_t>(); \
data.Push(x OP y); \
} else if (std::holds_alternative<int64_t>(data.back())) { \
int64_t x = data.Pop<int64_t>(); \
if (x < 0 && LEFT) \
return error("left shift of negative value"); \
if (y > 64) \
return error("shift out of bounds"); \
data.Push(x OP y); \
} else if (std::holds_alternative<llvm::APSInt>(data.back())) { \
llvm::APSInt x = data.Pop<llvm::APSInt>(); \
if (y > x.getBitWidth()) \
return error("shift out of bounds"); \
const llvm::APInt &bits = x; \
llvm::APInt shifted = \
LEFT ? bits.shl((unsigned)y) : bits.lshr((unsigned)y); \
data.Push(llvm::APSInt(std::move(shifted), /*isUnsigned=*/false)); \
} else \
return error("unsupported data types"); \
}

Referenced by lldb_private::FormatterBytecode::Interpret().

◆ TYPE_CHECK

#define TYPE_CHECK ( ...)
Value:
if (auto error = TypeCheck(data, __VA_ARGS__)) \
return error;

Referenced by lldb_private::FormatterBytecode::Interpret().

Generated on for LLDB by doxygen 1.14.0