//===-- NSIndexPath.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/DataFormatters/CXXFormatterFunctions.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/DataFormatters/TypeSynthetic.h"
#include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Process.h"
#include "lldb/Symbol/ClangASTContext.h"
using namespace lldb;
using namespace lldb_private;
using namespace lldb_private::formatters;
class NSIndexPathSyntheticFrontEnd : public SyntheticChildrenFrontEnd
{
public:
NSIndexPathSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
SyntheticChildrenFrontEnd (*valobj_sp.get()),
m_ptr_size(0),
m_ast_ctx(nullptr),
m_uint_star_type()
{
m_ptr_size = m_backend.GetTargetSP()->GetArchitecture().GetAddressByteSize();
}
virtual size_t
CalculateNumChildren ()
{
return m_impl.GetNumIndexes();
}
virtual lldb::ValueObjectSP
GetChildAtIndex (size_t idx)
{
return m_impl.GetIndexAtIndex(idx, m_uint_star_type);
}
virtual bool
Update()
{
m_impl.m_mode = Mode::Invalid;
m_ast_ctx = ClangASTContext::GetASTContext(m_backend.GetClangType().GetASTContext());
if (!m_ast_ctx)
return false;
m_uint_star_type = m_ast_ctx->GetPointerSizedIntType(false);
static ConstString g__indexes("_indexes");
static ConstString g__length("_length");
ProcessSP process_sp = m_backend.GetProcessSP();
if (!process_sp)
return false;
ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
if (!runtime)
return false;
ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(m_backend));
if (!descriptor.get() || !descriptor->IsValid())
return false;
uint64_t info_bits(0),value_bits(0),payload(0);
if (descriptor->GetTaggedPointerInfo(&info_bits, &value_bits, &payload))
{
m_impl.m_mode = Mode::Inlined;
m_impl.m_inlined.SetIndexes(payload, *process_sp);
}
else
{
ObjCLanguageRuntime::ClassDescriptor::iVarDescriptor _indexes_id;
ObjCLanguageRuntime::ClassDescriptor::iVarDescriptor _length_id;
bool has_indexes(false),has_length(false);
for (size_t x = 0;
x < descriptor->GetNumIVars();
x++)
{
const auto& ivar = descriptor->GetIVarAtIndex(x);
if (ivar.m_name == g__indexes)
{
_indexes_id = ivar;
has_indexes = true;
}
else if (ivar.m_name == g__length)
{
_length_id = ivar;
has_length = true;
}
if (has_length && has_indexes)
break;
}
if (has_length && has_indexes)
{
m_impl.m_outsourced.m_indexes = m_backend.GetSyntheticChildAtOffset(_indexes_id.m_offset,
m_uint_star_type.GetPointerType(),
true).get();
ValueObjectSP length_sp(m_backend.GetSyntheticChildAtOffset(_length_id.m_offset,
m_uint_star_type,
true));
if (length_sp)
{
m_impl.m_outsourced.m_count = length_sp->GetValueAsUnsigned(0);
if (m_impl.m_outsourced.m_indexes)
m_impl.m_mode = Mode::Outsourced;
}
}
}
return false;
}
virtual bool
MightHaveChildren ()
{
if (m_impl.m_mode == Mode::Invalid)
return false;
return true;
}
virtual size_t
GetIndexOfChildWithName (const ConstString &name)
{
const char* item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren())
return UINT32_MAX;
return idx;
}
virtual lldb::ValueObjectSP
GetSyntheticValue () { return nullptr; }
virtual
~NSIndexPathSyntheticFrontEnd () {}
protected:
ObjCLanguageRuntime::ClassDescriptorSP m_descriptor_sp;
enum class Mode {
Inlined,
Outsourced,
Invalid
};
struct Impl {
Mode m_mode;
size_t
GetNumIndexes ()
{
switch (m_mode)
{
case Mode::Inlined:
return m_inlined.GetNumIndexes();
case Mode::Outsourced:
return m_outsourced.m_count;
default:
return 0;
}
}
lldb::ValueObjectSP
GetIndexAtIndex (size_t idx, const ClangASTType& desired_type)
{
if (idx >= GetNumIndexes())
return nullptr;
switch (m_mode)
{
default: return nullptr;
case Mode::Inlined:
return m_inlined.GetIndexAtIndex (idx, desired_type);
case Mode::Outsourced:
return m_outsourced.GetIndexAtIndex (idx);
}
}
struct InlinedIndexes {
public:
void SetIndexes(uint64_t value, Process& p)
{
m_indexes = value;
_lengthForInlinePayload(p.GetAddressByteSize());
m_process = &p;
}
size_t
GetNumIndexes ()
{
return m_count;
}
lldb::ValueObjectSP
GetIndexAtIndex (size_t idx, const ClangASTType& desired_type)
{
std::pair<uint64_t, bool> value(_indexAtPositionForInlinePayload(idx));
if (!value.second)
return nullptr;
Value v;
if (m_ptr_size == 8)
{
Scalar scalar( (unsigned long long)value.first );
v = Value(scalar);
}
else
{
Scalar scalar( (unsigned int)value.first );
v = Value(scalar);
}
v.SetClangType(desired_type);
StreamString idx_name;
idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
return ValueObjectConstResult::Create(m_process, v, ConstString(idx_name.GetData()));
}
private:
uint64_t m_indexes;
size_t m_count;
uint32_t m_ptr_size;
Process *m_process;
// cfr. Foundation for the details of this code
size_t _lengthForInlinePayload(uint32_t ptr_size) {
m_ptr_size = ptr_size;
if (m_ptr_size == 8)
m_count = ((m_indexes >> 3) & 0x7);
else
m_count = ((m_indexes >> 3) & 0x3);
return m_count;
}
std::pair<uint64_t, bool>
_indexAtPositionForInlinePayload(size_t pos) {
if (m_ptr_size == 8)
{
switch (pos) {
case 5: return {((m_indexes >> 51) & 0x1ff),true};
case 4: return {((m_indexes >> 42) & 0x1ff),true};
case 3: return {((m_indexes >> 33) & 0x1ff),true};
case 2: return {((m_indexes >> 24) & 0x1ff),true};
case 1: return {((m_indexes >> 15) & 0x1ff),true};
case 0: return {((m_indexes >> 6) & 0x1ff),true};
}
}
else
{
switch (pos) {
case 2: return {((m_indexes >> 23) & 0x1ff),true};
case 1: return {((m_indexes >> 14) & 0x1ff),true};
case 0: return {((m_indexes >> 5) & 0x1ff),true};
}
}
return {0,false};
}
};
struct OutsourcedIndexes {
ValueObject *m_indexes;
size_t m_count;
lldb::ValueObjectSP
GetIndexAtIndex (size_t idx)
{
if (m_indexes)
{
ValueObjectSP index_sp(m_indexes->GetSyntheticArrayMemberFromPointer(idx, true));
return index_sp;
}
return nullptr;
}
};
union {
struct InlinedIndexes m_inlined;
struct OutsourcedIndexes m_outsourced;
};
} m_impl;
uint32_t m_ptr_size;
ClangASTContext* m_ast_ctx;
ClangASTType m_uint_star_type;
};
namespace lldb_private {
namespace formatters {
SyntheticChildrenFrontEnd* NSIndexPathSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
{
if (valobj_sp)
return new NSIndexPathSyntheticFrontEnd(valobj_sp);
return nullptr;
}
}
}
