1 //===-- SBValue.cpp ---------------------------------------------*- 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 #include "lldb/API/SBValue.h" 11 12 #include "lldb/API/SBDeclaration.h" 13 #include "lldb/API/SBStream.h" 14 #include "lldb/API/SBTypeFilter.h" 15 #include "lldb/API/SBTypeFormat.h" 16 #include "lldb/API/SBTypeSummary.h" 17 #include "lldb/API/SBTypeSynthetic.h" 18 19 #include "lldb/Breakpoint/Watchpoint.h" 20 #include "lldb/Core/DataExtractor.h" 21 #include "lldb/Core/Log.h" 22 #include "lldb/Core/Module.h" 23 #include "lldb/Core/Scalar.h" 24 #include "lldb/Core/Section.h" 25 #include "lldb/Core/Stream.h" 26 #include "lldb/Core/StreamFile.h" 27 #include "lldb/Core/Value.h" 28 #include "lldb/Core/ValueObject.h" 29 #include "lldb/Core/ValueObjectConstResult.h" 30 #include "lldb/DataFormatters/DataVisualization.h" 31 #include "lldb/Symbol/Block.h" 32 #include "lldb/Symbol/Declaration.h" 33 #include "lldb/Symbol/ObjectFile.h" 34 #include "lldb/Symbol/Type.h" 35 #include "lldb/Symbol/Variable.h" 36 #include "lldb/Symbol/VariableList.h" 37 #include "lldb/Target/ExecutionContext.h" 38 #include "lldb/Target/Process.h" 39 #include "lldb/Target/StackFrame.h" 40 #include "lldb/Target/Target.h" 41 #include "lldb/Target/Thread.h" 42 43 #include "lldb/API/SBDebugger.h" 44 #include "lldb/API/SBExpressionOptions.h" 45 #include "lldb/API/SBFrame.h" 46 #include "lldb/API/SBProcess.h" 47 #include "lldb/API/SBTarget.h" 48 #include "lldb/API/SBThread.h" 49 50 using namespace lldb; 51 using namespace lldb_private; 52 53 class ValueImpl 54 { 55 public: 56 ValueImpl () 57 { 58 } 59 60 ValueImpl (lldb::ValueObjectSP in_valobj_sp, 61 lldb::DynamicValueType use_dynamic, 62 bool use_synthetic, 63 const char *name = NULL) : 64 m_valobj_sp(), 65 m_use_dynamic(use_dynamic), 66 m_use_synthetic(use_synthetic), 67 m_name (name) 68 { 69 if (in_valobj_sp) 70 { 71 if ( (m_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable(lldb::eNoDynamicValues, false)) ) 72 { 73 if (!m_name.IsEmpty()) 74 m_valobj_sp->SetName(m_name); 75 } 76 } 77 } 78 79 ValueImpl (const ValueImpl& rhs) : 80 m_valobj_sp(rhs.m_valobj_sp), 81 m_use_dynamic(rhs.m_use_dynamic), 82 m_use_synthetic(rhs.m_use_synthetic), 83 m_name (rhs.m_name) 84 { 85 } 86 87 ValueImpl & 88 operator = (const ValueImpl &rhs) 89 { 90 if (this != &rhs) 91 { 92 m_valobj_sp = rhs.m_valobj_sp; 93 m_use_dynamic = rhs.m_use_dynamic; 94 m_use_synthetic = rhs.m_use_synthetic; 95 m_name = rhs.m_name; 96 } 97 return *this; 98 } 99 100 bool 101 IsValid () 102 { 103 if (m_valobj_sp.get() == NULL) 104 return false; 105 else 106 { 107 // FIXME: This check is necessary but not sufficient. We for sure don't want to touch SBValues whose owning 108 // targets have gone away. This check is a little weak in that it enforces that restriction when you call 109 // IsValid, but since IsValid doesn't lock the target, you have no guarantee that the SBValue won't go 110 // invalid after you call this... 111 // Also, an SBValue could depend on data from one of the modules in the target, and those could go away 112 // independently of the target, for instance if a module is unloaded. But right now, neither SBValues 113 // nor ValueObjects know which modules they depend on. So I have no good way to make that check without 114 // tracking that in all the ValueObject subclasses. 115 TargetSP target_sp = m_valobj_sp->GetTargetSP(); 116 if (target_sp && target_sp->IsValid()) 117 return true; 118 else 119 return false; 120 } 121 } 122 123 lldb::ValueObjectSP 124 GetRootSP () 125 { 126 return m_valobj_sp; 127 } 128 129 lldb::ValueObjectSP 130 GetSP(Process::StopLocker &stop_locker, std::unique_lock<std::recursive_mutex> &lock, Error &error) 131 { 132 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 133 if (!m_valobj_sp) 134 { 135 error.SetErrorString("invalid value object"); 136 return m_valobj_sp; 137 } 138 139 lldb::ValueObjectSP value_sp = m_valobj_sp; 140 141 Target *target = value_sp->GetTargetSP().get(); 142 if (!target) 143 return ValueObjectSP(); 144 145 lock = std::unique_lock<std::recursive_mutex>(target->GetAPIMutex()); 146 147 ProcessSP process_sp(value_sp->GetProcessSP()); 148 if (process_sp && !stop_locker.TryLock (&process_sp->GetRunLock())) 149 { 150 // We don't allow people to play around with ValueObject if the process is running. 151 // If you want to look at values, pause the process, then look. 152 if (log) 153 log->Printf ("SBValue(%p)::GetSP() => error: process is running", 154 static_cast<void*>(value_sp.get())); 155 error.SetErrorString ("process must be stopped."); 156 return ValueObjectSP(); 157 } 158 159 if (m_use_dynamic != eNoDynamicValues) 160 { 161 ValueObjectSP dynamic_sp = value_sp->GetDynamicValue(m_use_dynamic); 162 if (dynamic_sp) 163 value_sp = dynamic_sp; 164 } 165 166 if (m_use_synthetic) 167 { 168 ValueObjectSP synthetic_sp = value_sp->GetSyntheticValue(m_use_synthetic); 169 if (synthetic_sp) 170 value_sp = synthetic_sp; 171 } 172 173 if (!value_sp) 174 error.SetErrorString("invalid value object"); 175 if (!m_name.IsEmpty()) 176 value_sp->SetName(m_name); 177 178 return value_sp; 179 } 180 181 void 182 SetUseDynamic (lldb::DynamicValueType use_dynamic) 183 { 184 m_use_dynamic = use_dynamic; 185 } 186 187 void 188 SetUseSynthetic (bool use_synthetic) 189 { 190 m_use_synthetic = use_synthetic; 191 } 192 193 lldb::DynamicValueType 194 GetUseDynamic () 195 { 196 return m_use_dynamic; 197 } 198 199 bool 200 GetUseSynthetic () 201 { 202 return m_use_synthetic; 203 } 204 205 // All the derived values that we would make from the m_valobj_sp will share 206 // the ExecutionContext with m_valobj_sp, so we don't need to do the calculations 207 // in GetSP to return the Target, Process, Thread or Frame. It is convenient to 208 // provide simple accessors for these, which I do here. 209 TargetSP 210 GetTargetSP () 211 { 212 if (m_valobj_sp) 213 return m_valobj_sp->GetTargetSP(); 214 else 215 return TargetSP(); 216 } 217 218 ProcessSP 219 GetProcessSP () 220 { 221 if (m_valobj_sp) 222 return m_valobj_sp->GetProcessSP(); 223 else 224 return ProcessSP(); 225 } 226 227 ThreadSP 228 GetThreadSP () 229 { 230 if (m_valobj_sp) 231 return m_valobj_sp->GetThreadSP(); 232 else 233 return ThreadSP(); 234 } 235 236 StackFrameSP 237 GetFrameSP () 238 { 239 if (m_valobj_sp) 240 return m_valobj_sp->GetFrameSP(); 241 else 242 return StackFrameSP(); 243 } 244 245 private: 246 lldb::ValueObjectSP m_valobj_sp; 247 lldb::DynamicValueType m_use_dynamic; 248 bool m_use_synthetic; 249 ConstString m_name; 250 }; 251 252 class ValueLocker 253 { 254 public: 255 ValueLocker () 256 { 257 } 258 259 ValueObjectSP 260 GetLockedSP(ValueImpl &in_value) 261 { 262 return in_value.GetSP(m_stop_locker, m_lock, m_lock_error); 263 } 264 265 Error & 266 GetError() 267 { 268 return m_lock_error; 269 } 270 271 private: 272 Process::StopLocker m_stop_locker; 273 std::unique_lock<std::recursive_mutex> m_lock; 274 Error m_lock_error; 275 }; 276 277 SBValue::SBValue () : 278 m_opaque_sp () 279 { 280 } 281 282 SBValue::SBValue (const lldb::ValueObjectSP &value_sp) 283 { 284 SetSP(value_sp); 285 } 286 287 SBValue::SBValue(const SBValue &rhs) 288 { 289 SetSP(rhs.m_opaque_sp); 290 } 291 292 SBValue & 293 SBValue::operator = (const SBValue &rhs) 294 { 295 if (this != &rhs) 296 { 297 SetSP(rhs.m_opaque_sp); 298 } 299 return *this; 300 } 301 302 SBValue::~SBValue() 303 { 304 } 305 306 bool 307 SBValue::IsValid () 308 { 309 // If this function ever changes to anything that does more than just 310 // check if the opaque shared pointer is non NULL, then we need to update 311 // all "if (m_opaque_sp)" code in this file. 312 return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid() && m_opaque_sp->GetRootSP().get() != NULL; 313 } 314 315 void 316 SBValue::Clear() 317 { 318 m_opaque_sp.reset(); 319 } 320 321 SBError 322 SBValue::GetError() 323 { 324 SBError sb_error; 325 326 ValueLocker locker; 327 lldb::ValueObjectSP value_sp(GetSP(locker)); 328 if (value_sp) 329 sb_error.SetError(value_sp->GetError()); 330 else 331 sb_error.SetErrorStringWithFormat ("error: %s", locker.GetError().AsCString()); 332 333 return sb_error; 334 } 335 336 user_id_t 337 SBValue::GetID() 338 { 339 ValueLocker locker; 340 lldb::ValueObjectSP value_sp(GetSP(locker)); 341 if (value_sp) 342 return value_sp->GetID(); 343 return LLDB_INVALID_UID; 344 } 345 346 const char * 347 SBValue::GetName() 348 { 349 const char *name = NULL; 350 ValueLocker locker; 351 lldb::ValueObjectSP value_sp(GetSP(locker)); 352 if (value_sp) 353 name = value_sp->GetName().GetCString(); 354 355 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 356 if (log) 357 { 358 if (name) 359 log->Printf ("SBValue(%p)::GetName () => \"%s\"", 360 static_cast<void*>(value_sp.get()), name); 361 else 362 log->Printf ("SBValue(%p)::GetName () => NULL", 363 static_cast<void*>(value_sp.get())); 364 } 365 366 return name; 367 } 368 369 const char * 370 SBValue::GetTypeName () 371 { 372 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 373 const char *name = NULL; 374 ValueLocker locker; 375 lldb::ValueObjectSP value_sp(GetSP(locker)); 376 if (value_sp) 377 { 378 name = value_sp->GetQualifiedTypeName().GetCString(); 379 } 380 381 if (log) 382 { 383 if (name) 384 log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"", 385 static_cast<void*>(value_sp.get()), name); 386 else 387 log->Printf ("SBValue(%p)::GetTypeName () => NULL", 388 static_cast<void*>(value_sp.get())); 389 } 390 391 return name; 392 } 393 394 const char * 395 SBValue::GetDisplayTypeName () 396 { 397 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 398 const char *name = NULL; 399 ValueLocker locker; 400 lldb::ValueObjectSP value_sp(GetSP(locker)); 401 if (value_sp) 402 { 403 name = value_sp->GetDisplayTypeName().GetCString(); 404 } 405 406 if (log) 407 { 408 if (name) 409 log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"", 410 static_cast<void*>(value_sp.get()), name); 411 else 412 log->Printf ("SBValue(%p)::GetTypeName () => NULL", 413 static_cast<void*>(value_sp.get())); 414 } 415 416 return name; 417 } 418 419 size_t 420 SBValue::GetByteSize () 421 { 422 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 423 size_t result = 0; 424 425 ValueLocker locker; 426 lldb::ValueObjectSP value_sp(GetSP(locker)); 427 if (value_sp) 428 { 429 result = value_sp->GetByteSize(); 430 } 431 432 if (log) 433 log->Printf ("SBValue(%p)::GetByteSize () => %" PRIu64, 434 static_cast<void*>(value_sp.get()), 435 static_cast<uint64_t>(result)); 436 437 return result; 438 } 439 440 bool 441 SBValue::IsInScope () 442 { 443 bool result = false; 444 445 ValueLocker locker; 446 lldb::ValueObjectSP value_sp(GetSP(locker)); 447 if (value_sp) 448 { 449 result = value_sp->IsInScope (); 450 } 451 452 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 453 if (log) 454 log->Printf ("SBValue(%p)::IsInScope () => %i", 455 static_cast<void*>(value_sp.get()), result); 456 457 return result; 458 } 459 460 const char * 461 SBValue::GetValue () 462 { 463 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 464 465 const char *cstr = NULL; 466 ValueLocker locker; 467 lldb::ValueObjectSP value_sp(GetSP(locker)); 468 if (value_sp) 469 { 470 cstr = value_sp->GetValueAsCString (); 471 } 472 if (log) 473 { 474 if (cstr) 475 log->Printf ("SBValue(%p)::GetValue() => \"%s\"", 476 static_cast<void*>(value_sp.get()), cstr); 477 else 478 log->Printf ("SBValue(%p)::GetValue() => NULL", 479 static_cast<void*>(value_sp.get())); 480 } 481 482 return cstr; 483 } 484 485 ValueType 486 SBValue::GetValueType () 487 { 488 ValueType result = eValueTypeInvalid; 489 ValueLocker locker; 490 lldb::ValueObjectSP value_sp(GetSP(locker)); 491 if (value_sp) 492 result = value_sp->GetValueType(); 493 494 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 495 if (log) 496 { 497 switch (result) 498 { 499 case eValueTypeInvalid: 500 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeInvalid", 501 static_cast<void*>(value_sp.get())); 502 break; 503 case eValueTypeVariableGlobal: 504 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal", 505 static_cast<void*>(value_sp.get())); 506 break; 507 case eValueTypeVariableStatic: 508 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableStatic", 509 static_cast<void*>(value_sp.get())); 510 break; 511 case eValueTypeVariableArgument: 512 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableArgument", 513 static_cast<void*>(value_sp.get())); 514 break; 515 case eValueTypeVariableLocal: 516 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableLocal", 517 static_cast<void*>(value_sp.get())); 518 break; 519 case eValueTypeRegister: 520 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegister", 521 static_cast<void*>(value_sp.get())); 522 break; 523 case eValueTypeRegisterSet: 524 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegisterSet", 525 static_cast<void*>(value_sp.get())); 526 break; 527 case eValueTypeConstResult: 528 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeConstResult", 529 static_cast<void*>(value_sp.get())); 530 break; 531 } 532 } 533 return result; 534 } 535 536 const char * 537 SBValue::GetObjectDescription () 538 { 539 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 540 const char *cstr = NULL; 541 ValueLocker locker; 542 lldb::ValueObjectSP value_sp(GetSP(locker)); 543 if (value_sp) 544 { 545 cstr = value_sp->GetObjectDescription (); 546 } 547 if (log) 548 { 549 if (cstr) 550 log->Printf ("SBValue(%p)::GetObjectDescription() => \"%s\"", 551 static_cast<void*>(value_sp.get()), cstr); 552 else 553 log->Printf ("SBValue(%p)::GetObjectDescription() => NULL", 554 static_cast<void*>(value_sp.get())); 555 } 556 return cstr; 557 } 558 559 const char * 560 SBValue::GetTypeValidatorResult () 561 { 562 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 563 const char *cstr = NULL; 564 ValueLocker locker; 565 lldb::ValueObjectSP value_sp(GetSP(locker)); 566 if (value_sp) 567 { 568 const auto& validation(value_sp->GetValidationStatus()); 569 if (TypeValidatorResult::Failure == validation.first) 570 { 571 if (validation.second.empty()) 572 cstr = "unknown error"; 573 else 574 cstr = validation.second.c_str(); 575 } 576 } 577 if (log) 578 { 579 if (cstr) 580 log->Printf ("SBValue(%p)::GetTypeValidatorResult() => \"%s\"", 581 static_cast<void*>(value_sp.get()), cstr); 582 else 583 log->Printf ("SBValue(%p)::GetTypeValidatorResult() => NULL", 584 static_cast<void*>(value_sp.get())); 585 } 586 return cstr; 587 } 588 589 SBType 590 SBValue::GetType() 591 { 592 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 593 SBType sb_type; 594 ValueLocker locker; 595 lldb::ValueObjectSP value_sp(GetSP(locker)); 596 TypeImplSP type_sp; 597 if (value_sp) 598 { 599 type_sp.reset (new TypeImpl(value_sp->GetTypeImpl())); 600 sb_type.SetSP(type_sp); 601 } 602 if (log) 603 { 604 if (type_sp) 605 log->Printf ("SBValue(%p)::GetType => SBType(%p)", 606 static_cast<void*>(value_sp.get()), 607 static_cast<void*>(type_sp.get())); 608 else 609 log->Printf ("SBValue(%p)::GetType => NULL", 610 static_cast<void*>(value_sp.get())); 611 } 612 return sb_type; 613 } 614 615 bool 616 SBValue::GetValueDidChange () 617 { 618 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 619 bool result = false; 620 ValueLocker locker; 621 lldb::ValueObjectSP value_sp(GetSP(locker)); 622 if (value_sp) 623 { 624 if (value_sp->UpdateValueIfNeeded(false)) 625 result = value_sp->GetValueDidChange (); 626 } 627 if (log) 628 log->Printf ("SBValue(%p)::GetValueDidChange() => %i", 629 static_cast<void*>(value_sp.get()), result); 630 631 return result; 632 } 633 634 const char * 635 SBValue::GetSummary () 636 { 637 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 638 const char *cstr = NULL; 639 ValueLocker locker; 640 lldb::ValueObjectSP value_sp(GetSP(locker)); 641 if (value_sp) 642 { 643 cstr = value_sp->GetSummaryAsCString(); 644 } 645 if (log) 646 { 647 if (cstr) 648 log->Printf ("SBValue(%p)::GetSummary() => \"%s\"", 649 static_cast<void*>(value_sp.get()), cstr); 650 else 651 log->Printf ("SBValue(%p)::GetSummary() => NULL", 652 static_cast<void*>(value_sp.get())); 653 } 654 return cstr; 655 } 656 657 const char * 658 SBValue::GetSummary (lldb::SBStream& stream, 659 lldb::SBTypeSummaryOptions& options) 660 { 661 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 662 ValueLocker locker; 663 lldb::ValueObjectSP value_sp(GetSP(locker)); 664 if (value_sp) 665 { 666 std::string buffer; 667 if (value_sp->GetSummaryAsCString(buffer,options.ref()) && !buffer.empty()) 668 stream.Printf("%s",buffer.c_str()); 669 } 670 const char* cstr = stream.GetData(); 671 if (log) 672 { 673 if (cstr) 674 log->Printf ("SBValue(%p)::GetSummary() => \"%s\"", 675 static_cast<void*>(value_sp.get()), cstr); 676 else 677 log->Printf ("SBValue(%p)::GetSummary() => NULL", 678 static_cast<void*>(value_sp.get())); 679 } 680 return cstr; 681 } 682 683 const char * 684 SBValue::GetLocation () 685 { 686 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 687 const char *cstr = NULL; 688 ValueLocker locker; 689 lldb::ValueObjectSP value_sp(GetSP(locker)); 690 if (value_sp) 691 { 692 cstr = value_sp->GetLocationAsCString(); 693 } 694 if (log) 695 { 696 if (cstr) 697 log->Printf ("SBValue(%p)::GetLocation() => \"%s\"", 698 static_cast<void*>(value_sp.get()), cstr); 699 else 700 log->Printf ("SBValue(%p)::GetLocation() => NULL", 701 static_cast<void*>(value_sp.get())); 702 } 703 return cstr; 704 } 705 706 // Deprecated - use the one that takes an lldb::SBError 707 bool 708 SBValue::SetValueFromCString (const char *value_str) 709 { 710 lldb::SBError dummy; 711 return SetValueFromCString(value_str,dummy); 712 } 713 714 bool 715 SBValue::SetValueFromCString (const char *value_str, lldb::SBError& error) 716 { 717 bool success = false; 718 ValueLocker locker; 719 lldb::ValueObjectSP value_sp(GetSP(locker)); 720 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 721 if (value_sp) 722 { 723 success = value_sp->SetValueFromCString (value_str,error.ref()); 724 } 725 else 726 error.SetErrorStringWithFormat ("Could not get value: %s", locker.GetError().AsCString()); 727 728 if (log) 729 log->Printf ("SBValue(%p)::SetValueFromCString(\"%s\") => %i", 730 static_cast<void*>(value_sp.get()), value_str, success); 731 732 return success; 733 } 734 735 lldb::SBTypeFormat 736 SBValue::GetTypeFormat () 737 { 738 lldb::SBTypeFormat format; 739 ValueLocker locker; 740 lldb::ValueObjectSP value_sp(GetSP(locker)); 741 if (value_sp) 742 { 743 if (value_sp->UpdateValueIfNeeded(true)) 744 { 745 lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat(); 746 if (format_sp) 747 format.SetSP(format_sp); 748 } 749 } 750 return format; 751 } 752 753 lldb::SBTypeSummary 754 SBValue::GetTypeSummary () 755 { 756 lldb::SBTypeSummary summary; 757 ValueLocker locker; 758 lldb::ValueObjectSP value_sp(GetSP(locker)); 759 if (value_sp) 760 { 761 if (value_sp->UpdateValueIfNeeded(true)) 762 { 763 lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat(); 764 if (summary_sp) 765 summary.SetSP(summary_sp); 766 } 767 } 768 return summary; 769 } 770 771 lldb::SBTypeFilter 772 SBValue::GetTypeFilter () 773 { 774 lldb::SBTypeFilter filter; 775 ValueLocker locker; 776 lldb::ValueObjectSP value_sp(GetSP(locker)); 777 if (value_sp) 778 { 779 if (value_sp->UpdateValueIfNeeded(true)) 780 { 781 lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren(); 782 783 if (synthetic_sp && !synthetic_sp->IsScripted()) 784 { 785 TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(synthetic_sp); 786 filter.SetSP(filter_sp); 787 } 788 } 789 } 790 return filter; 791 } 792 793 #ifndef LLDB_DISABLE_PYTHON 794 lldb::SBTypeSynthetic 795 SBValue::GetTypeSynthetic () 796 { 797 lldb::SBTypeSynthetic synthetic; 798 ValueLocker locker; 799 lldb::ValueObjectSP value_sp(GetSP(locker)); 800 if (value_sp) 801 { 802 if (value_sp->UpdateValueIfNeeded(true)) 803 { 804 lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren(); 805 806 if (children_sp && children_sp->IsScripted()) 807 { 808 ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp); 809 synthetic.SetSP(synth_sp); 810 } 811 } 812 } 813 return synthetic; 814 } 815 #endif 816 817 lldb::SBValue 818 SBValue::CreateChildAtOffset (const char *name, uint32_t offset, SBType type) 819 { 820 lldb::SBValue sb_value; 821 ValueLocker locker; 822 lldb::ValueObjectSP value_sp(GetSP(locker)); 823 lldb::ValueObjectSP new_value_sp; 824 if (value_sp) 825 { 826 TypeImplSP type_sp (type.GetSP()); 827 if (type.IsValid()) 828 { 829 sb_value.SetSP(value_sp->GetSyntheticChildAtOffset(offset, type_sp->GetCompilerType(false), true),GetPreferDynamicValue(),GetPreferSyntheticValue(), name); 830 } 831 } 832 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 833 if (log) 834 { 835 if (new_value_sp) 836 log->Printf ("SBValue(%p)::CreateChildAtOffset => \"%s\"", 837 static_cast<void*>(value_sp.get()), 838 new_value_sp->GetName().AsCString()); 839 else 840 log->Printf ("SBValue(%p)::CreateChildAtOffset => NULL", 841 static_cast<void*>(value_sp.get())); 842 } 843 return sb_value; 844 } 845 846 lldb::SBValue 847 SBValue::Cast (SBType type) 848 { 849 lldb::SBValue sb_value; 850 ValueLocker locker; 851 lldb::ValueObjectSP value_sp(GetSP(locker)); 852 TypeImplSP type_sp (type.GetSP()); 853 if (value_sp && type_sp) 854 sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)),GetPreferDynamicValue(),GetPreferSyntheticValue()); 855 return sb_value; 856 } 857 858 lldb::SBValue 859 SBValue::CreateValueFromExpression (const char *name, const char* expression) 860 { 861 SBExpressionOptions options; 862 options.ref().SetKeepInMemory(true); 863 return CreateValueFromExpression (name, expression, options); 864 } 865 866 lldb::SBValue 867 SBValue::CreateValueFromExpression (const char *name, const char *expression, SBExpressionOptions &options) 868 { 869 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 870 lldb::SBValue sb_value; 871 ValueLocker locker; 872 lldb::ValueObjectSP value_sp(GetSP(locker)); 873 lldb::ValueObjectSP new_value_sp; 874 if (value_sp) 875 { 876 ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); 877 new_value_sp = ValueObject::CreateValueObjectFromExpression(name, expression, exe_ctx, options.ref()); 878 if (new_value_sp) 879 new_value_sp->SetName(ConstString(name)); 880 } 881 sb_value.SetSP(new_value_sp); 882 if (log) 883 { 884 if (new_value_sp) 885 log->Printf ("SBValue(%p)::CreateValueFromExpression(name=\"%s\", expression=\"%s\") => SBValue (%p)", 886 static_cast<void*>(value_sp.get()), name, expression, 887 static_cast<void*>(new_value_sp.get())); 888 else 889 log->Printf ("SBValue(%p)::CreateValueFromExpression(name=\"%s\", expression=\"%s\") => NULL", 890 static_cast<void*>(value_sp.get()), name, expression); 891 } 892 return sb_value; 893 } 894 895 lldb::SBValue 896 SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, SBType sb_type) 897 { 898 lldb::SBValue sb_value; 899 ValueLocker locker; 900 lldb::ValueObjectSP value_sp(GetSP(locker)); 901 lldb::ValueObjectSP new_value_sp; 902 lldb::TypeImplSP type_impl_sp (sb_type.GetSP()); 903 if (value_sp && type_impl_sp) 904 { 905 CompilerType ast_type(type_impl_sp->GetCompilerType(true)); 906 ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); 907 new_value_sp = ValueObject::CreateValueObjectFromAddress(name, address, exe_ctx, ast_type); 908 } 909 sb_value.SetSP(new_value_sp); 910 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 911 if (log) 912 { 913 if (new_value_sp) 914 log->Printf ("SBValue(%p)::CreateValueFromAddress => \"%s\"", 915 static_cast<void*>(value_sp.get()), 916 new_value_sp->GetName().AsCString()); 917 else 918 log->Printf ("SBValue(%p)::CreateValueFromAddress => NULL", 919 static_cast<void*>(value_sp.get())); 920 } 921 return sb_value; 922 } 923 924 lldb::SBValue 925 SBValue::CreateValueFromData (const char* name, SBData data, SBType sb_type) 926 { 927 lldb::SBValue sb_value; 928 lldb::ValueObjectSP new_value_sp; 929 ValueLocker locker; 930 lldb::ValueObjectSP value_sp(GetSP(locker)); 931 lldb::TypeImplSP type_impl_sp (sb_type.GetSP()); 932 if (value_sp && type_impl_sp) 933 { 934 ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); 935 new_value_sp = ValueObject::CreateValueObjectFromData(name, **data, exe_ctx, type_impl_sp->GetCompilerType(true)); 936 new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad); 937 } 938 sb_value.SetSP(new_value_sp); 939 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 940 if (log) 941 { 942 if (new_value_sp) 943 log->Printf ("SBValue(%p)::CreateValueFromData => \"%s\"", 944 static_cast<void*>(value_sp.get()), 945 new_value_sp->GetName().AsCString()); 946 else 947 log->Printf ("SBValue(%p)::CreateValueFromData => NULL", 948 static_cast<void*>(value_sp.get())); 949 } 950 return sb_value; 951 } 952 953 SBValue 954 SBValue::GetChildAtIndex (uint32_t idx) 955 { 956 const bool can_create_synthetic = false; 957 lldb::DynamicValueType use_dynamic = eNoDynamicValues; 958 TargetSP target_sp; 959 if (m_opaque_sp) 960 target_sp = m_opaque_sp->GetTargetSP(); 961 962 if (target_sp) 963 use_dynamic = target_sp->GetPreferDynamicValue(); 964 965 return GetChildAtIndex (idx, use_dynamic, can_create_synthetic); 966 } 967 968 SBValue 969 SBValue::GetChildAtIndex (uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic) 970 { 971 lldb::ValueObjectSP child_sp; 972 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 973 974 ValueLocker locker; 975 lldb::ValueObjectSP value_sp(GetSP(locker)); 976 if (value_sp) 977 { 978 const bool can_create = true; 979 child_sp = value_sp->GetChildAtIndex (idx, can_create); 980 if (can_create_synthetic && !child_sp) 981 { 982 child_sp = value_sp->GetSyntheticArrayMember(idx, can_create); 983 } 984 } 985 986 SBValue sb_value; 987 sb_value.SetSP (child_sp, use_dynamic, GetPreferSyntheticValue()); 988 if (log) 989 log->Printf ("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)", 990 static_cast<void*>(value_sp.get()), idx, 991 static_cast<void*>(value_sp.get())); 992 993 return sb_value; 994 } 995 996 uint32_t 997 SBValue::GetIndexOfChildWithName (const char *name) 998 { 999 uint32_t idx = UINT32_MAX; 1000 ValueLocker locker; 1001 lldb::ValueObjectSP value_sp(GetSP(locker)); 1002 if (value_sp) 1003 { 1004 idx = value_sp->GetIndexOfChildWithName (ConstString(name)); 1005 } 1006 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1007 if (log) 1008 { 1009 if (idx == UINT32_MAX) 1010 log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND", 1011 static_cast<void*>(value_sp.get()), name); 1012 else 1013 log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u", 1014 static_cast<void*>(value_sp.get()), name, idx); 1015 } 1016 return idx; 1017 } 1018 1019 SBValue 1020 SBValue::GetChildMemberWithName (const char *name) 1021 { 1022 lldb::DynamicValueType use_dynamic_value = eNoDynamicValues; 1023 TargetSP target_sp; 1024 if (m_opaque_sp) 1025 target_sp = m_opaque_sp->GetTargetSP(); 1026 1027 if (target_sp) 1028 use_dynamic_value = target_sp->GetPreferDynamicValue(); 1029 return GetChildMemberWithName (name, use_dynamic_value); 1030 } 1031 1032 SBValue 1033 SBValue::GetChildMemberWithName (const char *name, lldb::DynamicValueType use_dynamic_value) 1034 { 1035 lldb::ValueObjectSP child_sp; 1036 const ConstString str_name (name); 1037 1038 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1039 1040 ValueLocker locker; 1041 lldb::ValueObjectSP value_sp(GetSP(locker)); 1042 if (value_sp) 1043 { 1044 child_sp = value_sp->GetChildMemberWithName (str_name, true); 1045 } 1046 1047 SBValue sb_value; 1048 sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue()); 1049 1050 if (log) 1051 log->Printf ("SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)", 1052 static_cast<void*>(value_sp.get()), name, 1053 static_cast<void*>(value_sp.get())); 1054 1055 return sb_value; 1056 } 1057 1058 lldb::SBValue 1059 SBValue::GetDynamicValue (lldb::DynamicValueType use_dynamic) 1060 { 1061 SBValue value_sb; 1062 if (IsValid()) 1063 { 1064 ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),use_dynamic,m_opaque_sp->GetUseSynthetic())); 1065 value_sb.SetSP(proxy_sp); 1066 } 1067 return value_sb; 1068 } 1069 1070 lldb::SBValue 1071 SBValue::GetStaticValue () 1072 { 1073 SBValue value_sb; 1074 if (IsValid()) 1075 { 1076 ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),eNoDynamicValues,m_opaque_sp->GetUseSynthetic())); 1077 value_sb.SetSP(proxy_sp); 1078 } 1079 return value_sb; 1080 } 1081 1082 lldb::SBValue 1083 SBValue::GetNonSyntheticValue () 1084 { 1085 SBValue value_sb; 1086 if (IsValid()) 1087 { 1088 ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),m_opaque_sp->GetUseDynamic(),false)); 1089 value_sb.SetSP(proxy_sp); 1090 } 1091 return value_sb; 1092 } 1093 1094 lldb::DynamicValueType 1095 SBValue::GetPreferDynamicValue () 1096 { 1097 if (!IsValid()) 1098 return eNoDynamicValues; 1099 return m_opaque_sp->GetUseDynamic(); 1100 } 1101 1102 void 1103 SBValue::SetPreferDynamicValue (lldb::DynamicValueType use_dynamic) 1104 { 1105 if (IsValid()) 1106 return m_opaque_sp->SetUseDynamic (use_dynamic); 1107 } 1108 1109 bool 1110 SBValue::GetPreferSyntheticValue () 1111 { 1112 if (!IsValid()) 1113 return false; 1114 return m_opaque_sp->GetUseSynthetic(); 1115 } 1116 1117 void 1118 SBValue::SetPreferSyntheticValue (bool use_synthetic) 1119 { 1120 if (IsValid()) 1121 return m_opaque_sp->SetUseSynthetic (use_synthetic); 1122 } 1123 1124 bool 1125 SBValue::IsDynamic() 1126 { 1127 ValueLocker locker; 1128 lldb::ValueObjectSP value_sp(GetSP(locker)); 1129 if (value_sp) 1130 return value_sp->IsDynamic(); 1131 return false; 1132 } 1133 1134 bool 1135 SBValue::IsSynthetic () 1136 { 1137 ValueLocker locker; 1138 lldb::ValueObjectSP value_sp(GetSP(locker)); 1139 if (value_sp) 1140 return value_sp->IsSynthetic(); 1141 return false; 1142 } 1143 1144 lldb::SBValue 1145 SBValue::GetValueForExpressionPath(const char* expr_path) 1146 { 1147 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1148 lldb::ValueObjectSP child_sp; 1149 ValueLocker locker; 1150 lldb::ValueObjectSP value_sp(GetSP(locker)); 1151 if (value_sp) 1152 { 1153 // using default values for all the fancy options, just do it if you can 1154 child_sp = value_sp->GetValueForExpressionPath(expr_path); 1155 } 1156 1157 SBValue sb_value; 1158 sb_value.SetSP(child_sp,GetPreferDynamicValue(),GetPreferSyntheticValue()); 1159 1160 if (log) 1161 log->Printf ("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => SBValue(%p)", 1162 static_cast<void*>(value_sp.get()), expr_path, 1163 static_cast<void*>(value_sp.get())); 1164 1165 return sb_value; 1166 } 1167 1168 int64_t 1169 SBValue::GetValueAsSigned(SBError& error, int64_t fail_value) 1170 { 1171 error.Clear(); 1172 ValueLocker locker; 1173 lldb::ValueObjectSP value_sp(GetSP(locker)); 1174 if (value_sp) 1175 { 1176 bool success = true; 1177 uint64_t ret_val = fail_value; 1178 ret_val = value_sp->GetValueAsSigned(fail_value, &success); 1179 if (!success) 1180 error.SetErrorString("could not resolve value"); 1181 return ret_val; 1182 } 1183 else 1184 error.SetErrorStringWithFormat ("could not get SBValue: %s", locker.GetError().AsCString()); 1185 1186 return fail_value; 1187 } 1188 1189 uint64_t 1190 SBValue::GetValueAsUnsigned(SBError& error, uint64_t fail_value) 1191 { 1192 error.Clear(); 1193 ValueLocker locker; 1194 lldb::ValueObjectSP value_sp(GetSP(locker)); 1195 if (value_sp) 1196 { 1197 bool success = true; 1198 uint64_t ret_val = fail_value; 1199 ret_val = value_sp->GetValueAsUnsigned(fail_value, &success); 1200 if (!success) 1201 error.SetErrorString("could not resolve value"); 1202 return ret_val; 1203 } 1204 else 1205 error.SetErrorStringWithFormat ("could not get SBValue: %s", locker.GetError().AsCString()); 1206 1207 return fail_value; 1208 } 1209 1210 int64_t 1211 SBValue::GetValueAsSigned(int64_t fail_value) 1212 { 1213 ValueLocker locker; 1214 lldb::ValueObjectSP value_sp(GetSP(locker)); 1215 if (value_sp) 1216 { 1217 return value_sp->GetValueAsSigned(fail_value); 1218 } 1219 return fail_value; 1220 } 1221 1222 uint64_t 1223 SBValue::GetValueAsUnsigned(uint64_t fail_value) 1224 { 1225 ValueLocker locker; 1226 lldb::ValueObjectSP value_sp(GetSP(locker)); 1227 if (value_sp) 1228 { 1229 return value_sp->GetValueAsUnsigned(fail_value); 1230 } 1231 return fail_value; 1232 } 1233 1234 bool 1235 SBValue::MightHaveChildren () 1236 { 1237 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1238 bool has_children = false; 1239 ValueLocker locker; 1240 lldb::ValueObjectSP value_sp(GetSP(locker)); 1241 if (value_sp) 1242 has_children = value_sp->MightHaveChildren(); 1243 1244 if (log) 1245 log->Printf ("SBValue(%p)::MightHaveChildren() => %i", 1246 static_cast<void*>(value_sp.get()), has_children); 1247 return has_children; 1248 } 1249 1250 bool 1251 SBValue::IsRuntimeSupportValue () 1252 { 1253 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1254 bool is_support = false; 1255 ValueLocker locker; 1256 lldb::ValueObjectSP value_sp(GetSP(locker)); 1257 if (value_sp) 1258 is_support = value_sp->IsRuntimeSupportValue(); 1259 1260 if (log) 1261 log->Printf ("SBValue(%p)::IsRuntimeSupportValue() => %i", 1262 static_cast<void*>(value_sp.get()), is_support); 1263 return is_support; 1264 } 1265 1266 uint32_t 1267 SBValue::GetNumChildren () 1268 { 1269 return GetNumChildren (UINT32_MAX); 1270 } 1271 1272 uint32_t 1273 SBValue::GetNumChildren (uint32_t max) 1274 { 1275 uint32_t num_children = 0; 1276 1277 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1278 ValueLocker locker; 1279 lldb::ValueObjectSP value_sp(GetSP(locker)); 1280 if (value_sp) 1281 num_children = value_sp->GetNumChildren(max); 1282 1283 if (log) 1284 log->Printf ("SBValue(%p)::GetNumChildren (%u) => %u", 1285 static_cast<void*>(value_sp.get()), max, num_children); 1286 1287 return num_children; 1288 } 1289 1290 SBValue 1291 SBValue::Dereference () 1292 { 1293 SBValue sb_value; 1294 ValueLocker locker; 1295 lldb::ValueObjectSP value_sp(GetSP(locker)); 1296 if (value_sp) 1297 { 1298 Error error; 1299 sb_value = value_sp->Dereference (error); 1300 } 1301 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1302 if (log) 1303 log->Printf ("SBValue(%p)::Dereference () => SBValue(%p)", 1304 static_cast<void*>(value_sp.get()), 1305 static_cast<void*>(value_sp.get())); 1306 1307 return sb_value; 1308 } 1309 1310 // Deprecated - please use GetType().IsPointerType() instead. 1311 bool 1312 SBValue::TypeIsPointerType () 1313 { 1314 return GetType().IsPointerType(); 1315 } 1316 1317 void * 1318 SBValue::GetOpaqueType() 1319 { 1320 ValueLocker locker; 1321 lldb::ValueObjectSP value_sp(GetSP(locker)); 1322 if (value_sp) 1323 return value_sp->GetCompilerType().GetOpaqueQualType(); 1324 return NULL; 1325 } 1326 1327 lldb::SBTarget 1328 SBValue::GetTarget() 1329 { 1330 SBTarget sb_target; 1331 TargetSP target_sp; 1332 if (m_opaque_sp) 1333 { 1334 target_sp = m_opaque_sp->GetTargetSP(); 1335 sb_target.SetSP (target_sp); 1336 } 1337 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1338 if (log) 1339 { 1340 if (target_sp.get() == NULL) 1341 log->Printf ("SBValue(%p)::GetTarget () => NULL", 1342 static_cast<void*>(m_opaque_sp.get())); 1343 else 1344 log->Printf ("SBValue(%p)::GetTarget () => %p", 1345 static_cast<void*>(m_opaque_sp.get()), 1346 static_cast<void*>(target_sp.get())); 1347 } 1348 return sb_target; 1349 } 1350 1351 lldb::SBProcess 1352 SBValue::GetProcess() 1353 { 1354 SBProcess sb_process; 1355 ProcessSP process_sp; 1356 if (m_opaque_sp) 1357 { 1358 process_sp = m_opaque_sp->GetProcessSP(); 1359 sb_process.SetSP (process_sp); 1360 } 1361 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1362 if (log) 1363 { 1364 if (process_sp.get() == NULL) 1365 log->Printf ("SBValue(%p)::GetProcess () => NULL", 1366 static_cast<void*>(m_opaque_sp.get())); 1367 else 1368 log->Printf ("SBValue(%p)::GetProcess () => %p", 1369 static_cast<void*>(m_opaque_sp.get()), 1370 static_cast<void*>(process_sp.get())); 1371 } 1372 return sb_process; 1373 } 1374 1375 lldb::SBThread 1376 SBValue::GetThread() 1377 { 1378 SBThread sb_thread; 1379 ThreadSP thread_sp; 1380 if (m_opaque_sp) 1381 { 1382 thread_sp = m_opaque_sp->GetThreadSP(); 1383 sb_thread.SetThread(thread_sp); 1384 } 1385 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1386 if (log) 1387 { 1388 if (thread_sp.get() == NULL) 1389 log->Printf ("SBValue(%p)::GetThread () => NULL", 1390 static_cast<void*>(m_opaque_sp.get())); 1391 else 1392 log->Printf ("SBValue(%p)::GetThread () => %p", 1393 static_cast<void*>(m_opaque_sp.get()), 1394 static_cast<void*>(thread_sp.get())); 1395 } 1396 return sb_thread; 1397 } 1398 1399 lldb::SBFrame 1400 SBValue::GetFrame() 1401 { 1402 SBFrame sb_frame; 1403 StackFrameSP frame_sp; 1404 if (m_opaque_sp) 1405 { 1406 frame_sp = m_opaque_sp->GetFrameSP(); 1407 sb_frame.SetFrameSP (frame_sp); 1408 } 1409 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1410 if (log) 1411 { 1412 if (frame_sp.get() == NULL) 1413 log->Printf ("SBValue(%p)::GetFrame () => NULL", 1414 static_cast<void*>(m_opaque_sp.get())); 1415 else 1416 log->Printf ("SBValue(%p)::GetFrame () => %p", 1417 static_cast<void*>(m_opaque_sp.get()), 1418 static_cast<void*>(frame_sp.get())); 1419 } 1420 return sb_frame; 1421 } 1422 1423 1424 lldb::ValueObjectSP 1425 SBValue::GetSP (ValueLocker &locker) const 1426 { 1427 if (!m_opaque_sp || !m_opaque_sp->IsValid()) 1428 { 1429 locker.GetError().SetErrorString("No value"); 1430 return ValueObjectSP(); 1431 } 1432 return locker.GetLockedSP(*m_opaque_sp.get()); 1433 } 1434 1435 lldb::ValueObjectSP 1436 SBValue::GetSP () const 1437 { 1438 ValueLocker locker; 1439 return GetSP(locker); 1440 } 1441 1442 void 1443 SBValue::SetSP (ValueImplSP impl_sp) 1444 { 1445 m_opaque_sp = impl_sp; 1446 } 1447 1448 void 1449 SBValue::SetSP (const lldb::ValueObjectSP &sp) 1450 { 1451 if (sp) 1452 { 1453 lldb::TargetSP target_sp(sp->GetTargetSP()); 1454 if (target_sp) 1455 { 1456 lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue(); 1457 bool use_synthetic = target_sp->TargetProperties::GetEnableSyntheticValue(); 1458 m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic)); 1459 } 1460 else 1461 m_opaque_sp = ValueImplSP(new ValueImpl(sp,eNoDynamicValues,true)); 1462 } 1463 else 1464 m_opaque_sp = ValueImplSP(new ValueImpl(sp,eNoDynamicValues,false)); 1465 } 1466 1467 void 1468 SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic) 1469 { 1470 if (sp) 1471 { 1472 lldb::TargetSP target_sp(sp->GetTargetSP()); 1473 if (target_sp) 1474 { 1475 bool use_synthetic = target_sp->TargetProperties::GetEnableSyntheticValue(); 1476 SetSP (sp, use_dynamic, use_synthetic); 1477 } 1478 else 1479 SetSP (sp, use_dynamic, true); 1480 } 1481 else 1482 SetSP (sp, use_dynamic, false); 1483 } 1484 1485 void 1486 SBValue::SetSP (const lldb::ValueObjectSP &sp, bool use_synthetic) 1487 { 1488 if (sp) 1489 { 1490 lldb::TargetSP target_sp(sp->GetTargetSP()); 1491 if (target_sp) 1492 { 1493 lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue(); 1494 SetSP (sp, use_dynamic, use_synthetic); 1495 } 1496 else 1497 SetSP (sp, eNoDynamicValues, use_synthetic); 1498 } 1499 else 1500 SetSP (sp, eNoDynamicValues, use_synthetic); 1501 } 1502 1503 void 1504 SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic, bool use_synthetic) 1505 { 1506 m_opaque_sp = ValueImplSP(new ValueImpl(sp,use_dynamic,use_synthetic)); 1507 } 1508 1509 void 1510 SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic, bool use_synthetic, const char *name) 1511 { 1512 m_opaque_sp = ValueImplSP(new ValueImpl(sp,use_dynamic,use_synthetic, name)); 1513 } 1514 1515 bool 1516 SBValue::GetExpressionPath (SBStream &description) 1517 { 1518 ValueLocker locker; 1519 lldb::ValueObjectSP value_sp(GetSP(locker)); 1520 if (value_sp) 1521 { 1522 value_sp->GetExpressionPath (description.ref(), false); 1523 return true; 1524 } 1525 return false; 1526 } 1527 1528 bool 1529 SBValue::GetExpressionPath (SBStream &description, bool qualify_cxx_base_classes) 1530 { 1531 ValueLocker locker; 1532 lldb::ValueObjectSP value_sp(GetSP(locker)); 1533 if (value_sp) 1534 { 1535 value_sp->GetExpressionPath (description.ref(), qualify_cxx_base_classes); 1536 return true; 1537 } 1538 return false; 1539 } 1540 1541 bool 1542 SBValue::GetDescription (SBStream &description) 1543 { 1544 Stream &strm = description.ref(); 1545 1546 ValueLocker locker; 1547 lldb::ValueObjectSP value_sp(GetSP(locker)); 1548 if (value_sp) 1549 value_sp->Dump(strm); 1550 else 1551 strm.PutCString ("No value"); 1552 1553 return true; 1554 } 1555 1556 lldb::Format 1557 SBValue::GetFormat () 1558 { 1559 ValueLocker locker; 1560 lldb::ValueObjectSP value_sp(GetSP(locker)); 1561 if (value_sp) 1562 return value_sp->GetFormat(); 1563 return eFormatDefault; 1564 } 1565 1566 void 1567 SBValue::SetFormat (lldb::Format format) 1568 { 1569 ValueLocker locker; 1570 lldb::ValueObjectSP value_sp(GetSP(locker)); 1571 if (value_sp) 1572 value_sp->SetFormat(format); 1573 } 1574 1575 lldb::SBValue 1576 SBValue::AddressOf() 1577 { 1578 SBValue sb_value; 1579 ValueLocker locker; 1580 lldb::ValueObjectSP value_sp(GetSP(locker)); 1581 if (value_sp) 1582 { 1583 Error error; 1584 sb_value.SetSP(value_sp->AddressOf (error),GetPreferDynamicValue(), GetPreferSyntheticValue()); 1585 } 1586 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1587 if (log) 1588 log->Printf ("SBValue(%p)::AddressOf () => SBValue(%p)", 1589 static_cast<void*>(value_sp.get()), 1590 static_cast<void*>(value_sp.get())); 1591 1592 return sb_value; 1593 } 1594 1595 lldb::addr_t 1596 SBValue::GetLoadAddress() 1597 { 1598 lldb::addr_t value = LLDB_INVALID_ADDRESS; 1599 ValueLocker locker; 1600 lldb::ValueObjectSP value_sp(GetSP(locker)); 1601 if (value_sp) 1602 { 1603 TargetSP target_sp (value_sp->GetTargetSP()); 1604 if (target_sp) 1605 { 1606 const bool scalar_is_load_address = true; 1607 AddressType addr_type; 1608 value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type); 1609 if (addr_type == eAddressTypeFile) 1610 { 1611 ModuleSP module_sp (value_sp->GetModule()); 1612 if (!module_sp) 1613 value = LLDB_INVALID_ADDRESS; 1614 else 1615 { 1616 Address addr; 1617 module_sp->ResolveFileAddress(value, addr); 1618 value = addr.GetLoadAddress(target_sp.get()); 1619 } 1620 } 1621 else if (addr_type == eAddressTypeHost || addr_type == eAddressTypeInvalid) 1622 value = LLDB_INVALID_ADDRESS; 1623 } 1624 } 1625 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1626 if (log) 1627 log->Printf ("SBValue(%p)::GetLoadAddress () => (%" PRIu64 ")", 1628 static_cast<void*>(value_sp.get()), value); 1629 1630 return value; 1631 } 1632 1633 lldb::SBAddress 1634 SBValue::GetAddress() 1635 { 1636 Address addr; 1637 ValueLocker locker; 1638 lldb::ValueObjectSP value_sp(GetSP(locker)); 1639 if (value_sp) 1640 { 1641 TargetSP target_sp (value_sp->GetTargetSP()); 1642 if (target_sp) 1643 { 1644 lldb::addr_t value = LLDB_INVALID_ADDRESS; 1645 const bool scalar_is_load_address = true; 1646 AddressType addr_type; 1647 value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type); 1648 if (addr_type == eAddressTypeFile) 1649 { 1650 ModuleSP module_sp (value_sp->GetModule()); 1651 if (module_sp) 1652 module_sp->ResolveFileAddress(value, addr); 1653 } 1654 else if (addr_type == eAddressTypeLoad) 1655 { 1656 // no need to check the return value on this.. if it can actually do the resolve 1657 // addr will be in the form (section,offset), otherwise it will simply be returned 1658 // as (NULL, value) 1659 addr.SetLoadAddress(value, target_sp.get()); 1660 } 1661 } 1662 } 1663 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1664 if (log) 1665 log->Printf ("SBValue(%p)::GetAddress () => (%s,%" PRIu64 ")", 1666 static_cast<void*>(value_sp.get()), 1667 (addr.GetSection() 1668 ? addr.GetSection()->GetName().GetCString() 1669 : "NULL"), 1670 addr.GetOffset()); 1671 return SBAddress(new Address(addr)); 1672 } 1673 1674 lldb::SBData 1675 SBValue::GetPointeeData (uint32_t item_idx, 1676 uint32_t item_count) 1677 { 1678 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1679 lldb::SBData sb_data; 1680 ValueLocker locker; 1681 lldb::ValueObjectSP value_sp(GetSP(locker)); 1682 if (value_sp) 1683 { 1684 TargetSP target_sp (value_sp->GetTargetSP()); 1685 if (target_sp) 1686 { 1687 DataExtractorSP data_sp(new DataExtractor()); 1688 value_sp->GetPointeeData(*data_sp, item_idx, item_count); 1689 if (data_sp->GetByteSize() > 0) 1690 *sb_data = data_sp; 1691 } 1692 } 1693 if (log) 1694 log->Printf ("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)", 1695 static_cast<void*>(value_sp.get()), item_idx, item_count, 1696 static_cast<void*>(sb_data.get())); 1697 1698 return sb_data; 1699 } 1700 1701 lldb::SBData 1702 SBValue::GetData () 1703 { 1704 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1705 lldb::SBData sb_data; 1706 ValueLocker locker; 1707 lldb::ValueObjectSP value_sp(GetSP(locker)); 1708 if (value_sp) 1709 { 1710 DataExtractorSP data_sp(new DataExtractor()); 1711 Error error; 1712 value_sp->GetData(*data_sp, error); 1713 if (error.Success()) 1714 *sb_data = data_sp; 1715 } 1716 if (log) 1717 log->Printf ("SBValue(%p)::GetData () => SBData(%p)", 1718 static_cast<void*>(value_sp.get()), 1719 static_cast<void*>(sb_data.get())); 1720 1721 return sb_data; 1722 } 1723 1724 bool 1725 SBValue::SetData (lldb::SBData &data, SBError &error) 1726 { 1727 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1728 ValueLocker locker; 1729 lldb::ValueObjectSP value_sp(GetSP(locker)); 1730 bool ret = true; 1731 1732 if (value_sp) 1733 { 1734 DataExtractor *data_extractor = data.get(); 1735 1736 if (!data_extractor) 1737 { 1738 if (log) 1739 log->Printf ("SBValue(%p)::SetData() => error: no data to set", 1740 static_cast<void*>(value_sp.get())); 1741 1742 error.SetErrorString("No data to set"); 1743 ret = false; 1744 } 1745 else 1746 { 1747 Error set_error; 1748 1749 value_sp->SetData(*data_extractor, set_error); 1750 1751 if (!set_error.Success()) 1752 { 1753 error.SetErrorStringWithFormat("Couldn't set data: %s", set_error.AsCString()); 1754 ret = false; 1755 } 1756 } 1757 } 1758 else 1759 { 1760 error.SetErrorStringWithFormat ("Couldn't set data: could not get SBValue: %s", locker.GetError().AsCString()); 1761 ret = false; 1762 } 1763 1764 if (log) 1765 log->Printf ("SBValue(%p)::SetData (%p) => %s", 1766 static_cast<void*>(value_sp.get()), 1767 static_cast<void*>(data.get()), ret ? "true" : "false"); 1768 return ret; 1769 } 1770 1771 lldb::SBDeclaration 1772 SBValue::GetDeclaration () 1773 { 1774 ValueLocker locker; 1775 lldb::ValueObjectSP value_sp(GetSP(locker)); 1776 SBDeclaration decl_sb; 1777 if (value_sp) 1778 { 1779 Declaration decl; 1780 if (value_sp->GetDeclaration(decl)) 1781 decl_sb.SetDeclaration(decl); 1782 } 1783 return decl_sb; 1784 } 1785 1786 lldb::SBWatchpoint 1787 SBValue::Watch (bool resolve_location, bool read, bool write, SBError &error) 1788 { 1789 SBWatchpoint sb_watchpoint; 1790 1791 // If the SBValue is not valid, there's no point in even trying to watch it. 1792 ValueLocker locker; 1793 lldb::ValueObjectSP value_sp(GetSP(locker)); 1794 TargetSP target_sp (GetTarget().GetSP()); 1795 if (value_sp && target_sp) 1796 { 1797 // Read and Write cannot both be false. 1798 if (!read && !write) 1799 return sb_watchpoint; 1800 1801 // If the value is not in scope, don't try and watch and invalid value 1802 if (!IsInScope()) 1803 return sb_watchpoint; 1804 1805 addr_t addr = GetLoadAddress(); 1806 if (addr == LLDB_INVALID_ADDRESS) 1807 return sb_watchpoint; 1808 size_t byte_size = GetByteSize(); 1809 if (byte_size == 0) 1810 return sb_watchpoint; 1811 1812 uint32_t watch_type = 0; 1813 if (read) 1814 watch_type |= LLDB_WATCH_TYPE_READ; 1815 if (write) 1816 watch_type |= LLDB_WATCH_TYPE_WRITE; 1817 1818 Error rc; 1819 CompilerType type (value_sp->GetCompilerType()); 1820 WatchpointSP watchpoint_sp = target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc); 1821 error.SetError(rc); 1822 1823 if (watchpoint_sp) 1824 { 1825 sb_watchpoint.SetSP (watchpoint_sp); 1826 Declaration decl; 1827 if (value_sp->GetDeclaration (decl)) 1828 { 1829 if (decl.GetFile()) 1830 { 1831 StreamString ss; 1832 // True to show fullpath for declaration file. 1833 decl.DumpStopContext(&ss, true); 1834 watchpoint_sp->SetDeclInfo(ss.GetString()); 1835 } 1836 } 1837 } 1838 } 1839 else if (target_sp) 1840 { 1841 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1842 if (log) 1843 log->Printf ("SBValue(%p)::Watch() => error getting SBValue: %s", 1844 static_cast<void*>(value_sp.get()), 1845 locker.GetError().AsCString()); 1846 1847 error.SetErrorStringWithFormat("could not get SBValue: %s", locker.GetError().AsCString()); 1848 } 1849 else 1850 { 1851 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1852 if (log) 1853 log->Printf ("SBValue(%p)::Watch() => error getting SBValue: no target", 1854 static_cast<void*>(value_sp.get())); 1855 error.SetErrorString("could not set watchpoint, a target is required"); 1856 } 1857 1858 return sb_watchpoint; 1859 } 1860 1861 // FIXME: Remove this method impl (as well as the decl in .h) once it is no longer needed. 1862 // Backward compatibility fix in the interim. 1863 lldb::SBWatchpoint 1864 SBValue::Watch (bool resolve_location, bool read, bool write) 1865 { 1866 SBError error; 1867 return Watch(resolve_location, read, write, error); 1868 } 1869 1870 lldb::SBWatchpoint 1871 SBValue::WatchPointee (bool resolve_location, bool read, bool write, SBError &error) 1872 { 1873 SBWatchpoint sb_watchpoint; 1874 if (IsInScope() && GetType().IsPointerType()) 1875 sb_watchpoint = Dereference().Watch (resolve_location, read, write, error); 1876 return sb_watchpoint; 1877 } 1878 1879 lldb::SBValue 1880 SBValue::Persist () 1881 { 1882 ValueLocker locker; 1883 lldb::ValueObjectSP value_sp(GetSP(locker)); 1884 SBValue persisted_sb; 1885 if (value_sp) 1886 { 1887 persisted_sb.SetSP(value_sp->Persist()); 1888 } 1889 return persisted_sb; 1890 } 1891