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