forked from OSchip/llvm-project
992 lines
28 KiB
C++
992 lines
28 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/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/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)
|
|
{
|
|
}
|
|
|
|
const SBValue &
|
|
SBValue::operator = (const SBValue &rhs)
|
|
{
|
|
if (this != &rhs)
|
|
m_opaque_sp = rhs.m_opaque_sp;
|
|
return *this;
|
|
}
|
|
|
|
SBValue::~SBValue()
|
|
{
|
|
}
|
|
|
|
bool
|
|
SBValue::IsValid () const
|
|
{
|
|
// 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;
|
|
}
|
|
|
|
SBError
|
|
SBValue::GetError()
|
|
{
|
|
SBError sb_error;
|
|
|
|
if (m_opaque_sp.get())
|
|
sb_error.SetError(m_opaque_sp->GetError());
|
|
|
|
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(), name);
|
|
}
|
|
|
|
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 (const SBFrame &sb_frame)
|
|
{
|
|
return IsInScope();
|
|
}
|
|
|
|
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 SBFrame &sb_frame)
|
|
{
|
|
return GetValue();
|
|
}
|
|
|
|
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 SBFrame &sb_frame)
|
|
{
|
|
return GetObjectDescription ();
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
bool
|
|
SBValue::GetValueDidChange (const SBFrame &sb_frame)
|
|
{
|
|
return GetValueDidChange ();
|
|
}
|
|
|
|
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 SBFrame &sb_frame)
|
|
{
|
|
return GetSummary ();
|
|
}
|
|
|
|
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 SBFrame &sb_frame)
|
|
{
|
|
return GetLocation ();
|
|
}
|
|
|
|
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 SBFrame &sb_frame, const char *value_str)
|
|
{
|
|
return SetValueFromCString (value_str);
|
|
}
|
|
|
|
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, const 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.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetChildAtOffset => NULL", m_opaque_sp.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::Cast(const 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->GetUpdatePoint().GetExecutionContextScope()->CalculateStackFrame(),
|
|
true, true, eNoDynamicValues,
|
|
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.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetChildFromExpression => NULL", m_opaque_sp.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
lldb::SBValue
|
|
SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, const SBType& type)
|
|
{
|
|
lldb::SBValue result;
|
|
if (m_opaque_sp)
|
|
{
|
|
|
|
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->GetUpdatePoint().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.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetChildFromAddress => 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, idx);
|
|
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::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)
|
|
{
|
|
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)
|
|
{
|
|
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 result;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
result = SBTarget(lldb::TargetSP(m_opaque_sp->GetUpdatePoint().GetTargetSP()));
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (result.get() == NULL)
|
|
log->Printf ("SBValue(%p)::GetTarget () => NULL", m_opaque_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetTarget () => %p", m_opaque_sp.get(), result.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
lldb::SBProcess
|
|
SBValue::GetProcess()
|
|
{
|
|
SBProcess result;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
result = SBProcess(lldb::ProcessSP(m_opaque_sp->GetUpdatePoint().GetTargetSP()->GetProcessSP()));
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (result.get() == NULL)
|
|
log->Printf ("SBValue(%p)::GetProcess () => NULL", m_opaque_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetProcess () => %p", m_opaque_sp.get(), result.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
lldb::SBThread
|
|
SBValue::GetThread()
|
|
{
|
|
SBThread result;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetExecutionContextScope())
|
|
{
|
|
result = SBThread(lldb::ThreadSP(m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateThread()));
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (result.get() == NULL)
|
|
log->Printf ("SBValue(%p)::GetThread () => NULL", m_opaque_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetThread () => %p", m_opaque_sp.get(), result.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
lldb::SBFrame
|
|
SBValue::GetFrame()
|
|
{
|
|
SBFrame result;
|
|
if (m_opaque_sp)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetExecutionContextScope())
|
|
{
|
|
result = SBFrame(lldb::StackFrameSP(m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateStackFrame()));
|
|
}
|
|
}
|
|
LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
|
|
if (log)
|
|
{
|
|
if (result.get() == NULL)
|
|
log->Printf ("SBValue(%p)::GetFrame () => NULL", m_opaque_sp.get());
|
|
else
|
|
log->Printf ("SBValue(%p)::GetFrame () => %p", m_opaque_sp.get(), result.get());
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
// 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)
|
|
{
|
|
if (m_opaque_sp)
|
|
{
|
|
uint32_t ptr_depth = 0;
|
|
uint32_t curr_depth = 0;
|
|
uint32_t max_depth = UINT32_MAX;
|
|
bool show_types = false;
|
|
bool show_location = false;
|
|
bool use_objc = false;
|
|
lldb::DynamicValueType use_dynamic = eNoDynamicValues;
|
|
bool scope_already_checked = false;
|
|
bool flat_output = false;
|
|
bool use_synthetic = true;
|
|
uint32_t no_summary_depth = 0;
|
|
ValueObject::DumpValueObject (description.ref(),
|
|
m_opaque_sp.get(),
|
|
m_opaque_sp->GetName().GetCString(),
|
|
ptr_depth,
|
|
curr_depth,
|
|
max_depth,
|
|
show_types, show_location,
|
|
use_objc,
|
|
use_dynamic,
|
|
use_synthetic,
|
|
scope_already_checked,
|
|
flat_output,
|
|
no_summary_depth);
|
|
}
|
|
else
|
|
description.Printf ("No value");
|
|
|
|
return true;
|
|
}
|
|
|
|
lldb::Format
|
|
SBValue::GetFormat () const
|
|
{
|
|
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)
|
|
{
|
|
if (m_opaque_sp->GetUpdatePoint().GetTargetSP())
|
|
{
|
|
Mutex::Locker api_locker (m_opaque_sp->GetUpdatePoint().GetTargetSP()->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;
|
|
}
|