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