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