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