llvm-project/lldb/source/API/SBValue.cpp

1680 lines
51 KiB
C++
Raw Normal View History

//===-- SBValue.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 "lldb/API/SBValue.h"
#include "lldb/API/SBDeclaration.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBTypeFilter.h"
#include "lldb/API/SBTypeFormat.h"
#include "lldb/API/SBTypeSummary.h"
#include "lldb/API/SBTypeSynthetic.h"
#include "lldb/Breakpoint/Watchpoint.h"
#include "lldb/Core/Module.h"
<rdar://problem/11757916> Make breakpoint setting by file and line much more efficient by only looking for inlined breakpoint locations if we are setting a breakpoint in anything but a source implementation file. Implementing this complex for a many reasons. Turns out that parsing compile units lazily had some issues with respect to how we need to do things with DWARF in .o files. So the fixes in the checkin for this makes these changes: - Add a new setting called "target.inline-breakpoint-strategy" which can be set to "never", "always", or "headers". "never" will never try and set any inlined breakpoints (fastest). "always" always looks for inlined breakpoint locations (slowest, but most accurate). "headers", which is the default setting, will only look for inlined breakpoint locations if the breakpoint is set in what are consudered to be header files, which is realy defined as "not in an implementation source file". - modify the breakpoint setting by file and line to check the current "target.inline-breakpoint-strategy" setting and act accordingly - Modify compile units to be able to get their language and other info lazily. This allows us to create compile units from the debug map and not have to fill all of the details in, and then lazily discover this information as we go on debuggging. This is needed to avoid parsing all .o files when setting breakpoints in implementation only files (no inlines). Otherwise we would need to parse the .o file, the object file (mach-o in our case) and the symbol file (DWARF in the object file) just to see what the compile unit was. - modify the "SymbolFileDWARFDebugMap" to subclass lldb_private::Module so that the virtual "GetObjectFile()" and "GetSymbolVendor()" functions can be intercepted when the .o file contenst are later lazilly needed. Prior to this fix, when we first instantiated the "SymbolFileDWARFDebugMap" class, we would also make modules, object files and symbol files for every .o file in the debug map because we needed to fix up the sections in the .o files with information that is in the executable debug map. Now we lazily do this in the DebugMapModule::GetObjectFile() Cleaned up header includes a bit as well. llvm-svn: 162860
2012-08-30 05:13:06 +08:00
#include "lldb/Core/Section.h"
#include "lldb/Core/StreamFile.h"
#include "lldb/Core/Value.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/Symbol/Block.h"
#include "lldb/Symbol/Declaration.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Scalar.h"
#include "lldb/Utility/Stream.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBExpressionOptions.h"
#include "lldb/API/SBFrame.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBTarget.h"
#include "lldb/API/SBThread.h"
#include <memory>
using namespace lldb;
using namespace lldb_private;
class ValueImpl {
public:
ValueImpl() {}
ValueImpl(lldb::ValueObjectSP in_valobj_sp,
lldb::DynamicValueType use_dynamic, bool use_synthetic,
const char *name = NULL)
: m_valobj_sp(), m_use_dynamic(use_dynamic),
m_use_synthetic(use_synthetic), m_name(name) {
if (in_valobj_sp) {
if ((m_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable(
lldb::eNoDynamicValues, false))) {
if (!m_name.IsEmpty())
m_valobj_sp->SetName(m_name);
}
}
}
ValueImpl(const ValueImpl &rhs)
: m_valobj_sp(rhs.m_valobj_sp), m_use_dynamic(rhs.m_use_dynamic),
m_use_synthetic(rhs.m_use_synthetic), m_name(rhs.m_name) {}
ValueImpl &operator=(const ValueImpl &rhs) {
if (this != &rhs) {
m_valobj_sp = rhs.m_valobj_sp;
m_use_dynamic = rhs.m_use_dynamic;
m_use_synthetic = rhs.m_use_synthetic;
m_name = rhs.m_name;
}
return *this;
}
bool IsValid() {
if (m_valobj_sp.get() == NULL)
return false;
else {
// FIXME: This check is necessary but not sufficient. We for sure don't
// want to touch SBValues whose owning
// targets have gone away. This check is a little weak in that it
// enforces that restriction when you call IsValid, but since IsValid
// doesn't lock the target, you have no guarantee that the SBValue won't
// go invalid after you call this... Also, an SBValue could depend on
// data from one of the modules in the target, and those could go away
// independently of the target, for instance if a module is unloaded.
// But right now, neither SBValues nor ValueObjects know which modules
// they depend on. So I have no good way to make that check without
// tracking that in all the ValueObject subclasses.
TargetSP target_sp = m_valobj_sp->GetTargetSP();
return target_sp && target_sp->IsValid();
}
}
lldb::ValueObjectSP GetRootSP() { return m_valobj_sp; }
lldb::ValueObjectSP GetSP(Process::StopLocker &stop_locker,
std::unique_lock<std::recursive_mutex> &lock,
Status &error) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!m_valobj_sp) {
error.SetErrorString("invalid value object");
return m_valobj_sp;
}
lldb::ValueObjectSP value_sp = m_valobj_sp;
Target *target = value_sp->GetTargetSP().get();
if (!target)
return ValueObjectSP();
lock = std::unique_lock<std::recursive_mutex>(target->GetAPIMutex());
ProcessSP process_sp(value_sp->GetProcessSP());
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) {
// We don't allow people to play around with ValueObject if the process
// is running. If you want to look at values, pause the process, then
// look.
if (log)
log->Printf("SBValue(%p)::GetSP() => error: process is running",
static_cast<void *>(value_sp.get()));
error.SetErrorString("process must be stopped.");
return ValueObjectSP();
}
if (m_use_dynamic != eNoDynamicValues) {
ValueObjectSP dynamic_sp = value_sp->GetDynamicValue(m_use_dynamic);
if (dynamic_sp)
value_sp = dynamic_sp;
}
if (m_use_synthetic) {
ValueObjectSP synthetic_sp = value_sp->GetSyntheticValue(m_use_synthetic);
if (synthetic_sp)
value_sp = synthetic_sp;
}
if (!value_sp)
error.SetErrorString("invalid value object");
if (!m_name.IsEmpty())
value_sp->SetName(m_name);
return value_sp;
}
void SetUseDynamic(lldb::DynamicValueType use_dynamic) {
m_use_dynamic = use_dynamic;
}
void SetUseSynthetic(bool use_synthetic) { m_use_synthetic = use_synthetic; }
lldb::DynamicValueType GetUseDynamic() { return m_use_dynamic; }
bool GetUseSynthetic() { return m_use_synthetic; }
// All the derived values that we would make from the m_valobj_sp will share
// the ExecutionContext with m_valobj_sp, so we don't need to do the
// calculations in GetSP to return the Target, Process, Thread or Frame. It
// is convenient to provide simple accessors for these, which I do here.
TargetSP GetTargetSP() {
if (m_valobj_sp)
return m_valobj_sp->GetTargetSP();
else
return TargetSP();
}
ProcessSP GetProcessSP() {
if (m_valobj_sp)
return m_valobj_sp->GetProcessSP();
else
return ProcessSP();
}
ThreadSP GetThreadSP() {
if (m_valobj_sp)
return m_valobj_sp->GetThreadSP();
else
return ThreadSP();
}
StackFrameSP GetFrameSP() {
if (m_valobj_sp)
return m_valobj_sp->GetFrameSP();
else
return StackFrameSP();
}
private:
lldb::ValueObjectSP m_valobj_sp;
lldb::DynamicValueType m_use_dynamic;
bool m_use_synthetic;
ConstString m_name;
};
class ValueLocker {
public:
ValueLocker() {}
ValueObjectSP GetLockedSP(ValueImpl &in_value) {
return in_value.GetSP(m_stop_locker, m_lock, m_lock_error);
}
Status &GetError() { return m_lock_error; }
private:
Process::StopLocker m_stop_locker;
std::unique_lock<std::recursive_mutex> m_lock;
Status m_lock_error;
};
SBValue::SBValue() : m_opaque_sp() {}
SBValue::SBValue(const lldb::ValueObjectSP &value_sp) { SetSP(value_sp); }
SBValue::SBValue(const SBValue &rhs) { SetSP(rhs.m_opaque_sp); }
SBValue &SBValue::operator=(const SBValue &rhs) {
if (this != &rhs) {
SetSP(rhs.m_opaque_sp);
}
return *this;
}
SBValue::~SBValue() {}
bool SBValue::IsValid() {
// If this function ever changes to anything that does more than just check
// if the opaque shared pointer is non NULL, then we need to update all "if
// (m_opaque_sp)" code in this file.
return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid() &&
m_opaque_sp->GetRootSP().get() != NULL;
}
void SBValue::Clear() { m_opaque_sp.reset(); }
SBError SBValue::GetError() {
SBError sb_error;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
sb_error.SetError(value_sp->GetError());
else
sb_error.SetErrorStringWithFormat("error: %s",
locker.GetError().AsCString());
return sb_error;
}
user_id_t SBValue::GetID() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
return value_sp->GetID();
return LLDB_INVALID_UID;
Introduce the concept of a "display name" for types Rationale: Pretty simply, the idea is that sometimes type names are way too long and contain way too many details for the average developer to care about. For instance, a plain ol' vector of int might be shown as std::__1::vector<int, std::__1::allocator<.... rather than the much simpler std::vector<int> form, which is what most developers would actually type in their code Proposed solution: Introduce a notion of "display name" and a corresponding API GetDisplayTypeName() to return such a crafted for visual representation type name Obviously, the display name and the fully qualified (or "true") name are not necessarily the same - that's the whole point LLDB could choose to pick the "display name" as its one true notion of a type name, and if somebody really needs the fully qualified version of it, let them deal with the problem Or, LLDB could rename what it currently calls the "type name" to be the "display name", and add new APIs for the fully qualified name, making the display name the default choice The choice that I am making here is that the type name will keep meaning the same, and people who want a type name suited for display will explicitly ask for one It is the less risky/disruptive choice - and it should eventually make it fairly obvious when someone is asking for the wrong type Caveats: - for now, GetDisplayTypeName() == GetTypeName(), there is no logic to produce customized display type names yet. - while the fully-qualified type name is still the main key to the kingdom of data formatters, if we start showing custom names to people, those should match formatters llvm-svn: 209072
2014-05-18 03:14:17 +08:00
}
const char *SBValue::GetName() {
const char *name = NULL;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
name = value_sp->GetName().GetCString();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
if (name)
log->Printf("SBValue(%p)::GetName () => \"%s\"",
static_cast<void *>(value_sp.get()), name);
else
log->Printf("SBValue(%p)::GetName () => NULL",
static_cast<void *>(value_sp.get()));
}
return name;
}
const char *SBValue::GetTypeName() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *name = NULL;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
name = value_sp->GetQualifiedTypeName().GetCString();
}
if (log) {
if (name)
log->Printf("SBValue(%p)::GetTypeName () => \"%s\"",
static_cast<void *>(value_sp.get()), name);
else
log->Printf("SBValue(%p)::GetTypeName () => NULL",
static_cast<void *>(value_sp.get()));
}
return name;
}
const char *SBValue::GetDisplayTypeName() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *name = NULL;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
name = value_sp->GetDisplayTypeName().GetCString();
}
if (log) {
if (name)
log->Printf("SBValue(%p)::GetTypeName () => \"%s\"",
static_cast<void *>(value_sp.get()), name);
else
log->Printf("SBValue(%p)::GetTypeName () => NULL",
static_cast<void *>(value_sp.get()));
}
return name;
}
size_t SBValue::GetByteSize() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
size_t result = 0;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
result = value_sp->GetByteSize();
}
if (log)
log->Printf("SBValue(%p)::GetByteSize () => %" PRIu64,
static_cast<void *>(value_sp.get()),
static_cast<uint64_t>(result));
return result;
}
bool SBValue::IsInScope() {
bool result = false;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
result = value_sp->IsInScope();
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBValue(%p)::IsInScope () => %i",
static_cast<void *>(value_sp.get()), result);
return result;
}
const char *SBValue::GetValue() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *cstr = NULL;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
cstr = value_sp->GetValueAsCString();
}
if (log) {
if (cstr)
log->Printf("SBValue(%p)::GetValue() => \"%s\"",
static_cast<void *>(value_sp.get()), cstr);
else
log->Printf("SBValue(%p)::GetValue() => NULL",
static_cast<void *>(value_sp.get()));
}
return cstr;
}
ValueType SBValue::GetValueType() {
ValueType result = eValueTypeInvalid;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
result = value_sp->GetValueType();
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
switch (result) {
case eValueTypeInvalid:
log->Printf("SBValue(%p)::GetValueType () => eValueTypeInvalid",
static_cast<void *>(value_sp.get()));
break;
case eValueTypeVariableGlobal:
log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal",
static_cast<void *>(value_sp.get()));
break;
case eValueTypeVariableStatic:
log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableStatic",
static_cast<void *>(value_sp.get()));
break;
case eValueTypeVariableArgument:
log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableArgument",
static_cast<void *>(value_sp.get()));
break;
case eValueTypeVariableLocal:
log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableLocal",
static_cast<void *>(value_sp.get()));
break;
case eValueTypeRegister:
log->Printf("SBValue(%p)::GetValueType () => eValueTypeRegister",
static_cast<void *>(value_sp.get()));
break;
case eValueTypeRegisterSet:
log->Printf("SBValue(%p)::GetValueType () => eValueTypeRegisterSet",
static_cast<void *>(value_sp.get()));
break;
case eValueTypeConstResult:
log->Printf("SBValue(%p)::GetValueType () => eValueTypeConstResult",
static_cast<void *>(value_sp.get()));
break;
case eValueTypeVariableThreadLocal:
log->Printf(
"SBValue(%p)::GetValueType () => eValueTypeVariableThreadLocal",
static_cast<void *>(value_sp.get()));
break;
}
}
return result;
}
const char *SBValue::GetObjectDescription() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *cstr = NULL;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
cstr = value_sp->GetObjectDescription();
}
if (log) {
if (cstr)
log->Printf("SBValue(%p)::GetObjectDescription() => \"%s\"",
static_cast<void *>(value_sp.get()), cstr);
else
log->Printf("SBValue(%p)::GetObjectDescription() => NULL",
static_cast<void *>(value_sp.get()));
}
return cstr;
}
const char *SBValue::GetTypeValidatorResult() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *cstr = NULL;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
const auto &validation(value_sp->GetValidationStatus());
if (TypeValidatorResult::Failure == validation.first) {
if (validation.second.empty())
cstr = "unknown error";
else
cstr = validation.second.c_str();
}
}
if (log) {
if (cstr)
log->Printf("SBValue(%p)::GetTypeValidatorResult() => \"%s\"",
static_cast<void *>(value_sp.get()), cstr);
else
log->Printf("SBValue(%p)::GetTypeValidatorResult() => NULL",
static_cast<void *>(value_sp.get()));
}
return cstr;
}
SBType SBValue::GetType() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
SBType sb_type;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
TypeImplSP type_sp;
if (value_sp) {
type_sp = std::make_shared<TypeImpl>(value_sp->GetTypeImpl());
sb_type.SetSP(type_sp);
}
if (log) {
if (type_sp)
log->Printf("SBValue(%p)::GetType => SBType(%p)",
static_cast<void *>(value_sp.get()),
static_cast<void *>(type_sp.get()));
else
log->Printf("SBValue(%p)::GetType => NULL",
static_cast<void *>(value_sp.get()));
}
return sb_type;
}
bool SBValue::GetValueDidChange() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool result = false;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
if (value_sp->UpdateValueIfNeeded(false))
result = value_sp->GetValueDidChange();
}
if (log)
log->Printf("SBValue(%p)::GetValueDidChange() => %i",
static_cast<void *>(value_sp.get()), result);
return result;
}
const char *SBValue::GetSummary() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *cstr = NULL;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
cstr = value_sp->GetSummaryAsCString();
}
if (log) {
if (cstr)
log->Printf("SBValue(%p)::GetSummary() => \"%s\"",
static_cast<void *>(value_sp.get()), cstr);
else
log->Printf("SBValue(%p)::GetSummary() => NULL",
static_cast<void *>(value_sp.get()));
}
return cstr;
}
const char *SBValue::GetSummary(lldb::SBStream &stream,
lldb::SBTypeSummaryOptions &options) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
std::string buffer;
if (value_sp->GetSummaryAsCString(buffer, options.ref()) && !buffer.empty())
stream.Printf("%s", buffer.c_str());
}
const char *cstr = stream.GetData();
if (log) {
if (cstr)
log->Printf("SBValue(%p)::GetSummary() => \"%s\"",
static_cast<void *>(value_sp.get()), cstr);
else
log->Printf("SBValue(%p)::GetSummary() => NULL",
static_cast<void *>(value_sp.get()));
}
return cstr;
}
const char *SBValue::GetLocation() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
const char *cstr = NULL;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
cstr = value_sp->GetLocationAsCString();
}
if (log) {
if (cstr)
log->Printf("SBValue(%p)::GetLocation() => \"%s\"",
static_cast<void *>(value_sp.get()), cstr);
else
log->Printf("SBValue(%p)::GetLocation() => NULL",
static_cast<void *>(value_sp.get()));
}
return cstr;
}
// Deprecated - use the one that takes an lldb::SBError
bool SBValue::SetValueFromCString(const char *value_str) {
lldb::SBError dummy;
return SetValueFromCString(value_str, dummy);
}
bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
bool success = false;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (value_sp) {
success = value_sp->SetValueFromCString(value_str, error.ref());
} else
error.SetErrorStringWithFormat("Could not get value: %s",
locker.GetError().AsCString());
if (log)
log->Printf("SBValue(%p)::SetValueFromCString(\"%s\") => %i",
static_cast<void *>(value_sp.get()), value_str, success);
return success;
}
lldb::SBTypeFormat SBValue::GetTypeFormat() {
lldb::SBTypeFormat format;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
if (value_sp->UpdateValueIfNeeded(true)) {
lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat();
if (format_sp)
format.SetSP(format_sp);
}
}
return format;
}
lldb::SBTypeSummary SBValue::GetTypeSummary() {
lldb::SBTypeSummary summary;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
if (value_sp->UpdateValueIfNeeded(true)) {
lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat();
if (summary_sp)
summary.SetSP(summary_sp);
}
}
return summary;
}
lldb::SBTypeFilter SBValue::GetTypeFilter() {
lldb::SBTypeFilter filter;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
if (value_sp->UpdateValueIfNeeded(true)) {
lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren();
if (synthetic_sp && !synthetic_sp->IsScripted()) {
TypeFilterImplSP filter_sp =
std::static_pointer_cast<TypeFilterImpl>(synthetic_sp);
filter.SetSP(filter_sp);
}
}
}
return filter;
}
#ifndef LLDB_DISABLE_PYTHON
lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
lldb::SBTypeSynthetic synthetic;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
if (value_sp->UpdateValueIfNeeded(true)) {
lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren();
if (children_sp && children_sp->IsScripted()) {
ScriptedSyntheticChildrenSP synth_sp =
std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
synthetic.SetSP(synth_sp);
}
}
}
return synthetic;
}
#endif
lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
SBType type) {
lldb::SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
lldb::ValueObjectSP new_value_sp;
if (value_sp) {
TypeImplSP type_sp(type.GetSP());
if (type.IsValid()) {
sb_value.SetSP(value_sp->GetSyntheticChildAtOffset(
offset, type_sp->GetCompilerType(false), true),
GetPreferDynamicValue(), GetPreferSyntheticValue(), name);
}
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
if (new_value_sp)
log->Printf("SBValue(%p)::CreateChildAtOffset => \"%s\"",
static_cast<void *>(value_sp.get()),
new_value_sp->GetName().AsCString());
else
log->Printf("SBValue(%p)::CreateChildAtOffset => NULL",
static_cast<void *>(value_sp.get()));
}
return sb_value;
}
lldb::SBValue SBValue::Cast(SBType type) {
lldb::SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
TypeImplSP type_sp(type.GetSP());
if (value_sp && type_sp)
sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)),
GetPreferDynamicValue(), GetPreferSyntheticValue());
return sb_value;
}
lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
const char *expression) {
SBExpressionOptions options;
options.ref().SetKeepInMemory(true);
return CreateValueFromExpression(name, expression, options);
}
lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
const char *expression,
SBExpressionOptions &options) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
lldb::SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
lldb::ValueObjectSP new_value_sp;
if (value_sp) {
ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
new_value_sp = ValueObject::CreateValueObjectFromExpression(
name, expression, exe_ctx, options.ref());
if (new_value_sp)
new_value_sp->SetName(ConstString(name));
}
sb_value.SetSP(new_value_sp);
if (log) {
if (new_value_sp)
log->Printf("SBValue(%p)::CreateValueFromExpression(name=\"%s\", "
"expression=\"%s\") => SBValue (%p)",
static_cast<void *>(value_sp.get()), name, expression,
static_cast<void *>(new_value_sp.get()));
else
log->Printf("SBValue(%p)::CreateValueFromExpression(name=\"%s\", "
"expression=\"%s\") => NULL",
static_cast<void *>(value_sp.get()), name, expression);
}
return sb_value;
}
lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
lldb::addr_t address,
SBType sb_type) {
lldb::SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
lldb::ValueObjectSP new_value_sp;
lldb::TypeImplSP type_impl_sp(sb_type.GetSP());
if (value_sp && type_impl_sp) {
CompilerType ast_type(type_impl_sp->GetCompilerType(true));
ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
new_value_sp = ValueObject::CreateValueObjectFromAddress(name, address,
exe_ctx, ast_type);
}
sb_value.SetSP(new_value_sp);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
if (new_value_sp)
log->Printf("SBValue(%p)::CreateValueFromAddress => \"%s\"",
static_cast<void *>(value_sp.get()),
new_value_sp->GetName().AsCString());
else
log->Printf("SBValue(%p)::CreateValueFromAddress => NULL",
static_cast<void *>(value_sp.get()));
}
return sb_value;
}
lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
SBType sb_type) {
lldb::SBValue sb_value;
lldb::ValueObjectSP new_value_sp;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
lldb::TypeImplSP type_impl_sp(sb_type.GetSP());
if (value_sp && type_impl_sp) {
ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
new_value_sp = ValueObject::CreateValueObjectFromData(
name, **data, exe_ctx, type_impl_sp->GetCompilerType(true));
new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad);
}
sb_value.SetSP(new_value_sp);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
if (new_value_sp)
log->Printf("SBValue(%p)::CreateValueFromData => \"%s\"",
static_cast<void *>(value_sp.get()),
new_value_sp->GetName().AsCString());
else
log->Printf("SBValue(%p)::CreateValueFromData => NULL",
static_cast<void *>(value_sp.get()));
}
return sb_value;
}
SBValue SBValue::GetChildAtIndex(uint32_t idx) {
const bool can_create_synthetic = false;
lldb::DynamicValueType use_dynamic = eNoDynamicValues;
TargetSP target_sp;
if (m_opaque_sp)
target_sp = m_opaque_sp->GetTargetSP();
if (target_sp)
use_dynamic = target_sp->GetPreferDynamicValue();
return GetChildAtIndex(idx, use_dynamic, can_create_synthetic);
}
SBValue SBValue::GetChildAtIndex(uint32_t idx,
lldb::DynamicValueType use_dynamic,
bool can_create_synthetic) {
lldb::ValueObjectSP child_sp;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
const bool can_create = true;
child_sp = value_sp->GetChildAtIndex(idx, can_create);
if (can_create_synthetic && !child_sp) {
child_sp = value_sp->GetSyntheticArrayMember(idx, can_create);
}
}
SBValue sb_value;
sb_value.SetSP(child_sp, use_dynamic, GetPreferSyntheticValue());
if (log)
log->Printf("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)",
static_cast<void *>(value_sp.get()), idx,
static_cast<void *>(value_sp.get()));
return sb_value;
}
uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
uint32_t idx = UINT32_MAX;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
idx = value_sp->GetIndexOfChildWithName(ConstString(name));
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
if (idx == UINT32_MAX)
log->Printf(
"SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND",
static_cast<void *>(value_sp.get()), name);
else
log->Printf("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u",
static_cast<void *>(value_sp.get()), name, idx);
}
return idx;
}
SBValue SBValue::GetChildMemberWithName(const char *name) {
lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
TargetSP target_sp;
if (m_opaque_sp)
target_sp = m_opaque_sp->GetTargetSP();
if (target_sp)
use_dynamic_value = target_sp->GetPreferDynamicValue();
return GetChildMemberWithName(name, use_dynamic_value);
}
SBValue
SBValue::GetChildMemberWithName(const char *name,
lldb::DynamicValueType use_dynamic_value) {
lldb::ValueObjectSP child_sp;
const ConstString str_name(name);
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
child_sp = value_sp->GetChildMemberWithName(str_name, true);
}
SBValue sb_value;
sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue());
if (log)
log->Printf(
"SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)",
static_cast<void *>(value_sp.get()), name,
static_cast<void *>(value_sp.get()));
return sb_value;
}
lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
SBValue value_sb;
if (IsValid()) {
ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(), use_dynamic,
m_opaque_sp->GetUseSynthetic()));
value_sb.SetSP(proxy_sp);
}
return value_sb;
}
lldb::SBValue SBValue::GetStaticValue() {
SBValue value_sb;
if (IsValid()) {
ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),
eNoDynamicValues,
m_opaque_sp->GetUseSynthetic()));
value_sb.SetSP(proxy_sp);
}
return value_sb;
}
lldb::SBValue SBValue::GetNonSyntheticValue() {
SBValue value_sb;
if (IsValid()) {
ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),
m_opaque_sp->GetUseDynamic(), false));
value_sb.SetSP(proxy_sp);
}
return value_sb;
}
lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
if (!IsValid())
return eNoDynamicValues;
return m_opaque_sp->GetUseDynamic();
}
void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) {
if (IsValid())
return m_opaque_sp->SetUseDynamic(use_dynamic);
}
bool SBValue::GetPreferSyntheticValue() {
if (!IsValid())
return false;
return m_opaque_sp->GetUseSynthetic();
}
void SBValue::SetPreferSyntheticValue(bool use_synthetic) {
if (IsValid())
return m_opaque_sp->SetUseSynthetic(use_synthetic);
}
bool SBValue::IsDynamic() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
return value_sp->IsDynamic();
return false;
}
bool SBValue::IsSynthetic() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
return value_sp->IsSynthetic();
return false;
}
bool SBValue::IsSyntheticChildrenGenerated() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
return value_sp->IsSyntheticChildrenGenerated();
return false;
}
void SBValue::SetSyntheticChildrenGenerated(bool is) {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
return value_sp->SetSyntheticChildrenGenerated(is);
}
lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
lldb::ValueObjectSP child_sp;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
// using default values for all the fancy options, just do it if you can
child_sp = value_sp->GetValueForExpressionPath(expr_path);
}
SBValue sb_value;
sb_value.SetSP(child_sp, GetPreferDynamicValue(), GetPreferSyntheticValue());
if (log)
log->Printf("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => "
"SBValue(%p)",
static_cast<void *>(value_sp.get()), expr_path,
static_cast<void *>(value_sp.get()));
return sb_value;
}
int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
error.Clear();
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
bool success = true;
uint64_t ret_val = fail_value;
ret_val = value_sp->GetValueAsSigned(fail_value, &success);
if (!success)
error.SetErrorString("could not resolve value");
return ret_val;
} else
error.SetErrorStringWithFormat("could not get SBValue: %s",
locker.GetError().AsCString());
return fail_value;
}
uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
error.Clear();
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
bool success = true;
uint64_t ret_val = fail_value;
ret_val = value_sp->GetValueAsUnsigned(fail_value, &success);
if (!success)
error.SetErrorString("could not resolve value");
return ret_val;
} else
error.SetErrorStringWithFormat("could not get SBValue: %s",
locker.GetError().AsCString());
return fail_value;
}
int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
return value_sp->GetValueAsSigned(fail_value);
}
return fail_value;
}
uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
return value_sp->GetValueAsUnsigned(fail_value);
}
return fail_value;
}
bool SBValue::MightHaveChildren() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool has_children = false;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
has_children = value_sp->MightHaveChildren();
if (log)
log->Printf("SBValue(%p)::MightHaveChildren() => %i",
static_cast<void *>(value_sp.get()), has_children);
return has_children;
}
bool SBValue::IsRuntimeSupportValue() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
bool is_support = false;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
is_support = value_sp->IsRuntimeSupportValue();
if (log)
log->Printf("SBValue(%p)::IsRuntimeSupportValue() => %i",
static_cast<void *>(value_sp.get()), is_support);
return is_support;
}
uint32_t SBValue::GetNumChildren() { return GetNumChildren(UINT32_MAX); }
uint32_t SBValue::GetNumChildren(uint32_t max) {
uint32_t num_children = 0;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
num_children = value_sp->GetNumChildren(max);
if (log)
log->Printf("SBValue(%p)::GetNumChildren (%u) => %u",
static_cast<void *>(value_sp.get()), max, num_children);
return num_children;
}
SBValue SBValue::Dereference() {
SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
Status error;
sb_value = value_sp->Dereference(error);
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBValue(%p)::Dereference () => SBValue(%p)",
static_cast<void *>(value_sp.get()),
static_cast<void *>(value_sp.get()));
return sb_value;
}
// Deprecated - please use GetType().IsPointerType() instead.
bool SBValue::TypeIsPointerType() { return GetType().IsPointerType(); }
void *SBValue::GetOpaqueType() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
return value_sp->GetCompilerType().GetOpaqueQualType();
return NULL;
}
lldb::SBTarget SBValue::GetTarget() {
SBTarget sb_target;
TargetSP target_sp;
if (m_opaque_sp) {
target_sp = m_opaque_sp->GetTargetSP();
sb_target.SetSP(target_sp);
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
if (target_sp.get() == NULL)
log->Printf("SBValue(%p)::GetTarget () => NULL",
static_cast<void *>(m_opaque_sp.get()));
else
log->Printf("SBValue(%p)::GetTarget () => %p",
static_cast<void *>(m_opaque_sp.get()),
static_cast<void *>(target_sp.get()));
}
return sb_target;
}
lldb::SBProcess SBValue::GetProcess() {
SBProcess sb_process;
ProcessSP process_sp;
if (m_opaque_sp) {
process_sp = m_opaque_sp->GetProcessSP();
sb_process.SetSP(process_sp);
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
if (process_sp.get() == NULL)
log->Printf("SBValue(%p)::GetProcess () => NULL",
static_cast<void *>(m_opaque_sp.get()));
else
log->Printf("SBValue(%p)::GetProcess () => %p",
static_cast<void *>(m_opaque_sp.get()),
static_cast<void *>(process_sp.get()));
}
return sb_process;
}
lldb::SBThread SBValue::GetThread() {
SBThread sb_thread;
ThreadSP thread_sp;
if (m_opaque_sp) {
thread_sp = m_opaque_sp->GetThreadSP();
sb_thread.SetThread(thread_sp);
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
if (thread_sp.get() == NULL)
log->Printf("SBValue(%p)::GetThread () => NULL",
static_cast<void *>(m_opaque_sp.get()));
else
log->Printf("SBValue(%p)::GetThread () => %p",
static_cast<void *>(m_opaque_sp.get()),
static_cast<void *>(thread_sp.get()));
}
return sb_thread;
}
lldb::SBFrame SBValue::GetFrame() {
SBFrame sb_frame;
StackFrameSP frame_sp;
if (m_opaque_sp) {
frame_sp = m_opaque_sp->GetFrameSP();
sb_frame.SetFrameSP(frame_sp);
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log) {
if (frame_sp.get() == NULL)
log->Printf("SBValue(%p)::GetFrame () => NULL",
static_cast<void *>(m_opaque_sp.get()));
else
log->Printf("SBValue(%p)::GetFrame () => %p",
static_cast<void *>(m_opaque_sp.get()),
static_cast<void *>(frame_sp.get()));
}
return sb_frame;
}
lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const {
if (!m_opaque_sp || !m_opaque_sp->IsValid()) {
locker.GetError().SetErrorString("No value");
return ValueObjectSP();
}
return locker.GetLockedSP(*m_opaque_sp.get());
}
lldb::ValueObjectSP SBValue::GetSP() const {
ValueLocker locker;
return GetSP(locker);
}
void SBValue::SetSP(ValueImplSP impl_sp) { m_opaque_sp = impl_sp; }
void SBValue::SetSP(const lldb::ValueObjectSP &sp) {
if (sp) {
lldb::TargetSP target_sp(sp->GetTargetSP());
if (target_sp) {
lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
bool use_synthetic =
target_sp->TargetProperties::GetEnableSyntheticValue();
m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic));
} else
m_opaque_sp = ValueImplSP(new ValueImpl(sp, eNoDynamicValues, true));
} else
m_opaque_sp = ValueImplSP(new ValueImpl(sp, eNoDynamicValues, false));
}
void SBValue::SetSP(const lldb::ValueObjectSP &sp,
lldb::DynamicValueType use_dynamic) {
if (sp) {
lldb::TargetSP target_sp(sp->GetTargetSP());
if (target_sp) {
bool use_synthetic =
target_sp->TargetProperties::GetEnableSyntheticValue();
SetSP(sp, use_dynamic, use_synthetic);
} else
SetSP(sp, use_dynamic, true);
} else
SetSP(sp, use_dynamic, false);
}
void SBValue::SetSP(const lldb::ValueObjectSP &sp, bool use_synthetic) {
if (sp) {
lldb::TargetSP target_sp(sp->GetTargetSP());
if (target_sp) {
lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
SetSP(sp, use_dynamic, use_synthetic);
} else
SetSP(sp, eNoDynamicValues, use_synthetic);
} else
SetSP(sp, eNoDynamicValues, use_synthetic);
}
void SBValue::SetSP(const lldb::ValueObjectSP &sp,
lldb::DynamicValueType use_dynamic, bool use_synthetic) {
m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic));
}
void SBValue::SetSP(const lldb::ValueObjectSP &sp,
lldb::DynamicValueType use_dynamic, bool use_synthetic,
const char *name) {
m_opaque_sp =
ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic, name));
}
bool SBValue::GetExpressionPath(SBStream &description) {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
value_sp->GetExpressionPath(description.ref(), false);
return true;
}
return false;
}
bool SBValue::GetExpressionPath(SBStream &description,
bool qualify_cxx_base_classes) {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
value_sp->GetExpressionPath(description.ref(), qualify_cxx_base_classes);
return true;
}
return false;
}
lldb::SBValue SBValue::EvaluateExpression(const char* expr) const {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (!value_sp)
return SBValue();
lldb::TargetSP target_sp = value_sp->GetTargetSP();
if (!target_sp)
return SBValue();
lldb::SBExpressionOptions options;
options.SetFetchDynamicValue(target_sp->GetPreferDynamicValue());
options.SetUnwindOnError(true);
options.SetIgnoreBreakpoints(true);
return EvaluateExpression(expr, options, nullptr);
}
lldb::SBValue
SBValue::EvaluateExpression(const char *expr,
const SBExpressionOptions &options) const {
return EvaluateExpression(expr, options, nullptr);
}
lldb::SBValue SBValue::EvaluateExpression(const char *expr,
const SBExpressionOptions &options,
const char *name) const {
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (!expr || expr[0] == '\0') {
LLDB_LOG(log,
"SBValue::EvaluateExpression called with an empty expression");
return SBValue();
}
LLDB_LOG(log, "SBValue()::EvaluateExpression (expr=\"{0}\")...", expr);
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (!value_sp) {
LLDB_LOG(log, "SBValue::EvaluateExpression () => error: could not "
"reconstruct value object for this SBValue");
return SBValue();
}
lldb::TargetSP target_sp = value_sp->GetTargetSP();
if (!target_sp) {
LLDB_LOG(
log,
"SBValue::EvaluateExpression () => error: could not retrieve target");
return SBValue();
}
std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
ExecutionContext exe_ctx(target_sp.get());
StackFrame *frame = exe_ctx.GetFramePtr();
if (!frame) {
LLDB_LOG(log, "SBValue::EvaluateExpression () => error: could not retrieve "
"current stack frame");
return SBValue();
}
ValueObjectSP res_val_sp;
ExpressionResults expr_res = target_sp->EvaluateExpression(
expr, frame, res_val_sp, options.ref(), nullptr, value_sp.get());
if (name)
res_val_sp->SetName(ConstString(name));
LLDB_LOG(log,
"SBValue(Name=\"{0}\")::EvaluateExpression (expr=\"{1}\") => "
"SBValue(Success={2}) (execution result={3})",
value_sp->GetName(), expr, res_val_sp->GetError().Success(),
expr_res);
SBValue result;
result.SetSP(res_val_sp, options.GetFetchDynamicValue());
return result;
}
bool SBValue::GetDescription(SBStream &description) {
Stream &strm = description.ref();
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
value_sp->Dump(strm);
else
strm.PutCString("No value");
return true;
}
lldb::Format SBValue::GetFormat() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
return value_sp->GetFormat();
return eFormatDefault;
}
void SBValue::SetFormat(lldb::Format format) {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp)
value_sp->SetFormat(format);
}
lldb::SBValue SBValue::AddressOf() {
SBValue sb_value;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
Status error;
sb_value.SetSP(value_sp->AddressOf(error), GetPreferDynamicValue(),
GetPreferSyntheticValue());
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBValue(%p)::AddressOf () => SBValue(%p)",
static_cast<void *>(value_sp.get()),
static_cast<void *>(value_sp.get()));
return sb_value;
}
lldb::addr_t SBValue::GetLoadAddress() {
lldb::addr_t value = LLDB_INVALID_ADDRESS;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
TargetSP target_sp(value_sp->GetTargetSP());
if (target_sp) {
const bool scalar_is_load_address = true;
AddressType addr_type;
value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
if (addr_type == eAddressTypeFile) {
ModuleSP module_sp(value_sp->GetModule());
if (!module_sp)
value = LLDB_INVALID_ADDRESS;
else {
Address addr;
module_sp->ResolveFileAddress(value, addr);
value = addr.GetLoadAddress(target_sp.get());
Redesign of the interaction between Python and frozen objects: - introduced two new classes ValueObjectConstResultChild and ValueObjectConstResultImpl: the first one is a ValueObjectChild obtained from a ValueObjectConstResult, the second is a common implementation backend for VOCR and VOCRCh of method calls meant to read through pointers stored in frozen objects ; now such reads transparently move from host to target as required - as a consequence of the above, removed code that made target-memory copies of expression results in several places throughout LLDB, and also removed code that enabled to recognize an expression result VO as such - introduced a new GetPointeeData() method in ValueObject that lets you read a given amount of objects of type T from a VO representing a T* or T[], and doing dereferences transparently in private layer it returns a DataExtractor ; in public layer it returns an instance of a newly created lldb::SBData - as GetPointeeData() does the right thing for both frozen and non-frozen ValueObject's, reimplemented ReadPointedString() to use it en lieu of doing the raw read itself - introduced a new GetData() method in ValueObject that lets you get a copy of the data that backs the ValueObject (for pointers, this returns the address without any previous dereferencing steps ; for arrays it actually reads the whole chunk of memory) in public layer this returns an SBData, just like GetPointeeData() - introduced a new CreateValueFromData() method in SBValue that lets you create a new SBValue from a chunk of data wrapped in an SBData the limitation to remember for this kind of SBValue is that they have no address: extracting the address-of for these objects (with any of GetAddress(), GetLoadAddress() and AddressOf()) will return invalid values - added several tests to check that "p"-ing objects (STL classes, char* and char[]) will do the right thing Solved a bug where global pointers to global variables were not dereferenced correctly for display New target setting "max-string-summary-length" gives the maximum number of characters to show in a string when summarizing it, instead of the hardcoded 128 Solved a bug where the summary for char[] and char* would not be shown if the ValueObject's were dumped via the "p" command Removed m_pointers_point_to_load_addrs from ValueObject. Introduced a new m_address_type_of_children, which each ValueObject can set to tell the address type of any pointers and/or references it creates. In the current codebase, this is load address most of the time (the only notable exception being file addresses that generate file address children UNLESS we have a live process) Updated help text for summary-string Fixed an issue in STL formatters where std::stlcontainer::iterator would match the container's synthetic children providers Edited the syntax and help for some commands to have proper argument types llvm-svn: 139160
2011-09-07 03:20:51 +08:00
}
} else if (addr_type == eAddressTypeHost ||
addr_type == eAddressTypeInvalid)
value = LLDB_INVALID_ADDRESS;
}
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBValue(%p)::GetLoadAddress () => (%" PRIu64 ")",
static_cast<void *>(value_sp.get()), value);
return value;
}
lldb::SBAddress SBValue::GetAddress() {
Address addr;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
TargetSP target_sp(value_sp->GetTargetSP());
if (target_sp) {
lldb::addr_t value = LLDB_INVALID_ADDRESS;
const bool scalar_is_load_address = true;
AddressType addr_type;
value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
if (addr_type == eAddressTypeFile) {
ModuleSP module_sp(value_sp->GetModule());
if (module_sp)
module_sp->ResolveFileAddress(value, addr);
} else if (addr_type == eAddressTypeLoad) {
// no need to check the return value on this.. if it can actually do
// the resolve addr will be in the form (section,offset), otherwise it
// will simply be returned as (NULL, value)
addr.SetLoadAddress(value, target_sp.get());
}
}
}
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
log->Printf("SBValue(%p)::GetAddress () => (%s,%" PRIu64 ")",
static_cast<void *>(value_sp.get()),
(addr.GetSection() ? addr.GetSection()->GetName().GetCString()
: "NULL"),
addr.GetOffset());
return SBAddress(new Address(addr));
}
lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
lldb::SBData sb_data;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
TargetSP target_sp(value_sp->GetTargetSP());
if (target_sp) {
DataExtractorSP data_sp(new DataExtractor());
value_sp->GetPointeeData(*data_sp, item_idx, item_count);
if (data_sp->GetByteSize() > 0)
*sb_data = data_sp;
}
}
if (log)
log->Printf("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)",
static_cast<void *>(value_sp.get()), item_idx, item_count,
static_cast<void *>(sb_data.get()));
return sb_data;
}
lldb::SBData SBValue::GetData() {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
lldb::SBData sb_data;
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
if (value_sp) {
DataExtractorSP data_sp(new DataExtractor());
Status error;
value_sp->GetData(*data_sp, error);
if (error.Success())
*sb_data = data_sp;
}
if (log)
log->Printf("SBValue(%p)::GetData () => SBData(%p)",
static_cast<void *>(value_sp.get()),
static_cast<void *>(sb_data.get()));
return sb_data;
}
bool SBValue::SetData(lldb::SBData &data, SBError &error) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
bool ret = true;
if (value_sp) {
DataExtractor *data_extractor = data.get();
if (!data_extractor) {
if (log)
log->Printf("SBValue(%p)::SetData() => error: no data to set",
static_cast<void *>(value_sp.get()));
error.SetErrorString("No data to set");
ret = false;
} else {
Status set_error;
value_sp->SetData(*data_extractor, set_error);
if (!set_error.Success()) {
error.SetErrorStringWithFormat("Couldn't set data: %s",
set_error.AsCString());
ret = false;
}
}
} else {
error.SetErrorStringWithFormat(
"Couldn't set data: could not get SBValue: %s",
locker.GetError().AsCString());
ret = false;
}
if (log)
log->Printf("SBValue(%p)::SetData (%p) => %s",
static_cast<void *>(value_sp.get()),
static_cast<void *>(data.get()), ret ? "true" : "false");
return ret;
}
lldb::SBDeclaration SBValue::GetDeclaration() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
SBDeclaration decl_sb;
if (value_sp) {
Declaration decl;
if (value_sp->GetDeclaration(decl))
decl_sb.SetDeclaration(decl);
}
return decl_sb;
}
lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
SBError &error) {
SBWatchpoint sb_watchpoint;
// If the SBValue is not valid, there's no point in even trying to watch it.
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
TargetSP target_sp(GetTarget().GetSP());
if (value_sp && target_sp) {
// Read and Write cannot both be false.
if (!read && !write)
return sb_watchpoint;
// If the value is not in scope, don't try and watch and invalid value
if (!IsInScope())
return sb_watchpoint;
addr_t addr = GetLoadAddress();
if (addr == LLDB_INVALID_ADDRESS)
return sb_watchpoint;
size_t byte_size = GetByteSize();
if (byte_size == 0)
return sb_watchpoint;
uint32_t watch_type = 0;
if (read)
watch_type |= LLDB_WATCH_TYPE_READ;
if (write)
watch_type |= LLDB_WATCH_TYPE_WRITE;
Status rc;
CompilerType type(value_sp->GetCompilerType());
WatchpointSP watchpoint_sp =
target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc);
error.SetError(rc);
if (watchpoint_sp) {
sb_watchpoint.SetSP(watchpoint_sp);
Declaration decl;
if (value_sp->GetDeclaration(decl)) {
if (decl.GetFile()) {
StreamString ss;
// True to show fullpath for declaration file.
decl.DumpStopContext(&ss, true);
watchpoint_sp->SetDeclInfo(ss.GetString());
Redesign of the interaction between Python and frozen objects: - introduced two new classes ValueObjectConstResultChild and ValueObjectConstResultImpl: the first one is a ValueObjectChild obtained from a ValueObjectConstResult, the second is a common implementation backend for VOCR and VOCRCh of method calls meant to read through pointers stored in frozen objects ; now such reads transparently move from host to target as required - as a consequence of the above, removed code that made target-memory copies of expression results in several places throughout LLDB, and also removed code that enabled to recognize an expression result VO as such - introduced a new GetPointeeData() method in ValueObject that lets you read a given amount of objects of type T from a VO representing a T* or T[], and doing dereferences transparently in private layer it returns a DataExtractor ; in public layer it returns an instance of a newly created lldb::SBData - as GetPointeeData() does the right thing for both frozen and non-frozen ValueObject's, reimplemented ReadPointedString() to use it en lieu of doing the raw read itself - introduced a new GetData() method in ValueObject that lets you get a copy of the data that backs the ValueObject (for pointers, this returns the address without any previous dereferencing steps ; for arrays it actually reads the whole chunk of memory) in public layer this returns an SBData, just like GetPointeeData() - introduced a new CreateValueFromData() method in SBValue that lets you create a new SBValue from a chunk of data wrapped in an SBData the limitation to remember for this kind of SBValue is that they have no address: extracting the address-of for these objects (with any of GetAddress(), GetLoadAddress() and AddressOf()) will return invalid values - added several tests to check that "p"-ing objects (STL classes, char* and char[]) will do the right thing Solved a bug where global pointers to global variables were not dereferenced correctly for display New target setting "max-string-summary-length" gives the maximum number of characters to show in a string when summarizing it, instead of the hardcoded 128 Solved a bug where the summary for char[] and char* would not be shown if the ValueObject's were dumped via the "p" command Removed m_pointers_point_to_load_addrs from ValueObject. Introduced a new m_address_type_of_children, which each ValueObject can set to tell the address type of any pointers and/or references it creates. In the current codebase, this is load address most of the time (the only notable exception being file addresses that generate file address children UNLESS we have a live process) Updated help text for summary-string Fixed an issue in STL formatters where std::stlcontainer::iterator would match the container's synthetic children providers Edited the syntax and help for some commands to have proper argument types llvm-svn: 139160
2011-09-07 03:20:51 +08:00
}
}
Redesign of the interaction between Python and frozen objects: - introduced two new classes ValueObjectConstResultChild and ValueObjectConstResultImpl: the first one is a ValueObjectChild obtained from a ValueObjectConstResult, the second is a common implementation backend for VOCR and VOCRCh of method calls meant to read through pointers stored in frozen objects ; now such reads transparently move from host to target as required - as a consequence of the above, removed code that made target-memory copies of expression results in several places throughout LLDB, and also removed code that enabled to recognize an expression result VO as such - introduced a new GetPointeeData() method in ValueObject that lets you read a given amount of objects of type T from a VO representing a T* or T[], and doing dereferences transparently in private layer it returns a DataExtractor ; in public layer it returns an instance of a newly created lldb::SBData - as GetPointeeData() does the right thing for both frozen and non-frozen ValueObject's, reimplemented ReadPointedString() to use it en lieu of doing the raw read itself - introduced a new GetData() method in ValueObject that lets you get a copy of the data that backs the ValueObject (for pointers, this returns the address without any previous dereferencing steps ; for arrays it actually reads the whole chunk of memory) in public layer this returns an SBData, just like GetPointeeData() - introduced a new CreateValueFromData() method in SBValue that lets you create a new SBValue from a chunk of data wrapped in an SBData the limitation to remember for this kind of SBValue is that they have no address: extracting the address-of for these objects (with any of GetAddress(), GetLoadAddress() and AddressOf()) will return invalid values - added several tests to check that "p"-ing objects (STL classes, char* and char[]) will do the right thing Solved a bug where global pointers to global variables were not dereferenced correctly for display New target setting "max-string-summary-length" gives the maximum number of characters to show in a string when summarizing it, instead of the hardcoded 128 Solved a bug where the summary for char[] and char* would not be shown if the ValueObject's were dumped via the "p" command Removed m_pointers_point_to_load_addrs from ValueObject. Introduced a new m_address_type_of_children, which each ValueObject can set to tell the address type of any pointers and/or references it creates. In the current codebase, this is load address most of the time (the only notable exception being file addresses that generate file address children UNLESS we have a live process) Updated help text for summary-string Fixed an issue in STL formatters where std::stlcontainer::iterator would match the container's synthetic children providers Edited the syntax and help for some commands to have proper argument types llvm-svn: 139160
2011-09-07 03:20:51 +08:00
}
} else if (target_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
Redesign of the interaction between Python and frozen objects: - introduced two new classes ValueObjectConstResultChild and ValueObjectConstResultImpl: the first one is a ValueObjectChild obtained from a ValueObjectConstResult, the second is a common implementation backend for VOCR and VOCRCh of method calls meant to read through pointers stored in frozen objects ; now such reads transparently move from host to target as required - as a consequence of the above, removed code that made target-memory copies of expression results in several places throughout LLDB, and also removed code that enabled to recognize an expression result VO as such - introduced a new GetPointeeData() method in ValueObject that lets you read a given amount of objects of type T from a VO representing a T* or T[], and doing dereferences transparently in private layer it returns a DataExtractor ; in public layer it returns an instance of a newly created lldb::SBData - as GetPointeeData() does the right thing for both frozen and non-frozen ValueObject's, reimplemented ReadPointedString() to use it en lieu of doing the raw read itself - introduced a new GetData() method in ValueObject that lets you get a copy of the data that backs the ValueObject (for pointers, this returns the address without any previous dereferencing steps ; for arrays it actually reads the whole chunk of memory) in public layer this returns an SBData, just like GetPointeeData() - introduced a new CreateValueFromData() method in SBValue that lets you create a new SBValue from a chunk of data wrapped in an SBData the limitation to remember for this kind of SBValue is that they have no address: extracting the address-of for these objects (with any of GetAddress(), GetLoadAddress() and AddressOf()) will return invalid values - added several tests to check that "p"-ing objects (STL classes, char* and char[]) will do the right thing Solved a bug where global pointers to global variables were not dereferenced correctly for display New target setting "max-string-summary-length" gives the maximum number of characters to show in a string when summarizing it, instead of the hardcoded 128 Solved a bug where the summary for char[] and char* would not be shown if the ValueObject's were dumped via the "p" command Removed m_pointers_point_to_load_addrs from ValueObject. Introduced a new m_address_type_of_children, which each ValueObject can set to tell the address type of any pointers and/or references it creates. In the current codebase, this is load address most of the time (the only notable exception being file addresses that generate file address children UNLESS we have a live process) Updated help text for summary-string Fixed an issue in STL formatters where std::stlcontainer::iterator would match the container's synthetic children providers Edited the syntax and help for some commands to have proper argument types llvm-svn: 139160
2011-09-07 03:20:51 +08:00
if (log)
log->Printf("SBValue(%p)::Watch() => error getting SBValue: %s",
static_cast<void *>(value_sp.get()),
locker.GetError().AsCString());
error.SetErrorStringWithFormat("could not get SBValue: %s",
locker.GetError().AsCString());
} else {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
Redesign of the interaction between Python and frozen objects: - introduced two new classes ValueObjectConstResultChild and ValueObjectConstResultImpl: the first one is a ValueObjectChild obtained from a ValueObjectConstResult, the second is a common implementation backend for VOCR and VOCRCh of method calls meant to read through pointers stored in frozen objects ; now such reads transparently move from host to target as required - as a consequence of the above, removed code that made target-memory copies of expression results in several places throughout LLDB, and also removed code that enabled to recognize an expression result VO as such - introduced a new GetPointeeData() method in ValueObject that lets you read a given amount of objects of type T from a VO representing a T* or T[], and doing dereferences transparently in private layer it returns a DataExtractor ; in public layer it returns an instance of a newly created lldb::SBData - as GetPointeeData() does the right thing for both frozen and non-frozen ValueObject's, reimplemented ReadPointedString() to use it en lieu of doing the raw read itself - introduced a new GetData() method in ValueObject that lets you get a copy of the data that backs the ValueObject (for pointers, this returns the address without any previous dereferencing steps ; for arrays it actually reads the whole chunk of memory) in public layer this returns an SBData, just like GetPointeeData() - introduced a new CreateValueFromData() method in SBValue that lets you create a new SBValue from a chunk of data wrapped in an SBData the limitation to remember for this kind of SBValue is that they have no address: extracting the address-of for these objects (with any of GetAddress(), GetLoadAddress() and AddressOf()) will return invalid values - added several tests to check that "p"-ing objects (STL classes, char* and char[]) will do the right thing Solved a bug where global pointers to global variables were not dereferenced correctly for display New target setting "max-string-summary-length" gives the maximum number of characters to show in a string when summarizing it, instead of the hardcoded 128 Solved a bug where the summary for char[] and char* would not be shown if the ValueObject's were dumped via the "p" command Removed m_pointers_point_to_load_addrs from ValueObject. Introduced a new m_address_type_of_children, which each ValueObject can set to tell the address type of any pointers and/or references it creates. In the current codebase, this is load address most of the time (the only notable exception being file addresses that generate file address children UNLESS we have a live process) Updated help text for summary-string Fixed an issue in STL formatters where std::stlcontainer::iterator would match the container's synthetic children providers Edited the syntax and help for some commands to have proper argument types llvm-svn: 139160
2011-09-07 03:20:51 +08:00
if (log)
log->Printf("SBValue(%p)::Watch() => error getting SBValue: no target",
static_cast<void *>(value_sp.get()));
error.SetErrorString("could not set watchpoint, a target is required");
}
return sb_watchpoint;
Redesign of the interaction between Python and frozen objects: - introduced two new classes ValueObjectConstResultChild and ValueObjectConstResultImpl: the first one is a ValueObjectChild obtained from a ValueObjectConstResult, the second is a common implementation backend for VOCR and VOCRCh of method calls meant to read through pointers stored in frozen objects ; now such reads transparently move from host to target as required - as a consequence of the above, removed code that made target-memory copies of expression results in several places throughout LLDB, and also removed code that enabled to recognize an expression result VO as such - introduced a new GetPointeeData() method in ValueObject that lets you read a given amount of objects of type T from a VO representing a T* or T[], and doing dereferences transparently in private layer it returns a DataExtractor ; in public layer it returns an instance of a newly created lldb::SBData - as GetPointeeData() does the right thing for both frozen and non-frozen ValueObject's, reimplemented ReadPointedString() to use it en lieu of doing the raw read itself - introduced a new GetData() method in ValueObject that lets you get a copy of the data that backs the ValueObject (for pointers, this returns the address without any previous dereferencing steps ; for arrays it actually reads the whole chunk of memory) in public layer this returns an SBData, just like GetPointeeData() - introduced a new CreateValueFromData() method in SBValue that lets you create a new SBValue from a chunk of data wrapped in an SBData the limitation to remember for this kind of SBValue is that they have no address: extracting the address-of for these objects (with any of GetAddress(), GetLoadAddress() and AddressOf()) will return invalid values - added several tests to check that "p"-ing objects (STL classes, char* and char[]) will do the right thing Solved a bug where global pointers to global variables were not dereferenced correctly for display New target setting "max-string-summary-length" gives the maximum number of characters to show in a string when summarizing it, instead of the hardcoded 128 Solved a bug where the summary for char[] and char* would not be shown if the ValueObject's were dumped via the "p" command Removed m_pointers_point_to_load_addrs from ValueObject. Introduced a new m_address_type_of_children, which each ValueObject can set to tell the address type of any pointers and/or references it creates. In the current codebase, this is load address most of the time (the only notable exception being file addresses that generate file address children UNLESS we have a live process) Updated help text for summary-string Fixed an issue in STL formatters where std::stlcontainer::iterator would match the container's synthetic children providers Edited the syntax and help for some commands to have proper argument types llvm-svn: 139160
2011-09-07 03:20:51 +08:00
}
// FIXME: Remove this method impl (as well as the decl in .h) once it is no
// longer needed.
// Backward compatibility fix in the interim.
lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read,
bool write) {
SBError error;
return Watch(resolve_location, read, write, error);
}
lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read,
bool write, SBError &error) {
SBWatchpoint sb_watchpoint;
if (IsInScope() && GetType().IsPointerType())
sb_watchpoint = Dereference().Watch(resolve_location, read, write, error);
return sb_watchpoint;
}
lldb::SBValue SBValue::Persist() {
ValueLocker locker;
lldb::ValueObjectSP value_sp(GetSP(locker));
SBValue persisted_sb;
if (value_sp) {
persisted_sb.SetSP(value_sp->Persist());
}
return persisted_sb;
}