shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
llvm-project/lldb/source/API/SBFrame.cpp
Jonas Devlieghere 581af8b09d [SBAPI] Log from record macro 
The current record macros already log the function being called. This
patch extends the macros to also log their input arguments and removes
explicit logging from the SB API.

This might degrade the amount of information in some cases (because of
smarter casts or efforts to log return values). However I think this is
outweighed by the increased coverage and consistency. Furthermore, using
the reproducer infrastructure, diagnosing bugs in the API layer should
become much easier compared to relying on log messages.

Differential revision: https://reviews.llvm.org/D59101

llvm-svn: 355649
2019-03-07 22:47:13 +00:00

1295 lines
41 KiB
C++
Raw Blame History

//===-- SBFrame.cpp ---------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <algorithm>
#include <set>
#include <string>
#include "lldb/API/SBFrame.h"
#include "lldb/lldb-types.h"
#include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
#include "SBReproducerPrivate.h"
#include "Utils.h"
#include "lldb/Core/Address.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Core/ValueObjectRegister.h"
#include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Expression/UserExpression.h"
#include "lldb/Host/Host.h"
#include "lldb/Symbol/Block.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/StackFrameRecognizer.h"
#include "lldb/Target/StackID.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Stream.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBExpressionOptions.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBSymbolContext.h"
#include "lldb/API/SBThread.h"
#include "lldb/API/SBValue.h"
#include "lldb/API/SBVariablesOptions.h"
#include "llvm/Support/PrettyStackTrace.h"
using namespace lldb;
using namespace lldb_private;
SBFrame::SBFrame() : m_opaque_sp(new ExecutionContextRef()) {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFrame);
}
SBFrame::SBFrame(const StackFrameSP &lldb_object_sp)
: m_opaque_sp(new ExecutionContextRef(lldb_object_sp)) {
LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::StackFrameSP &),
lldb_object_sp);
}
SBFrame::SBFrame(const SBFrame &rhs) : m_opaque_sp() {
LLDB_RECORD_CONSTRUCTOR(SBFrame, (const lldb::SBFrame &), rhs);
m_opaque_sp = clone(rhs.m_opaque_sp);
}
SBFrame::~SBFrame() = default;
const SBFrame &SBFrame::operator=(const SBFrame &rhs) {
LLDB_RECORD_METHOD(const lldb::SBFrame &,
SBFrame, operator=,(const lldb::SBFrame &), rhs);
if (this != &rhs)
m_opaque_sp = clone(rhs.m_opaque_sp);
return *this;
}
StackFrameSP SBFrame::GetFrameSP() const {
return (m_opaque_sp ? m_opaque_sp->GetFrameSP() : StackFrameSP());
}
void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) {
return m_opaque_sp->SetFrameSP(lldb_object_sp);
}
bool SBFrame::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsValid);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock()))
return GetFrameSP().get() != nullptr;
}
// Without a target & process we can't have a valid stack frame.
return false;
}
SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const {
LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBFrame, GetSymbolContext,
(uint32_t), resolve_scope);
SBSymbolContext sb_sym_ctx;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame)
sb_sym_ctx.SetSymbolContext(&frame->GetSymbolContext(scope));
}
}
return LLDB_RECORD_RESULT(sb_sym_ctx);
}
SBModule SBFrame::GetModule() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBModule, SBFrame, GetModule);
SBModule sb_module;
ModuleSP module_sp;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
module_sp = frame->GetSymbolContext(eSymbolContextModule).module_sp;
sb_module.SetSP(module_sp);
}
}
}
return LLDB_RECORD_RESULT(sb_module);
}
SBCompileUnit SBFrame::GetCompileUnit() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBCompileUnit, SBFrame,
GetCompileUnit);
SBCompileUnit sb_comp_unit;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
sb_comp_unit.reset(
frame->GetSymbolContext(eSymbolContextCompUnit).comp_unit);
}
}
}
return LLDB_RECORD_RESULT(sb_comp_unit);
}
SBFunction SBFrame::GetFunction() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFunction, SBFrame, GetFunction);
SBFunction sb_function;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
sb_function.reset(
frame->GetSymbolContext(eSymbolContextFunction).function);
}
}
}
return LLDB_RECORD_RESULT(sb_function);
}
SBSymbol SBFrame::GetSymbol() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBSymbol, SBFrame, GetSymbol);
SBSymbol sb_symbol;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
sb_symbol.reset(frame->GetSymbolContext(eSymbolContextSymbol).symbol);
}
}
}
return LLDB_RECORD_RESULT(sb_symbol);
}
SBBlock SBFrame::GetBlock() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetBlock);
SBBlock sb_block;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame)
sb_block.SetPtr(frame->GetSymbolContext(eSymbolContextBlock).block);
}
}
return LLDB_RECORD_RESULT(sb_block);
}
SBBlock SBFrame::GetFrameBlock() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBlock, SBFrame, GetFrameBlock);
SBBlock sb_block;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame)
sb_block.SetPtr(frame->GetFrameBlock());
}
}
return LLDB_RECORD_RESULT(sb_block);
}
SBLineEntry SBFrame::GetLineEntry() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBLineEntry, SBFrame, GetLineEntry);
SBLineEntry sb_line_entry;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
sb_line_entry.SetLineEntry(
frame->GetSymbolContext(eSymbolContextLineEntry).line_entry);
}
}
}
return LLDB_RECORD_RESULT(sb_line_entry);
}
uint32_t SBFrame::GetFrameID() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBFrame, GetFrameID);
uint32_t frame_idx = UINT32_MAX;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = exe_ctx.GetFramePtr();
if (frame)
frame_idx = frame->GetFrameIndex();
return frame_idx;
}
lldb::addr_t SBFrame::GetCFA() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetCFA);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = exe_ctx.GetFramePtr();
if (frame)
return frame->GetStackID().GetCallFrameAddress();
return LLDB_INVALID_ADDRESS;
}
addr_t SBFrame::GetPC() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetPC);
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
addr = frame->GetFrameCodeAddress().GetOpcodeLoadAddress(
target, AddressClass::eCode);
}
}
}
return addr;
}
bool SBFrame::SetPC(addr_t new_pc) {
LLDB_RECORD_METHOD(bool, SBFrame, SetPC, (lldb::addr_t), new_pc);
bool ret_val = false;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
ret_val = frame->GetRegisterContext()->SetPC(new_pc);
}
}
}
return ret_val;
}
addr_t SBFrame::GetSP() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetSP);
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
addr = frame->GetRegisterContext()->GetSP();
}
}
}
return addr;
}
addr_t SBFrame::GetFP() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::addr_t, SBFrame, GetFP);
addr_t addr = LLDB_INVALID_ADDRESS;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame)
addr = frame->GetRegisterContext()->GetFP();
}
}
return addr;
}
SBAddress SBFrame::GetPCAddress() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBAddress, SBFrame, GetPCAddress);
SBAddress sb_addr;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame)
sb_addr.SetAddress(&frame->GetFrameCodeAddress());
}
}
return LLDB_RECORD_RESULT(sb_addr);
}
void SBFrame::Clear() {
LLDB_RECORD_METHOD_NO_ARGS(void, SBFrame, Clear);
m_opaque_sp->Clear();
}
lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
(const char *), var_path);
SBValue sb_value;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
if (frame && target) {
lldb::DynamicValueType use_dynamic =
frame->CalculateTarget()->GetPreferDynamicValue();
sb_value = GetValueForVariablePath(var_path, use_dynamic);
}
return LLDB_RECORD_RESULT(sb_value);
}
lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
DynamicValueType use_dynamic) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, GetValueForVariablePath,
(const char *, lldb::DynamicValueType), var_path,
use_dynamic);
SBValue sb_value;
if (var_path == nullptr || var_path[0] == '\0') {
return LLDB_RECORD_RESULT(sb_value);
}
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
VariableSP var_sp;
Status error;
ValueObjectSP value_sp(frame->GetValueForVariableExpressionPath(
var_path, eNoDynamicValues,
StackFrame::eExpressionPathOptionCheckPtrVsMember |
StackFrame::eExpressionPathOptionsAllowDirectIVarAccess,
var_sp, error));
sb_value.SetSP(value_sp, use_dynamic);
}
}
}
return LLDB_RECORD_RESULT(sb_value);
}
SBValue SBFrame::FindVariable(const char *name) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable, (const char *),
name);
SBValue value;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
if (frame && target) {
lldb::DynamicValueType use_dynamic =
frame->CalculateTarget()->GetPreferDynamicValue();
value = FindVariable(name, use_dynamic);
}
return LLDB_RECORD_RESULT(value);
}
SBValue SBFrame::FindVariable(const char *name,
lldb::DynamicValueType use_dynamic) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindVariable,
(const char *, lldb::DynamicValueType), name, use_dynamic);
VariableSP var_sp;
SBValue sb_value;
if (name == nullptr || name[0] == '\0') {
return LLDB_RECORD_RESULT(sb_value);
}
ValueObjectSP value_sp;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
value_sp = frame->FindVariable(ConstString(name));
if (value_sp)
sb_value.SetSP(value_sp, use_dynamic);
}
}
}
return LLDB_RECORD_RESULT(sb_value);
}
SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
(const char *, lldb::ValueType), name, value_type);
SBValue value;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
if (frame && target) {
lldb::DynamicValueType use_dynamic =
frame->CalculateTarget()->GetPreferDynamicValue();
value = FindValue(name, value_type, use_dynamic);
}
return LLDB_RECORD_RESULT(value);
}
SBValue SBFrame::FindValue(const char *name, ValueType value_type,
lldb::DynamicValueType use_dynamic) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindValue,
(const char *, lldb::ValueType, lldb::DynamicValueType),
name, value_type, use_dynamic);
SBValue sb_value;
if (name == nullptr || name[0] == '\0') {
return LLDB_RECORD_RESULT(sb_value);
}
ValueObjectSP value_sp;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
VariableList variable_list;
switch (value_type) {
case eValueTypeVariableGlobal: // global variable
case eValueTypeVariableStatic: // static variable
case eValueTypeVariableArgument: // function argument variables
case eValueTypeVariableLocal: // function local variables
case eValueTypeVariableThreadLocal: // thread local variables
{
SymbolContext sc(frame->GetSymbolContext(eSymbolContextBlock));
const bool can_create = true;
const bool get_parent_variables = true;
const bool stop_if_block_is_inlined_function = true;
if (sc.block)
sc.block->AppendVariables(
can_create, get_parent_variables,
stop_if_block_is_inlined_function,
[frame](Variable *v) { return v->IsInScope(frame); },
&variable_list);
if (value_type == eValueTypeVariableGlobal) {
const bool get_file_globals = true;
VariableList *frame_vars = frame->GetVariableList(get_file_globals);
if (frame_vars)
frame_vars->AppendVariablesIfUnique(variable_list);
}
ConstString const_name(name);
VariableSP variable_sp(
variable_list.FindVariable(const_name, value_type));
if (variable_sp) {
value_sp = frame->GetValueObjectForFrameVariable(variable_sp,
eNoDynamicValues);
sb_value.SetSP(value_sp, use_dynamic);
}
} break;
case eValueTypeRegister: // stack frame register value
{
RegisterContextSP reg_ctx(frame->GetRegisterContext());
if (reg_ctx) {
const uint32_t num_regs = reg_ctx->GetRegisterCount();
for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
const RegisterInfo *reg_info =
reg_ctx->GetRegisterInfoAtIndex(reg_idx);
if (reg_info &&
((reg_info->name && strcasecmp(reg_info->name, name) == 0) ||
(reg_info->alt_name &&
strcasecmp(reg_info->alt_name, name) == 0))) {
value_sp = ValueObjectRegister::Create(frame, reg_ctx, reg_idx);
sb_value.SetSP(value_sp);
break;
}
}
}
} break;
case eValueTypeRegisterSet: // A collection of stack frame register
// values
{
RegisterContextSP reg_ctx(frame->GetRegisterContext());
if (reg_ctx) {
const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx) {
const RegisterSet *reg_set = reg_ctx->GetRegisterSet(set_idx);
if (reg_set &&
((reg_set->name && strcasecmp(reg_set->name, name) == 0) ||
(reg_set->short_name &&
strcasecmp(reg_set->short_name, name) == 0))) {
value_sp =
ValueObjectRegisterSet::Create(frame, reg_ctx, set_idx);
sb_value.SetSP(value_sp);
break;
}
}
}
} break;
case eValueTypeConstResult: // constant result variables
{
ConstString const_name(name);
ExpressionVariableSP expr_var_sp(
target->GetPersistentVariable(const_name));
if (expr_var_sp) {
value_sp = expr_var_sp->GetValueObject();
sb_value.SetSP(value_sp, use_dynamic);
}
} break;
default:
break;
}
}
}
}
return LLDB_RECORD_RESULT(sb_value);
}
bool SBFrame::IsEqual(const SBFrame &that) const {
LLDB_RECORD_METHOD_CONST(bool, SBFrame, IsEqual, (const lldb::SBFrame &),
that);
lldb::StackFrameSP this_sp = GetFrameSP();
lldb::StackFrameSP that_sp = that.GetFrameSP();
return (this_sp && that_sp && this_sp->GetStackID() == that_sp->GetStackID());
}
bool SBFrame::operator==(const SBFrame &rhs) const {
LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator==,(const lldb::SBFrame &),
rhs);
return IsEqual(rhs);
}
bool SBFrame::operator!=(const SBFrame &rhs) const {
LLDB_RECORD_METHOD_CONST(bool, SBFrame, operator!=,(const lldb::SBFrame &),
rhs);
return !IsEqual(rhs);
}
SBThread SBFrame::GetThread() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBFrame, GetThread);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
ThreadSP thread_sp(exe_ctx.GetThreadSP());
SBThread sb_thread(thread_sp);
return LLDB_RECORD_RESULT(sb_thread);
}
const char *SBFrame::Disassemble() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, Disassemble);
const char *disassembly = nullptr;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
disassembly = frame->Disassemble();
}
}
}
return disassembly;
}
SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
bool in_scope_only) {
LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
(bool, bool, bool, bool), arguments, locals, statics,
in_scope_only);
SBValueList value_list;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
if (frame && target) {
lldb::DynamicValueType use_dynamic =
frame->CalculateTarget()->GetPreferDynamicValue();
const bool include_runtime_support_values =
target ? target->GetDisplayRuntimeSupportValues() : false;
SBVariablesOptions options;
options.SetIncludeArguments(arguments);
options.SetIncludeLocals(locals);
options.SetIncludeStatics(statics);
options.SetInScopeOnly(in_scope_only);
options.SetIncludeRuntimeSupportValues(include_runtime_support_values);
options.SetUseDynamic(use_dynamic);
value_list = GetVariables(options);
}
return LLDB_RECORD_RESULT(value_list);
}
lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
bool statics, bool in_scope_only,
lldb::DynamicValueType use_dynamic) {
LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
(bool, bool, bool, bool, lldb::DynamicValueType),
arguments, locals, statics, in_scope_only, use_dynamic);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
Target *target = exe_ctx.GetTargetPtr();
const bool include_runtime_support_values =
target ? target->GetDisplayRuntimeSupportValues() : false;
SBVariablesOptions options;
options.SetIncludeArguments(arguments);
options.SetIncludeLocals(locals);
options.SetIncludeStatics(statics);
options.SetInScopeOnly(in_scope_only);
options.SetIncludeRuntimeSupportValues(include_runtime_support_values);
options.SetUseDynamic(use_dynamic);
return LLDB_RECORD_RESULT(GetVariables(options));
}
SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
LLDB_RECORD_METHOD(lldb::SBValueList, SBFrame, GetVariables,
(const lldb::SBVariablesOptions &), options);
SBValueList value_list;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
const bool statics = options.GetIncludeStatics();
const bool arguments = options.GetIncludeArguments();
const bool recognized_arguments =
options.GetIncludeRecognizedArguments(SBTarget(exe_ctx.GetTargetSP()));
const bool locals = options.GetIncludeLocals();
const bool in_scope_only = options.GetInScopeOnly();
const bool include_runtime_support_values =
options.GetIncludeRuntimeSupportValues();
const lldb::DynamicValueType use_dynamic = options.GetUseDynamic();
std::set<VariableSP> variable_set;
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
size_t i;
VariableList *variable_list = nullptr;
variable_list = frame->GetVariableList(true);
if (variable_list) {
const size_t num_variables = variable_list->GetSize();
if (num_variables) {
for (i = 0; i < num_variables; ++i) {
VariableSP variable_sp(variable_list->GetVariableAtIndex(i));
if (variable_sp) {
bool add_variable = false;
switch (variable_sp->GetScope()) {
case eValueTypeVariableGlobal:
case eValueTypeVariableStatic:
case eValueTypeVariableThreadLocal:
add_variable = statics;
break;
case eValueTypeVariableArgument:
add_variable = arguments;
break;
case eValueTypeVariableLocal:
add_variable = locals;
break;
default:
break;
}
if (add_variable) {
// Only add variables once so we don't end up with duplicates
if (variable_set.find(variable_sp) == variable_set.end())
variable_set.insert(variable_sp);
else
continue;
if (in_scope_only && !variable_sp->IsInScope(frame))
continue;
ValueObjectSP valobj_sp(frame->GetValueObjectForFrameVariable(
variable_sp, eNoDynamicValues));
if (!include_runtime_support_values && valobj_sp != nullptr &&
valobj_sp->IsRuntimeSupportValue())
continue;
SBValue value_sb;
value_sb.SetSP(valobj_sp, use_dynamic);
value_list.Append(value_sb);
}
}
}
}
}
if (recognized_arguments) {
auto recognized_frame = frame->GetRecognizedFrame();
if (recognized_frame) {
ValueObjectListSP recognized_arg_list =
recognized_frame->GetRecognizedArguments();
if (recognized_arg_list) {
for (auto &rec_value_sp : recognized_arg_list->GetObjects()) {
SBValue value_sb;
value_sb.SetSP(rec_value_sp, use_dynamic);
value_list.Append(value_sb);
}
}
}
}
}
}
}
return LLDB_RECORD_RESULT(value_list);
}
SBValueList SBFrame::GetRegisters() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBValueList, SBFrame, GetRegisters);
SBValueList value_list;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
RegisterContextSP reg_ctx(frame->GetRegisterContext());
if (reg_ctx) {
const uint32_t num_sets = reg_ctx->GetRegisterSetCount();
for (uint32_t set_idx = 0; set_idx < num_sets; ++set_idx) {
value_list.Append(
ValueObjectRegisterSet::Create(frame, reg_ctx, set_idx));
}
}
}
}
}
return LLDB_RECORD_RESULT(value_list);
}
SBValue SBFrame::FindRegister(const char *name) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, FindRegister, (const char *),
name);
SBValue result;
ValueObjectSP value_sp;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
RegisterContextSP reg_ctx(frame->GetRegisterContext());
if (reg_ctx) {
const uint32_t num_regs = reg_ctx->GetRegisterCount();
for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx) {
const RegisterInfo *reg_info =
reg_ctx->GetRegisterInfoAtIndex(reg_idx);
if (reg_info &&
((reg_info->name && strcasecmp(reg_info->name, name) == 0) ||
(reg_info->alt_name &&
strcasecmp(reg_info->alt_name, name) == 0))) {
value_sp = ValueObjectRegister::Create(frame, reg_ctx, reg_idx);
result.SetSP(value_sp);
break;
}
}
}
}
}
}
return LLDB_RECORD_RESULT(result);
}
bool SBFrame::GetDescription(SBStream &description) {
LLDB_RECORD_METHOD(bool, SBFrame, GetDescription, (lldb::SBStream &),
description);
Stream &strm = description.ref();
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
frame->DumpUsingSettingsFormat(&strm);
}
}
} else
strm.PutCString("No value");
return true;
}
SBValue SBFrame::EvaluateExpression(const char *expr) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression, (const char *),
expr);
SBValue result;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
if (frame && target) {
SBExpressionOptions options;
lldb::DynamicValueType fetch_dynamic_value =
frame->CalculateTarget()->GetPreferDynamicValue();
options.SetFetchDynamicValue(fetch_dynamic_value);
options.SetUnwindOnError(true);
options.SetIgnoreBreakpoints(true);
if (target->GetLanguage() != eLanguageTypeUnknown)
options.SetLanguage(target->GetLanguage());
else
options.SetLanguage(frame->GetLanguage());
return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
}
return LLDB_RECORD_RESULT(result);
}
SBValue
SBFrame::EvaluateExpression(const char *expr,
lldb::DynamicValueType fetch_dynamic_value) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
(const char *, lldb::DynamicValueType), expr,
fetch_dynamic_value);
SBExpressionOptions options;
options.SetFetchDynamicValue(fetch_dynamic_value);
options.SetUnwindOnError(true);
options.SetIgnoreBreakpoints(true);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
if (target && target->GetLanguage() != eLanguageTypeUnknown)
options.SetLanguage(target->GetLanguage());
else if (frame)
options.SetLanguage(frame->GetLanguage());
return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
}
SBValue SBFrame::EvaluateExpression(const char *expr,
lldb::DynamicValueType fetch_dynamic_value,
bool unwind_on_error) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
(const char *, lldb::DynamicValueType, bool), expr,
fetch_dynamic_value, unwind_on_error);
SBExpressionOptions options;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
options.SetFetchDynamicValue(fetch_dynamic_value);
options.SetUnwindOnError(unwind_on_error);
options.SetIgnoreBreakpoints(true);
StackFrame *frame = exe_ctx.GetFramePtr();
Target *target = exe_ctx.GetTargetPtr();
if (target && target->GetLanguage() != eLanguageTypeUnknown)
options.SetLanguage(target->GetLanguage());
else if (frame)
options.SetLanguage(frame->GetLanguage());
return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
}
lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
const SBExpressionOptions &options) {
LLDB_RECORD_METHOD(lldb::SBValue, SBFrame, EvaluateExpression,
(const char *, const lldb::SBExpressionOptions &), expr,
options);
#ifndef LLDB_DISABLE_PYTHON
Log *expr_log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
#endif
ExpressionResults exe_results = eExpressionSetupError;
SBValue expr_result;
if (expr == nullptr || expr[0] == '\0') {
return LLDB_RECORD_RESULT(expr_result);
}
ValueObjectSP expr_value_sp;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
std::unique_ptr<llvm::PrettyStackTraceFormat> stack_trace;
if (target->GetDisplayExpressionsInCrashlogs()) {
StreamString frame_description;
frame->DumpUsingSettingsFormat(&frame_description);
stack_trace = llvm::make_unique<llvm::PrettyStackTraceFormat>(
"SBFrame::EvaluateExpression (expr = \"%s\", fetch_dynamic_value "
"= %u) %s",
expr, options.GetFetchDynamicValue(),
frame_description.GetData());
}
exe_results = target->EvaluateExpression(expr, frame, expr_value_sp,
options.ref());
expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
}
}
}
#ifndef LLDB_DISABLE_PYTHON
if (expr_log)
expr_log->Printf("** [SBFrame::EvaluateExpression] Expression result is "
"%s, summary %s **",
expr_result.GetValue(), expr_result.GetSummary());
#endif
return LLDB_RECORD_RESULT(expr_result);
}
bool SBFrame::IsInlined() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsInlined);
return static_cast<const SBFrame *>(this)->IsInlined();
}
bool SBFrame::IsInlined() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsInlined);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
Block *block = frame->GetSymbolContext(eSymbolContextBlock).block;
if (block)
return block->GetContainingInlinedBlock() != nullptr;
}
}
}
return false;
}
bool SBFrame::IsArtificial() {
LLDB_RECORD_METHOD_NO_ARGS(bool, SBFrame, IsArtificial);
return static_cast<const SBFrame *>(this)->IsArtificial();
}
bool SBFrame::IsArtificial() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFrame, IsArtificial);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = exe_ctx.GetFramePtr();
if (frame)
return frame->IsArtificial();
return false;
}
const char *SBFrame::GetFunctionName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetFunctionName);
return static_cast<const SBFrame *>(this)->GetFunctionName();
}
lldb::LanguageType SBFrame::GuessLanguage() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBFrame, GuessLanguage);
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
return frame->GuessLanguage();
}
}
}
return eLanguageTypeUnknown;
}
const char *SBFrame::GetFunctionName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBFrame, GetFunctionName);
const char *name = nullptr;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction |
eSymbolContextBlock |
eSymbolContextSymbol));
if (sc.block) {
Block *inlined_block = sc.block->GetContainingInlinedBlock();
if (inlined_block) {
const InlineFunctionInfo *inlined_info =
inlined_block->GetInlinedFunctionInfo();
name =
inlined_info->GetName(sc.function->GetLanguage()).AsCString();
}
}
if (name == nullptr) {
if (sc.function)
name = sc.function->GetName().GetCString();
}
if (name == nullptr) {
if (sc.symbol)
name = sc.symbol->GetName().GetCString();
}
}
}
}
return name;
}
const char *SBFrame::GetDisplayFunctionName() {
LLDB_RECORD_METHOD_NO_ARGS(const char *, SBFrame, GetDisplayFunctionName);
const char *name = nullptr;
std::unique_lock<std::recursive_mutex> lock;
ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
StackFrame *frame = nullptr;
Target *target = exe_ctx.GetTargetPtr();
Process *process = exe_ctx.GetProcessPtr();
if (target && process) {
Process::StopLocker stop_locker;
if (stop_locker.TryLock(&process->GetRunLock())) {
frame = exe_ctx.GetFramePtr();
if (frame) {
SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction |
eSymbolContextBlock |
eSymbolContextSymbol));
if (sc.block) {
Block *inlined_block = sc.block->GetContainingInlinedBlock();
if (inlined_block) {
const InlineFunctionInfo *inlined_info =
inlined_block->GetInlinedFunctionInfo();
name = inlined_info->GetDisplayName(sc.function->GetLanguage())
.AsCString();
}
}
if (name == nullptr) {
if (sc.function)
name = sc.function->GetDisplayName().GetCString();
}
if (name == nullptr) {
if (sc.symbol)
name = sc.symbol->GetDisplayName().GetCString();
}
}
}
}
return name;
}
Reference in New Issue View Git Blame Copy Permalink