contrib/llvm/tools/lldb/include/lldb/DataFormatters/CXXFormatterFunctions.h

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