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/Target.h"
  23
  24 #include "clang/AST/ASTContext.h"
  25
  26 namespace 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_