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, Mutex::Locker &api_locker, 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 api_locker.Lock(target->GetAPIMutex()); 144 else 145 return ValueObjectSP(); 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_api_locker, 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 Mutex::Locker m_api_locker; 274 Error m_lock_error; 275 276 }; 277 278 SBValue::SBValue () : 279 m_opaque_sp () 280 { 281 } 282 283 SBValue::SBValue (const lldb::ValueObjectSP &value_sp) 284 { 285 SetSP(value_sp); 286 } 287 288 SBValue::SBValue(const SBValue &rhs) 289 { 290 SetSP(rhs.m_opaque_sp); 291 } 292 293 SBValue & 294 SBValue::operator = (const SBValue &rhs) 295 { 296 if (this != &rhs) 297 { 298 SetSP(rhs.m_opaque_sp); 299 } 300 return *this; 301 } 302 303 SBValue::~SBValue() 304 { 305 } 306 307 bool 308 SBValue::IsValid () 309 { 310 // If this function ever changes to anything that does more than just 311 // check if the opaque shared pointer is non NULL, then we need to update 312 // all "if (m_opaque_sp)" code in this file. 313 return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid() && m_opaque_sp->GetRootSP().get() != NULL; 314 } 315 316 void 317 SBValue::Clear() 318 { 319 m_opaque_sp.reset(); 320 } 321 322 SBError 323 SBValue::GetError() 324 { 325 SBError sb_error; 326 327 ValueLocker locker; 328 lldb::ValueObjectSP value_sp(GetSP(locker)); 329 if (value_sp) 330 sb_error.SetError(value_sp->GetError()); 331 else 332 sb_error.SetErrorStringWithFormat ("error: %s", locker.GetError().AsCString()); 333 334 return sb_error; 335 } 336 337 user_id_t 338 SBValue::GetID() 339 { 340 ValueLocker locker; 341 lldb::ValueObjectSP value_sp(GetSP(locker)); 342 if (value_sp) 343 return value_sp->GetID(); 344 return LLDB_INVALID_UID; 345 } 346 347 const char * 348 SBValue::GetName() 349 { 350 const char *name = NULL; 351 ValueLocker locker; 352 lldb::ValueObjectSP value_sp(GetSP(locker)); 353 if (value_sp) 354 name = value_sp->GetName().GetCString(); 355 356 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 357 if (log) 358 { 359 if (name) 360 log->Printf ("SBValue(%p)::GetName () => \"%s\"", 361 static_cast<void*>(value_sp.get()), name); 362 else 363 log->Printf ("SBValue(%p)::GetName () => NULL", 364 static_cast<void*>(value_sp.get())); 365 } 366 367 return name; 368 } 369 370 const char * 371 SBValue::GetTypeName () 372 { 373 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 374 const char *name = NULL; 375 ValueLocker locker; 376 lldb::ValueObjectSP value_sp(GetSP(locker)); 377 if (value_sp) 378 { 379 name = value_sp->GetQualifiedTypeName().GetCString(); 380 } 381 382 if (log) 383 { 384 if (name) 385 log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"", 386 static_cast<void*>(value_sp.get()), name); 387 else 388 log->Printf ("SBValue(%p)::GetTypeName () => NULL", 389 static_cast<void*>(value_sp.get())); 390 } 391 392 return name; 393 } 394 395 const char * 396 SBValue::GetDisplayTypeName () 397 { 398 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 399 const char *name = NULL; 400 ValueLocker locker; 401 lldb::ValueObjectSP value_sp(GetSP(locker)); 402 if (value_sp) 403 { 404 name = value_sp->GetDisplayTypeName().GetCString(); 405 } 406 407 if (log) 408 { 409 if (name) 410 log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"", 411 static_cast<void*>(value_sp.get()), name); 412 else 413 log->Printf ("SBValue(%p)::GetTypeName () => NULL", 414 static_cast<void*>(value_sp.get())); 415 } 416 417 return name; 418 } 419 420 size_t 421 SBValue::GetByteSize () 422 { 423 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 424 size_t result = 0; 425 426 ValueLocker locker; 427 lldb::ValueObjectSP value_sp(GetSP(locker)); 428 if (value_sp) 429 { 430 result = value_sp->GetByteSize(); 431 } 432 433 if (log) 434 log->Printf ("SBValue(%p)::GetByteSize () => %" PRIu64, 435 static_cast<void*>(value_sp.get()), 436 static_cast<uint64_t>(result)); 437 438 return result; 439 } 440 441 bool 442 SBValue::IsInScope () 443 { 444 bool result = false; 445 446 ValueLocker locker; 447 lldb::ValueObjectSP value_sp(GetSP(locker)); 448 if (value_sp) 449 { 450 result = value_sp->IsInScope (); 451 } 452 453 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 454 if (log) 455 log->Printf ("SBValue(%p)::IsInScope () => %i", 456 static_cast<void*>(value_sp.get()), result); 457 458 return result; 459 } 460 461 const char * 462 SBValue::GetValue () 463 { 464 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 465 466 const char *cstr = NULL; 467 ValueLocker locker; 468 lldb::ValueObjectSP value_sp(GetSP(locker)); 469 if (value_sp) 470 { 471 cstr = value_sp->GetValueAsCString (); 472 } 473 if (log) 474 { 475 if (cstr) 476 log->Printf ("SBValue(%p)::GetValue() => \"%s\"", 477 static_cast<void*>(value_sp.get()), cstr); 478 else 479 log->Printf ("SBValue(%p)::GetValue() => NULL", 480 static_cast<void*>(value_sp.get())); 481 } 482 483 return cstr; 484 } 485 486 ValueType 487 SBValue::GetValueType () 488 { 489 ValueType result = eValueTypeInvalid; 490 ValueLocker locker; 491 lldb::ValueObjectSP value_sp(GetSP(locker)); 492 if (value_sp) 493 result = value_sp->GetValueType(); 494 495 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 496 if (log) 497 { 498 switch (result) 499 { 500 case eValueTypeInvalid: 501 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeInvalid", 502 static_cast<void*>(value_sp.get())); 503 break; 504 case eValueTypeVariableGlobal: 505 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal", 506 static_cast<void*>(value_sp.get())); 507 break; 508 case eValueTypeVariableStatic: 509 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableStatic", 510 static_cast<void*>(value_sp.get())); 511 break; 512 case eValueTypeVariableArgument: 513 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableArgument", 514 static_cast<void*>(value_sp.get())); 515 break; 516 case eValueTypeVariableLocal: 517 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableLocal", 518 static_cast<void*>(value_sp.get())); 519 break; 520 case eValueTypeRegister: 521 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegister", 522 static_cast<void*>(value_sp.get())); 523 break; 524 case eValueTypeRegisterSet: 525 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegisterSet", 526 static_cast<void*>(value_sp.get())); 527 break; 528 case eValueTypeConstResult: 529 log->Printf ("SBValue(%p)::GetValueType () => eValueTypeConstResult", 530 static_cast<void*>(value_sp.get())); 531 break; 532 } 533 } 534 return result; 535 } 536 537 const char * 538 SBValue::GetObjectDescription () 539 { 540 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 541 const char *cstr = NULL; 542 ValueLocker locker; 543 lldb::ValueObjectSP value_sp(GetSP(locker)); 544 if (value_sp) 545 { 546 cstr = value_sp->GetObjectDescription (); 547 } 548 if (log) 549 { 550 if (cstr) 551 log->Printf ("SBValue(%p)::GetObjectDescription() => \"%s\"", 552 static_cast<void*>(value_sp.get()), cstr); 553 else 554 log->Printf ("SBValue(%p)::GetObjectDescription() => NULL", 555 static_cast<void*>(value_sp.get())); 556 } 557 return cstr; 558 } 559 560 const char * 561 SBValue::GetTypeValidatorResult () 562 { 563 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 564 const char *cstr = NULL; 565 ValueLocker locker; 566 lldb::ValueObjectSP value_sp(GetSP(locker)); 567 if (value_sp) 568 { 569 const auto& validation(value_sp->GetValidationStatus()); 570 if (TypeValidatorResult::Failure == validation.first) 571 { 572 if (validation.second.empty()) 573 cstr = "unknown error"; 574 else 575 cstr = validation.second.c_str(); 576 } 577 } 578 if (log) 579 { 580 if (cstr) 581 log->Printf ("SBValue(%p)::GetTypeValidatorResult() => \"%s\"", 582 static_cast<void*>(value_sp.get()), cstr); 583 else 584 log->Printf ("SBValue(%p)::GetTypeValidatorResult() => NULL", 585 static_cast<void*>(value_sp.get())); 586 } 587 return cstr; 588 } 589 590 SBType 591 SBValue::GetType() 592 { 593 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 594 SBType sb_type; 595 ValueLocker locker; 596 lldb::ValueObjectSP value_sp(GetSP(locker)); 597 TypeImplSP type_sp; 598 if (value_sp) 599 { 600 type_sp.reset (new TypeImpl(value_sp->GetTypeImpl())); 601 sb_type.SetSP(type_sp); 602 } 603 if (log) 604 { 605 if (type_sp) 606 log->Printf ("SBValue(%p)::GetType => SBType(%p)", 607 static_cast<void*>(value_sp.get()), 608 static_cast<void*>(type_sp.get())); 609 else 610 log->Printf ("SBValue(%p)::GetType => NULL", 611 static_cast<void*>(value_sp.get())); 612 } 613 return sb_type; 614 } 615 616 bool 617 SBValue::GetValueDidChange () 618 { 619 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 620 bool result = false; 621 ValueLocker locker; 622 lldb::ValueObjectSP value_sp(GetSP(locker)); 623 if (value_sp) 624 { 625 if (value_sp->UpdateValueIfNeeded(false)) 626 result = value_sp->GetValueDidChange (); 627 } 628 if (log) 629 log->Printf ("SBValue(%p)::GetValueDidChange() => %i", 630 static_cast<void*>(value_sp.get()), result); 631 632 return result; 633 } 634 635 const char * 636 SBValue::GetSummary () 637 { 638 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 639 const char *cstr = NULL; 640 ValueLocker locker; 641 lldb::ValueObjectSP value_sp(GetSP(locker)); 642 if (value_sp) 643 { 644 cstr = value_sp->GetSummaryAsCString(); 645 } 646 if (log) 647 { 648 if (cstr) 649 log->Printf ("SBValue(%p)::GetSummary() => \"%s\"", 650 static_cast<void*>(value_sp.get()), cstr); 651 else 652 log->Printf ("SBValue(%p)::GetSummary() => NULL", 653 static_cast<void*>(value_sp.get())); 654 } 655 return cstr; 656 } 657 658 const char * 659 SBValue::GetSummary (lldb::SBStream& stream, 660 lldb::SBTypeSummaryOptions& options) 661 { 662 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 663 ValueLocker locker; 664 lldb::ValueObjectSP value_sp(GetSP(locker)); 665 if (value_sp) 666 { 667 std::string buffer; 668 if (value_sp->GetSummaryAsCString(buffer,options.ref()) && !buffer.empty()) 669 stream.Printf("%s",buffer.c_str()); 670 } 671 const char* cstr = stream.GetData(); 672 if (log) 673 { 674 if (cstr) 675 log->Printf ("SBValue(%p)::GetSummary() => \"%s\"", 676 static_cast<void*>(value_sp.get()), cstr); 677 else 678 log->Printf ("SBValue(%p)::GetSummary() => NULL", 679 static_cast<void*>(value_sp.get())); 680 } 681 return cstr; 682 } 683 684 const char * 685 SBValue::GetLocation () 686 { 687 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 688 const char *cstr = NULL; 689 ValueLocker locker; 690 lldb::ValueObjectSP value_sp(GetSP(locker)); 691 if (value_sp) 692 { 693 cstr = value_sp->GetLocationAsCString(); 694 } 695 if (log) 696 { 697 if (cstr) 698 log->Printf ("SBValue(%p)::GetLocation() => \"%s\"", 699 static_cast<void*>(value_sp.get()), cstr); 700 else 701 log->Printf ("SBValue(%p)::GetLocation() => NULL", 702 static_cast<void*>(value_sp.get())); 703 } 704 return cstr; 705 } 706 707 // Deprecated - use the one that takes an lldb::SBError 708 bool 709 SBValue::SetValueFromCString (const char *value_str) 710 { 711 lldb::SBError dummy; 712 return SetValueFromCString(value_str,dummy); 713 } 714 715 bool 716 SBValue::SetValueFromCString (const char *value_str, lldb::SBError& error) 717 { 718 bool success = false; 719 ValueLocker locker; 720 lldb::ValueObjectSP value_sp(GetSP(locker)); 721 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 722 if (value_sp) 723 { 724 success = value_sp->SetValueFromCString (value_str,error.ref()); 725 } 726 else 727 error.SetErrorStringWithFormat ("Could not get value: %s", locker.GetError().AsCString()); 728 729 if (log) 730 log->Printf ("SBValue(%p)::SetValueFromCString(\"%s\") => %i", 731 static_cast<void*>(value_sp.get()), value_str, success); 732 733 return success; 734 } 735 736 lldb::SBTypeFormat 737 SBValue::GetTypeFormat () 738 { 739 lldb::SBTypeFormat format; 740 ValueLocker locker; 741 lldb::ValueObjectSP value_sp(GetSP(locker)); 742 if (value_sp) 743 { 744 if (value_sp->UpdateValueIfNeeded(true)) 745 { 746 lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat(); 747 if (format_sp) 748 format.SetSP(format_sp); 749 } 750 } 751 return format; 752 } 753 754 lldb::SBTypeSummary 755 SBValue::GetTypeSummary () 756 { 757 lldb::SBTypeSummary summary; 758 ValueLocker locker; 759 lldb::ValueObjectSP value_sp(GetSP(locker)); 760 if (value_sp) 761 { 762 if (value_sp->UpdateValueIfNeeded(true)) 763 { 764 lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat(); 765 if (summary_sp) 766 summary.SetSP(summary_sp); 767 } 768 } 769 return summary; 770 } 771 772 lldb::SBTypeFilter 773 SBValue::GetTypeFilter () 774 { 775 lldb::SBTypeFilter filter; 776 ValueLocker locker; 777 lldb::ValueObjectSP value_sp(GetSP(locker)); 778 if (value_sp) 779 { 780 if (value_sp->UpdateValueIfNeeded(true)) 781 { 782 lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren(); 783 784 if (synthetic_sp && !synthetic_sp->IsScripted()) 785 { 786 TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(synthetic_sp); 787 filter.SetSP(filter_sp); 788 } 789 } 790 } 791 return filter; 792 } 793 794 #ifndef LLDB_DISABLE_PYTHON 795 lldb::SBTypeSynthetic 796 SBValue::GetTypeSynthetic () 797 { 798 lldb::SBTypeSynthetic synthetic; 799 ValueLocker locker; 800 lldb::ValueObjectSP value_sp(GetSP(locker)); 801 if (value_sp) 802 { 803 if (value_sp->UpdateValueIfNeeded(true)) 804 { 805 lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren(); 806 807 if (children_sp && children_sp->IsScripted()) 808 { 809 ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp); 810 synthetic.SetSP(synth_sp); 811 } 812 } 813 } 814 return synthetic; 815 } 816 #endif 817 818 lldb::SBValue 819 SBValue::CreateChildAtOffset (const char *name, uint32_t offset, SBType type) 820 { 821 lldb::SBValue sb_value; 822 ValueLocker locker; 823 lldb::ValueObjectSP value_sp(GetSP(locker)); 824 lldb::ValueObjectSP new_value_sp; 825 if (value_sp) 826 { 827 TypeImplSP type_sp (type.GetSP()); 828 if (type.IsValid()) 829 { 830 sb_value.SetSP(value_sp->GetSyntheticChildAtOffset(offset, type_sp->GetCompilerType(false), true),GetPreferDynamicValue(),GetPreferSyntheticValue(), name); 831 } 832 } 833 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 834 if (log) 835 { 836 if (new_value_sp) 837 log->Printf ("SBValue(%p)::CreateChildAtOffset => \"%s\"", 838 static_cast<void*>(value_sp.get()), 839 new_value_sp->GetName().AsCString()); 840 else 841 log->Printf ("SBValue(%p)::CreateChildAtOffset => NULL", 842 static_cast<void*>(value_sp.get())); 843 } 844 return sb_value; 845 } 846 847 lldb::SBValue 848 SBValue::Cast (SBType type) 849 { 850 lldb::SBValue sb_value; 851 ValueLocker locker; 852 lldb::ValueObjectSP value_sp(GetSP(locker)); 853 TypeImplSP type_sp (type.GetSP()); 854 if (value_sp && type_sp) 855 sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)),GetPreferDynamicValue(),GetPreferSyntheticValue()); 856 return sb_value; 857 } 858 859 lldb::SBValue 860 SBValue::CreateValueFromExpression (const char *name, const char* expression) 861 { 862 SBExpressionOptions options; 863 options.ref().SetKeepInMemory(true); 864 return CreateValueFromExpression (name, expression, options); 865 } 866 867 lldb::SBValue 868 SBValue::CreateValueFromExpression (const char *name, const char *expression, SBExpressionOptions &options) 869 { 870 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 871 lldb::SBValue sb_value; 872 ValueLocker locker; 873 lldb::ValueObjectSP value_sp(GetSP(locker)); 874 lldb::ValueObjectSP new_value_sp; 875 if (value_sp) 876 { 877 ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); 878 new_value_sp = ValueObject::CreateValueObjectFromExpression(name, expression, exe_ctx, options.ref()); 879 if (new_value_sp) 880 new_value_sp->SetName(ConstString(name)); 881 } 882 sb_value.SetSP(new_value_sp); 883 if (log) 884 { 885 if (new_value_sp) 886 log->Printf ("SBValue(%p)::CreateValueFromExpression(name=\"%s\", expression=\"%s\") => SBValue (%p)", 887 static_cast<void*>(value_sp.get()), name, expression, 888 static_cast<void*>(new_value_sp.get())); 889 else 890 log->Printf ("SBValue(%p)::CreateValueFromExpression(name=\"%s\", expression=\"%s\") => NULL", 891 static_cast<void*>(value_sp.get()), name, expression); 892 } 893 return sb_value; 894 } 895 896 lldb::SBValue 897 SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, SBType sb_type) 898 { 899 lldb::SBValue sb_value; 900 ValueLocker locker; 901 lldb::ValueObjectSP value_sp(GetSP(locker)); 902 lldb::ValueObjectSP new_value_sp; 903 lldb::TypeImplSP type_impl_sp (sb_type.GetSP()); 904 if (value_sp && type_impl_sp) 905 { 906 CompilerType ast_type(type_impl_sp->GetCompilerType(true)); 907 ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); 908 new_value_sp = ValueObject::CreateValueObjectFromAddress(name, address, exe_ctx, ast_type); 909 } 910 sb_value.SetSP(new_value_sp); 911 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 912 if (log) 913 { 914 if (new_value_sp) 915 log->Printf ("SBValue(%p)::CreateValueFromAddress => \"%s\"", 916 static_cast<void*>(value_sp.get()), 917 new_value_sp->GetName().AsCString()); 918 else 919 log->Printf ("SBValue(%p)::CreateValueFromAddress => NULL", 920 static_cast<void*>(value_sp.get())); 921 } 922 return sb_value; 923 } 924 925 lldb::SBValue 926 SBValue::CreateValueFromData (const char* name, SBData data, SBType type) 927 { 928 lldb::SBValue sb_value; 929 lldb::ValueObjectSP new_value_sp; 930 ValueLocker locker; 931 lldb::ValueObjectSP value_sp(GetSP(locker)); 932 if (value_sp) 933 { 934 ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); 935 new_value_sp = ValueObject::CreateValueObjectFromData(name, **data, exe_ctx, type.GetSP()->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