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