e8daa2f843
Rationale: Pretty simply, the idea is that sometimes type names are way too long and contain way too many details for the average developer to care about. For instance, a plain ol' vector of int might be shown as std::__1::vector<int, std::__1::allocator<.... rather than the much simpler std::vector<int> form, which is what most developers would actually type in their code Proposed solution: Introduce a notion of "display name" and a corresponding API GetDisplayTypeName() to return such a crafted for visual representation type name Obviously, the display name and the fully qualified (or "true") name are not necessarily the same - that's the whole point LLDB could choose to pick the "display name" as its one true notion of a type name, and if somebody really needs the fully qualified version of it, let them deal with the problem Or, LLDB could rename what it currently calls the "type name" to be the "display name", and add new APIs for the fully qualified name, making the display name the default choice The choice that I am making here is that the type name will keep meaning the same, and people who want a type name suited for display will explicitly ask for one It is the less risky/disruptive choice - and it should eventually make it fairly obvious when someone is asking for the wrong type Caveats: - for now, GetDisplayTypeName() == GetTypeName(), there is no logic to produce customized display type names yet. - while the fully-qualified type name is still the main key to the kingdom of data formatters, if we start showing custom names to people, those should match formatters llvm-svn: 209072
361 lines
11 KiB
C++
361 lines
11 KiB
C++
//===-- ValueObjectConstResult.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/Core/ValueObjectConstResult.h"
|
|
|
|
#include "lldb/Core/ValueObjectChild.h"
|
|
#include "lldb/Core/ValueObjectConstResultChild.h"
|
|
#include "lldb/Core/DataExtractor.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/ValueObjectDynamicValue.h"
|
|
#include "lldb/Core/ValueObjectList.h"
|
|
|
|
#include "lldb/Symbol/ClangASTType.h"
|
|
#include "lldb/Symbol/ObjectFile.h"
|
|
#include "lldb/Symbol/SymbolContext.h"
|
|
#include "lldb/Symbol/Type.h"
|
|
#include "lldb/Symbol/Variable.h"
|
|
|
|
#include "lldb/Target/ExecutionContext.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/Target.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
ValueObjectSP
|
|
ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
|
|
ByteOrder byte_order,
|
|
uint32_t addr_byte_size,
|
|
lldb::addr_t address)
|
|
{
|
|
return (new ValueObjectConstResult (exe_scope,
|
|
byte_order,
|
|
addr_byte_size,
|
|
address))->GetSP();
|
|
}
|
|
|
|
ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
|
|
ByteOrder byte_order,
|
|
uint32_t addr_byte_size,
|
|
lldb::addr_t address) :
|
|
ValueObject (exe_scope),
|
|
m_type_name (),
|
|
m_byte_size (0),
|
|
m_impl(this, address)
|
|
{
|
|
SetIsConstant ();
|
|
SetValueIsValid(true);
|
|
m_data.SetByteOrder(byte_order);
|
|
m_data.SetAddressByteSize(addr_byte_size);
|
|
SetAddressTypeOfChildren(eAddressTypeLoad);
|
|
}
|
|
|
|
ValueObjectSP
|
|
ValueObjectConstResult::Create
|
|
(
|
|
ExecutionContextScope *exe_scope,
|
|
const ClangASTType &clang_type,
|
|
const ConstString &name,
|
|
const DataExtractor &data,
|
|
lldb::addr_t address
|
|
)
|
|
{
|
|
return (new ValueObjectConstResult (exe_scope,
|
|
clang_type,
|
|
name,
|
|
data,
|
|
address))->GetSP();
|
|
}
|
|
|
|
ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
|
|
const ClangASTType &clang_type,
|
|
const ConstString &name,
|
|
const DataExtractor &data,
|
|
lldb::addr_t address) :
|
|
ValueObject (exe_scope),
|
|
m_type_name (),
|
|
m_byte_size (0),
|
|
m_impl(this, address)
|
|
{
|
|
m_data = data;
|
|
|
|
if (!m_data.GetSharedDataBuffer())
|
|
{
|
|
DataBufferSP shared_data_buffer(new DataBufferHeap(data.GetDataStart(), data.GetByteSize()));
|
|
m_data.SetData(shared_data_buffer);
|
|
}
|
|
|
|
m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
|
|
m_value.SetValueType(Value::eValueTypeHostAddress);
|
|
m_value.SetClangType(clang_type);
|
|
m_name = name;
|
|
SetIsConstant ();
|
|
SetValueIsValid(true);
|
|
SetAddressTypeOfChildren(eAddressTypeLoad);
|
|
}
|
|
|
|
ValueObjectSP
|
|
ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
|
|
const ClangASTType &clang_type,
|
|
const ConstString &name,
|
|
const lldb::DataBufferSP &data_sp,
|
|
lldb::ByteOrder data_byte_order,
|
|
uint32_t data_addr_size,
|
|
lldb::addr_t address)
|
|
{
|
|
return (new ValueObjectConstResult (exe_scope,
|
|
clang_type,
|
|
name,
|
|
data_sp,
|
|
data_byte_order,
|
|
data_addr_size,
|
|
address))->GetSP();
|
|
}
|
|
|
|
ValueObjectSP
|
|
ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
|
|
Value &value,
|
|
const ConstString &name)
|
|
{
|
|
return (new ValueObjectConstResult (exe_scope, value, name))->GetSP();
|
|
}
|
|
|
|
ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
|
|
const ClangASTType &clang_type,
|
|
const ConstString &name,
|
|
const lldb::DataBufferSP &data_sp,
|
|
lldb::ByteOrder data_byte_order,
|
|
uint32_t data_addr_size,
|
|
lldb::addr_t address) :
|
|
ValueObject (exe_scope),
|
|
m_type_name (),
|
|
m_byte_size (0),
|
|
m_impl(this, address)
|
|
{
|
|
m_data.SetByteOrder(data_byte_order);
|
|
m_data.SetAddressByteSize(data_addr_size);
|
|
m_data.SetData(data_sp);
|
|
m_value.GetScalar() = (uintptr_t)data_sp->GetBytes();
|
|
m_value.SetValueType(Value::eValueTypeHostAddress);
|
|
//m_value.SetContext(Value::eContextTypeClangType, clang_type);
|
|
m_value.SetClangType (clang_type);
|
|
m_name = name;
|
|
SetIsConstant ();
|
|
SetValueIsValid(true);
|
|
SetAddressTypeOfChildren(eAddressTypeLoad);
|
|
}
|
|
|
|
ValueObjectSP
|
|
ValueObjectConstResult::Create (ExecutionContextScope *exe_scope,
|
|
const ClangASTType &clang_type,
|
|
const ConstString &name,
|
|
lldb::addr_t address,
|
|
AddressType address_type,
|
|
uint32_t addr_byte_size)
|
|
{
|
|
return (new ValueObjectConstResult (exe_scope,
|
|
clang_type,
|
|
name,
|
|
address,
|
|
address_type,
|
|
addr_byte_size))->GetSP();
|
|
}
|
|
|
|
ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
|
|
const ClangASTType &clang_type,
|
|
const ConstString &name,
|
|
lldb::addr_t address,
|
|
AddressType address_type,
|
|
uint32_t addr_byte_size) :
|
|
ValueObject (exe_scope),
|
|
m_type_name (),
|
|
m_byte_size (0),
|
|
m_impl(this, address)
|
|
{
|
|
m_value.GetScalar() = address;
|
|
m_data.SetAddressByteSize(addr_byte_size);
|
|
m_value.GetScalar().GetData (m_data, addr_byte_size);
|
|
//m_value.SetValueType(Value::eValueTypeHostAddress);
|
|
switch (address_type)
|
|
{
|
|
case eAddressTypeInvalid: m_value.SetValueType(Value::eValueTypeScalar); break;
|
|
case eAddressTypeFile: m_value.SetValueType(Value::eValueTypeFileAddress); break;
|
|
case eAddressTypeLoad: m_value.SetValueType(Value::eValueTypeLoadAddress); break;
|
|
case eAddressTypeHost: m_value.SetValueType(Value::eValueTypeHostAddress); break;
|
|
}
|
|
// m_value.SetContext(Value::eContextTypeClangType, clang_type);
|
|
m_value.SetClangType (clang_type);
|
|
m_name = name;
|
|
SetIsConstant ();
|
|
SetValueIsValid(true);
|
|
SetAddressTypeOfChildren(eAddressTypeLoad);
|
|
}
|
|
|
|
ValueObjectSP
|
|
ValueObjectConstResult::Create
|
|
(
|
|
ExecutionContextScope *exe_scope,
|
|
const Error& error
|
|
)
|
|
{
|
|
return (new ValueObjectConstResult (exe_scope,
|
|
error))->GetSP();
|
|
}
|
|
|
|
ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
|
|
const Error& error) :
|
|
ValueObject (exe_scope),
|
|
m_type_name (),
|
|
m_byte_size (0),
|
|
m_impl(this)
|
|
{
|
|
m_error = error;
|
|
SetIsConstant ();
|
|
}
|
|
|
|
ValueObjectConstResult::ValueObjectConstResult (ExecutionContextScope *exe_scope,
|
|
const Value &value,
|
|
const ConstString &name) :
|
|
ValueObject (exe_scope),
|
|
m_type_name (),
|
|
m_byte_size (0),
|
|
m_impl(this)
|
|
{
|
|
m_value = value;
|
|
m_value.GetData(m_data);
|
|
}
|
|
|
|
ValueObjectConstResult::~ValueObjectConstResult()
|
|
{
|
|
}
|
|
|
|
ClangASTType
|
|
ValueObjectConstResult::GetClangTypeImpl()
|
|
{
|
|
return m_value.GetClangType();
|
|
}
|
|
|
|
lldb::ValueType
|
|
ValueObjectConstResult::GetValueType() const
|
|
{
|
|
return eValueTypeConstResult;
|
|
}
|
|
|
|
uint64_t
|
|
ValueObjectConstResult::GetByteSize()
|
|
{
|
|
if (m_byte_size == 0)
|
|
m_byte_size = GetClangType().GetByteSize();
|
|
return m_byte_size;
|
|
}
|
|
|
|
void
|
|
ValueObjectConstResult::SetByteSize (size_t size)
|
|
{
|
|
m_byte_size = size;
|
|
}
|
|
|
|
size_t
|
|
ValueObjectConstResult::CalculateNumChildren()
|
|
{
|
|
return GetClangType().GetNumChildren (true);
|
|
}
|
|
|
|
ConstString
|
|
ValueObjectConstResult::GetTypeName()
|
|
{
|
|
if (m_type_name.IsEmpty())
|
|
m_type_name = GetClangType().GetConstTypeName ();
|
|
return m_type_name;
|
|
}
|
|
|
|
ConstString
|
|
ValueObjectConstResult::GetDisplayTypeName()
|
|
{
|
|
return GetClangType().GetDisplayTypeName();
|
|
}
|
|
|
|
bool
|
|
ValueObjectConstResult::UpdateValue ()
|
|
{
|
|
// Const value is always valid
|
|
SetValueIsValid (true);
|
|
return true;
|
|
}
|
|
|
|
|
|
bool
|
|
ValueObjectConstResult::IsInScope ()
|
|
{
|
|
// A const result value is always in scope since it serializes all
|
|
// information needed to contain the constant value.
|
|
return true;
|
|
}
|
|
|
|
lldb::ValueObjectSP
|
|
ValueObjectConstResult::Dereference (Error &error)
|
|
{
|
|
return m_impl.Dereference(error);
|
|
}
|
|
|
|
lldb::ValueObjectSP
|
|
ValueObjectConstResult::GetSyntheticChildAtOffset(uint32_t offset, const ClangASTType& type, bool can_create)
|
|
{
|
|
return m_impl.GetSyntheticChildAtOffset(offset, type, can_create);
|
|
}
|
|
|
|
lldb::ValueObjectSP
|
|
ValueObjectConstResult::AddressOf (Error &error)
|
|
{
|
|
return m_impl.AddressOf(error);
|
|
}
|
|
|
|
lldb::addr_t
|
|
ValueObjectConstResult::GetAddressOf (bool scalar_is_load_address,
|
|
AddressType *address_type)
|
|
{
|
|
return m_impl.GetAddressOf(scalar_is_load_address, address_type);
|
|
}
|
|
|
|
ValueObject *
|
|
ValueObjectConstResult::CreateChildAtIndex (size_t idx, bool synthetic_array_member, int32_t synthetic_index)
|
|
{
|
|
return m_impl.CreateChildAtIndex(idx, synthetic_array_member, synthetic_index);
|
|
}
|
|
|
|
size_t
|
|
ValueObjectConstResult::GetPointeeData (DataExtractor& data,
|
|
uint32_t item_idx,
|
|
uint32_t item_count)
|
|
{
|
|
return m_impl.GetPointeeData(data, item_idx, item_count);
|
|
}
|
|
|
|
lldb::ValueObjectSP
|
|
ValueObjectConstResult::GetDynamicValue (lldb::DynamicValueType use_dynamic)
|
|
{
|
|
// Always recalculate dynamic values for const results as the memory that
|
|
// they might point to might have changed at any time.
|
|
if (use_dynamic != eNoDynamicValues)
|
|
{
|
|
if (!IsDynamic())
|
|
{
|
|
ExecutionContext exe_ctx (GetExecutionContextRef());
|
|
Process *process = exe_ctx.GetProcessPtr();
|
|
if (process && process->IsPossibleDynamicValue(*this))
|
|
m_dynamic_value = new ValueObjectDynamicValue (*this, use_dynamic);
|
|
}
|
|
if (m_dynamic_value)
|
|
return m_dynamic_value->GetSP();
|
|
}
|
|
return ValueObjectSP();
|
|
}
|
|
|