mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-01 14:36:10 +00:00
5160ce5c72
LLDB is crashing when logging is enabled from lldb-perf-clang. This has to do with the global destructor chain as the process and its threads are being torn down. All logging channels now make one and only one instance that is kept in a global pointer which is never freed. This guarantees that logging can correctly continue as the process tears itself down. llvm-svn: 178191
1974 lines
59 KiB
C++
1974 lines
59 KiB
C++
//===-- SBValue.cpp ---------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/lldb-python.h"
|
|
|
|
#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/DataExtractor.h"
|
|
#include "lldb/Core/Log.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/Scalar.h"
|
|
#include "lldb/Core/Section.h"
|
|
#include "lldb/Core/Stream.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/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"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
namespace {
|
|
class ValueImpl
|
|
{
|
|
public:
|
|
ValueImpl ()
|
|
{
|
|
}
|
|
|
|
ValueImpl (lldb::ValueObjectSP opaque_sp,
|
|
lldb::DynamicValueType use_dynamic,
|
|
bool use_synthetic) :
|
|
m_opaque_sp(opaque_sp),
|
|
m_use_dynamic(use_dynamic),
|
|
m_use_synthetic(use_synthetic)
|
|
{
|
|
}
|
|
|
|
ValueImpl (const ValueImpl& rhs) :
|
|
m_opaque_sp(rhs.m_opaque_sp),
|
|
m_use_dynamic(rhs.m_use_dynamic),
|
|
m_use_synthetic(rhs.m_use_synthetic)
|
|
{
|
|
}
|
|
|
|
ValueImpl &
|
|
operator = (const ValueImpl &rhs)
|
|
{
|
|
if (this != &rhs)
|
|
{
|
|
m_opaque_sp = rhs.m_opaque_sp;
|
|
m_use_dynamic = rhs.m_use_dynamic;
|
|
m_use_synthetic = rhs.m_use_synthetic;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
bool
|
|
IsValid ()
|
|
{
|
|
return m_opaque_sp.get() != NULL;
|
|
}
|
|
|
|
lldb::ValueObjectSP
|
|
GetRootSP ()
|
|
{
|
|
return m_opaque_sp;
|
|
}
|
|
|
|
lldb::ValueObjectSP
|
|
GetSP ()
|
|
{
|
|
if (!m_opaque_sp)
|
|
return m_opaque_sp;
|
|
lldb::ValueObjectSP value_sp = m_opaque_sp;
|
|
if (value_sp->GetDynamicValue(m_use_dynamic))
|
|
value_sp = value_sp->GetDynamicValue(m_use_dynamic);
|
|
if (value_sp->GetSyntheticValue(m_use_synthetic))
|
|
value_sp = value_sp->GetSyntheticValue(m_use_synthetic);
|
|
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;
|
|
}
|
|
|
|
private:
|
|
lldb::ValueObjectSP m_opaque_sp;
|
|
lldb::DynamicValueType m_use_dynamic;
|
|
bool m_use_synthetic;
|
|
};
|
|
}
|
|
|
|
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->GetRootSP().get() != NULL;
|
|
}
|
|
|
|
void
|
|
SBValue::Clear()
|
|
{
|
|
m_opaque_sp.reset();
|
|
}
|
|
|
|
SBError
|
|
SBValue::GetError()
|
|
{
|
|
SBError sb_error;
|
|
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
sb_error.SetError(value_sp->GetError());
|
|
else
|
|
sb_error.SetErrorString("error: invalid value");
|
|
|
|
return sb_error;
|
|
}
|
|
|
|
user_id_t
|
|
SBValue::GetID()
|
|
{
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
return value_sp->GetID();
|
|
return LLDB_INVALID_UID;
|
|
}
|
|
|
|
const char *
|
|
SBValue::GetName()
|
|
{
|
|
|
|
const char *name = NULL;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
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\"", value_sp.get(), name);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetName () => NULL", value_sp.get());
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
const char *
|
|
SBValue::GetTypeName ()
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
const char *name = NULL;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
// For a dynamic type we might have to run code to determine the type we are going to report,
|
|
// and we might not have updated the type before we get asked this. So make sure to get the API lock.
|
|
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetTypeName() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
name = value_sp->GetQualifiedTypeName().GetCString();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (log)
|
|
{
|
|
if (name)
|
|
log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"", value_sp.get(), name);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetTypeName () => NULL", value_sp.get());
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
size_t
|
|
SBValue::GetByteSize ()
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
size_t result = 0;
|
|
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
// For a dynamic type we might have to run code to determine the type we are going to report,
|
|
// and we might not have updated the type before we get asked this. So make sure to get the API lock.
|
|
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetTypeName() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
result = value_sp->GetByteSize();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetByteSize () => %" PRIu64, value_sp.get(), (uint64_t)result);
|
|
|
|
return result;
|
|
}
|
|
|
|
bool
|
|
SBValue::IsInScope ()
|
|
{
|
|
bool result = false;
|
|
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
result = value_sp->IsInScope ();
|
|
}
|
|
}
|
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::IsInScope () => %i", value_sp.get(), result);
|
|
|
|
return result;
|
|
}
|
|
|
|
const char *
|
|
SBValue::GetValue ()
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
|
|
const char *cstr = NULL;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetValue() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
cstr = value_sp->GetValueAsCString ();
|
|
}
|
|
}
|
|
}
|
|
if (log)
|
|
{
|
|
if (cstr)
|
|
log->Printf ("SBValue(%p)::GetValue() => \"%s\"", value_sp.get(), cstr);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetValue() => NULL", value_sp.get());
|
|
}
|
|
|
|
return cstr;
|
|
}
|
|
|
|
ValueType
|
|
SBValue::GetValueType ()
|
|
{
|
|
ValueType result = eValueTypeInvalid;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
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", value_sp.get()); break;
|
|
case eValueTypeVariableGlobal: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal", value_sp.get()); break;
|
|
case eValueTypeVariableStatic: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableStatic", value_sp.get()); break;
|
|
case eValueTypeVariableArgument:log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableArgument", value_sp.get()); break;
|
|
case eValueTypeVariableLocal: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableLocal", value_sp.get()); break;
|
|
case eValueTypeRegister: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegister", value_sp.get()); break;
|
|
case eValueTypeRegisterSet: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegisterSet", value_sp.get()); break;
|
|
case eValueTypeConstResult: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeConstResult", value_sp.get()); break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const char *
|
|
SBValue::GetObjectDescription ()
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
const char *cstr = NULL;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetObjectDescription() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
cstr = value_sp->GetObjectDescription ();
|
|
}
|
|
}
|
|
}
|
|
if (log)
|
|
{
|
|
if (cstr)
|
|
log->Printf ("SBValue(%p)::GetObjectDescription() => \"%s\"", value_sp.get(), cstr);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetObjectDescription() => NULL", value_sp.get());
|
|
}
|
|
return cstr;
|
|
}
|
|
|
|
SBType
|
|
SBValue::GetType()
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
SBType sb_type;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
TypeImplSP type_sp;
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetType() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
type_sp.reset (new TypeImpl(ClangASTType (value_sp->GetClangAST(), value_sp->GetClangType())));
|
|
sb_type.SetSP(type_sp);
|
|
}
|
|
}
|
|
}
|
|
if (log)
|
|
{
|
|
if (type_sp)
|
|
log->Printf ("SBValue(%p)::GetType => SBType(%p)", value_sp.get(), type_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetType => NULL", value_sp.get());
|
|
}
|
|
return sb_type;
|
|
}
|
|
|
|
bool
|
|
SBValue::GetValueDidChange ()
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
bool result = false;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetValueDidChange() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
result = value_sp->GetValueDidChange ();
|
|
}
|
|
}
|
|
}
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetValueDidChange() => %i", value_sp.get(), result);
|
|
|
|
return result;
|
|
}
|
|
|
|
#ifndef LLDB_DISABLE_PYTHON
|
|
const char *
|
|
SBValue::GetSummary ()
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
const char *cstr = NULL;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetSummary() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
cstr = value_sp->GetSummaryAsCString();
|
|
}
|
|
}
|
|
}
|
|
if (log)
|
|
{
|
|
if (cstr)
|
|
log->Printf ("SBValue(%p)::GetSummary() => \"%s\"", value_sp.get(), cstr);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetSummary() => NULL", value_sp.get());
|
|
}
|
|
return cstr;
|
|
}
|
|
#endif // LLDB_DISABLE_PYTHON
|
|
|
|
const char *
|
|
SBValue::GetLocation ()
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
const char *cstr = NULL;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetLocation() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
cstr = value_sp->GetLocationAsCString();
|
|
}
|
|
}
|
|
}
|
|
if (log)
|
|
{
|
|
if (cstr)
|
|
log->Printf ("SBValue(%p)::GetLocation() => \"%s\"", value_sp.get(), cstr);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetLocation() => NULL", 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;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::SetValueFromCString() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
success = value_sp->SetValueFromCString (value_str,error.ref());
|
|
}
|
|
}
|
|
}
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::SetValueFromCString(\"%s\") => %i", value_sp.get(), value_str, success);
|
|
|
|
return success;
|
|
}
|
|
|
|
lldb::SBTypeFormat
|
|
SBValue::GetTypeFormat ()
|
|
{
|
|
lldb::SBTypeFormat format;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetTypeFormat() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
if (value_sp->UpdateValueIfNeeded(true))
|
|
{
|
|
lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat();
|
|
if (format_sp)
|
|
format.SetSP(format_sp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return format;
|
|
}
|
|
|
|
#ifndef LLDB_DISABLE_PYTHON
|
|
lldb::SBTypeSummary
|
|
SBValue::GetTypeSummary ()
|
|
{
|
|
lldb::SBTypeSummary summary;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetTypeSummary() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
if (value_sp->UpdateValueIfNeeded(true))
|
|
{
|
|
lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat();
|
|
if (summary_sp)
|
|
summary.SetSP(summary_sp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return summary;
|
|
}
|
|
#endif // LLDB_DISABLE_PYTHON
|
|
|
|
lldb::SBTypeFilter
|
|
SBValue::GetTypeFilter ()
|
|
{
|
|
lldb::SBTypeFilter filter;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetTypeFilter() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
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;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetTypeSynthetic() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
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;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
lldb::ValueObjectSP new_value_sp;
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::CreateChildAtOffset() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
TypeImplSP type_sp (type.GetSP());
|
|
if (type.IsValid())
|
|
{
|
|
sb_value.SetSP(value_sp->GetSyntheticChildAtOffset(offset, type_sp->GetClangASTType(), true),GetPreferDynamicValue(),GetPreferSyntheticValue());
|
|
new_value_sp = sb_value.GetSP();
|
|
if (new_value_sp)
|
|
new_value_sp->SetName(ConstString(name));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (new_value_sp)
|
|
log->Printf ("SBValue(%p)::CreateChildAtOffset => \"%s\"",
|
|
value_sp.get(),
|
|
new_value_sp->GetName().AsCString());
|
|
else
|
|
log->Printf ("SBValue(%p)::CreateChildAtOffset => NULL",
|
|
value_sp.get());
|
|
}
|
|
return sb_value;
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::Cast (SBType type)
|
|
{
|
|
lldb::SBValue sb_value;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
TypeImplSP type_sp (type.GetSP());
|
|
if (value_sp && type_sp)
|
|
sb_value.SetSP(value_sp->Cast(type_sp->GetClangASTType()),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;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
lldb::ValueObjectSP new_value_sp;
|
|
if (value_sp)
|
|
{
|
|
ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
|
|
ProcessSP process_sp(exe_ctx.GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::CreateValueFromExpression() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
Target* target = exe_ctx.GetTargetPtr();
|
|
if (target)
|
|
{
|
|
options.ref().SetKeepInMemory(true);
|
|
target->EvaluateExpression (expression,
|
|
exe_ctx.GetFramePtr(),
|
|
new_value_sp,
|
|
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)",
|
|
value_sp.get(),
|
|
name,
|
|
expression,
|
|
new_value_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::CreateValueFromExpression(name=\"%s\", expression=\"%s\") => NULL",
|
|
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;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
lldb::ValueObjectSP new_value_sp;
|
|
lldb::TypeImplSP type_impl_sp (sb_type.GetSP());
|
|
if (value_sp && type_impl_sp)
|
|
{
|
|
ClangASTType pointee_ast_type(type_impl_sp->GetASTContext(), type_impl_sp->GetClangASTType().GetPointerType ());
|
|
lldb::TypeImplSP pointee_type_impl_sp (new TypeImpl(pointee_ast_type));
|
|
if (pointee_type_impl_sp)
|
|
{
|
|
|
|
lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t)));
|
|
|
|
ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
|
|
ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
|
|
pointee_type_impl_sp->GetASTContext(),
|
|
pointee_type_impl_sp->GetOpaqueQualType(),
|
|
ConstString(name),
|
|
buffer,
|
|
lldb::endian::InlHostByteOrder(),
|
|
exe_ctx.GetAddressByteSize()));
|
|
|
|
if (ptr_result_valobj_sp)
|
|
{
|
|
ptr_result_valobj_sp->GetValue().SetValueType(Value::eValueTypeLoadAddress);
|
|
Error err;
|
|
new_value_sp = ptr_result_valobj_sp->Dereference(err);
|
|
if (new_value_sp)
|
|
new_value_sp->SetName(ConstString(name));
|
|
}
|
|
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\"", value_sp.get(), new_value_sp->GetName().AsCString());
|
|
else
|
|
log->Printf ("SBValue(%p)::CreateValueFromAddress => NULL", value_sp.get());
|
|
}
|
|
return sb_value;
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::CreateValueFromData (const char* name, SBData data, SBType type)
|
|
{
|
|
lldb::SBValue sb_value;
|
|
lldb::ValueObjectSP new_value_sp;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
|
|
|
|
new_value_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(),
|
|
type.m_opaque_sp->GetASTContext() ,
|
|
type.m_opaque_sp->GetOpaqueQualType(),
|
|
ConstString(name),
|
|
*data.m_opaque_sp,
|
|
LLDB_INVALID_ADDRESS);
|
|
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\"", value_sp.get(), new_value_sp->GetName().AsCString());
|
|
else
|
|
log->Printf ("SBValue(%p)::CreateValueFromData => NULL", value_sp.get());
|
|
}
|
|
return sb_value;
|
|
}
|
|
|
|
SBValue
|
|
SBValue::GetChildAtIndex (uint32_t idx)
|
|
{
|
|
const bool can_create_synthetic = false;
|
|
lldb::DynamicValueType use_dynamic = eNoDynamicValues;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
TargetSP target_sp(value_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));
|
|
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetChildAtIndex() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
const bool can_create = true;
|
|
child_sp = value_sp->GetChildAtIndex (idx, can_create);
|
|
if (can_create_synthetic && !child_sp)
|
|
{
|
|
if (value_sp->IsPointerType())
|
|
{
|
|
child_sp = value_sp->GetSyntheticArrayMemberFromPointer(idx, can_create);
|
|
}
|
|
else if (value_sp->IsArrayType())
|
|
{
|
|
child_sp = value_sp->GetSyntheticArrayMemberFromArray(idx, can_create);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
SBValue sb_value;
|
|
sb_value.SetSP (child_sp, use_dynamic, GetPreferSyntheticValue());
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)", value_sp.get(), idx, value_sp.get());
|
|
|
|
return sb_value;
|
|
}
|
|
|
|
uint32_t
|
|
SBValue::GetIndexOfChildWithName (const char *name)
|
|
{
|
|
uint32_t idx = UINT32_MAX;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
|
|
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", value_sp.get(), name);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u", value_sp.get(), name, idx);
|
|
}
|
|
return idx;
|
|
}
|
|
|
|
SBValue
|
|
SBValue::GetChildMemberWithName (const char *name)
|
|
{
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
use_dynamic_value = target_sp->GetPreferDynamicValue();
|
|
}
|
|
return GetChildMemberWithName (name, use_dynamic_value);
|
|
}
|
|
return SBValue();
|
|
}
|
|
|
|
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));
|
|
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetChildMemberWithName() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
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)", value_sp.get(), name, 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()
|
|
{
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
return value_sp->IsDynamic();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SBValue::IsSynthetic ()
|
|
{
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
return value_sp->IsSynthetic();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::GetValueForExpressionPath(const char* expr_path)
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
lldb::ValueObjectSP child_sp;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetValueForExpressionPath() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
// 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)", value_sp.get(), expr_path, value_sp.get());
|
|
|
|
return sb_value;
|
|
}
|
|
|
|
int64_t
|
|
SBValue::GetValueAsSigned(SBError& error, int64_t fail_value)
|
|
{
|
|
error.Clear();
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetValueAsSigned() => error: process is running", value_sp.get());
|
|
error.SetErrorString("process is running");
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
Scalar scalar;
|
|
if (value_sp->ResolveValue (scalar))
|
|
return scalar.SLongLong(fail_value);
|
|
else
|
|
error.SetErrorString("could not get value");
|
|
}
|
|
else
|
|
error.SetErrorString("could not get target");
|
|
}
|
|
}
|
|
error.SetErrorString("invalid SBValue");
|
|
return fail_value;
|
|
}
|
|
|
|
uint64_t
|
|
SBValue::GetValueAsUnsigned(SBError& error, uint64_t fail_value)
|
|
{
|
|
error.Clear();
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetValueAsUnsigned() => error: process is running", value_sp.get());
|
|
error.SetErrorString("process is running");
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
Scalar scalar;
|
|
if (value_sp->ResolveValue (scalar))
|
|
return scalar.ULongLong(fail_value);
|
|
else
|
|
error.SetErrorString("could not get value");
|
|
}
|
|
else
|
|
error.SetErrorString("could not get target");
|
|
}
|
|
}
|
|
error.SetErrorString("invalid SBValue");
|
|
return fail_value;
|
|
}
|
|
|
|
int64_t
|
|
SBValue::GetValueAsSigned(int64_t fail_value)
|
|
{
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetValueAsSigned() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
Scalar scalar;
|
|
if (value_sp->ResolveValue (scalar))
|
|
return scalar.SLongLong(fail_value);
|
|
}
|
|
}
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
uint64_t
|
|
SBValue::GetValueAsUnsigned(uint64_t fail_value)
|
|
{
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetValueAsUnsigned() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
Scalar scalar;
|
|
if (value_sp->ResolveValue (scalar))
|
|
return scalar.ULongLong(fail_value);
|
|
}
|
|
}
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
bool
|
|
SBValue::MightHaveChildren ()
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
bool has_children = false;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
has_children = value_sp->MightHaveChildren();
|
|
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::MightHaveChildren() => %i", value_sp.get(), has_children);
|
|
return has_children;
|
|
}
|
|
|
|
uint32_t
|
|
SBValue::GetNumChildren ()
|
|
{
|
|
uint32_t num_children = 0;
|
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetNumChildren() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
|
|
num_children = value_sp->GetNumChildren();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetNumChildren () => %u", value_sp.get(), num_children);
|
|
|
|
return num_children;
|
|
}
|
|
|
|
|
|
SBValue
|
|
SBValue::Dereference ()
|
|
{
|
|
SBValue sb_value;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
|
|
Error error;
|
|
sb_value = value_sp->Dereference (error);
|
|
}
|
|
}
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::Dereference () => SBValue(%p)", value_sp.get(), value_sp.get());
|
|
|
|
return sb_value;
|
|
}
|
|
|
|
bool
|
|
SBValue::TypeIsPointerType ()
|
|
{
|
|
bool is_ptr_type = false;
|
|
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
|
|
is_ptr_type = value_sp->IsPointerType();
|
|
}
|
|
}
|
|
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::TypeIsPointerType () => %i", value_sp.get(), is_ptr_type);
|
|
|
|
|
|
return is_ptr_type;
|
|
}
|
|
|
|
void *
|
|
SBValue::GetOpaqueType()
|
|
{
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
TargetSP target_sp(value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
|
|
return value_sp->GetClangType();
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
lldb::SBTarget
|
|
SBValue::GetTarget()
|
|
{
|
|
SBTarget sb_target;
|
|
TargetSP target_sp;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
target_sp = value_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", value_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetTarget () => %p", value_sp.get(), target_sp.get());
|
|
}
|
|
return sb_target;
|
|
}
|
|
|
|
lldb::SBProcess
|
|
SBValue::GetProcess()
|
|
{
|
|
SBProcess sb_process;
|
|
ProcessSP process_sp;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
process_sp = value_sp->GetProcessSP();
|
|
if (process_sp)
|
|
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", value_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetProcess () => %p", value_sp.get(), process_sp.get());
|
|
}
|
|
return sb_process;
|
|
}
|
|
|
|
lldb::SBThread
|
|
SBValue::GetThread()
|
|
{
|
|
SBThread sb_thread;
|
|
ThreadSP thread_sp;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
thread_sp = value_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", value_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetThread () => %p", value_sp.get(), thread_sp.get());
|
|
}
|
|
return sb_thread;
|
|
}
|
|
|
|
lldb::SBFrame
|
|
SBValue::GetFrame()
|
|
{
|
|
SBFrame sb_frame;
|
|
StackFrameSP frame_sp;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
frame_sp = value_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", value_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetFrame () => %p", value_sp.get(), frame_sp.get());
|
|
}
|
|
return sb_frame;
|
|
}
|
|
|
|
|
|
lldb::ValueObjectSP
|
|
SBValue::GetSP () const
|
|
{
|
|
if (!m_opaque_sp || !m_opaque_sp->IsValid())
|
|
return ValueObjectSP();
|
|
return m_opaque_sp->GetSP();
|
|
}
|
|
|
|
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));
|
|
}
|
|
|
|
bool
|
|
SBValue::GetExpressionPath (SBStream &description)
|
|
{
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
value_sp->GetExpressionPath (description.ref(), false);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SBValue::GetExpressionPath (SBStream &description, bool qualify_cxx_base_classes)
|
|
{
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
value_sp->GetExpressionPath (description.ref(), qualify_cxx_base_classes);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SBValue::GetDescription (SBStream &description)
|
|
{
|
|
Stream &strm = description.ref();
|
|
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetDescription() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
ValueObject::DumpValueObject (strm, value_sp.get());
|
|
}
|
|
}
|
|
else
|
|
strm.PutCString ("No value");
|
|
|
|
return true;
|
|
}
|
|
|
|
lldb::Format
|
|
SBValue::GetFormat ()
|
|
{
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
return value_sp->GetFormat();
|
|
return eFormatDefault;
|
|
}
|
|
|
|
void
|
|
SBValue::SetFormat (lldb::Format format)
|
|
{
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
value_sp->SetFormat(format);
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::AddressOf()
|
|
{
|
|
SBValue sb_value;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
TargetSP target_sp (value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
Error 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)", value_sp.get(), value_sp.get());
|
|
|
|
return sb_value;
|
|
}
|
|
|
|
lldb::addr_t
|
|
SBValue::GetLoadAddress()
|
|
{
|
|
lldb::addr_t value = LLDB_INVALID_ADDRESS;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
TargetSP target_sp (value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
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());
|
|
}
|
|
}
|
|
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 ")", value_sp.get(), value);
|
|
|
|
return value;
|
|
}
|
|
|
|
lldb::SBAddress
|
|
SBValue::GetAddress()
|
|
{
|
|
Address addr;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
TargetSP target_sp (value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
lldb::addr_t value = LLDB_INVALID_ADDRESS;
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
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 ")", 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;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetPointeeData() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp (value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
DataExtractorSP data_sp(new DataExtractor());
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
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)",
|
|
value_sp.get(),
|
|
item_idx,
|
|
item_count,
|
|
sb_data.get());
|
|
|
|
return sb_data;
|
|
}
|
|
|
|
lldb::SBData
|
|
SBValue::GetData ()
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
lldb::SBData sb_data;
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
if (value_sp)
|
|
{
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetData() => error: process is running", value_sp.get());
|
|
}
|
|
else
|
|
{
|
|
TargetSP target_sp (value_sp->GetTargetSP());
|
|
if (target_sp)
|
|
{
|
|
Mutex::Locker api_locker (target_sp->GetAPIMutex());
|
|
DataExtractorSP data_sp(new DataExtractor());
|
|
value_sp->GetData(*data_sp);
|
|
if (data_sp->GetByteSize() > 0)
|
|
*sb_data = data_sp;
|
|
}
|
|
}
|
|
}
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetData () => SBData(%p)",
|
|
value_sp.get(),
|
|
sb_data.get());
|
|
|
|
return sb_data;
|
|
}
|
|
|
|
lldb::SBDeclaration
|
|
SBValue::GetDeclaration ()
|
|
{
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
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.
|
|
lldb::ValueObjectSP value_sp(GetSP());
|
|
TargetSP target_sp (GetTarget().GetSP());
|
|
if (value_sp && target_sp)
|
|
{
|
|
// Can't watch this if the process is running
|
|
ProcessSP process_sp(value_sp->GetProcessSP());
|
|
Process::StopLocker stop_locker;
|
|
if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock()))
|
|
{
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::Watch() => error: process is running", value_sp.get());
|
|
return sb_watchpoint;
|
|
}
|
|
|
|
// 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;
|
|
|
|
Error rc;
|
|
ClangASTType type (value_sp->GetClangAST(), value_sp->GetClangType());
|
|
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());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return sb_watchpoint;
|
|
}
|
|
|
|
// 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;
|
|
}
|