CXXFormatterFunctions.h revision 689696c19cbf0fa8a09e2461f0aaa37409782e3b 
1//===-- CXXFormatterFunctions.h------------------------------------*- 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#ifndef liblldb_CXXFormatterFunctions_h_
11#define liblldb_CXXFormatterFunctions_h_
12
13#include <stdint.h>
14#include "lldb/lldb-forward.h"
15
16#include "lldb/Core/ConstString.h"
17#include "lldb/DataFormatters/FormatClasses.h"
18#include "lldb/Target/Target.h"
19
20#include "clang/AST/ASTContext.h"
21
22namespace lldb_private {
23    namespace formatters
24    {
25        bool
26        ExtractValueFromObjCExpression (ValueObject &valobj,
27                                        const char* target_type,
28                                        const char* selector,
29                                        uint64_t &value);
30
31        lldb::ValueObjectSP
32        CallSelectorOnObject (ValueObject &valobj,
33                              const char* return_type,
34                              const char* selector,
35                              uint64_t index);
36
37        lldb::ValueObjectSP
38        CallSelectorOnObject (ValueObject &valobj,
39                              const char* return_type,
40                              const char* selector,
41                              const char* key);
42
43        bool
44        Char16StringSummaryProvider (ValueObject& valobj, Stream& stream); // char16_t* and unichar*
45
46        bool
47        Char32StringSummaryProvider (ValueObject& valobj, Stream& stream); // char32_t*
48
49        bool
50        WCharStringSummaryProvider (ValueObject& valobj, Stream& stream); // wchar_t*
51
52        bool
53        Char16SummaryProvider (ValueObject& valobj, Stream& stream); // char16_t and unichar
54
55        bool
56        Char32SummaryProvider (ValueObject& valobj, Stream& stream); // char32_t
57
58        bool
59        WCharSummaryProvider (ValueObject& valobj, Stream& stream); // wchar_t
60
61        bool
62        LibcxxStringSummaryProvider (ValueObject& valobj, Stream& stream); // libc++ std::string
63
64        bool
65        LibcxxWStringSummaryProvider (ValueObject& valobj, Stream& stream); // libc++ std::wstring
66
67        template<bool name_entries>
68        bool
69        NSDictionarySummaryProvider (ValueObject& valobj, Stream& stream);
70
71        bool
72        NSArraySummaryProvider (ValueObject& valobj, Stream& stream);
73
74        template<bool needs_at>
75        bool
76        NSDataSummaryProvider (ValueObject& valobj, Stream& stream);
77
78        bool
79        NSNumberSummaryProvider (ValueObject& valobj, Stream& stream);
80
81        bool
82        NSStringSummaryProvider (ValueObject& valobj, Stream& stream);
83
84        bool
85        ObjCBOOLSummaryProvider (ValueObject& valobj, Stream& stream);
86
87        template <bool is_sel_ptr>
88        bool
89        ObjCSELSummaryProvider (ValueObject& valobj, Stream& stream);
90
91        bool
92        RuntimeSpecificDescriptionSummaryProvider (ValueObject& valobj, Stream& stream);
93
94        extern template bool
95        NSDictionarySummaryProvider<true> (ValueObject&, Stream&) ;
96
97        extern template bool
98        NSDictionarySummaryProvider<false> (ValueObject&, Stream&) ;
99
100        extern template bool
101        NSDataSummaryProvider<true> (ValueObject&, Stream&) ;
102
103        extern template bool
104        NSDataSummaryProvider<false> (ValueObject&, Stream&) ;
105
106        extern template bool
107        ObjCSELSummaryProvider<true> (ValueObject&, Stream&);
108
109        extern template bool
110        ObjCSELSummaryProvider<false> (ValueObject&, Stream&);
111
112        class NSArrayMSyntheticFrontEnd : public SyntheticChildrenFrontEnd
113        {
114        private:
115            struct DataDescriptor_32
116            {
117                uint32_t _used;
118                uint32_t _priv1 : 2 ;
119                uint32_t _size : 30;
120                uint32_t _priv2 : 2;
121                uint32_t offset : 30;
122                uint32_t _priv3;
123                uint32_t _data;
124            };
125            struct DataDescriptor_64
126            {
127                uint64_t _used;
128                uint64_t _priv1 : 2 ;
129                uint64_t _size : 62;
130                uint64_t _priv2 : 2;
131                uint64_t offset : 62;
132                uint32_t _priv3;
133                uint64_t _data;
134            };
135        public:
136            NSArrayMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
137
138            virtual size_t
139            CalculateNumChildren ();
140
141            virtual lldb::ValueObjectSP
142            GetChildAtIndex (size_t idx);
143
144            virtual bool
145            Update();
146
147            virtual bool
148            MightHaveChildren ();
149
150            virtual size_t
151            GetIndexOfChildWithName (const ConstString &name);
152
153            virtual
154            ~NSArrayMSyntheticFrontEnd ();
155        private:
156            ExecutionContextRef m_exe_ctx_ref;
157            uint8_t m_ptr_size;
158            DataDescriptor_32 *m_data_32;
159            DataDescriptor_64 *m_data_64;
160            ClangASTType m_id_type;
161            std::vector<lldb::ValueObjectSP> m_children;
162        };
163
164        class NSArrayISyntheticFrontEnd : public SyntheticChildrenFrontEnd
165        {
166        public:
167            NSArrayISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
168
169            virtual size_t
170            CalculateNumChildren ();
171
172            virtual lldb::ValueObjectSP
173            GetChildAtIndex (size_t idx);
174
175            virtual bool
176            Update();
177
178            virtual bool
179            MightHaveChildren ();
180
181            virtual size_t
182            GetIndexOfChildWithName (const ConstString &name);
183
184            virtual
185            ~NSArrayISyntheticFrontEnd ();
186        private:
187            ExecutionContextRef m_exe_ctx_ref;
188            uint8_t m_ptr_size;
189            uint64_t m_items;
190            lldb::addr_t m_data_ptr;
191            ClangASTType m_id_type;
192            std::vector<lldb::ValueObjectSP> m_children;
193        };
194
195        class NSArrayCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd
196        {
197        public:
198            NSArrayCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
199
200            virtual size_t
201            CalculateNumChildren ();
202
203            virtual lldb::ValueObjectSP
204            GetChildAtIndex (size_t idx);
205
206            virtual bool
207            Update();
208
209            virtual bool
210            MightHaveChildren ();
211
212            virtual size_t
213            GetIndexOfChildWithName (const ConstString &name);
214
215            virtual
216            ~NSArrayCodeRunningSyntheticFrontEnd ();
217        };
218
219        SyntheticChildrenFrontEnd* NSArraySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
220
221        class NSDictionaryISyntheticFrontEnd : public SyntheticChildrenFrontEnd
222        {
223        private:
224            struct DataDescriptor_32
225            {
226                uint32_t _used : 26;
227                uint32_t _szidx : 6;
228            };
229            struct DataDescriptor_64
230            {
231                uint64_t _used : 58;
232                uint32_t _szidx : 6;
233            };
234
235            struct DictionaryItemDescriptor
236            {
237                lldb::addr_t key_ptr;
238                lldb::addr_t val_ptr;
239                lldb::ValueObjectSP valobj_sp;
240            };
241
242        public:
243            NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
244
245            virtual size_t
246            CalculateNumChildren ();
247
248            virtual lldb::ValueObjectSP
249            GetChildAtIndex (size_t idx);
250
251            virtual bool
252            Update();
253
254            virtual bool
255            MightHaveChildren ();
256
257            virtual size_t
258            GetIndexOfChildWithName (const ConstString &name);
259
260            virtual
261            ~NSDictionaryISyntheticFrontEnd ();
262        private:
263            ExecutionContextRef m_exe_ctx_ref;
264            uint8_t m_ptr_size;
265            DataDescriptor_32 *m_data_32;
266            DataDescriptor_64 *m_data_64;
267            lldb::addr_t m_data_ptr;
268            std::vector<DictionaryItemDescriptor> m_children;
269        };
270
271        class NSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd
272        {
273        private:
274            struct DataDescriptor_32
275            {
276                uint32_t _used : 26;
277                uint32_t _kvo : 1;
278                uint32_t _size;
279                uint32_t _mutations;
280                uint32_t _objs_addr;
281                uint32_t _keys_addr;
282            };
283            struct DataDescriptor_64
284            {
285                uint64_t _used : 58;
286                uint32_t _kvo : 1;
287                uint64_t _size;
288                uint64_t _mutations;
289                uint64_t _objs_addr;
290                uint64_t _keys_addr;
291            };
292            struct DictionaryItemDescriptor
293            {
294                lldb::addr_t key_ptr;
295                lldb::addr_t val_ptr;
296                lldb::ValueObjectSP valobj_sp;
297            };
298        public:
299            NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
300
301            virtual size_t
302            CalculateNumChildren ();
303
304            virtual lldb::ValueObjectSP
305            GetChildAtIndex (size_t idx);
306
307            virtual bool
308            Update();
309
310            virtual bool
311            MightHaveChildren ();
312
313            virtual size_t
314            GetIndexOfChildWithName (const ConstString &name);
315
316            virtual
317            ~NSDictionaryMSyntheticFrontEnd ();
318        private:
319            ExecutionContextRef m_exe_ctx_ref;
320            uint8_t m_ptr_size;
321            DataDescriptor_32 *m_data_32;
322            DataDescriptor_64 *m_data_64;
323            std::vector<DictionaryItemDescriptor> m_children;
324        };
325
326        class NSDictionaryCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd
327        {
328        public:
329            NSDictionaryCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
330
331            virtual size_t
332            CalculateNumChildren ();
333
334            virtual lldb::ValueObjectSP
335            GetChildAtIndex (size_t idx);
336
337            virtual bool
338            Update();
339
340            virtual bool
341            MightHaveChildren ();
342
343            virtual size_t
344            GetIndexOfChildWithName (const ConstString &name);
345
346            virtual
347            ~NSDictionaryCodeRunningSyntheticFrontEnd ();
348        };
349
350        SyntheticChildrenFrontEnd* NSDictionarySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
351
352        class LibcxxVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd
353        {
354        public:
355            LibcxxVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
356
357            virtual size_t
358            CalculateNumChildren ();
359
360            virtual lldb::ValueObjectSP
361            GetChildAtIndex (size_t idx);
362
363            virtual bool
364            Update();
365
366            virtual bool
367            MightHaveChildren ();
368
369            virtual size_t
370            GetIndexOfChildWithName (const ConstString &name);
371
372            virtual
373            ~LibcxxVectorBoolSyntheticFrontEnd ();
374        private:
375            ExecutionContextRef m_exe_ctx_ref;
376            uint64_t m_count;
377            lldb::addr_t m_base_data_address;
378            EvaluateExpressionOptions m_options;
379        };
380
381        SyntheticChildrenFrontEnd* LibcxxVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
382
383        class LibstdcppVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd
384        {
385        public:
386            LibstdcppVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
387
388            virtual size_t
389            CalculateNumChildren ();
390
391            virtual lldb::ValueObjectSP
392            GetChildAtIndex (size_t idx);
393
394            virtual bool
395            Update();
396
397            virtual bool
398            MightHaveChildren ();
399
400            virtual size_t
401            GetIndexOfChildWithName (const ConstString &name);
402
403            virtual
404            ~LibstdcppVectorBoolSyntheticFrontEnd ();
405        private:
406            ExecutionContextRef m_exe_ctx_ref;
407            uint64_t m_count;
408            lldb::addr_t m_base_data_address;
409            EvaluateExpressionOptions m_options;
410        };
411
412        SyntheticChildrenFrontEnd* LibstdcppVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
413
414
415    }
416}
417
418#endif
419