CXXFormatterFunctions.h revision 269024 
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 <time.h>
15
16#include "lldb/lldb-forward.h"
17
18#include "lldb/Core/ConstString.h"
19#include "lldb/DataFormatters/FormatClasses.h"
20#include "lldb/DataFormatters/TypeSynthetic.h"
21#include "lldb/Target/ExecutionContext.h"
22#include "lldb/Target/Target.h"
23
24#include "clang/AST/ASTContext.h"
25
26namespace lldb_private {
27    namespace formatters
28    {
29        bool
30        ExtractValueFromObjCExpression (ValueObject &valobj,
31                                        const char* target_type,
32                                        const char* selector,
33                                        uint64_t &value);
34
35        bool
36        ExtractSummaryFromObjCExpression (ValueObject &valobj,
37                                          const char* target_type,
38                                          const char* selector,
39                                          Stream &stream);
40
41        lldb::ValueObjectSP
42        CallSelectorOnObject (ValueObject &valobj,
43                              const char* return_type,
44                              const char* selector,
45                              uint64_t index);
46
47        lldb::ValueObjectSP
48        CallSelectorOnObject (ValueObject &valobj,
49                              const char* return_type,
50                              const char* selector,
51                              const char* key);
52
53        size_t
54        ExtractIndexFromString (const char* item_name);
55
56        time_t
57        GetOSXEpoch ();
58
59        bool
60        Char16StringSummaryProvider (ValueObject& valobj, Stream& stream); // char16_t* and unichar*
61
62        bool
63        Char32StringSummaryProvider (ValueObject& valobj, Stream& stream); // char32_t*
64
65        bool
66        WCharStringSummaryProvider (ValueObject& valobj, Stream& stream); // wchar_t*
67
68        bool
69        Char16SummaryProvider (ValueObject& valobj, Stream& stream); // char16_t and unichar
70
71        bool
72        Char32SummaryProvider (ValueObject& valobj, Stream& stream); // char32_t
73
74        bool
75        WCharSummaryProvider (ValueObject& valobj, Stream& stream); // wchar_t
76
77        bool
78        LibcxxStringSummaryProvider (ValueObject& valobj, Stream& stream); // libc++ std::string
79
80        bool
81        LibcxxWStringSummaryProvider (ValueObject& valobj, Stream& stream); // libc++ std::wstring
82
83        bool
84        LibcxxSmartPointerSummaryProvider (ValueObject& valobj, Stream& stream); // libc++ std::shared_ptr<> and std::weak_ptr<>
85
86        bool
87        ObjCClassSummaryProvider (ValueObject& valobj, Stream& stream);
88
89        SyntheticChildrenFrontEnd* ObjCClassSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
90
91        template<bool name_entries>
92        bool
93        NSDictionarySummaryProvider (ValueObject& valobj, Stream& stream);
94
95        bool
96        NSIndexSetSummaryProvider (ValueObject& valobj, Stream& stream);
97
98        bool
99        NSArraySummaryProvider (ValueObject& valobj, Stream& stream);
100
101        template<bool cf_style>
102        bool
103        NSSetSummaryProvider (ValueObject& valobj, Stream& stream);
104
105        template<bool needs_at>
106        bool
107        NSDataSummaryProvider (ValueObject& valobj, Stream& stream);
108
109        bool
110        NSNumberSummaryProvider (ValueObject& valobj, Stream& stream);
111
112        bool
113        NSNotificationSummaryProvider (ValueObject& valobj, Stream& stream);
114
115        bool
116        NSTimeZoneSummaryProvider (ValueObject& valobj, Stream& stream);
117
118        bool
119        NSMachPortSummaryProvider (ValueObject& valobj, Stream& stream);
120
121        bool
122        CFBagSummaryProvider (ValueObject& valobj, Stream& stream);
123
124        bool
125        CFBinaryHeapSummaryProvider (ValueObject& valobj, Stream& stream);
126
127        bool
128        CFBitVectorSummaryProvider (ValueObject& valobj, Stream& stream);
129
130        bool
131        NSDateSummaryProvider (ValueObject& valobj, Stream& stream);
132
133        bool
134        CFAbsoluteTimeSummaryProvider (ValueObject& valobj, Stream& stream);
135
136        bool
137        NSBundleSummaryProvider (ValueObject& valobj, Stream& stream);
138
139        bool
140        NSStringSummaryProvider (ValueObject& valobj, Stream& stream);
141
142        bool
143        NSAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream);
144
145        bool
146        NSMutableAttributedStringSummaryProvider (ValueObject& valobj, Stream& stream);
147
148        bool
149        NSURLSummaryProvider (ValueObject& valobj, Stream& stream);
150
151        bool
152        ObjCBOOLSummaryProvider (ValueObject& valobj, Stream& stream);
153
154        template <bool is_sel_ptr>
155        bool
156        ObjCSELSummaryProvider (ValueObject& valobj, Stream& stream);
157
158        bool
159        RuntimeSpecificDescriptionSummaryProvider (ValueObject& valobj, Stream& stream);
160
161        extern template bool
162        NSDictionarySummaryProvider<true> (ValueObject&, Stream&) ;
163
164        extern template bool
165        NSDictionarySummaryProvider<false> (ValueObject&, Stream&) ;
166
167        extern template bool
168        NSDataSummaryProvider<true> (ValueObject&, Stream&) ;
169
170        extern template bool
171        NSDataSummaryProvider<false> (ValueObject&, Stream&) ;
172
173        extern template bool
174        ObjCSELSummaryProvider<true> (ValueObject&, Stream&);
175
176        extern template bool
177        ObjCSELSummaryProvider<false> (ValueObject&, Stream&);
178
179        class NSArrayMSyntheticFrontEnd : public SyntheticChildrenFrontEnd
180        {
181        private:
182            struct DataDescriptor_32
183            {
184                uint32_t _used;
185                uint32_t _priv1 : 2 ;
186                uint32_t _size : 30;
187                uint32_t _priv2 : 2;
188                uint32_t offset : 30;
189                uint32_t _priv3;
190                uint32_t _data;
191            };
192            struct DataDescriptor_64
193            {
194                uint64_t _used;
195                uint64_t _priv1 : 2 ;
196                uint64_t _size : 62;
197                uint64_t _priv2 : 2;
198                uint64_t offset : 62;
199                uint32_t _priv3;
200                uint64_t _data;
201            };
202        public:
203            NSArrayMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
204
205            virtual size_t
206            CalculateNumChildren ();
207
208            virtual lldb::ValueObjectSP
209            GetChildAtIndex (size_t idx);
210
211            virtual bool
212            Update();
213
214            virtual bool
215            MightHaveChildren ();
216
217            virtual size_t
218            GetIndexOfChildWithName (const ConstString &name);
219
220            virtual
221            ~NSArrayMSyntheticFrontEnd ();
222        private:
223            ExecutionContextRef m_exe_ctx_ref;
224            uint8_t m_ptr_size;
225            DataDescriptor_32 *m_data_32;
226            DataDescriptor_64 *m_data_64;
227            ClangASTType m_id_type;
228            std::vector<lldb::ValueObjectSP> m_children;
229        };
230
231        class NSArrayISyntheticFrontEnd : public SyntheticChildrenFrontEnd
232        {
233        public:
234            NSArrayISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
235
236            virtual size_t
237            CalculateNumChildren ();
238
239            virtual lldb::ValueObjectSP
240            GetChildAtIndex (size_t idx);
241
242            virtual bool
243            Update();
244
245            virtual bool
246            MightHaveChildren ();
247
248            virtual size_t
249            GetIndexOfChildWithName (const ConstString &name);
250
251            virtual
252            ~NSArrayISyntheticFrontEnd ();
253        private:
254            ExecutionContextRef m_exe_ctx_ref;
255            uint8_t m_ptr_size;
256            uint64_t m_items;
257            lldb::addr_t m_data_ptr;
258            ClangASTType m_id_type;
259            std::vector<lldb::ValueObjectSP> m_children;
260        };
261
262        class NSArrayCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd
263        {
264        public:
265            NSArrayCodeRunningSyntheticFrontEnd (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            ~NSArrayCodeRunningSyntheticFrontEnd ();
284        };
285
286        SyntheticChildrenFrontEnd* NSArraySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
287
288        class NSDictionaryISyntheticFrontEnd : public SyntheticChildrenFrontEnd
289        {
290        private:
291            struct DataDescriptor_32
292            {
293                uint32_t _used : 26;
294                uint32_t _szidx : 6;
295            };
296            struct DataDescriptor_64
297            {
298                uint64_t _used : 58;
299                uint32_t _szidx : 6;
300            };
301
302            struct DictionaryItemDescriptor
303            {
304                lldb::addr_t key_ptr;
305                lldb::addr_t val_ptr;
306                lldb::ValueObjectSP valobj_sp;
307            };
308
309        public:
310            NSDictionaryISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
311
312            virtual size_t
313            CalculateNumChildren ();
314
315            virtual lldb::ValueObjectSP
316            GetChildAtIndex (size_t idx);
317
318            virtual bool
319            Update();
320
321            virtual bool
322            MightHaveChildren ();
323
324            virtual size_t
325            GetIndexOfChildWithName (const ConstString &name);
326
327            virtual
328            ~NSDictionaryISyntheticFrontEnd ();
329        private:
330            ExecutionContextRef m_exe_ctx_ref;
331            uint8_t m_ptr_size;
332            lldb::ByteOrder m_order;
333            DataDescriptor_32 *m_data_32;
334            DataDescriptor_64 *m_data_64;
335            lldb::addr_t m_data_ptr;
336            ClangASTType m_pair_type;
337            std::vector<DictionaryItemDescriptor> m_children;
338        };
339
340        class NSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd
341        {
342        private:
343            struct DataDescriptor_32
344            {
345                uint32_t _used : 26;
346                uint32_t _kvo : 1;
347                uint32_t _size;
348                uint32_t _mutations;
349                uint32_t _objs_addr;
350                uint32_t _keys_addr;
351            };
352            struct DataDescriptor_64
353            {
354                uint64_t _used : 58;
355                uint32_t _kvo : 1;
356                uint64_t _size;
357                uint64_t _mutations;
358                uint64_t _objs_addr;
359                uint64_t _keys_addr;
360            };
361            struct DictionaryItemDescriptor
362            {
363                lldb::addr_t key_ptr;
364                lldb::addr_t val_ptr;
365                lldb::ValueObjectSP valobj_sp;
366            };
367        public:
368            NSDictionaryMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
369
370            virtual size_t
371            CalculateNumChildren ();
372
373            virtual lldb::ValueObjectSP
374            GetChildAtIndex (size_t idx);
375
376            virtual bool
377            Update();
378
379            virtual bool
380            MightHaveChildren ();
381
382            virtual size_t
383            GetIndexOfChildWithName (const ConstString &name);
384
385            virtual
386            ~NSDictionaryMSyntheticFrontEnd ();
387        private:
388            ExecutionContextRef m_exe_ctx_ref;
389            uint8_t m_ptr_size;
390            lldb::ByteOrder m_order;
391            DataDescriptor_32 *m_data_32;
392            DataDescriptor_64 *m_data_64;
393            ClangASTType m_pair_type;
394            std::vector<DictionaryItemDescriptor> m_children;
395        };
396
397        class NSDictionaryCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd
398        {
399        public:
400            NSDictionaryCodeRunningSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
401
402            virtual size_t
403            CalculateNumChildren ();
404
405            virtual lldb::ValueObjectSP
406            GetChildAtIndex (size_t idx);
407
408            virtual bool
409            Update();
410
411            virtual bool
412            MightHaveChildren ();
413
414            virtual size_t
415            GetIndexOfChildWithName (const ConstString &name);
416
417            virtual
418            ~NSDictionaryCodeRunningSyntheticFrontEnd ();
419        };
420
421        SyntheticChildrenFrontEnd* NSDictionarySyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
422
423        class NSSetISyntheticFrontEnd : public SyntheticChildrenFrontEnd
424        {
425        private:
426            struct DataDescriptor_32
427            {
428                uint32_t _used : 26;
429                uint32_t _szidx : 6;
430            };
431            struct DataDescriptor_64
432            {
433                uint64_t _used : 58;
434                uint32_t _szidx : 6;
435            };
436
437            struct SetItemDescriptor
438            {
439                lldb::addr_t item_ptr;
440                lldb::ValueObjectSP valobj_sp;
441            };
442
443        public:
444            NSSetISyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
445
446            virtual size_t
447            CalculateNumChildren ();
448
449            virtual lldb::ValueObjectSP
450            GetChildAtIndex (size_t idx);
451
452            virtual bool
453            Update();
454
455            virtual bool
456            MightHaveChildren ();
457
458            virtual size_t
459            GetIndexOfChildWithName (const ConstString &name);
460
461            virtual
462            ~NSSetISyntheticFrontEnd ();
463        private:
464            ExecutionContextRef m_exe_ctx_ref;
465            uint8_t m_ptr_size;
466            DataDescriptor_32 *m_data_32;
467            DataDescriptor_64 *m_data_64;
468            lldb::addr_t m_data_ptr;
469            std::vector<SetItemDescriptor> m_children;
470        };
471
472        class NSOrderedSetSyntheticFrontEnd : public SyntheticChildrenFrontEnd
473        {
474        private:
475
476        public:
477            NSOrderedSetSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
478
479            virtual size_t
480            CalculateNumChildren ();
481
482            virtual lldb::ValueObjectSP
483            GetChildAtIndex (size_t idx);
484
485            virtual bool
486            Update();
487
488            virtual bool
489            MightHaveChildren ();
490
491            virtual size_t
492            GetIndexOfChildWithName (const ConstString &name);
493
494            virtual
495            ~NSOrderedSetSyntheticFrontEnd ();
496        private:
497            uint32_t m_count;
498            std::map<uint32_t,lldb::ValueObjectSP> m_children;
499        };
500
501        class NSSetMSyntheticFrontEnd : public SyntheticChildrenFrontEnd
502        {
503        private:
504            struct DataDescriptor_32
505            {
506                uint32_t _used : 26;
507                uint32_t _size;
508                uint32_t _mutations;
509                uint32_t _objs_addr;
510            };
511            struct DataDescriptor_64
512            {
513                uint64_t _used : 58;
514                uint64_t _size;
515                uint64_t _mutations;
516                uint64_t _objs_addr;
517            };
518            struct SetItemDescriptor
519            {
520                lldb::addr_t item_ptr;
521                lldb::ValueObjectSP valobj_sp;
522            };
523        public:
524            NSSetMSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
525
526            virtual size_t
527            CalculateNumChildren ();
528
529            virtual lldb::ValueObjectSP
530            GetChildAtIndex (size_t idx);
531
532            virtual bool
533            Update();
534
535            virtual bool
536            MightHaveChildren ();
537
538            virtual size_t
539            GetIndexOfChildWithName (const ConstString &name);
540
541            virtual
542            ~NSSetMSyntheticFrontEnd ();
543        private:
544            ExecutionContextRef m_exe_ctx_ref;
545            uint8_t m_ptr_size;
546            DataDescriptor_32 *m_data_32;
547            DataDescriptor_64 *m_data_64;
548            std::vector<SetItemDescriptor> m_children;
549        };
550
551        class NSSetCodeRunningSyntheticFrontEnd : public SyntheticChildrenFrontEnd
552        {
553        public:
554            NSSetCodeRunningSyntheticFrontEnd (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            ~NSSetCodeRunningSyntheticFrontEnd ();
573        };
574
575        SyntheticChildrenFrontEnd* NSSetSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
576
577        class LibcxxVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd
578        {
579        public:
580            LibcxxVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
581
582            virtual size_t
583            CalculateNumChildren ();
584
585            virtual lldb::ValueObjectSP
586            GetChildAtIndex (size_t idx);
587
588            virtual bool
589            Update();
590
591            virtual bool
592            MightHaveChildren ();
593
594            virtual size_t
595            GetIndexOfChildWithName (const ConstString &name);
596
597            virtual
598            ~LibcxxVectorBoolSyntheticFrontEnd ();
599        private:
600            ClangASTType m_bool_type;
601            ExecutionContextRef m_exe_ctx_ref;
602            uint64_t m_count;
603            lldb::addr_t m_base_data_address;
604            std::map<size_t,lldb::ValueObjectSP> m_children;
605        };
606
607        SyntheticChildrenFrontEnd* LibcxxVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
608
609        bool
610        LibcxxContainerSummaryProvider (ValueObject& valobj, Stream& stream);
611
612        class LibstdcppVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd
613        {
614        public:
615            LibstdcppVectorBoolSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
616
617            virtual size_t
618            CalculateNumChildren ();
619
620            virtual lldb::ValueObjectSP
621            GetChildAtIndex (size_t idx);
622
623            virtual bool
624            Update();
625
626            virtual bool
627            MightHaveChildren ();
628
629            virtual size_t
630            GetIndexOfChildWithName (const ConstString &name);
631
632            virtual
633            ~LibstdcppVectorBoolSyntheticFrontEnd ();
634        private:
635            ExecutionContextRef m_exe_ctx_ref;
636            uint64_t m_count;
637            lldb::addr_t m_base_data_address;
638            EvaluateExpressionOptions m_options;
639        };
640
641        SyntheticChildrenFrontEnd* LibstdcppVectorBoolSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
642
643        class LibstdcppMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd
644        {
645        public:
646            LibstdcppMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
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            ~LibstdcppMapIteratorSyntheticFrontEnd ();
665        private:
666            ExecutionContextRef m_exe_ctx_ref;
667            lldb::addr_t m_pair_address;
668            ClangASTType m_pair_type;
669            EvaluateExpressionOptions m_options;
670            lldb::ValueObjectSP m_pair_sp;
671        };
672
673        SyntheticChildrenFrontEnd* LibstdcppMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
674
675        class LibCxxMapIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd
676        {
677        public:
678            LibCxxMapIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
679
680            virtual size_t
681            CalculateNumChildren ();
682
683            virtual lldb::ValueObjectSP
684            GetChildAtIndex (size_t idx);
685
686            virtual bool
687            Update();
688
689            virtual bool
690            MightHaveChildren ();
691
692            virtual size_t
693            GetIndexOfChildWithName (const ConstString &name);
694
695            virtual
696            ~LibCxxMapIteratorSyntheticFrontEnd ();
697        private:
698            ValueObject *m_pair_ptr;
699        };
700
701        SyntheticChildrenFrontEnd* LibCxxMapIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
702
703        class VectorIteratorSyntheticFrontEnd : public SyntheticChildrenFrontEnd
704        {
705        public:
706            VectorIteratorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp,
707                                             ConstString item_name);
708
709            virtual size_t
710            CalculateNumChildren ();
711
712            virtual lldb::ValueObjectSP
713            GetChildAtIndex (size_t idx);
714
715            virtual bool
716            Update();
717
718            virtual bool
719            MightHaveChildren ();
720
721            virtual size_t
722            GetIndexOfChildWithName (const ConstString &name);
723
724            virtual
725            ~VectorIteratorSyntheticFrontEnd ();
726        private:
727            ExecutionContextRef m_exe_ctx_ref;
728            ConstString m_item_name;
729            lldb::ValueObjectSP m_item_sp;
730        };
731
732        SyntheticChildrenFrontEnd* LibCxxVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
733
734        SyntheticChildrenFrontEnd* LibStdcppVectorIteratorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
735
736        class LibcxxSharedPtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd
737        {
738        public:
739            LibcxxSharedPtrSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
740
741            virtual size_t
742            CalculateNumChildren ();
743
744            virtual lldb::ValueObjectSP
745            GetChildAtIndex (size_t idx);
746
747            virtual bool
748            Update();
749
750            virtual bool
751            MightHaveChildren ();
752
753            virtual size_t
754            GetIndexOfChildWithName (const ConstString &name);
755
756            virtual
757            ~LibcxxSharedPtrSyntheticFrontEnd ();
758        private:
759            ValueObject* m_cntrl;
760            lldb::ValueObjectSP m_count_sp;
761            lldb::ValueObjectSP m_weak_count_sp;
762            uint8_t m_ptr_size;
763            lldb::ByteOrder m_byte_order;
764        };
765
766        SyntheticChildrenFrontEnd* LibcxxSharedPtrSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
767
768        class LibcxxStdVectorSyntheticFrontEnd : public SyntheticChildrenFrontEnd
769        {
770        public:
771            LibcxxStdVectorSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
772
773            virtual size_t
774            CalculateNumChildren ();
775
776            virtual lldb::ValueObjectSP
777            GetChildAtIndex (size_t idx);
778
779            virtual bool
780            Update();
781
782            virtual bool
783            MightHaveChildren ();
784
785            virtual size_t
786            GetIndexOfChildWithName (const ConstString &name);
787
788            virtual
789            ~LibcxxStdVectorSyntheticFrontEnd ();
790        private:
791            ValueObject* m_start;
792            ValueObject* m_finish;
793            ClangASTType m_element_type;
794            uint32_t m_element_size;
795            std::map<size_t,lldb::ValueObjectSP> m_children;
796        };
797
798        SyntheticChildrenFrontEnd* LibcxxStdVectorSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
799
800        class LibcxxStdListSyntheticFrontEnd : public SyntheticChildrenFrontEnd
801        {
802        public:
803            LibcxxStdListSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
804
805            virtual size_t
806            CalculateNumChildren ();
807
808            virtual lldb::ValueObjectSP
809            GetChildAtIndex (size_t idx);
810
811            virtual bool
812            Update();
813
814            virtual bool
815            MightHaveChildren ();
816
817            virtual size_t
818            GetIndexOfChildWithName (const ConstString &name);
819
820            virtual
821            ~LibcxxStdListSyntheticFrontEnd ();
822        private:
823            bool
824            HasLoop();
825
826            size_t m_list_capping_size;
827            static const bool g_use_loop_detect = true;
828            lldb::addr_t m_node_address;
829            ValueObject* m_head;
830            ValueObject* m_tail;
831            ClangASTType m_element_type;
832            size_t m_count;
833            std::map<size_t,lldb::ValueObjectSP> m_children;
834        };
835
836        SyntheticChildrenFrontEnd* LibcxxStdListSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
837
838        class LibcxxStdMapSyntheticFrontEnd : public SyntheticChildrenFrontEnd
839        {
840        public:
841            LibcxxStdMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
842
843            virtual size_t
844            CalculateNumChildren ();
845
846            virtual lldb::ValueObjectSP
847            GetChildAtIndex (size_t idx);
848
849            virtual bool
850            Update();
851
852            virtual bool
853            MightHaveChildren ();
854
855            virtual size_t
856            GetIndexOfChildWithName (const ConstString &name);
857
858            virtual
859            ~LibcxxStdMapSyntheticFrontEnd ();
860        private:
861            bool
862            GetDataType();
863
864            void
865            GetValueOffset (const lldb::ValueObjectSP& node);
866
867            ValueObject* m_tree;
868            ValueObject* m_root_node;
869            ClangASTType m_element_type;
870            uint32_t m_skip_size;
871            size_t m_count;
872            std::map<size_t,lldb::ValueObjectSP> m_children;
873        };
874
875        SyntheticChildrenFrontEnd* LibcxxStdMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
876
877        class LibcxxStdUnorderedMapSyntheticFrontEnd : public SyntheticChildrenFrontEnd
878        {
879        public:
880            LibcxxStdUnorderedMapSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp);
881
882            virtual size_t
883            CalculateNumChildren ();
884
885            virtual lldb::ValueObjectSP
886            GetChildAtIndex (size_t idx);
887
888            virtual bool
889            Update();
890
891            virtual bool
892            MightHaveChildren ();
893
894            virtual size_t
895            GetIndexOfChildWithName (const ConstString &name);
896
897            virtual
898            ~LibcxxStdUnorderedMapSyntheticFrontEnd ();
899        private:
900
901            ValueObject* m_tree;
902            size_t m_num_elements;
903            ValueObject* m_next_element;
904            std::map<size_t,lldb::ValueObjectSP> m_children;
905            std::vector<std::pair<ValueObject*, uint64_t> > m_elements_cache;
906        };
907
908        SyntheticChildrenFrontEnd* LibcxxStdUnorderedMapSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP);
909
910    } // namespace formatters
911} // namespace lldb_private
912
913#endif // liblldb_CXXFormatterFunctions_h_
914