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