CXXFormatterFunctions.h revision cba09f60618744e2155bc97c9049fa9c797698ad 
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        bool
32        ExtractSummaryFromObjCExpression (ValueObject &valobj,
33                                          const char* target_type,
34                                          const char* selector,
35                                          Stream &stream);
36
37        lldb::ValueObjectSP
38        CallSelectorOnObject (ValueObject &valobj,
39                              const char* return_type,
40                              const char* selector,
41                              uint64_t index);
42
43        lldb::ValueObjectSP
44        CallSelectorOnObject (ValueObject &valobj,
45                              const char* return_type,
46                              const char* selector,
47                              const char* key);
48
49        size_t
50        ExtractIndexFromString (const char* item_name);
51
52        bool
53        Char16StringSummaryProvider (ValueObject& valobj, Stream& stream); // char16_t* and unichar*
54
55        bool
56        Char32StringSummaryProvider (ValueObject& valobj, Stream& stream); // char32_t*
57
58        bool
59        WCharStringSummaryProvider (ValueObject& valobj, Stream& stream); // wchar_t*
60
61        bool
62        Char16SummaryProvider (ValueObject& valobj, Stream& stream); // char16_t and unichar
63
64        bool
65        Char32SummaryProvider (ValueObject& valobj, Stream& stream); // char32_t
66
67        bool
68        WCharSummaryProvider (ValueObject& valobj, Stream& stream); // wchar_t
69
70        bool
71        LibcxxStringSummaryProvider (ValueObject& valobj, Stream& stream); // libc++ std::string
72
73        bool
74        LibcxxWStringSummaryProvider (ValueObject& valobj, Stream& stream); // libc++ std::wstring
75
76        bool
77        ObjCClassSummaryProvider (ValueObject& valobj, Stream& stream);
78
79        template<bool name_entries>
80        bool
81        NSDictionarySummaryProvider (ValueObject& valobj, Stream& stream);
82
83        bool
84        NSIndexSetSummaryProvider (ValueObject& valobj, Stream& stream);
85
86        bool
87        NSArraySummaryProvider (ValueObject& valobj, Stream& stream);
88
89        template<bool cf_style>
90        bool
91        NSSetSummaryProvider (ValueObject& valobj, Stream& stream);
92
93        template<bool needs_at>
94        bool
95        NSDataSummaryProvider (ValueObject& valobj, Stream& stream);
96
97        bool
98        NSNumberSummaryProvider (ValueObject& valobj, Stream& stream);
99
100        bool
101        NSNotificationSummaryProvider (ValueObject& valobj, Stream& stream);
102
103        bool
104        NSTimeZoneSummaryProvider (ValueObject& valobj, Stream& stream);
105
106        bool
107        NSMachPortSummaryProvider (ValueObject& valobj, Stream& stream);
108
109        bool
110        CFBagSummaryProvider (ValueObject& valobj, Stream& stream);
111
112        bool
113        CFBinaryHeapSummaryProvider (ValueObject& valobj, Stream& stream);
114
115        bool
116        CFBitVectorSummaryProvider (ValueObject& valobj, Stream& stream);
117
118        bool
119        NSDateSummaryProvider (ValueObject& valobj, Stream& stream);
120
121        bool
122        CFAbsoluteTimeSummaryProvider (ValueObject& valobj, Stream& stream);
123
124        bool
125        NSBundleSummaryProvider (ValueObject& valobj, Stream& stream);
126
127        bool
128        NSStringSummaryProvider (ValueObject& valobj, Stream& stream);
129
130        bool
131        NSAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream);
132
133        bool
134        NSMutableAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream);
135
136        bool
137        NSURLSummaryProvider (ValueObject& valobj, Stream& stream);
138
139        bool
140        ObjCBOOLSummaryProvider (ValueObject& valobj, Stream& stream);
141
142        template <bool is_sel_ptr>
143        bool
144        ObjCSELSummaryProvider (ValueObject& valobj, Stream& stream);
145
146        bool
147        RuntimeSpecificDescriptionSummaryProvider (ValueObject& valobj, Stream& stream);
148
149        extern template bool
150        NSDictionarySummaryProvider<true> (ValueObject&, Stream&) ;
151
152        extern template bool
153        NSDictionarySummaryProvider<false> (ValueObject&, Stream&) ;
154
155        extern template bool
156        NSDataSummaryProvider<true> (ValueObject&, Stream&) ;
157
158        extern template bool
159        NSDataSummaryProvider<false> (ValueObject&, Stream&) ;
160
161        extern template bool
162        ObjCSELSummaryProvider<true> (ValueObject&, Stream&);
163
164        extern template bool
165        ObjCSELSummaryProvider<false> (ValueObject&, Stream&);
166
167        class NSArrayMSyntheticFrontEnd : public SyntheticChildrenFrontEnd
168        {
169        private:
170            struct DataDescriptor_32
171            {
172                uint32_t _used;
173                uint32_t _priv1 : 2 ;
174                uint32_t _size : 30;
175                uint32_t _priv2 : 2;
176                uint32_t offset : 30;
177                uint32_t _priv3;
178                uint32_t _data;
179            };
180            struct DataDescriptor_64
181            {
182                uint64_t _used;
183                uint64_t _priv1 : 2 ;
184                uint64_t _size : 62;
185                uint64_t _priv2 : 2;
186                uint64_t offset : 62;
187                uint32_t _priv3;
188                uint64_t _data;
189            };
190        public:
191            NSArrayMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
192
193            virtual size_t
194            CalculateNumChildren ();
195
196            virtual lldb::ValueObjectSP
197            GetChildAtIndex (size_t idx);
198
199            virtual bool
200            Update();
201
202            virtual bool
203            MightHaveChildren ();
204
205            virtual size_t
206            GetIndexOfChildWithName (const ConstString &name);
207
208            virtual
209            ~NSArrayMSyntheticFrontEnd ();
210        private:
211            ExecutionContextRef m_exe_ctx_ref;
212            uint8_t m_ptr_size;
213            DataDescriptor_32 *m_data_32;
214            DataDescriptor_64 *m_data_64;
215            ClangASTType m_id_type;
216            std::vector<lldb::ValueObjectSP> m_children;
217        };
218
219        class NSArrayISyntheticFrontEnd : public SyntheticChildrenFrontEnd
220        {
221        public:
222            NSArrayISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
223
224            virtual size_t
225            CalculateNumChildren ();
226
227            virtual lldb::ValueObjectSP
228            GetChildAtIndex (size_t idx);
229
230            virtual bool
231            Update();
232
233            virtual bool
234            MightHaveChildren ();
235
236            virtual size_t
237            GetIndexOfChildWithName (const ConstString &name);
238
239            virtual
240            ~NSArrayISyntheticFrontEnd ();
241        private:
242            ExecutionContextRef m_exe_ctx_ref;
243            uint8_t m_ptr_size;
244            uint64_t m_items;
245            lldb::addr_t m_data_ptr;
246            ClangASTType m_id_type;
247            std::vector<lldb::ValueObjectSP> m_children;
248        };
249
250        class NSArrayCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd
251        {
252        public:
253            NSArrayCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
254
255            virtual size_t
256            CalculateNumChildren ();
257
258            virtual lldb::ValueObjectSP
259            GetChildAtIndex (size_t idx);
260
261            virtual bool
262            Update();
263
264            virtual bool
265            MightHaveChildren ();
266
267            virtual size_t
268            GetIndexOfChildWithName (const ConstString &name);
269
270            virtual
271            ~NSArrayCodeRunningSyntheticFrontEnd ();
272        };
273
274        SyntheticChildrenFrontEnd* NSArraySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
275
276        class NSDictionaryISyntheticFrontEnd : public SyntheticChildrenFrontEnd
277        {
278        private:
279            struct DataDescriptor_32
280            {
281                uint32_t _used : 26;
282                uint32_t _szidx : 6;
283            };
284            struct DataDescriptor_64
285            {
286                uint64_t _used : 58;
287                uint32_t _szidx : 6;
288            };
289
290            struct DictionaryItemDescriptor
291            {
292                lldb::addr_t key_ptr;
293                lldb::addr_t val_ptr;
294                lldb::ValueObjectSP valobj_sp;
295            };
296
297        public:
298            NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
299
300            virtual size_t
301            CalculateNumChildren ();
302
303            virtual lldb::ValueObjectSP
304            GetChildAtIndex (size_t idx);
305
306            virtual bool
307            Update();
308
309            virtual bool
310            MightHaveChildren ();
311
312            virtual size_t
313            GetIndexOfChildWithName (const ConstString &name);
314
315            virtual
316            ~NSDictionaryISyntheticFrontEnd ();
317        private:
318            ExecutionContextRef m_exe_ctx_ref;
319            uint8_t m_ptr_size;
320            DataDescriptor_32 *m_data_32;
321            DataDescriptor_64 *m_data_64;
322            lldb::addr_t m_data_ptr;
323            std::vector<DictionaryItemDescriptor> m_children;
324        };
325
326        class NSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd
327        {
328        private:
329            struct DataDescriptor_32
330            {
331                uint32_t _used : 26;
332                uint32_t _kvo : 1;
333                uint32_t _size;
334                uint32_t _mutations;
335                uint32_t _objs_addr;
336                uint32_t _keys_addr;
337            };
338            struct DataDescriptor_64
339            {
340                uint64_t _used : 58;
341                uint32_t _kvo : 1;
342                uint64_t _size;
343                uint64_t _mutations;
344                uint64_t _objs_addr;
345                uint64_t _keys_addr;
346            };
347            struct DictionaryItemDescriptor
348            {
349                lldb::addr_t key_ptr;
350                lldb::addr_t val_ptr;
351                lldb::ValueObjectSP valobj_sp;
352            };
353        public:
354            NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
355
356            virtual size_t
357            CalculateNumChildren ();
358
359            virtual lldb::ValueObjectSP
360            GetChildAtIndex (size_t idx);
361
362            virtual bool
363            Update();
364
365            virtual bool
366            MightHaveChildren ();
367
368            virtual size_t
369            GetIndexOfChildWithName (const ConstString &name);
370
371            virtual
372            ~NSDictionaryMSyntheticFrontEnd ();
373        private:
374            ExecutionContextRef m_exe_ctx_ref;
375            uint8_t m_ptr_size;
376            DataDescriptor_32 *m_data_32;
377            DataDescriptor_64 *m_data_64;
378            std::vector<DictionaryItemDescriptor> m_children;
379        };
380
381        class NSDictionaryCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd
382        {
383        public:
384            NSDictionaryCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
385
386            virtual size_t
387            CalculateNumChildren ();
388
389            virtual lldb::ValueObjectSP
390            GetChildAtIndex (size_t idx);
391
392            virtual bool
393            Update();
394
395            virtual bool
396            MightHaveChildren ();
397
398            virtual size_t
399            GetIndexOfChildWithName (const ConstString &name);
400
401            virtual
402            ~NSDictionaryCodeRunningSyntheticFrontEnd ();
403        };
404
405        SyntheticChildrenFrontEnd* NSDictionarySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
406
407        class NSSetISyntheticFrontEnd : public SyntheticChildrenFrontEnd
408        {
409        private:
410            struct DataDescriptor_32
411            {
412                uint32_t _used : 26;
413                uint32_t _szidx : 6;
414            };
415            struct DataDescriptor_64
416            {
417                uint64_t _used : 58;
418                uint32_t _szidx : 6;
419            };
420
421            struct SetItemDescriptor
422            {
423                lldb::addr_t item_ptr;
424                lldb::ValueObjectSP valobj_sp;
425            };
426
427        public:
428            NSSetISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
429
430            virtual size_t
431            CalculateNumChildren ();
432
433            virtual lldb::ValueObjectSP
434            GetChildAtIndex (size_t idx);
435
436            virtual bool
437            Update();
438
439            virtual bool
440            MightHaveChildren ();
441
442            virtual size_t
443            GetIndexOfChildWithName (const ConstString &name);
444
445            virtual
446            ~NSSetISyntheticFrontEnd ();
447        private:
448            ExecutionContextRef m_exe_ctx_ref;
449            uint8_t m_ptr_size;
450            DataDescriptor_32 *m_data_32;
451            DataDescriptor_64 *m_data_64;
452            lldb::addr_t m_data_ptr;
453            std::vector<SetItemDescriptor> m_children;
454        };
455
456        class NSSetMSyntheticFrontEnd : public SyntheticChildrenFrontEnd
457        {
458        private:
459            struct DataDescriptor_32
460            {
461                uint32_t _used : 26;
462                uint32_t _size;
463                uint32_t _mutations;
464                uint32_t _objs_addr;
465            };
466            struct DataDescriptor_64
467            {
468                uint64_t _used : 58;
469                uint64_t _size;
470                uint64_t _mutations;
471                uint64_t _objs_addr;
472            };
473            struct SetItemDescriptor
474            {
475                lldb::addr_t item_ptr;
476                lldb::ValueObjectSP valobj_sp;
477            };
478        public:
479            NSSetMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
480
481            virtual size_t
482            CalculateNumChildren ();
483
484            virtual lldb::ValueObjectSP
485            GetChildAtIndex (size_t idx);
486
487            virtual bool
488            Update();
489
490            virtual bool
491            MightHaveChildren ();
492
493            virtual size_t
494            GetIndexOfChildWithName (const ConstString &name);
495
496            virtual
497            ~NSSetMSyntheticFrontEnd ();
498        private:
499            ExecutionContextRef m_exe_ctx_ref;
500            uint8_t m_ptr_size;
501            DataDescriptor_32 *m_data_32;
502            DataDescriptor_64 *m_data_64;
503            std::vector<SetItemDescriptor> m_children;
504        };
505
506        class NSSetCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd
507        {
508        public:
509            NSSetCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
510
511            virtual size_t
512            CalculateNumChildren ();
513
514            virtual lldb::ValueObjectSP
515            GetChildAtIndex (size_t idx);
516
517            virtual bool
518            Update();
519
520            virtual bool
521            MightHaveChildren ();
522
523            virtual size_t
524            GetIndexOfChildWithName (const ConstString &name);
525
526            virtual
527            ~NSSetCodeRunningSyntheticFrontEnd ();
528        };
529
530        SyntheticChildrenFrontEnd* NSSetSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
531
532        class LibcxxVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd
533        {
534        public:
535            LibcxxVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
536
537            virtual size_t
538            CalculateNumChildren ();
539
540            virtual lldb::ValueObjectSP
541            GetChildAtIndex (size_t idx);
542
543            virtual bool
544            Update();
545
546            virtual bool
547            MightHaveChildren ();
548
549            virtual size_t
550            GetIndexOfChildWithName (const ConstString &name);
551
552            virtual
553            ~LibcxxVectorBoolSyntheticFrontEnd ();
554        private:
555            ExecutionContextRef m_exe_ctx_ref;
556            uint64_t m_count;
557            lldb::addr_t m_base_data_address;
558            EvaluateExpressionOptions m_options;
559        };
560
561        SyntheticChildrenFrontEnd* LibcxxVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
562
563        class LibstdcppVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd
564        {
565        public:
566            LibstdcppVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
567
568            virtual size_t
569            CalculateNumChildren ();
570
571            virtual lldb::ValueObjectSP
572            GetChildAtIndex (size_t idx);
573
574            virtual bool
575            Update();
576
577            virtual bool
578            MightHaveChildren ();
579
580            virtual size_t
581            GetIndexOfChildWithName (const ConstString &name);
582
583            virtual
584            ~LibstdcppVectorBoolSyntheticFrontEnd ();
585        private:
586            ExecutionContextRef m_exe_ctx_ref;
587            uint64_t m_count;
588            lldb::addr_t m_base_data_address;
589            EvaluateExpressionOptions m_options;
590        };
591
592        SyntheticChildrenFrontEnd* LibstdcppVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
593
594        class LibstdcppMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd
595        {
596        public:
597            LibstdcppMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
598
599            virtual size_t
600            CalculateNumChildren ();
601
602            virtual lldb::ValueObjectSP
603            GetChildAtIndex (size_t idx);
604
605            virtual bool
606            Update();
607
608            virtual bool
609            MightHaveChildren ();
610
611            virtual size_t
612            GetIndexOfChildWithName (const ConstString &name);
613
614            virtual
615            ~LibstdcppMapIteratorSyntheticFrontEnd ();
616        private:
617            ExecutionContextRef m_exe_ctx_ref;
618            lldb::addr_t m_pair_address;
619            ClangASTType m_pair_type;
620            EvaluateExpressionOptions m_options;
621            lldb::ValueObjectSP m_pair_sp;
622        };
623
624        SyntheticChildrenFrontEnd* LibstdcppMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
625
626        class LibCxxMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd
627        {
628        public:
629            LibCxxMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
630
631            virtual size_t
632            CalculateNumChildren ();
633
634            virtual lldb::ValueObjectSP
635            GetChildAtIndex (size_t idx);
636
637            virtual bool
638            Update();
639
640            virtual bool
641            MightHaveChildren ();
642
643            virtual size_t
644            GetIndexOfChildWithName (const ConstString &name);
645
646            virtual
647            ~LibCxxMapIteratorSyntheticFrontEnd ();
648        private:
649            ValueObject *m_pair_ptr;
650        };
651
652        SyntheticChildrenFrontEnd* LibCxxMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
653
654        class VectorIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd
655        {
656        public:
657            VectorIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp,
658                                             ConstString item_name);
659
660            virtual size_t
661            CalculateNumChildren ();
662
663            virtual lldb::ValueObjectSP
664            GetChildAtIndex (size_t idx);
665
666            virtual bool
667            Update();
668
669            virtual bool
670            MightHaveChildren ();
671
672            virtual size_t
673            GetIndexOfChildWithName (const ConstString &name);
674
675            virtual
676            ~VectorIteratorSyntheticFrontEnd ();
677        private:
678            ExecutionContextRef m_exe_ctx_ref;
679            ConstString m_item_name;
680            lldb::ValueObjectSP m_item_sp;
681        };
682
683        SyntheticChildrenFrontEnd* LibCxxVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
684
685        SyntheticChildrenFrontEnd* LibStdcppVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
686
687    } // namespace formatters
688} // namespace lldb_private
689
690#endif // liblldb_CXXFormatterFunctions_h_
691