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