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