NSDictionary.cpp revision fe26a2333298602bac55decfee87bc6d33b79d54 
1//===-- NSDictionary.cpp ------------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "lldb/lldb-python.h"
11
12#include "lldb/DataFormatters/CXXFormatterFunctions.h"
13
14#include "lldb/Core/DataBufferHeap.h"
15#include "lldb/Core/Error.h"
16#include "lldb/Core/Stream.h"
17#include "lldb/Core/ValueObject.h"
18#include "lldb/Core/ValueObjectConstResult.h"
19#include "lldb/Host/Endian.h"
20#include "lldb/Symbol/ClangASTContext.h"
21#include "lldb/Target/ObjCLanguageRuntime.h"
22#include "lldb/Target/Target.h"
23
24#include "clang/AST/DeclCXX.h"
25
26using namespace lldb;
27using namespace lldb_private;
28using namespace lldb_private::formatters;
29
30static ClangASTType
31GetLLDBNSPairType (TargetSP target_sp)
32{
33    ClangASTType clang_type = ClangASTType();
34
35    ClangASTContext *target_ast_context = target_sp->GetScratchClangASTContext();
36
37    if (!target_ast_context)
38        return clang_type;
39
40    const char* type_name = "__lldb_autogen_nspair";
41
42    clang::IdentifierInfo &myIdent = target_ast_context->getASTContext()->Idents.get(type_name);
43    clang::DeclarationName myName = target_ast_context->getASTContext()->DeclarationNames.getIdentifier(&myIdent);
44
45    clang::DeclContext::lookup_const_result result = target_ast_context->getASTContext()->getTranslationUnitDecl()->lookup(myName);
46
47    clang_type_t opaque_type = NULL;
48
49    for (clang::NamedDecl *named_decl : result)
50    {
51        if (const clang::CXXRecordDecl *record_decl = llvm::dyn_cast<clang::CXXRecordDecl>(named_decl))
52        {
53            opaque_type = clang::QualType(record_decl->getTypeForDecl(), 0).getAsOpaquePtr();
54            break;
55        }
56        else
57        {
58            // somebody else (the user?) has defined a type with the magic name already - fail!!!
59            return clang_type;
60        }
61    }
62
63    if (!opaque_type)
64    {
65        opaque_type = target_ast_context->CreateRecordType(NULL, lldb::eAccessPublic, type_name, clang::TTK_Struct, lldb::eLanguageTypeC);
66
67        if (!opaque_type)
68            return clang_type;
69
70        target_ast_context->StartTagDeclarationDefinition(opaque_type);
71
72        target_ast_context->AddFieldToRecordType(opaque_type, "key", target_ast_context->GetBuiltInType_objc_id(), lldb::eAccessPublic, 0);
73        target_ast_context->AddFieldToRecordType(opaque_type, "value", target_ast_context->GetBuiltInType_objc_id(), lldb::eAccessPublic, 0);
74
75        target_ast_context->CompleteTagDeclarationDefinition(opaque_type);
76    }
77
78    clang_type.SetClangType(target_ast_context->getASTContext(), opaque_type);
79    return clang_type;
80}
81
82template<bool name_entries>
83bool
84lldb_private::formatters::NSDictionarySummaryProvider (ValueObject& valobj, Stream& stream)
85{
86    ProcessSP process_sp = valobj.GetProcessSP();
87    if (!process_sp)
88        return false;
89
90    ObjCLanguageRuntime* runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
91
92    if (!runtime)
93        return false;
94
95    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(valobj));
96
97    if (!descriptor.get() || !descriptor->IsValid())
98        return false;
99
100    uint32_t ptr_size = process_sp->GetAddressByteSize();
101    bool is_64bit = (ptr_size == 8);
102
103    lldb::addr_t valobj_addr = valobj.GetValueAsUnsigned(0);
104
105    if (!valobj_addr)
106        return false;
107
108    uint64_t value = 0;
109
110    const char* class_name = descriptor->GetClassName().GetCString();
111
112    if (!class_name || !*class_name)
113        return false;
114
115    if (!strcmp(class_name,"__NSDictionaryI"))
116    {
117        Error error;
118        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error);
119        if (error.Fail())
120            return false;
121        value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
122    }
123    else if (!strcmp(class_name,"__NSDictionaryM"))
124    {
125        Error error;
126        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + ptr_size, ptr_size, 0, error);
127        if (error.Fail())
128            return false;
129        value &= (is_64bit ? ~0xFC00000000000000UL : ~0xFC000000U);
130    }
131    /*else if (!strcmp(class_name,"__NSCFDictionary"))
132    {
133        Error error;
134        value = process_sp->ReadUnsignedIntegerFromMemory(valobj_addr + (is_64bit ? 20 : 12), 4, 0, error);
135        if (error.Fail())
136            return false;
137        if (is_64bit)
138            value &= ~0x0f1f000000000000UL;
139    }*/
140    else
141    {
142        if (!ExtractValueFromObjCExpression(valobj, "int", "count", value))
143            return false;
144    }
145
146    stream.Printf("%s%" PRIu64 " %s%s",
147                  (name_entries ? "@\"" : ""),
148                  value,
149                  (name_entries ? (value == 1 ? "entry" : "entries") : (value == 1 ? "key/value pair" : "key/value pairs")),
150                  (name_entries ? "\"" : ""));
151    return true;
152}
153
154SyntheticChildrenFrontEnd* lldb_private::formatters::NSDictionarySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
155{
156
157    lldb::ProcessSP process_sp (valobj_sp->GetProcessSP());
158    if (!process_sp)
159        return NULL;
160    ObjCLanguageRuntime *runtime = (ObjCLanguageRuntime*)process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
161    if (!runtime)
162        return NULL;
163
164    if (!valobj_sp->IsPointerType())
165    {
166        Error error;
167        valobj_sp = valobj_sp->AddressOf(error);
168        if (error.Fail() || !valobj_sp)
169            return NULL;
170    }
171
172    ObjCLanguageRuntime::ClassDescriptorSP descriptor(runtime->GetClassDescriptor(*valobj_sp.get()));
173
174    if (!descriptor.get() || !descriptor->IsValid())
175        return NULL;
176
177    const char* class_name = descriptor->GetClassName().GetCString();
178
179    if (!class_name || !*class_name)
180        return NULL;
181
182    if (!strcmp(class_name,"__NSDictionaryI"))
183    {
184        return (new NSDictionaryISyntheticFrontEnd(valobj_sp));
185    }
186    else if (!strcmp(class_name,"__NSDictionaryM"))
187    {
188        return (new NSDictionaryMSyntheticFrontEnd(valobj_sp));
189    }
190    else
191    {
192        return (new NSDictionaryCodeRunningSyntheticFrontEnd(valobj_sp));
193    }
194}
195
196lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::NSDictionaryCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
197SyntheticChildrenFrontEnd(*valobj_sp.get())
198{}
199
200size_t
201lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::CalculateNumChildren ()
202{
203    uint64_t count = 0;
204    if (ExtractValueFromObjCExpression(m_backend, "int", "count", count))
205        return count;
206    return 0;
207}
208
209lldb::ValueObjectSP
210lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::GetChildAtIndex (size_t idx)
211{
212    StreamString idx_name;
213    idx_name.Printf("[%zu]",idx);
214    StreamString key_fetcher_expr;
215    key_fetcher_expr.Printf("(id)[(NSArray*)[(id)0x%" PRIx64 " allKeys] objectAtIndex:%zu]",m_backend.GetPointerValue(),idx);
216    StreamString value_fetcher_expr;
217    value_fetcher_expr.Printf("(id)[(id)0x%" PRIx64 " objectForKey:(%s)]",m_backend.GetPointerValue(),key_fetcher_expr.GetData());
218    StreamString object_fetcher_expr;
219    object_fetcher_expr.Printf("struct __lldb_autogen_nspair { id key; id value; } _lldb_valgen_item; _lldb_valgen_item.key = %s; _lldb_valgen_item.value = %s; _lldb_valgen_item;",key_fetcher_expr.GetData(),value_fetcher_expr.GetData());
220    lldb::ValueObjectSP child_sp;
221    m_backend.GetTargetSP()->EvaluateExpression(object_fetcher_expr.GetData(), m_backend.GetFrameSP().get(), child_sp,
222                                                EvaluateExpressionOptions().SetKeepInMemory(true));
223    if (child_sp)
224        child_sp->SetName(ConstString(idx_name.GetData()));
225    return child_sp;
226}
227
228bool
229lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::Update()
230{
231    return false;
232}
233
234bool
235lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::MightHaveChildren ()
236{
237    return true;
238}
239
240size_t
241lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
242{
243    return 0;
244}
245
246lldb_private::formatters::NSDictionaryCodeRunningSyntheticFrontEnd::~NSDictionaryCodeRunningSyntheticFrontEnd ()
247{}
248
249lldb_private::formatters::NSDictionaryISyntheticFrontEnd::NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
250SyntheticChildrenFrontEnd(*valobj_sp.get()),
251m_exe_ctx_ref(),
252m_ptr_size(8),
253m_order(lldb::eByteOrderInvalid),
254m_data_32(NULL),
255m_data_64(NULL),
256m_pair_type()
257{
258}
259
260lldb_private::formatters::NSDictionaryISyntheticFrontEnd::~NSDictionaryISyntheticFrontEnd ()
261{
262    delete m_data_32;
263    m_data_32 = NULL;
264    delete m_data_64;
265    m_data_64 = NULL;
266}
267
268size_t
269lldb_private::formatters::NSDictionaryISyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
270{
271    const char* item_name = name.GetCString();
272    uint32_t idx = ExtractIndexFromString(item_name);
273    if (idx < UINT32_MAX && idx >= CalculateNumChildren())
274        return UINT32_MAX;
275    return idx;
276}
277
278size_t
279lldb_private::formatters::NSDictionaryISyntheticFrontEnd::CalculateNumChildren ()
280{
281    if (!m_data_32 && !m_data_64)
282        return 0;
283    return (m_data_32 ? m_data_32->_used : m_data_64->_used);
284}
285
286bool
287lldb_private::formatters::NSDictionaryISyntheticFrontEnd::Update()
288{
289    m_children.clear();
290    delete m_data_32;
291    m_data_32 = NULL;
292    delete m_data_64;
293    m_data_64 = NULL;
294    m_ptr_size = 0;
295    ValueObjectSP valobj_sp = m_backend.GetSP();
296    if (!valobj_sp)
297        return false;
298    m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
299    Error error;
300    error.Clear();
301    lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
302    if (!process_sp)
303        return false;
304    m_ptr_size = process_sp->GetAddressByteSize();
305    m_order = process_sp->GetByteOrder();
306    uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
307    if (m_ptr_size == 4)
308    {
309        m_data_32 = new DataDescriptor_32();
310        process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error);
311    }
312    else
313    {
314        m_data_64 = new DataDescriptor_64();
315        process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error);
316    }
317    if (error.Fail())
318        return false;
319    m_data_ptr = data_location + m_ptr_size;
320    return false;
321}
322
323bool
324lldb_private::formatters::NSDictionaryISyntheticFrontEnd::MightHaveChildren ()
325{
326    return true;
327}
328
329lldb::ValueObjectSP
330lldb_private::formatters::NSDictionaryISyntheticFrontEnd::GetChildAtIndex (size_t idx)
331{
332    uint32_t num_children = CalculateNumChildren();
333
334    if (idx >= num_children)
335        return lldb::ValueObjectSP();
336
337    if (m_children.empty())
338    {
339        // do the scan phase
340        lldb::addr_t key_at_idx = 0, val_at_idx = 0;
341
342        uint32_t tries = 0;
343        uint32_t test_idx = 0;
344
345        while(tries < num_children)
346        {
347            key_at_idx = m_data_ptr + (2*test_idx * m_ptr_size);
348            val_at_idx = key_at_idx + m_ptr_size;
349            ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
350            if (!process_sp)
351                return lldb::ValueObjectSP();
352            Error error;
353            key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error);
354            if (error.Fail())
355                return lldb::ValueObjectSP();
356            val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error);
357            if (error.Fail())
358                return lldb::ValueObjectSP();
359
360            test_idx++;
361
362            if (!key_at_idx || !val_at_idx)
363                continue;
364            tries++;
365
366            DictionaryItemDescriptor descriptor = {key_at_idx,val_at_idx,lldb::ValueObjectSP()};
367
368            m_children.push_back(descriptor);
369        }
370    }
371
372    if (idx >= m_children.size()) // should never happen
373        return lldb::ValueObjectSP();
374
375    DictionaryItemDescriptor &dict_item = m_children[idx];
376    if (!dict_item.valobj_sp)
377    {
378        if (!m_pair_type.IsValid())
379        {
380            TargetSP target_sp(m_backend.GetTargetSP());
381            if (!target_sp)
382                return ValueObjectSP();
383            m_pair_type = GetLLDBNSPairType(target_sp);
384        }
385        if (!m_pair_type.IsValid())
386            return ValueObjectSP();
387
388        DataBufferSP buffer_sp(new DataBufferHeap(2*m_ptr_size,0));
389
390        if (m_ptr_size == 8)
391        {
392            uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
393            *data_ptr = dict_item.key_ptr;
394            *(data_ptr+1) = dict_item.val_ptr;
395        }
396        else
397        {
398            uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
399            *data_ptr = dict_item.key_ptr;
400            *(data_ptr+1) = dict_item.val_ptr;
401        }
402
403        StreamString idx_name;
404        idx_name.Printf("[%zu]",idx);
405        DataExtractor data(buffer_sp, m_order, m_ptr_size);
406        dict_item.valobj_sp = ValueObject::CreateValueObjectFromData(idx_name.GetData(), data, m_exe_ctx_ref, m_pair_type);
407    }
408    return dict_item.valobj_sp;
409}
410
411lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
412SyntheticChildrenFrontEnd(*valobj_sp.get()),
413m_exe_ctx_ref(),
414m_ptr_size(8),
415m_order(lldb::eByteOrderInvalid),
416m_data_32(NULL),
417m_data_64(NULL),
418m_pair_type()
419{
420}
421
422lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::~NSDictionaryMSyntheticFrontEnd ()
423{
424    delete m_data_32;
425    m_data_32 = NULL;
426    delete m_data_64;
427    m_data_64 = NULL;
428}
429
430size_t
431lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::GetIndexOfChildWithName (const ConstString &name)
432{
433    const char* item_name = name.GetCString();
434    uint32_t idx = ExtractIndexFromString(item_name);
435    if (idx < UINT32_MAX && idx >= CalculateNumChildren())
436        return UINT32_MAX;
437    return idx;
438}
439
440size_t
441lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::CalculateNumChildren ()
442{
443    if (!m_data_32 && !m_data_64)
444        return 0;
445    return (m_data_32 ? m_data_32->_used : m_data_64->_used);
446}
447
448bool
449lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::Update()
450{
451    m_children.clear();
452    ValueObjectSP valobj_sp = m_backend.GetSP();
453    m_ptr_size = 0;
454    delete m_data_32;
455    m_data_32 = NULL;
456    delete m_data_64;
457    m_data_64 = NULL;
458    if (!valobj_sp)
459        return false;
460    m_exe_ctx_ref = valobj_sp->GetExecutionContextRef();
461    Error error;
462    error.Clear();
463    lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
464    if (!process_sp)
465        return false;
466    m_ptr_size = process_sp->GetAddressByteSize();
467    m_order = process_sp->GetByteOrder();
468    uint64_t data_location = valobj_sp->GetValueAsUnsigned(0) + m_ptr_size;
469    if (m_ptr_size == 4)
470    {
471        m_data_32 = new DataDescriptor_32();
472        process_sp->ReadMemory (data_location, m_data_32, sizeof(DataDescriptor_32), error);
473    }
474    else
475    {
476        m_data_64 = new DataDescriptor_64();
477        process_sp->ReadMemory (data_location, m_data_64, sizeof(DataDescriptor_64), error);
478    }
479    if (error.Fail())
480        return false;
481    return false;
482}
483
484bool
485lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::MightHaveChildren ()
486{
487    return true;
488}
489
490lldb::ValueObjectSP
491lldb_private::formatters::NSDictionaryMSyntheticFrontEnd::GetChildAtIndex (size_t idx)
492{
493    lldb::addr_t m_keys_ptr = (m_data_32 ? m_data_32->_keys_addr : m_data_64->_keys_addr);
494    lldb::addr_t m_values_ptr = (m_data_32 ? m_data_32->_objs_addr : m_data_64->_objs_addr);
495
496    uint32_t num_children = CalculateNumChildren();
497
498    if (idx >= num_children)
499        return lldb::ValueObjectSP();
500
501    if (m_children.empty())
502    {
503        // do the scan phase
504        lldb::addr_t key_at_idx = 0, val_at_idx = 0;
505
506        uint32_t tries = 0;
507        uint32_t test_idx = 0;
508
509        while(tries < num_children)
510        {
511            key_at_idx = m_keys_ptr + (test_idx * m_ptr_size);
512            val_at_idx = m_values_ptr + (test_idx * m_ptr_size);;
513            ProcessSP process_sp = m_exe_ctx_ref.GetProcessSP();
514            if (!process_sp)
515                return lldb::ValueObjectSP();
516            Error error;
517            key_at_idx = process_sp->ReadPointerFromMemory(key_at_idx, error);
518            if (error.Fail())
519                return lldb::ValueObjectSP();
520            val_at_idx = process_sp->ReadPointerFromMemory(val_at_idx, error);
521            if (error.Fail())
522                return lldb::ValueObjectSP();
523
524            test_idx++;
525
526            if (!key_at_idx || !val_at_idx)
527                continue;
528            tries++;
529
530            DictionaryItemDescriptor descriptor = {key_at_idx,val_at_idx,lldb::ValueObjectSP()};
531
532            m_children.push_back(descriptor);
533        }
534    }
535
536    if (idx >= m_children.size()) // should never happen
537        return lldb::ValueObjectSP();
538
539    DictionaryItemDescriptor &dict_item = m_children[idx];
540    if (!dict_item.valobj_sp)
541    {
542        if (!m_pair_type.IsValid())
543        {
544            TargetSP target_sp(m_backend.GetTargetSP());
545            if (!target_sp)
546                return ValueObjectSP();
547            m_pair_type = GetLLDBNSPairType(target_sp);
548        }
549        if (!m_pair_type.IsValid())
550            return ValueObjectSP();
551
552        DataBufferSP buffer_sp(new DataBufferHeap(2*m_ptr_size,0));
553
554        if (m_ptr_size == 8)
555        {
556            uint64_t *data_ptr = (uint64_t *)buffer_sp->GetBytes();
557            *data_ptr = dict_item.key_ptr;
558            *(data_ptr+1) = dict_item.val_ptr;
559        }
560        else
561        {
562            uint32_t *data_ptr = (uint32_t *)buffer_sp->GetBytes();
563            *data_ptr = dict_item.key_ptr;
564            *(data_ptr+1) = dict_item.val_ptr;
565        }
566
567        StreamString idx_name;
568        idx_name.Printf("[%zu]",idx);
569        DataExtractor data(buffer_sp, m_order, m_ptr_size);
570        dict_item.valobj_sp = ValueObject::CreateValueObjectFromData(idx_name.GetData(), data, m_exe_ctx_ref, m_pair_type);
571    }
572    return dict_item.valobj_sp;
573}
574
575template bool
576lldb_private::formatters::NSDictionarySummaryProvider<true> (ValueObject&, Stream&) ;
577
578template bool
579lldb_private::formatters::NSDictionarySummaryProvider<false> (ValueObject&, Stream&) ;
580