1 //===-- LibCxx.cpp --------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "LibCxx.h" 10 11 #include "lldb/Core/Debugger.h" 12 #include "lldb/Core/FormatEntity.h" 13 #include "lldb/Core/ValueObject.h" 14 #include "lldb/Core/ValueObjectConstResult.h" 15 #include "lldb/DataFormatters/FormattersHelpers.h" 16 #include "lldb/DataFormatters/StringPrinter.h" 17 #include "lldb/DataFormatters/TypeSummary.h" 18 #include "lldb/DataFormatters/VectorIterator.h" 19 #include "lldb/Target/ProcessStructReader.h" 20 #include "lldb/Target/SectionLoadList.h" 21 #include "lldb/Target/Target.h" 22 #include "lldb/Utility/ConstString.h" 23 #include "lldb/Utility/DataBufferHeap.h" 24 #include "lldb/Utility/Endian.h" 25 #include "lldb/Utility/Status.h" 26 #include "lldb/Utility/Stream.h" 27 28 #include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h" 29 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h" 30 #include <tuple> 31 32 using namespace lldb; 33 using namespace lldb_private; 34 using namespace lldb_private::formatters; 35 36 bool lldb_private::formatters::LibcxxOptionalSummaryProvider( 37 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 38 ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue()); 39 if (!valobj_sp) 40 return false; 41 42 // An optional either contains a value or not, the member __engaged_ is 43 // a bool flag, it is true if the optional has a value and false otherwise. 44 ValueObjectSP engaged_sp( 45 valobj_sp->GetChildMemberWithName(ConstString("__engaged_"), true)); 46 47 if (!engaged_sp) 48 return false; 49 50 llvm::StringRef engaged_as_cstring( 51 engaged_sp->GetValueAsUnsigned(0) == 1 ? "true" : "false"); 52 53 stream.Printf(" Has Value=%s ", engaged_as_cstring.data()); 54 55 return true; 56 } 57 58 bool lldb_private::formatters::LibcxxFunctionSummaryProvider( 59 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 60 61 ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue()); 62 63 if (!valobj_sp) 64 return false; 65 66 ExecutionContext exe_ctx(valobj_sp->GetExecutionContextRef()); 67 Process *process = exe_ctx.GetProcessPtr(); 68 69 if (process == nullptr) 70 return false; 71 72 CPPLanguageRuntime *cpp_runtime = CPPLanguageRuntime::Get(*process); 73 74 if (!cpp_runtime) 75 return false; 76 77 CPPLanguageRuntime::LibCppStdFunctionCallableInfo callable_info = 78 cpp_runtime->FindLibCppStdFunctionCallableInfo(valobj_sp); 79 80 switch (callable_info.callable_case) { 81 case CPPLanguageRuntime::LibCppStdFunctionCallableCase::Invalid: 82 stream.Printf(" __f_ = %" PRIu64, callable_info.member__f_pointer_value); 83 return false; 84 break; 85 case CPPLanguageRuntime::LibCppStdFunctionCallableCase::Lambda: 86 stream.Printf( 87 " Lambda in File %s at Line %u", 88 callable_info.callable_line_entry.file.GetFilename().GetCString(), 89 callable_info.callable_line_entry.line); 90 break; 91 case CPPLanguageRuntime::LibCppStdFunctionCallableCase::CallableObject: 92 stream.Printf( 93 " Function in File %s at Line %u", 94 callable_info.callable_line_entry.file.GetFilename().GetCString(), 95 callable_info.callable_line_entry.line); 96 break; 97 case CPPLanguageRuntime::LibCppStdFunctionCallableCase::FreeOrMemberFunction: 98 stream.Printf(" Function = %s ", 99 callable_info.callable_symbol.GetName().GetCString()); 100 break; 101 } 102 103 return true; 104 } 105 106 bool lldb_private::formatters::LibcxxSmartPointerSummaryProvider( 107 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 108 ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue()); 109 if (!valobj_sp) 110 return false; 111 ValueObjectSP ptr_sp( 112 valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true)); 113 ValueObjectSP count_sp(valobj_sp->GetChildAtNamePath( 114 {ConstString("__cntrl_"), ConstString("__shared_owners_")})); 115 ValueObjectSP weakcount_sp(valobj_sp->GetChildAtNamePath( 116 {ConstString("__cntrl_"), ConstString("__shared_weak_owners_")})); 117 118 if (!ptr_sp) 119 return false; 120 121 if (ptr_sp->GetValueAsUnsigned(0) == 0) { 122 stream.Printf("nullptr"); 123 return true; 124 } else { 125 bool print_pointee = false; 126 Status error; 127 ValueObjectSP pointee_sp = ptr_sp->Dereference(error); 128 if (pointee_sp && error.Success()) { 129 if (pointee_sp->DumpPrintableRepresentation( 130 stream, ValueObject::eValueObjectRepresentationStyleSummary, 131 lldb::eFormatInvalid, 132 ValueObject::PrintableRepresentationSpecialCases::eDisable, 133 false)) 134 print_pointee = true; 135 } 136 if (!print_pointee) 137 stream.Printf("ptr = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0)); 138 } 139 140 if (count_sp) 141 stream.Printf(" strong=%" PRIu64, 1 + count_sp->GetValueAsUnsigned(0)); 142 143 if (weakcount_sp) 144 stream.Printf(" weak=%" PRIu64, 1 + weakcount_sp->GetValueAsUnsigned(0)); 145 146 return true; 147 } 148 149 bool lldb_private::formatters::LibcxxUniquePointerSummaryProvider( 150 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 151 ValueObjectSP valobj_sp(valobj.GetNonSyntheticValue()); 152 if (!valobj_sp) 153 return false; 154 155 ValueObjectSP ptr_sp( 156 valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true)); 157 if (!ptr_sp) 158 return false; 159 160 ptr_sp = GetValueOfLibCXXCompressedPair(*ptr_sp); 161 if (!ptr_sp) 162 return false; 163 164 if (ptr_sp->GetValueAsUnsigned(0) == 0) { 165 stream.Printf("nullptr"); 166 return true; 167 } else { 168 bool print_pointee = false; 169 Status error; 170 ValueObjectSP pointee_sp = ptr_sp->Dereference(error); 171 if (pointee_sp && error.Success()) { 172 if (pointee_sp->DumpPrintableRepresentation( 173 stream, ValueObject::eValueObjectRepresentationStyleSummary, 174 lldb::eFormatInvalid, 175 ValueObject::PrintableRepresentationSpecialCases::eDisable, 176 false)) 177 print_pointee = true; 178 } 179 if (!print_pointee) 180 stream.Printf("ptr = 0x%" PRIx64, ptr_sp->GetValueAsUnsigned(0)); 181 } 182 183 return true; 184 } 185 186 /* 187 (lldb) fr var ibeg --raw --ptr-depth 1 188 (std::__1::__map_iterator<std::__1::__tree_iterator<std::__1::pair<int, 189 std::__1::basic_string<char, std::__1::char_traits<char>, 190 std::__1::allocator<char> > >, std::__1::__tree_node<std::__1::pair<int, 191 std::__1::basic_string<char, std::__1::char_traits<char>, 192 std::__1::allocator<char> > >, void *> *, long> >) ibeg = { 193 __i_ = { 194 __ptr_ = 0x0000000100103870 { 195 std::__1::__tree_node_base<void *> = { 196 std::__1::__tree_end_node<std::__1::__tree_node_base<void *> *> = { 197 __left_ = 0x0000000000000000 198 } 199 __right_ = 0x0000000000000000 200 __parent_ = 0x00000001001038b0 201 __is_black_ = true 202 } 203 __value_ = { 204 first = 0 205 second = { std::string } 206 */ 207 208 lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd:: 209 LibCxxMapIteratorSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) 210 : SyntheticChildrenFrontEnd(*valobj_sp), m_pair_ptr(), m_pair_sp() { 211 if (valobj_sp) 212 Update(); 213 } 214 215 bool lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::Update() { 216 m_pair_sp.reset(); 217 m_pair_ptr = nullptr; 218 219 ValueObjectSP valobj_sp = m_backend.GetSP(); 220 if (!valobj_sp) 221 return false; 222 223 TargetSP target_sp(valobj_sp->GetTargetSP()); 224 225 if (!target_sp) 226 return false; 227 228 if (!valobj_sp) 229 return false; 230 231 static ConstString g___i_("__i_"); 232 233 // this must be a ValueObject* because it is a child of the ValueObject we 234 // are producing children for it if were a ValueObjectSP, we would end up 235 // with a loop (iterator -> synthetic -> child -> parent == iterator) and 236 // that would in turn leak memory by never allowing the ValueObjects to die 237 // and free their memory 238 m_pair_ptr = valobj_sp 239 ->GetValueForExpressionPath( 240 ".__i_.__ptr_->__value_", nullptr, nullptr, 241 ValueObject::GetValueForExpressionPathOptions() 242 .DontCheckDotVsArrowSyntax() 243 .SetSyntheticChildrenTraversal( 244 ValueObject::GetValueForExpressionPathOptions:: 245 SyntheticChildrenTraversal::None), 246 nullptr) 247 .get(); 248 249 if (!m_pair_ptr) { 250 m_pair_ptr = valobj_sp 251 ->GetValueForExpressionPath( 252 ".__i_.__ptr_", nullptr, nullptr, 253 ValueObject::GetValueForExpressionPathOptions() 254 .DontCheckDotVsArrowSyntax() 255 .SetSyntheticChildrenTraversal( 256 ValueObject::GetValueForExpressionPathOptions:: 257 SyntheticChildrenTraversal::None), 258 nullptr) 259 .get(); 260 if (m_pair_ptr) { 261 auto __i_(valobj_sp->GetChildMemberWithName(g___i_, true)); 262 if (!__i_) { 263 m_pair_ptr = nullptr; 264 return false; 265 } 266 CompilerType pair_type( 267 __i_->GetCompilerType().GetTypeTemplateArgument(0)); 268 std::string name; 269 uint64_t bit_offset_ptr; 270 uint32_t bitfield_bit_size_ptr; 271 bool is_bitfield_ptr; 272 pair_type = pair_type.GetFieldAtIndex( 273 0, name, &bit_offset_ptr, &bitfield_bit_size_ptr, &is_bitfield_ptr); 274 if (!pair_type) { 275 m_pair_ptr = nullptr; 276 return false; 277 } 278 279 auto addr(m_pair_ptr->GetValueAsUnsigned(LLDB_INVALID_ADDRESS)); 280 m_pair_ptr = nullptr; 281 if (addr && addr != LLDB_INVALID_ADDRESS) { 282 TypeSystemClang *ast_ctx = 283 llvm::dyn_cast_or_null<TypeSystemClang>(pair_type.GetTypeSystem()); 284 if (!ast_ctx) 285 return false; 286 CompilerType tree_node_type = ast_ctx->CreateStructForIdentifier( 287 ConstString(), 288 {{"ptr0", 289 ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()}, 290 {"ptr1", 291 ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()}, 292 {"ptr2", 293 ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()}, 294 {"cw", ast_ctx->GetBasicType(lldb::eBasicTypeBool)}, 295 {"payload", pair_type}}); 296 llvm::Optional<uint64_t> size = tree_node_type.GetByteSize(nullptr); 297 if (!size) 298 return false; 299 DataBufferSP buffer_sp(new DataBufferHeap(*size, 0)); 300 ProcessSP process_sp(target_sp->GetProcessSP()); 301 Status error; 302 process_sp->ReadMemory(addr, buffer_sp->GetBytes(), 303 buffer_sp->GetByteSize(), error); 304 if (error.Fail()) 305 return false; 306 DataExtractor extractor(buffer_sp, process_sp->GetByteOrder(), 307 process_sp->GetAddressByteSize()); 308 auto pair_sp = CreateValueObjectFromData( 309 "pair", extractor, valobj_sp->GetExecutionContextRef(), 310 tree_node_type); 311 if (pair_sp) 312 m_pair_sp = pair_sp->GetChildAtIndex(4, true); 313 } 314 } 315 } 316 317 return false; 318 } 319 320 size_t lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd:: 321 CalculateNumChildren() { 322 return 2; 323 } 324 325 lldb::ValueObjectSP 326 lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::GetChildAtIndex( 327 size_t idx) { 328 if (m_pair_ptr) 329 return m_pair_ptr->GetChildAtIndex(idx, true); 330 if (m_pair_sp) 331 return m_pair_sp->GetChildAtIndex(idx, true); 332 return lldb::ValueObjectSP(); 333 } 334 335 bool lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd:: 336 MightHaveChildren() { 337 return true; 338 } 339 340 size_t lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd:: 341 GetIndexOfChildWithName(ConstString name) { 342 if (name == "first") 343 return 0; 344 if (name == "second") 345 return 1; 346 return UINT32_MAX; 347 } 348 349 lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd:: 350 ~LibCxxMapIteratorSyntheticFrontEnd() { 351 // this will be deleted when its parent dies (since it's a child object) 352 // delete m_pair_ptr; 353 } 354 355 SyntheticChildrenFrontEnd * 356 lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator( 357 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { 358 return (valobj_sp ? new LibCxxMapIteratorSyntheticFrontEnd(valobj_sp) 359 : nullptr); 360 } 361 362 /* 363 (lldb) fr var ibeg --raw --ptr-depth 1 -T 364 (std::__1::__wrap_iter<int *>) ibeg = { 365 (std::__1::__wrap_iter<int *>::iterator_type) __i = 0x00000001001037a0 { 366 (int) *__i = 1 367 } 368 } 369 */ 370 371 SyntheticChildrenFrontEnd * 372 lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator( 373 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { 374 static ConstString g_item_name; 375 if (!g_item_name) 376 g_item_name.SetCString("__i"); 377 return (valobj_sp 378 ? new VectorIteratorSyntheticFrontEnd(valobj_sp, g_item_name) 379 : nullptr); 380 } 381 382 lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd:: 383 LibcxxSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) 384 : SyntheticChildrenFrontEnd(*valobj_sp), m_cntrl(nullptr) { 385 if (valobj_sp) 386 Update(); 387 } 388 389 size_t lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd:: 390 CalculateNumChildren() { 391 return (m_cntrl ? 1 : 0); 392 } 393 394 lldb::ValueObjectSP 395 lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::GetChildAtIndex( 396 size_t idx) { 397 if (!m_cntrl) 398 return lldb::ValueObjectSP(); 399 400 ValueObjectSP valobj_sp = m_backend.GetSP(); 401 if (!valobj_sp) 402 return lldb::ValueObjectSP(); 403 404 if (idx == 0) 405 return valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true); 406 407 if (idx == 1) { 408 if (auto ptr_sp = 409 valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true)) { 410 Status status; 411 auto value_sp = ptr_sp->Dereference(status); 412 if (status.Success()) { 413 auto value_type_sp = 414 valobj_sp->GetCompilerType().GetTypeTemplateArgument(0); 415 return value_sp->Cast(value_type_sp); 416 } 417 } 418 } 419 420 return lldb::ValueObjectSP(); 421 } 422 423 bool lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::Update() { 424 m_cntrl = nullptr; 425 426 ValueObjectSP valobj_sp = m_backend.GetSP(); 427 if (!valobj_sp) 428 return false; 429 430 TargetSP target_sp(valobj_sp->GetTargetSP()); 431 if (!target_sp) 432 return false; 433 434 lldb::ValueObjectSP cntrl_sp( 435 valobj_sp->GetChildMemberWithName(ConstString("__cntrl_"), true)); 436 437 m_cntrl = cntrl_sp.get(); // need to store the raw pointer to avoid a circular 438 // dependency 439 return false; 440 } 441 442 bool lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd:: 443 MightHaveChildren() { 444 return true; 445 } 446 447 size_t lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd:: 448 GetIndexOfChildWithName(ConstString name) { 449 if (name == "__ptr_") 450 return 0; 451 if (name == "$$dereference$$") 452 return 1; 453 return UINT32_MAX; 454 } 455 456 lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd:: 457 ~LibcxxSharedPtrSyntheticFrontEnd() = default; 458 459 SyntheticChildrenFrontEnd * 460 lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator( 461 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { 462 return (valobj_sp ? new LibcxxSharedPtrSyntheticFrontEnd(valobj_sp) 463 : nullptr); 464 } 465 466 lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEnd:: 467 LibcxxUniquePtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) 468 : SyntheticChildrenFrontEnd(*valobj_sp) { 469 if (valobj_sp) 470 Update(); 471 } 472 473 lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEnd:: 474 ~LibcxxUniquePtrSyntheticFrontEnd() = default; 475 476 SyntheticChildrenFrontEnd * 477 lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEndCreator( 478 CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { 479 return (valobj_sp ? new LibcxxUniquePtrSyntheticFrontEnd(valobj_sp) 480 : nullptr); 481 } 482 483 size_t lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEnd:: 484 CalculateNumChildren() { 485 return (m_value_ptr_sp ? 1 : 0); 486 } 487 488 lldb::ValueObjectSP 489 lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEnd::GetChildAtIndex( 490 size_t idx) { 491 if (!m_value_ptr_sp) 492 return lldb::ValueObjectSP(); 493 494 if (idx == 0) 495 return m_value_ptr_sp; 496 497 if (idx == 1) { 498 Status status; 499 auto value_sp = m_value_ptr_sp->Dereference(status); 500 if (status.Success()) { 501 return value_sp; 502 } 503 } 504 505 return lldb::ValueObjectSP(); 506 } 507 508 bool lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEnd::Update() { 509 ValueObjectSP valobj_sp = m_backend.GetSP(); 510 if (!valobj_sp) 511 return false; 512 513 ValueObjectSP ptr_sp( 514 valobj_sp->GetChildMemberWithName(ConstString("__ptr_"), true)); 515 if (!ptr_sp) 516 return false; 517 518 m_value_ptr_sp = GetValueOfLibCXXCompressedPair(*ptr_sp); 519 520 return false; 521 } 522 523 bool lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEnd:: 524 MightHaveChildren() { 525 return true; 526 } 527 528 size_t lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEnd:: 529 GetIndexOfChildWithName(ConstString name) { 530 if (name == "__value_") 531 return 0; 532 if (name == "$$dereference$$") 533 return 1; 534 return UINT32_MAX; 535 } 536 537 bool lldb_private::formatters::LibcxxContainerSummaryProvider( 538 ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { 539 if (valobj.IsPointerType()) { 540 uint64_t value = valobj.GetValueAsUnsigned(0); 541 if (!value) 542 return false; 543 stream.Printf("0x%016" PRIx64 " ", value); 544 } 545 return FormatEntity::FormatStringRef("size=${svar%#}", stream, nullptr, 546 nullptr, nullptr, &valobj, false, false); 547 } 548 549 // the field layout in a libc++ string (cap, side, data or data, size, cap) 550 enum LibcxxStringLayoutMode { 551 eLibcxxStringLayoutModeCSD = 0, 552 eLibcxxStringLayoutModeDSC = 1, 553 eLibcxxStringLayoutModeInvalid = 0xffff 554 }; 555 556 /// Determine the size in bytes of \p valobj (a libc++ std::string object) and 557 /// extract its data payload. Return the size + payload pair. 558 static llvm::Optional<std::pair<uint64_t, ValueObjectSP>> 559 ExtractLibcxxStringInfo(ValueObject &valobj) { 560 ValueObjectSP D(valobj.GetChildAtIndexPath({0, 0, 0, 0})); 561 if (!D) 562 return {}; 563 564 ValueObjectSP layout_decider( 565 D->GetChildAtIndexPath(llvm::ArrayRef<size_t>({0, 0}))); 566 567 // this child should exist 568 if (!layout_decider) 569 return {}; 570 571 ConstString g_data_name("__data_"); 572 ConstString g_size_name("__size_"); 573 bool short_mode = false; // this means the string is in short-mode and the 574 // data is stored inline 575 LibcxxStringLayoutMode layout = (layout_decider->GetName() == g_data_name) 576 ? eLibcxxStringLayoutModeDSC 577 : eLibcxxStringLayoutModeCSD; 578 uint64_t size_mode_value = 0; 579 580 if (layout == eLibcxxStringLayoutModeDSC) { 581 ValueObjectSP size_mode(D->GetChildAtIndexPath({1, 1, 0})); 582 if (!size_mode) 583 return {}; 584 585 if (size_mode->GetName() != g_size_name) { 586 // we are hitting the padding structure, move along 587 size_mode = D->GetChildAtIndexPath({1, 1, 1}); 588 if (!size_mode) 589 return {}; 590 } 591 592 size_mode_value = (size_mode->GetValueAsUnsigned(0)); 593 short_mode = ((size_mode_value & 0x80) == 0); 594 } else { 595 ValueObjectSP size_mode(D->GetChildAtIndexPath({1, 0, 0})); 596 if (!size_mode) 597 return {}; 598 599 size_mode_value = (size_mode->GetValueAsUnsigned(0)); 600 short_mode = ((size_mode_value & 1) == 0); 601 } 602 603 if (short_mode) { 604 ValueObjectSP s(D->GetChildAtIndex(1, true)); 605 if (!s) 606 return {}; 607 ValueObjectSP location_sp = s->GetChildAtIndex( 608 (layout == eLibcxxStringLayoutModeDSC) ? 0 : 1, true); 609 const uint64_t size = (layout == eLibcxxStringLayoutModeDSC) 610 ? size_mode_value 611 : ((size_mode_value >> 1) % 256); 612 613 // When the small-string optimization takes place, the data must fit in the 614 // inline string buffer (23 bytes on x86_64/Darwin). If it doesn't, it's 615 // likely that the string isn't initialized and we're reading garbage. 616 ExecutionContext exe_ctx(location_sp->GetExecutionContextRef()); 617 const llvm::Optional<uint64_t> max_bytes = 618 location_sp->GetCompilerType().GetByteSize( 619 exe_ctx.GetBestExecutionContextScope()); 620 if (!max_bytes || size > *max_bytes || !location_sp) 621 return {}; 622 623 return std::make_pair(size, location_sp); 624 } 625 626 ValueObjectSP l(D->GetChildAtIndex(0, true)); 627 if (!l) 628 return {}; 629 // we can use the layout_decider object as the data pointer 630 ValueObjectSP location_sp = (layout == eLibcxxStringLayoutModeDSC) 631 ? layout_decider 632 : l->GetChildAtIndex(2, true); 633 ValueObjectSP size_vo(l->GetChildAtIndex(1, true)); 634 const unsigned capacity_index = 635 (layout == eLibcxxStringLayoutModeDSC) ? 2 : 0; 636 ValueObjectSP capacity_vo(l->GetChildAtIndex(capacity_index, true)); 637 if (!size_vo || !location_sp || !capacity_vo) 638 return {}; 639 const uint64_t size = size_vo->GetValueAsUnsigned(LLDB_INVALID_OFFSET); 640 const uint64_t capacity = 641 capacity_vo->GetValueAsUnsigned(LLDB_INVALID_OFFSET); 642 if (size == LLDB_INVALID_OFFSET || capacity == LLDB_INVALID_OFFSET || 643 capacity < size) 644 return {}; 645 return std::make_pair(size, location_sp); 646 } 647 648 static bool 649 LibcxxWStringSummaryProvider(ValueObject &valobj, Stream &stream, 650 const TypeSummaryOptions &summary_options, 651 ValueObjectSP location_sp, size_t size) { 652 if (size == 0) { 653 stream.Printf("L\"\""); 654 return true; 655 } 656 if (!location_sp) 657 return false; 658 659 StringPrinter::ReadBufferAndDumpToStreamOptions options(valobj); 660 if (summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryCapped) { 661 const auto max_size = valobj.GetTargetSP()->GetMaximumSizeOfStringSummary(); 662 if (size > max_size) { 663 size = max_size; 664 options.SetIsTruncated(true); 665 } 666 } 667 668 DataExtractor extractor; 669 const size_t bytes_read = location_sp->GetPointeeData(extractor, 0, size); 670 if (bytes_read < size) 671 return false; 672 673 // std::wstring::size() is measured in 'characters', not bytes 674 TypeSystemClang *ast_context = 675 ScratchTypeSystemClang::GetForTarget(*valobj.GetTargetSP()); 676 if (!ast_context) 677 return false; 678 679 auto wchar_t_size = 680 ast_context->GetBasicType(lldb::eBasicTypeWChar).GetByteSize(nullptr); 681 if (!wchar_t_size) 682 return false; 683 684 options.SetData(std::move(extractor)); 685 options.SetStream(&stream); 686 options.SetPrefixToken("L"); 687 options.SetQuote('"'); 688 options.SetSourceSize(size); 689 options.SetBinaryZeroIsTerminator(false); 690 691 switch (*wchar_t_size) { 692 case 1: 693 return StringPrinter::ReadBufferAndDumpToStream< 694 lldb_private::formatters::StringPrinter::StringElementType::UTF8>( 695 options); 696 break; 697 698 case 2: 699 return StringPrinter::ReadBufferAndDumpToStream< 700 lldb_private::formatters::StringPrinter::StringElementType::UTF16>( 701 options); 702 break; 703 704 case 4: 705 return StringPrinter::ReadBufferAndDumpToStream< 706 lldb_private::formatters::StringPrinter::StringElementType::UTF32>( 707 options); 708 } 709 return false; 710 } 711 712 bool lldb_private::formatters::LibcxxWStringSummaryProvider( 713 ValueObject &valobj, Stream &stream, 714 const TypeSummaryOptions &summary_options) { 715 auto string_info = ExtractLibcxxStringInfo(valobj); 716 if (!string_info) 717 return false; 718 uint64_t size; 719 ValueObjectSP location_sp; 720 std::tie(size, location_sp) = *string_info; 721 722 return ::LibcxxWStringSummaryProvider(valobj, stream, summary_options, 723 location_sp, size); 724 } 725 726 template <StringPrinter::StringElementType element_type> 727 static bool 728 LibcxxStringSummaryProvider(ValueObject &valobj, Stream &stream, 729 const TypeSummaryOptions &summary_options, 730 std::string prefix_token, ValueObjectSP location_sp, 731 uint64_t size) { 732 733 if (size == 0) { 734 stream.Printf("\"\""); 735 return true; 736 } 737 738 if (!location_sp) 739 return false; 740 741 StringPrinter::ReadBufferAndDumpToStreamOptions options(valobj); 742 743 if (summary_options.GetCapping() == TypeSummaryCapping::eTypeSummaryCapped) { 744 const auto max_size = valobj.GetTargetSP()->GetMaximumSizeOfStringSummary(); 745 if (size > max_size) { 746 size = max_size; 747 options.SetIsTruncated(true); 748 } 749 } 750 751 { 752 DataExtractor extractor; 753 const size_t bytes_read = location_sp->GetPointeeData(extractor, 0, size); 754 if (bytes_read < size) 755 return false; 756 757 options.SetData(std::move(extractor)); 758 } 759 options.SetStream(&stream); 760 if (prefix_token.empty()) 761 options.SetPrefixToken(nullptr); 762 else 763 options.SetPrefixToken(prefix_token); 764 options.SetQuote('"'); 765 options.SetSourceSize(size); 766 options.SetBinaryZeroIsTerminator(false); 767 return StringPrinter::ReadBufferAndDumpToStream<element_type>(options); 768 } 769 770 template <StringPrinter::StringElementType element_type> 771 static bool 772 LibcxxStringSummaryProvider(ValueObject &valobj, Stream &stream, 773 const TypeSummaryOptions &summary_options, 774 std::string prefix_token) { 775 auto string_info = ExtractLibcxxStringInfo(valobj); 776 if (!string_info) 777 return false; 778 uint64_t size; 779 ValueObjectSP location_sp; 780 std::tie(size, location_sp) = *string_info; 781 782 return LibcxxStringSummaryProvider<element_type>( 783 valobj, stream, summary_options, prefix_token, location_sp, size); 784 } 785 template <StringPrinter::StringElementType element_type> 786 static bool formatStringImpl(ValueObject &valobj, Stream &stream, 787 const TypeSummaryOptions &summary_options, 788 std::string prefix_token) { 789 StreamString scratch_stream; 790 const bool success = LibcxxStringSummaryProvider<element_type>( 791 valobj, scratch_stream, summary_options, prefix_token); 792 if (success) 793 stream << scratch_stream.GetData(); 794 else 795 stream << "Summary Unavailable"; 796 return true; 797 } 798 799 bool lldb_private::formatters::LibcxxStringSummaryProviderASCII( 800 ValueObject &valobj, Stream &stream, 801 const TypeSummaryOptions &summary_options) { 802 return formatStringImpl<StringPrinter::StringElementType::ASCII>( 803 valobj, stream, summary_options, ""); 804 } 805 806 bool lldb_private::formatters::LibcxxStringSummaryProviderUTF16( 807 ValueObject &valobj, Stream &stream, 808 const TypeSummaryOptions &summary_options) { 809 return formatStringImpl<StringPrinter::StringElementType::UTF16>( 810 valobj, stream, summary_options, "u"); 811 } 812 813 bool lldb_private::formatters::LibcxxStringSummaryProviderUTF32( 814 ValueObject &valobj, Stream &stream, 815 const TypeSummaryOptions &summary_options) { 816 return formatStringImpl<StringPrinter::StringElementType::UTF32>( 817 valobj, stream, summary_options, "U"); 818 } 819 820 static std::tuple<bool, ValueObjectSP, size_t> 821 LibcxxExtractStringViewData(ValueObject& valobj) { 822 ConstString g_data_name("__data"); 823 ConstString g_size_name("__size"); 824 auto dataobj = valobj.GetChildMemberWithName(g_data_name, true); 825 auto sizeobj = valobj.GetChildMemberWithName(g_size_name, true); 826 827 if (!dataobj || !sizeobj) 828 return std::make_tuple<bool,ValueObjectSP,size_t>(false, {}, {}); 829 830 if (!dataobj->GetError().Success() || !sizeobj->GetError().Success()) 831 return std::make_tuple<bool,ValueObjectSP,size_t>(false, {}, {}); 832 833 bool success{false}; 834 uint64_t size = sizeobj->GetValueAsUnsigned(0, &success); 835 if (!success) 836 return std::make_tuple<bool,ValueObjectSP,size_t>(false, {}, {}); 837 838 return std::make_tuple(true,dataobj,size); 839 } 840 841 template <StringPrinter::StringElementType element_type> 842 static bool formatStringViewImpl(ValueObject &valobj, Stream &stream, 843 const TypeSummaryOptions &summary_options, 844 std::string prefix_token) { 845 846 bool success; 847 ValueObjectSP dataobj; 848 size_t size; 849 std::tie(success, dataobj, size) = LibcxxExtractStringViewData(valobj); 850 851 if (!success) { 852 stream << "Summary Unavailable"; 853 return true; 854 } 855 856 return LibcxxStringSummaryProvider<element_type>( 857 valobj, stream, summary_options, prefix_token, dataobj, size); 858 } 859 860 bool lldb_private::formatters::LibcxxStringViewSummaryProviderASCII( 861 ValueObject &valobj, Stream &stream, 862 const TypeSummaryOptions &summary_options) { 863 return formatStringViewImpl<StringPrinter::StringElementType::ASCII>( 864 valobj, stream, summary_options, ""); 865 } 866 867 bool lldb_private::formatters::LibcxxStringViewSummaryProviderUTF16( 868 ValueObject &valobj, Stream &stream, 869 const TypeSummaryOptions &summary_options) { 870 return formatStringViewImpl<StringPrinter::StringElementType::UTF16>( 871 valobj, stream, summary_options, "u"); 872 } 873 874 bool lldb_private::formatters::LibcxxStringViewSummaryProviderUTF32( 875 ValueObject &valobj, Stream &stream, 876 const TypeSummaryOptions &summary_options) { 877 return formatStringViewImpl<StringPrinter::StringElementType::UTF32>( 878 valobj, stream, summary_options, "U"); 879 } 880 881 bool lldb_private::formatters::LibcxxWStringViewSummaryProvider( 882 ValueObject &valobj, Stream &stream, 883 const TypeSummaryOptions &summary_options) { 884 885 bool success; 886 ValueObjectSP dataobj; 887 size_t size; 888 std::tie( success, dataobj, size ) = LibcxxExtractStringViewData(valobj); 889 890 if (!success) { 891 stream << "Summary Unavailable"; 892 return true; 893 } 894 895 896 return ::LibcxxWStringSummaryProvider(valobj, stream, summary_options, 897 dataobj, size); 898 } 899