contrib/llvm/tools/lldb/source/API/SBValue.cpp

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