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