b9556acc9e
frames might go away (the object itself, not the actual logical frame) when
we are single stepping due to the way we currently sometimes end up flushing
frames when stepping in/out/over. They later will come back to life
represented by another object yet they have the same StackID. Now when you get
a lldb::SBFrame object, it will track the frame it is initialized with until
the thread goes away or the StackID no longer exists in the stack for the
thread it was created on. It uses a weak_ptr to both the frame and thread and
also stores the StackID. These three items allow us to determine when the
stack frame object has gone away (the weak_ptr will be NULL) and allows us to
find the correct frame again. In our test suite we had such cases where we
were just getting lucky when something like this happened:
1 - stop at breakpoint
2 - get first frame in thread where we stopped
3 - run an expression that causes the program to JIT and run code
4 - run more expressions on the frame from step 2 which was very very luckily
still around inside a shared pointer, yet, not part of the current
thread (a new stack frame object had appeared with the same stack ID and
depth).
We now avoid all such issues and properly keep up to date, or we start
returning errors when the frame doesn't exist and always responds with
invalid answers.
Also fixed the UserSettingsController (not going to rewrite this just yet)
so that it doesn't crash on shutdown. Using weak_ptr's came in real handy to
track when the master controller has already gone away and this allowed me to
pull out the previous NotifyOwnerIsShuttingDown() patch as it is no longer
needed.
llvm-svn: 149231
1247 lines
37 KiB
C++
1247 lines
37 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/API/SBValue.h"
|
|
#include "lldb/API/SBStream.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/Stream.h"
|
|
#include "lldb/Core/StreamFile.h"
|
|
#include "lldb/Core/Value.h"
|
|
#include "lldb/Core/ValueObject.h"
|
|
#include "lldb/Core/ValueObjectConstResult.h"
|
|
#include "lldb/Symbol/Block.h"
|
|
#include "lldb/Symbol/ObjectFile.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/SBProcess.h"
|
|
#include "lldb/API/SBTarget.h"
|
|
#include "lldb/API/SBThread.h"
|
|
#include "lldb/API/SBFrame.h"
|
|
#include "lldb/API/SBDebugger.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
SBValue::SBValue () :
|
|
m_opaque_sp ()
|
|
{
|
|
}
|
|
|
|
SBValue::SBValue (const lldb::ValueObjectSP &value_sp) :
|
|
m_opaque_sp (value_sp)
|
|
{
|
|
}
|
|
|
|
SBValue::SBValue(const SBValue &rhs) :
|
|
m_opaque_sp (rhs.m_opaque_sp)
|
|
{
|
|
}
|
|
|
|
SBValue &
|
|
SBValue::operator = (const SBValue &rhs)
|
|
{
|
|
if (this != &rhs)
|
|
m_opaque_sp = 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;
|
|
}
|
|
|
|
void
|
|
SBValue::Clear()
|
|
{
|
|
m_opaque_sp.reset();
|
|
}
|
|
|
|
SBError
|
|
SBValue::GetError()
|
|
{
|
|
SBError sb_error;
|
|
|
|
if (m_opaque_sp.get())
|
|
sb_error.SetError(m_opaque_sp->GetError());
|
|
else
|
|
sb_error.SetErrorString("error: invalid value");
|
|
|
|
return sb_error;
|
|
}
|
|
|
|
user_id_t
|
|
SBValue::GetID()
|
|
{
|
|
if (m_opaque_sp)
|
|
return m_opaque_sp->GetID();
|
|
return LLDB_INVALID_UID;
|
|
}
|
|
|
|
const char *
|
|
SBValue::GetName()
|
|
{
|
|
|
|
const char *name = NULL;
|
|
if (m_opaque_sp)
|
|
name = m_opaque_sp->GetName().GetCString();
|
|
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (name)
|
|
log->Printf ("SBValue(%p)::GetName () => \"%s\"", m_opaque_sp.get(), name);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetName () => NULL", m_opaque_sp.get());
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
const char *
|
|
SBValue::GetTypeName ()
|
|
{
|
|
const char *name = NULL;
|
|
if (m_opaque_sp)
|
|
name = m_opaque_sp->GetTypeName().GetCString();
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (name)
|
|
log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"", m_opaque_sp.get(), name);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetTypeName () => NULL", m_opaque_sp.get());
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
size_t
|
|
SBValue::GetByteSize ()
|
|
{
|
|
size_t result = 0;
|
|
|
|
if (m_opaque_sp)
|
|
result = m_opaque_sp->GetByteSize();
|
|
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetByteSize () => %zu", m_opaque_sp.get(), result);
|
|
|
|
return result;
|
|
}
|
|
|
|
bool
|
|
SBValue::IsInScope ()
|
|
{
|
|
bool result = false;
|
|
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
result = m_opaque_sp->IsInScope ();
|
|
}
|
|
}
|
|
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::IsInScope () => %i", m_opaque_sp.get(), result);
|
|
|
|
return result;
|
|
}
|
|
|
|
const char *
|
|
SBValue::GetValue ()
|
|
{
|
|
const char *cstr = NULL;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
cstr = m_opaque_sp->GetValueAsCString ();
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (cstr)
|
|
log->Printf ("SBValue(%p)::GetValue => \"%s\"", m_opaque_sp.get(), cstr);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetValue => NULL", m_opaque_sp.get());
|
|
}
|
|
|
|
return cstr;
|
|
}
|
|
|
|
ValueType
|
|
SBValue::GetValueType ()
|
|
{
|
|
ValueType result = eValueTypeInvalid;
|
|
if (m_opaque_sp)
|
|
result = m_opaque_sp->GetValueType();
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
switch (result)
|
|
{
|
|
case eValueTypeInvalid: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeInvalid", m_opaque_sp.get()); break;
|
|
case eValueTypeVariableGlobal: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal", m_opaque_sp.get()); break;
|
|
case eValueTypeVariableStatic: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableStatic", m_opaque_sp.get()); break;
|
|
case eValueTypeVariableArgument:log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableArgument", m_opaque_sp.get()); break;
|
|
case eValueTypeVariableLocal: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableLocal", m_opaque_sp.get()); break;
|
|
case eValueTypeRegister: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegister", m_opaque_sp.get()); break;
|
|
case eValueTypeRegisterSet: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegisterSet", m_opaque_sp.get()); break;
|
|
case eValueTypeConstResult: log->Printf ("SBValue(%p)::GetValueType () => eValueTypeConstResult", m_opaque_sp.get()); break;
|
|
default: log->Printf ("SBValue(%p)::GetValueType () => %i ???", m_opaque_sp.get(), result); break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const char *
|
|
SBValue::GetObjectDescription ()
|
|
{
|
|
const char *cstr = NULL;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
cstr = m_opaque_sp->GetObjectDescription ();
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (cstr)
|
|
log->Printf ("SBValue(%p)::GetObjectDescription => \"%s\"", m_opaque_sp.get(), cstr);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetObjectDescription => NULL", m_opaque_sp.get());
|
|
}
|
|
return cstr;
|
|
}
|
|
|
|
SBType
|
|
SBValue::GetType()
|
|
{
|
|
SBType result;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
result = SBType(ClangASTType (m_opaque_sp->GetClangAST(), m_opaque_sp->GetClangType()));
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (result.IsValid())
|
|
log->Printf ("SBValue(%p)::GetType => %p", m_opaque_sp.get(), &result);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetType => NULL", m_opaque_sp.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
bool
|
|
SBValue::GetValueDidChange ()
|
|
{
|
|
bool result = false;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
result = m_opaque_sp->GetValueDidChange ();
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetValueDidChange => %i", m_opaque_sp.get(), result);
|
|
|
|
return result;
|
|
}
|
|
|
|
const char *
|
|
SBValue::GetSummary ()
|
|
{
|
|
const char *cstr = NULL;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
cstr = m_opaque_sp->GetSummaryAsCString();
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (cstr)
|
|
log->Printf ("SBValue(%p)::GetSummary => \"%s\"", m_opaque_sp.get(), cstr);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetSummary => NULL", m_opaque_sp.get());
|
|
}
|
|
return cstr;
|
|
}
|
|
|
|
const char *
|
|
SBValue::GetLocation ()
|
|
{
|
|
const char *cstr = NULL;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
cstr = m_opaque_sp->GetLocationAsCString();
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (cstr)
|
|
log->Printf ("SBValue(%p)::GetSummary => \"%s\"", m_opaque_sp.get(), cstr);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetSummary => NULL", m_opaque_sp.get());
|
|
}
|
|
return cstr;
|
|
}
|
|
|
|
bool
|
|
SBValue::SetValueFromCString (const char *value_str)
|
|
{
|
|
bool success = false;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
success = m_opaque_sp->SetValueFromCString (value_str);
|
|
}
|
|
}
|
|
return success;
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::CreateChildAtOffset (const char *name, uint32_t offset, SBType type)
|
|
{
|
|
lldb::SBValue result;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (type.IsValid())
|
|
{
|
|
result = SBValue(m_opaque_sp->GetSyntheticChildAtOffset(offset, type.m_opaque_sp->GetClangASTType(), true));
|
|
result.m_opaque_sp->SetName(ConstString(name));
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (result.IsValid())
|
|
log->Printf ("SBValue(%p)::GetChildAtOffset => \"%s\"", m_opaque_sp.get(), result.m_opaque_sp->GetName().AsCString());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetChildAtOffset => NULL", m_opaque_sp.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::Cast (SBType type)
|
|
{
|
|
return CreateChildAtOffset(m_opaque_sp->GetName().GetCString(), 0, type);
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::CreateValueFromExpression (const char *name, const char* expression)
|
|
{
|
|
lldb::SBValue result;
|
|
if (m_opaque_sp)
|
|
{
|
|
ValueObjectSP result_valobj_sp;
|
|
m_opaque_sp->GetUpdatePoint().GetTargetSP()->EvaluateExpression (expression,
|
|
m_opaque_sp->GetExecutionContextScope()->CalculateStackFrame(),
|
|
eExecutionPolicyOnlyWhenNeeded,
|
|
false, // coerce to id
|
|
true, // unwind on error
|
|
true, // keep in memory
|
|
eNoDynamicValues,
|
|
result_valobj_sp);
|
|
if (result_valobj_sp)
|
|
{
|
|
result_valobj_sp->SetName(ConstString(name));
|
|
result = SBValue(result_valobj_sp);
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (result.IsValid())
|
|
log->Printf ("SBValue(%p)::GetChildFromExpression => \"%s\"", m_opaque_sp.get(), result.m_opaque_sp->GetName().AsCString());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetChildFromExpression => NULL", m_opaque_sp.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, SBType type)
|
|
{
|
|
lldb::SBValue result;
|
|
if (m_opaque_sp && type.IsValid() && type.GetPointerType().IsValid())
|
|
{
|
|
SBType real_type(type.GetPointerType());
|
|
|
|
lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t)));
|
|
|
|
ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (m_opaque_sp->GetExecutionContextScope(),
|
|
real_type.m_opaque_sp->GetASTContext(),
|
|
real_type.m_opaque_sp->GetOpaqueQualType(),
|
|
ConstString(name),
|
|
buffer,
|
|
lldb::endian::InlHostByteOrder(),
|
|
GetTarget().GetProcess().GetAddressByteSize()));
|
|
|
|
ValueObjectSP result_valobj_sp;
|
|
|
|
ptr_result_valobj_sp->GetValue().SetValueType(Value::eValueTypeLoadAddress);
|
|
if (ptr_result_valobj_sp)
|
|
{
|
|
Error err;
|
|
result_valobj_sp = ptr_result_valobj_sp->Dereference(err);
|
|
if (result_valobj_sp)
|
|
result_valobj_sp->SetName(ConstString(name));
|
|
}
|
|
result = SBValue(result_valobj_sp);
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (result.IsValid())
|
|
log->Printf ("SBValue(%p)::GetChildFromAddress => \"%s\"", m_opaque_sp.get(), result.m_opaque_sp->GetName().AsCString());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetChildFromAddress => NULL", m_opaque_sp.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::CreateValueFromData (const char* name, SBData data, SBType type)
|
|
{
|
|
SBValue result;
|
|
|
|
AddressType addr_of_children_priv = eAddressTypeLoad;
|
|
|
|
if (m_opaque_sp)
|
|
{
|
|
ValueObjectSP valobj_sp;
|
|
valobj_sp = ValueObjectConstResult::Create (m_opaque_sp->GetExecutionContextScope(),
|
|
type.m_opaque_sp->GetASTContext() ,
|
|
type.m_opaque_sp->GetOpaqueQualType(),
|
|
ConstString(name),
|
|
*data.m_opaque_sp,
|
|
LLDB_INVALID_ADDRESS);
|
|
valobj_sp->SetAddressTypeOfChildren(addr_of_children_priv);
|
|
result = SBValue(valobj_sp);
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (result.IsValid())
|
|
log->Printf ("SBValue(%p)::GetChildFromExpression => \"%s\"", m_opaque_sp.get(), result.m_opaque_sp->GetName().AsCString());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetChildFromExpression => NULL", m_opaque_sp.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
SBValue
|
|
SBValue::GetChildAtIndex (uint32_t idx)
|
|
{
|
|
const bool can_create_synthetic = false;
|
|
lldb::DynamicValueType use_dynamic = eNoDynamicValues;
|
|
if (m_opaque_sp)
|
|
use_dynamic = m_opaque_sp->GetUpdatePoint().GetTargetSP()->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;
|
|
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
const bool can_create = true;
|
|
child_sp = m_opaque_sp->GetChildAtIndex (idx, can_create);
|
|
if (can_create_synthetic && !child_sp)
|
|
{
|
|
if (m_opaque_sp->IsPointerType())
|
|
{
|
|
child_sp = m_opaque_sp->GetSyntheticArrayMemberFromPointer(idx, can_create);
|
|
}
|
|
else if (m_opaque_sp->IsArrayType())
|
|
{
|
|
child_sp = m_opaque_sp->GetSyntheticArrayMemberFromArray(idx, can_create);
|
|
}
|
|
}
|
|
|
|
if (child_sp)
|
|
{
|
|
if (use_dynamic != lldb::eNoDynamicValues)
|
|
{
|
|
lldb::ValueObjectSP dynamic_sp(child_sp->GetDynamicValue (use_dynamic));
|
|
if (dynamic_sp)
|
|
child_sp = dynamic_sp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SBValue sb_value (child_sp);
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)", m_opaque_sp.get(), idx, sb_value.get());
|
|
|
|
return sb_value;
|
|
}
|
|
|
|
uint32_t
|
|
SBValue::GetIndexOfChildWithName (const char *name)
|
|
{
|
|
uint32_t idx = UINT32_MAX;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
|
|
idx = m_opaque_sp->GetIndexOfChildWithName (ConstString(name));
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (idx == UINT32_MAX)
|
|
log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND", m_opaque_sp.get(), name);
|
|
else
|
|
log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u", m_opaque_sp.get(), name, idx);
|
|
}
|
|
return idx;
|
|
}
|
|
|
|
SBValue
|
|
SBValue::GetChildMemberWithName (const char *name)
|
|
{
|
|
if (m_opaque_sp)
|
|
{
|
|
lldb::DynamicValueType use_dynamic_value = m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetPreferDynamicValue();
|
|
return GetChildMemberWithName (name, use_dynamic_value);
|
|
}
|
|
else
|
|
return GetChildMemberWithName (name, eNoDynamicValues);
|
|
}
|
|
|
|
SBValue
|
|
SBValue::GetChildMemberWithName (const char *name, lldb::DynamicValueType use_dynamic_value)
|
|
{
|
|
lldb::ValueObjectSP child_sp;
|
|
const ConstString str_name (name);
|
|
|
|
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
child_sp = m_opaque_sp->GetChildMemberWithName (str_name, true);
|
|
if (use_dynamic_value != lldb::eNoDynamicValues)
|
|
{
|
|
if (child_sp)
|
|
{
|
|
lldb::ValueObjectSP dynamic_sp = child_sp->GetDynamicValue (use_dynamic_value);
|
|
if (dynamic_sp)
|
|
child_sp = dynamic_sp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SBValue sb_value (child_sp);
|
|
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)", m_opaque_sp.get(), name, sb_value.get());
|
|
|
|
return sb_value;
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::GetDynamicValue (lldb::DynamicValueType use_dynamic)
|
|
{
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
return SBValue (m_opaque_sp->GetDynamicValue(use_dynamic));
|
|
}
|
|
}
|
|
|
|
return SBValue();
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::GetStaticValue ()
|
|
{
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
return SBValue(m_opaque_sp->GetStaticValue());
|
|
}
|
|
}
|
|
|
|
return SBValue();
|
|
}
|
|
|
|
bool
|
|
SBValue::IsDynamic()
|
|
{
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
return m_opaque_sp->IsDynamic();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::GetValueForExpressionPath(const char* expr_path)
|
|
{
|
|
lldb::ValueObjectSP child_sp;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
// using default values for all the fancy options, just do it if you can
|
|
child_sp = m_opaque_sp->GetValueForExpressionPath(expr_path);
|
|
}
|
|
}
|
|
|
|
SBValue sb_value (child_sp);
|
|
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => SBValue(%p)", m_opaque_sp.get(), expr_path, sb_value.get());
|
|
|
|
return sb_value;
|
|
}
|
|
|
|
int64_t
|
|
SBValue::GetValueAsSigned(SBError& error, int64_t fail_value)
|
|
{
|
|
error.Clear();
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
Scalar scalar;
|
|
if (m_opaque_sp->ResolveValue (scalar))
|
|
return scalar.GetRawBits64(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();
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
Scalar scalar;
|
|
if (m_opaque_sp->ResolveValue (scalar))
|
|
return scalar.GetRawBits64(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)
|
|
{
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
Scalar scalar;
|
|
if (m_opaque_sp->ResolveValue (scalar))
|
|
return scalar.GetRawBits64(fail_value);
|
|
}
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
uint64_t
|
|
SBValue::GetValueAsUnsigned(uint64_t fail_value)
|
|
{
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
Scalar scalar;
|
|
if (m_opaque_sp->ResolveValue (scalar))
|
|
return scalar.GetRawBits64(fail_value);
|
|
}
|
|
}
|
|
return fail_value;
|
|
}
|
|
|
|
uint32_t
|
|
SBValue::GetNumChildren ()
|
|
{
|
|
uint32_t num_children = 0;
|
|
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
|
|
num_children = m_opaque_sp->GetNumChildren();
|
|
}
|
|
}
|
|
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetNumChildren () => %u", m_opaque_sp.get(), num_children);
|
|
|
|
return num_children;
|
|
}
|
|
|
|
|
|
SBValue
|
|
SBValue::Dereference ()
|
|
{
|
|
SBValue sb_value;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
|
|
Error error;
|
|
sb_value = m_opaque_sp->Dereference (error);
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::Dereference () => SBValue(%p)", m_opaque_sp.get(), sb_value.get());
|
|
|
|
return sb_value;
|
|
}
|
|
|
|
bool
|
|
SBValue::TypeIsPointerType ()
|
|
{
|
|
bool is_ptr_type = false;
|
|
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
|
|
is_ptr_type = m_opaque_sp->IsPointerType();
|
|
}
|
|
}
|
|
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::TypeIsPointerType () => %i", m_opaque_sp.get(), is_ptr_type);
|
|
|
|
|
|
return is_ptr_type;
|
|
}
|
|
|
|
void *
|
|
SBValue::GetOpaqueType()
|
|
{
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetAPIMutex());
|
|
|
|
return m_opaque_sp->GetClangType();
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
lldb::SBTarget
|
|
SBValue::GetTarget()
|
|
{
|
|
SBTarget sb_target;
|
|
TargetSP target_sp;
|
|
if (m_opaque_sp)
|
|
{
|
|
target_sp = m_opaque_sp->GetUpdatePoint().GetTargetSP();
|
|
sb_target.SetSP (target_sp);
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (target_sp.get() == NULL)
|
|
log->Printf ("SBValue(%p)::GetTarget () => NULL", m_opaque_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetTarget () => %p", m_opaque_sp.get(), 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->GetUpdatePoint().GetProcessSP();
|
|
if (process_sp)
|
|
sb_process.SetSP (process_sp);
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (process_sp.get() == NULL)
|
|
log->Printf ("SBValue(%p)::GetProcess () => NULL", m_opaque_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetProcess () => %p", m_opaque_sp.get(), process_sp.get());
|
|
}
|
|
return sb_process;
|
|
}
|
|
|
|
lldb::SBThread
|
|
SBValue::GetThread()
|
|
{
|
|
SBThread sb_thread;
|
|
ThreadSP thread_sp;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetExecutionContextScope())
|
|
{
|
|
thread_sp = m_opaque_sp->GetExecutionContextScope()->CalculateThread()->shared_from_this();
|
|
sb_thread.SetThread(thread_sp);
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (thread_sp.get() == NULL)
|
|
log->Printf ("SBValue(%p)::GetThread () => NULL", m_opaque_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetThread () => %p", m_opaque_sp.get(), thread_sp.get());
|
|
}
|
|
return sb_thread;
|
|
}
|
|
|
|
lldb::SBFrame
|
|
SBValue::GetFrame()
|
|
{
|
|
SBFrame sb_frame;
|
|
StackFrameSP frame_sp;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetExecutionContextScope())
|
|
{
|
|
frame_sp = m_opaque_sp->GetExecutionContextScope()->CalculateStackFrame()->shared_from_this();
|
|
sb_frame.SetFrameSP (frame_sp);
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (frame_sp.get() == NULL)
|
|
log->Printf ("SBValue(%p)::GetFrame () => NULL", m_opaque_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetFrame () => %p", m_opaque_sp.get(), frame_sp.get());
|
|
}
|
|
return sb_frame;
|
|
}
|
|
|
|
|
|
// Mimic shared pointer...
|
|
lldb_private::ValueObject *
|
|
SBValue::get() const
|
|
{
|
|
return m_opaque_sp.get();
|
|
}
|
|
|
|
lldb_private::ValueObject *
|
|
SBValue::operator->() const
|
|
{
|
|
return m_opaque_sp.get();
|
|
}
|
|
|
|
lldb::ValueObjectSP &
|
|
SBValue::operator*()
|
|
{
|
|
return m_opaque_sp;
|
|
}
|
|
|
|
const lldb::ValueObjectSP &
|
|
SBValue::operator*() const
|
|
{
|
|
return m_opaque_sp;
|
|
}
|
|
|
|
bool
|
|
SBValue::GetExpressionPath (SBStream &description)
|
|
{
|
|
if (m_opaque_sp)
|
|
{
|
|
m_opaque_sp->GetExpressionPath (description.ref(), false);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SBValue::GetExpressionPath (SBStream &description, bool qualify_cxx_base_classes)
|
|
{
|
|
if (m_opaque_sp)
|
|
{
|
|
m_opaque_sp->GetExpressionPath (description.ref(), qualify_cxx_base_classes);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
SBValue::GetDescription (SBStream &description)
|
|
{
|
|
Stream &strm = description.ref();
|
|
|
|
if (m_opaque_sp)
|
|
{
|
|
ValueObject::DumpValueObject (strm, m_opaque_sp.get());
|
|
}
|
|
else
|
|
strm.PutCString ("No value");
|
|
|
|
return true;
|
|
}
|
|
|
|
lldb::Format
|
|
SBValue::GetFormat ()
|
|
{
|
|
if (m_opaque_sp)
|
|
return m_opaque_sp->GetFormat();
|
|
return eFormatDefault;
|
|
}
|
|
|
|
void
|
|
SBValue::SetFormat (lldb::Format format)
|
|
{
|
|
if (m_opaque_sp)
|
|
m_opaque_sp->SetFormat(format);
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::AddressOf()
|
|
{
|
|
SBValue sb_value;
|
|
if (m_opaque_sp)
|
|
{
|
|
Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get();
|
|
if (target)
|
|
{
|
|
Mutex::Locker api_locker (target->GetAPIMutex());
|
|
Error error;
|
|
sb_value = m_opaque_sp->AddressOf (error);
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetPointerToObject () => SBValue(%p)", m_opaque_sp.get(), sb_value.get());
|
|
|
|
return sb_value;
|
|
}
|
|
|
|
lldb::addr_t
|
|
SBValue::GetLoadAddress()
|
|
{
|
|
lldb::addr_t value = LLDB_INVALID_ADDRESS;
|
|
if (m_opaque_sp)
|
|
{
|
|
Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get();
|
|
if (target)
|
|
{
|
|
Mutex::Locker api_locker (target->GetAPIMutex());
|
|
const bool scalar_is_load_address = true;
|
|
AddressType addr_type;
|
|
value = m_opaque_sp->GetAddressOf(scalar_is_load_address, &addr_type);
|
|
if (addr_type == eAddressTypeFile)
|
|
{
|
|
Module* module = m_opaque_sp->GetModule();
|
|
if (!module)
|
|
value = LLDB_INVALID_ADDRESS;
|
|
else
|
|
{
|
|
Address addr;
|
|
module->ResolveFileAddress(value, addr);
|
|
value = addr.GetLoadAddress(m_opaque_sp->GetUpdatePoint().GetTargetSP().get());
|
|
}
|
|
}
|
|
else if (addr_type == eAddressTypeHost || addr_type == eAddressTypeInvalid)
|
|
value = LLDB_INVALID_ADDRESS;
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetLoadAddress () => (%llu)", m_opaque_sp.get(), value);
|
|
|
|
return value;
|
|
}
|
|
|
|
lldb::SBAddress
|
|
SBValue::GetAddress()
|
|
{
|
|
Address addr;
|
|
if (m_opaque_sp)
|
|
{
|
|
Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get();
|
|
if (target)
|
|
{
|
|
lldb::addr_t value = LLDB_INVALID_ADDRESS;
|
|
Mutex::Locker api_locker (target->GetAPIMutex());
|
|
const bool scalar_is_load_address = true;
|
|
AddressType addr_type;
|
|
value = m_opaque_sp->GetAddressOf(scalar_is_load_address, &addr_type);
|
|
if (addr_type == eAddressTypeFile)
|
|
{
|
|
Module* module = m_opaque_sp->GetModule();
|
|
if (module)
|
|
module->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);
|
|
}
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetAddress () => (%s,%llu)", m_opaque_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)
|
|
{
|
|
lldb::SBData sb_data;
|
|
if (m_opaque_sp)
|
|
{
|
|
Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get();
|
|
if (target)
|
|
{
|
|
DataExtractorSP data_sp(new DataExtractor());
|
|
Mutex::Locker api_locker (target->GetAPIMutex());
|
|
m_opaque_sp->GetPointeeData(*data_sp, item_idx, item_count);
|
|
if (data_sp->GetByteSize() > 0)
|
|
*sb_data = data_sp;
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)",
|
|
m_opaque_sp.get(),
|
|
item_idx,
|
|
item_count,
|
|
sb_data.get());
|
|
|
|
return sb_data;
|
|
}
|
|
|
|
lldb::SBData
|
|
SBValue::GetData ()
|
|
{
|
|
lldb::SBData sb_data;
|
|
if (m_opaque_sp)
|
|
{
|
|
Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get();
|
|
if (target)
|
|
{
|
|
DataExtractorSP data_sp(new DataExtractor());
|
|
Mutex::Locker api_locker (target->GetAPIMutex());
|
|
m_opaque_sp->GetData(*data_sp);
|
|
if (data_sp->GetByteSize() > 0)
|
|
*sb_data = data_sp;
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::GetData () => SBData(%p)",
|
|
m_opaque_sp.get(),
|
|
sb_data.get());
|
|
|
|
return sb_data;
|
|
}
|
|
|
|
lldb::SBWatchpoint
|
|
SBValue::Watch (bool resolve_location, bool read, bool write)
|
|
{
|
|
lldb::SBWatchpoint sb_watchpoint;
|
|
if (!m_opaque_sp)
|
|
return sb_watchpoint;
|
|
|
|
Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get();
|
|
if (target)
|
|
{
|
|
Mutex::Locker api_locker (target->GetAPIMutex());
|
|
sb_watchpoint = WatchValue(read, write, false);
|
|
}
|
|
LogSP log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::Watch (resolve_location=%i, read=%i, write=%i) => wp(%p)",
|
|
m_opaque_sp.get(), resolve_location, read, write, sb_watchpoint.get());
|
|
return sb_watchpoint;
|
|
}
|
|
|
|
lldb::SBWatchpoint
|
|
SBValue::WatchPointee (bool resolve_location, bool read, bool write)
|
|
{
|
|
lldb::SBWatchpoint sb_watchpoint;
|
|
if (!m_opaque_sp)
|
|
return sb_watchpoint;
|
|
|
|
Target* target = m_opaque_sp->GetUpdatePoint().GetTargetSP().get();
|
|
if (target)
|
|
{
|
|
Mutex::Locker api_locker (target->GetAPIMutex());
|
|
sb_watchpoint = WatchValue(read, write, true);
|
|
}
|
|
LogSP log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
log->Printf ("SBValue(%p)::WatchPointee (resolve_location=%i, read=%i, write=%i) => wp(%p)",
|
|
m_opaque_sp.get(), resolve_location, read, write, sb_watchpoint.get());
|
|
return sb_watchpoint;
|
|
}
|
|
|
|
// Helper function for SBValue::Watch() and SBValue::WatchPointee().
|
|
SBWatchpoint
|
|
SBValue::WatchValue(bool read, bool write, bool watch_pointee)
|
|
{
|
|
SBWatchpoint sb_wp_empty;
|
|
|
|
// If the SBValue is not valid, there's no point in even trying to watch it.
|
|
if (!IsValid())
|
|
return sb_wp_empty;
|
|
|
|
// Read and Write cannot both be false.
|
|
if (!read && !write)
|
|
return sb_wp_empty;
|
|
|
|
// If we are watching the pointee, check that the SBValue is a pointer type.
|
|
if (watch_pointee && !GetType().IsPointerType())
|
|
return sb_wp_empty;
|
|
|
|
TargetSP target_sp (GetTarget().GetSP());
|
|
if (!target_sp)
|
|
return sb_wp_empty;
|
|
|
|
StackFrameSP frame_sp (GetFrame().GetFrameSP());
|
|
if (!frame_sp)
|
|
return sb_wp_empty;
|
|
|
|
addr_t addr;
|
|
size_t size;
|
|
if (watch_pointee) {
|
|
addr = GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
|
|
size = GetType().GetPointeeType().GetByteSize();
|
|
} else {
|
|
addr = GetLoadAddress();
|
|
size = GetByteSize();
|
|
}
|
|
|
|
// Sanity check the address and the size before calling Target::CreateWatchpoint().
|
|
if (addr == LLDB_INVALID_ADDRESS || size == 0)
|
|
return sb_wp_empty;
|
|
|
|
uint32_t watch_type = (read ? LLDB_WATCH_TYPE_READ : 0) |
|
|
(write ? LLDB_WATCH_TYPE_WRITE : 0);
|
|
WatchpointSP wp_sp = target_sp->CreateWatchpoint(addr, size, watch_type);
|
|
|
|
if (wp_sp) {
|
|
// StackFrame::GetInScopeVariableList(true) to get file globals as well.
|
|
VariableListSP var_list_sp(frame_sp->GetInScopeVariableList(true));
|
|
VariableSP var_sp = var_list_sp->FindVariable(ConstString(GetName()));
|
|
if (var_sp && var_sp->GetDeclaration().GetFile()) {
|
|
StreamString ss;
|
|
// True to show fullpath for declaration file.
|
|
var_sp->GetDeclaration().DumpStopContext(&ss, true);
|
|
wp_sp->SetDeclInfo(ss.GetString());
|
|
}
|
|
}
|
|
return wp_sp;
|
|
}
|
|
|