mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-05-02 05:16:07 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/lldb/source/API/SBBlock.cpp
Enrico Granata e3e91517ff <rdar://problem/12437442> 
Given our implementation of ValueObjects we could have a scenario where a ValueObject has a dynamic type of Foo* at one point, and then its dynamic type changes to Bar*
If Bar* has synthetic children enabled, by the time we figure that out, our public API is already vending SBValues wrapping a DynamicVO, instead of a SyntheticVO and there was
no trivial way for us to change the SP inside an SBValue on the fly
This checkin reimplements SBValue in terms of a wrapper, ValueImpl, that allows this substitutions on-the-fly by overriding GetSP() to do The Right Thing (TM)
As an additional bonus, GetNonSyntheticValue() now works, and we can get rid of the ForceDisableSyntheticChildren idiom in ScriptInterpreterPython
Lastly, this checkin makes sure the synthetic VOs get the correct m_value and m_data from their parents (prevented summaries from working in some cases)

llvm-svn: 166426
2012-10-22 18:18:36 +00:00

374 lines
9.6 KiB
C++
Raw Blame History

//===-- SBBlock.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/SBBlock.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBFrame.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBValue.h"
#include "lldb/Core/AddressRange.h"
#include "lldb/Core/Log.h"
#include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Symbol/Block.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
using namespace lldb;
using namespace lldb_private;
SBBlock::SBBlock () :
m_opaque_ptr (NULL)
{
}
SBBlock::SBBlock (lldb_private::Block *lldb_object_ptr) :
m_opaque_ptr (lldb_object_ptr)
{
}
SBBlock::SBBlock(const SBBlock &rhs) :
m_opaque_ptr (rhs.m_opaque_ptr)
{
}
const SBBlock &
SBBlock::operator = (const SBBlock &rhs)
{
m_opaque_ptr = rhs.m_opaque_ptr;
return *this;
}
SBBlock::~SBBlock ()
{
m_opaque_ptr = NULL;
}
bool
SBBlock::IsValid () const
{
return m_opaque_ptr != NULL;
}
bool
SBBlock::IsInlined () const
{
if (m_opaque_ptr)
return m_opaque_ptr->GetInlinedFunctionInfo () != NULL;
return false;
}
const char *
SBBlock::GetInlinedName () const
{
if (m_opaque_ptr)
{
const InlineFunctionInfo* inlined_info = m_opaque_ptr->GetInlinedFunctionInfo ();
if (inlined_info)
return inlined_info->GetName().AsCString (NULL);
}
return NULL;
}
SBFileSpec
SBBlock::GetInlinedCallSiteFile () const
{
SBFileSpec sb_file;
if (m_opaque_ptr)
{
const InlineFunctionInfo* inlined_info = m_opaque_ptr->GetInlinedFunctionInfo ();
if (inlined_info)
sb_file.SetFileSpec (inlined_info->GetCallSite().GetFile());
}
return sb_file;
}
uint32_t
SBBlock::GetInlinedCallSiteLine () const
{
if (m_opaque_ptr)
{
const InlineFunctionInfo* inlined_info = m_opaque_ptr->GetInlinedFunctionInfo ();
if (inlined_info)
return inlined_info->GetCallSite().GetLine();
}
return 0;
}
uint32_t
SBBlock::GetInlinedCallSiteColumn () const
{
if (m_opaque_ptr)
{
const InlineFunctionInfo* inlined_info = m_opaque_ptr->GetInlinedFunctionInfo ();
if (inlined_info)
return inlined_info->GetCallSite().GetColumn();
}
return 0;
}
void
SBBlock::AppendVariables (bool can_create, bool get_parent_variables, lldb_private::VariableList *var_list)
{
if (IsValid())
{
bool show_inline = true;
m_opaque_ptr->AppendVariables (can_create, get_parent_variables, show_inline, var_list);
}
}
SBBlock
SBBlock::GetParent ()
{
SBBlock sb_block;
if (m_opaque_ptr)
sb_block.m_opaque_ptr = m_opaque_ptr->GetParent();
return sb_block;
}
lldb::SBBlock
SBBlock::GetContainingInlinedBlock ()
{
SBBlock sb_block;
if (m_opaque_ptr)
sb_block.m_opaque_ptr = m_opaque_ptr->GetContainingInlinedBlock ();
return sb_block;
}
SBBlock
SBBlock::GetSibling ()
{
SBBlock sb_block;
if (m_opaque_ptr)
sb_block.m_opaque_ptr = m_opaque_ptr->GetSibling();
return sb_block;
}
SBBlock
SBBlock::GetFirstChild ()
{
SBBlock sb_block;
if (m_opaque_ptr)
sb_block.m_opaque_ptr = m_opaque_ptr->GetFirstChild();
return sb_block;
}
lldb_private::Block *
SBBlock::GetPtr ()
{
return m_opaque_ptr;
}
void
SBBlock::SetPtr (lldb_private::Block *block)
{
m_opaque_ptr = block;
}
bool
SBBlock::GetDescription (SBStream &description)
{
Stream &strm = description.ref();
if (m_opaque_ptr)
{
lldb::user_id_t id = m_opaque_ptr->GetID();
strm.Printf ("Block: {id: %llu} ", id);
if (IsInlined())
{
strm.Printf (" (inlined, '%s') ", GetInlinedName());
}
lldb_private::SymbolContext sc;
m_opaque_ptr->CalculateSymbolContext (&sc);
if (sc.function)
{
m_opaque_ptr->DumpAddressRanges (&strm,
sc.function->GetAddressRange().GetBaseAddress().GetFileAddress());
}
}
else
strm.PutCString ("No value");
return true;
}
uint32_t
SBBlock::GetNumRanges ()
{
if (m_opaque_ptr)
return m_opaque_ptr->GetNumRanges();
return 0;
}
lldb::SBAddress
SBBlock::GetRangeStartAddress (uint32_t idx)
{
lldb::SBAddress sb_addr;
if (m_opaque_ptr)
{
AddressRange range;
if (m_opaque_ptr->GetRangeAtIndex(idx, range))
{
sb_addr.ref() = range.GetBaseAddress();
}
}
return sb_addr;
}
lldb::SBAddress
SBBlock::GetRangeEndAddress (uint32_t idx)
{
lldb::SBAddress sb_addr;
if (m_opaque_ptr)
{
AddressRange range;
if (m_opaque_ptr->GetRangeAtIndex(idx, range))
{
sb_addr.ref() = range.GetBaseAddress();
sb_addr.ref().Slide(range.GetByteSize());
}
}
return sb_addr;
}
uint32_t
SBBlock::GetRangeIndexForBlockAddress (lldb::SBAddress block_addr)
{
if (m_opaque_ptr && block_addr.IsValid())
{
return m_opaque_ptr->GetRangeIndexContainingAddress (block_addr.ref());
}
return UINT32_MAX;
}
lldb::SBValueList
SBBlock::GetVariables (lldb::SBFrame& frame,
bool arguments,
bool locals,
bool statics,
lldb::DynamicValueType use_dynamic)
{
Block *block = GetPtr();
SBValueList value_list;
if (block)
{
StackFrameSP frame_sp(frame.GetFrameSP());
VariableListSP variable_list_sp (block->GetBlockVariableList (true));
if (variable_list_sp)
{
const size_t num_variables = variable_list_sp->GetSize();
if (num_variables)
{
for (size_t i = 0; i < num_variables; ++i)
{
VariableSP variable_sp (variable_list_sp->GetVariableAtIndex(i));
if (variable_sp)
{
bool add_variable = false;
switch (variable_sp->GetScope())
{
case eValueTypeVariableGlobal:
case eValueTypeVariableStatic:
add_variable = statics;
break;
case eValueTypeVariableArgument:
add_variable = arguments;
break;
case eValueTypeVariableLocal:
add_variable = locals;
break;
default:
break;
}
if (add_variable)
{
if (frame_sp)
{
lldb::ValueObjectSP valobj_sp(frame_sp->GetValueObjectForFrameVariable (variable_sp,eNoDynamicValues));
SBValue value_sb;
value_sb.SetSP(valobj_sp, use_dynamic);
value_list.Append (value_sb);
}
}
}
}
}
}
}
return value_list;
}
lldb::SBValueList
SBBlock::GetVariables (lldb::SBTarget& target,
bool arguments,
bool locals,
bool statics)
{
Block *block = GetPtr();
SBValueList value_list;
if (block)
{
TargetSP target_sp(target.GetSP());
VariableListSP variable_list_sp (block->GetBlockVariableList (true));
if (variable_list_sp)
{
const size_t num_variables = variable_list_sp->GetSize();
if (num_variables)
{
for (size_t i = 0; i < num_variables; ++i)
{
VariableSP variable_sp (variable_list_sp->GetVariableAtIndex(i));
if (variable_sp)
{
bool add_variable = false;
switch (variable_sp->GetScope())
{
case eValueTypeVariableGlobal:
case eValueTypeVariableStatic:
add_variable = statics;
break;
case eValueTypeVariableArgument:
add_variable = arguments;
break;
case eValueTypeVariableLocal:
add_variable = locals;
break;
default:
break;
}
if (add_variable)
{
if (target_sp)
value_list.Append (ValueObjectVariable::Create (target_sp.get(), variable_sp));
}
}
}
}
}
}
return value_list;
}
Reference in New Issue View Git Blame Copy Permalink