Update clang, llvm, lld, lldb, compiler-rt and libc++ to 4.0.0 release:

MFC r309142 (by emaste):

Add WITH_LLD_AS_LD build knob

If set it installs LLD as /usr/bin/ld.  LLD (as of version 3.9) is not
capable of linking the world and kernel, but can self-host and link many
substantial applications. GNU ld continues to be used for the world and
kernel build, regardless of how this knob is set.

It is on by default for arm64, and off for all other CPU architectures.

Sponsored by:	The FreeBSD Foundation

MFC r310840:

Reapply 310775, now it also builds correctly if lldb is disabled:

Move llvm-objdump from CLANG_EXTRAS to installed by default

We currently install three tools from binutils 2.17.50: as, ld, and
objdump. Work is underway to migrate to a permissively-licensed
tool-chain, with one goal being the retirement of binutils 2.17.50.

LLVM's llvm-objdump is intended to be compatible with GNU objdump
although it is currently missing some options and may have formatting
differences. Enable it by default for testing and further investigation.
It may later be changed to install as /usr/bin/objdump, it becomes a
fully viable replacement.

Reviewed by:	emaste
Differential Revision:	https://reviews.freebsd.org/D8879

MFC r312855 (by emaste):

Rename LLD_AS_LD to LLD_IS_LD, for consistency with CLANG_IS_CC

Reported by:	Dan McGregor <dan.mcgregor usask.ca>

MFC r313559 | glebius | 2017-02-10 18:34:48 +0100 (Fri, 10 Feb 2017) | 5 lines

Don't check struct rtentry on FreeBSD, it is an internal kernel structure.
On other systems it may be API structure for SIOCADDRT/SIOCDELRT.

Reviewed by:	emaste, dim

MFC r314152 (by jkim):

Remove an assembler flag, which is redundant since r309124.  The upstream
took care of it by introducing a macro NO_EXEC_STACK_DIRECTIVE.

http://llvm.org/viewvc/llvm-project?rev=273500&view=rev

Reviewed by:	dim

MFC r314564:

Upgrade our copies of clang, llvm, lld, lldb, compiler-rt and libc++ to
4.0.0 (branches/release_40 296509).  The release will follow soon.

Please note that from 3.5.0 onwards, clang, llvm and lldb require C++11
support to build; see UPDATING for more information.

Also note that as of 4.0.0, lld should be able to link the base system
on amd64 and aarch64.  See the WITH_LLD_IS_LLD setting in src.conf(5).
Though please be aware that this is work in progress.

Release notes for llvm, clang and lld will be available here:
<http://releases.llvm.org/4.0.0/docs/ReleaseNotes.html>
<http://releases.llvm.org/4.0.0/tools/clang/docs/ReleaseNotes.html>
<http://releases.llvm.org/4.0.0/tools/lld/docs/ReleaseNotes.html>

Thanks to Ed Maste, Jan Beich, Antoine Brodin and Eric Fiselier for
their help.

Relnotes:	yes
Exp-run:	antoine
PR:		215969, 216008

MFC r314708:

For now, revert r287232 from upstream llvm trunk (by Daniil Fukalov):

  [SCEV] limit recursion depth of CompareSCEVComplexity

  Summary:
  CompareSCEVComplexity goes too deep (50+ on a quite a big unrolled
  loop) and runs almost infinite time.

  Added cache of "equal" SCEV pairs to earlier cutoff of further
  estimation. Recursion depth limit was also introduced as a parameter.

  Reviewers: sanjoy

  Subscribers: mzolotukhin, tstellarAMD, llvm-commits

  Differential Revision: https://reviews.llvm.org/D26389

This commit is the cause of excessive compile times on skein_block.c
(and possibly other files) during kernel builds on amd64.

We never saw the problematic behavior described in this upstream commit,
so for now it is better to revert it.  An upstream bug has been filed
here: https://bugs.llvm.org/show_bug.cgi?id=32142

Reported by:	mjg

MFC r314795:

Reapply r287232 from upstream llvm trunk (by Daniil Fukalov):

  [SCEV] limit recursion depth of CompareSCEVComplexity

  Summary:
  CompareSCEVComplexity goes too deep (50+ on a quite a big unrolled
  loop) and runs almost infinite time.

  Added cache of "equal" SCEV pairs to earlier cutoff of further
  estimation. Recursion depth limit was also introduced as a parameter.

  Reviewers: sanjoy

  Subscribers: mzolotukhin, tstellarAMD, llvm-commits

  Differential Revision: https://reviews.llvm.org/D26389

Pull in r296992 from upstream llvm trunk (by Sanjoy Das):

  [SCEV] Decrease the recursion threshold for CompareValueComplexity

  Fixes PR32142.

  r287232 accidentally increased the recursion threshold for
  CompareValueComplexity from 2 to 32.  This change reverses that
  change by introducing a separate flag for CompareValueComplexity's
  threshold.

The latter revision fixes the excessive compile times for skein_block.c.

MFC r314907 | mmel | 2017-03-08 12:40:27 +0100 (Wed, 08 Mar 2017) | 7 lines

Unbreak ARMv6 world.

The new compiler_rt library imported with clang 4.0.0 have several fatal
issues (non-functional __udivsi3 for example) with ARM specific instrict
functions. As temporary workaround, until upstream solve these problems,
disable all thumb[1][2] related feature.

MFC r315016:

Update clang, llvm, lld, lldb, compiler-rt and libc++ to 4.0.0 release.
We were already very close to the last release candidate, so this is a
pretty minor update.

Relnotes:	yes

MFC r316005:

Revert r314907, and pull in r298713 from upstream compiler-rt trunk (by
Weiming Zhao):

  builtins: Select correct code fragments when compiling for Thumb1/Thum2/ARM ISA.

  Summary:
  Value of __ARM_ARCH_ISA_THUMB isn't based on the actual compilation
  mode (-mthumb, -marm), it reflect's capability of given CPU.

  Due to this:
   - use  __tbumb__ and __thumb2__ insteand of __ARM_ARCH_ISA_THUMB
   - use '.thumb' directive consistently  in all affected files
   - decorate all thumb functions using
     DEFINE_COMPILERRT_THUMB_FUNCTION()

  ---------
  Note: This patch doesn't fix broken Thumb1 variant of __udivsi3 !

  Reviewers: weimingz, rengolin, compnerd

  Subscribers: aemerson, dim

  Differential Revision: https://reviews.llvm.org/D30938

Discussed with:	mmel

1 files changed, 1438 insertions, 1744 deletions

diff --git a/contrib/llvm/tools/lldb/source/API/SBValue.cpp b/contrib/llvm/tools/lldb/source/API/SBValue.cpp
index 4fdcb0d..0531a3f 100644
--- a/contrib/llvm/tools/lldb/source/API/SBValue.cpp
+++ b/contrib/llvm/tools/lldb/source/API/SBValue.cpp
@@ -50,1864 +50,1558 @@
 using namespace lldb;
 using namespace lldb_private;
 
-class ValueImpl
-{
+class ValueImpl {
 public:
-    ValueImpl ()
-    {
+  ValueImpl() {}
+
+  ValueImpl(lldb::ValueObjectSP in_valobj_sp,
+            lldb::DynamicValueType use_dynamic, bool use_synthetic,
+            const char *name = NULL)
+      : m_valobj_sp(), m_use_dynamic(use_dynamic),
+        m_use_synthetic(use_synthetic), m_name(name) {
+    if (in_valobj_sp) {
+      if ((m_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable(
+               lldb::eNoDynamicValues, false))) {
+        if (!m_name.IsEmpty())
+          m_valobj_sp->SetName(m_name);
+      }
     }
+  }
 
-    ValueImpl (lldb::ValueObjectSP in_valobj_sp,
-               lldb::DynamicValueType use_dynamic,
-               bool use_synthetic,
-               const char *name = NULL) :
-    m_valobj_sp(),
-    m_use_dynamic(use_dynamic),
-    m_use_synthetic(use_synthetic),
-    m_name (name)
-    {
-        if (in_valobj_sp)
-        {
-            if ( (m_valobj_sp = in_valobj_sp->GetQualifiedRepresentationIfAvailable(lldb::eNoDynamicValues, false)) )
-            {
-                if (!m_name.IsEmpty())
-                    m_valobj_sp->SetName(m_name);
-            }
-        }
-    }
+  ValueImpl(const ValueImpl &rhs)
+      : m_valobj_sp(rhs.m_valobj_sp), m_use_dynamic(rhs.m_use_dynamic),
+        m_use_synthetic(rhs.m_use_synthetic), m_name(rhs.m_name) {}
 
-    ValueImpl (const ValueImpl& rhs) :
-    m_valobj_sp(rhs.m_valobj_sp),
-    m_use_dynamic(rhs.m_use_dynamic),
-    m_use_synthetic(rhs.m_use_synthetic),
-    m_name (rhs.m_name)
-    {
+  ValueImpl &operator=(const ValueImpl &rhs) {
+    if (this != &rhs) {
+      m_valobj_sp = rhs.m_valobj_sp;
+      m_use_dynamic = rhs.m_use_dynamic;
+      m_use_synthetic = rhs.m_use_synthetic;
+      m_name = rhs.m_name;
     }
-
-    ValueImpl &
-    operator = (const ValueImpl &rhs)
-    {
-        if (this != &rhs)
-        {
-            m_valobj_sp = rhs.m_valobj_sp;
-            m_use_dynamic = rhs.m_use_dynamic;
-            m_use_synthetic = rhs.m_use_synthetic;
-            m_name = rhs.m_name;
-        }
-        return *this;
+    return *this;
+  }
+
+  bool IsValid() {
+    if (m_valobj_sp.get() == NULL)
+      return false;
+    else {
+      // FIXME: This check is necessary but not sufficient.  We for sure don't
+      // want to touch SBValues whose owning
+      // targets have gone away.  This check is a little weak in that it
+      // enforces that restriction when you call
+      // IsValid, but since IsValid doesn't lock the target, you have no
+      // guarantee that the SBValue won't go
+      // invalid after you call this...
+      // Also, an SBValue could depend on data from one of the modules in the
+      // target, and those could go away
+      // independently of the target, for instance if a module is unloaded.  But
+      // right now, neither SBValues
+      // nor ValueObjects know which modules they depend on.  So I have no good
+      // way to make that check without
+      // tracking that in all the ValueObject subclasses.
+      TargetSP target_sp = m_valobj_sp->GetTargetSP();
+      if (target_sp && target_sp->IsValid())
+        return true;
+      else
+        return false;
     }
+  }
 
-    bool
-    IsValid ()
-    {
-        if (m_valobj_sp.get() == NULL)
-            return false;
-        else
-        {
-            // FIXME: This check is necessary but not sufficient.  We for sure don't want to touch SBValues whose owning
-            // targets have gone away.  This check is a little weak in that it enforces that restriction when you call
-            // IsValid, but since IsValid doesn't lock the target, you have no guarantee that the SBValue won't go
-            // invalid after you call this...
-            // Also, an SBValue could depend on data from one of the modules in the target, and those could go away
-            // independently of the target, for instance if a module is unloaded.  But right now, neither SBValues
-            // nor ValueObjects know which modules they depend on.  So I have no good way to make that check without
-            // tracking that in all the ValueObject subclasses.
-            TargetSP target_sp = m_valobj_sp->GetTargetSP();
-            if (target_sp && target_sp->IsValid())
-                return true;
-            else
-                return false;
-        }
-    }
+  lldb::ValueObjectSP GetRootSP() { return m_valobj_sp; }
 
-    lldb::ValueObjectSP
-    GetRootSP ()
-    {
-        return m_valobj_sp;
+  lldb::ValueObjectSP GetSP(Process::StopLocker &stop_locker,
+                            std::unique_lock<std::recursive_mutex> &lock,
+                            Error &error) {
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+    if (!m_valobj_sp) {
+      error.SetErrorString("invalid value object");
+      return m_valobj_sp;
     }
 
-    lldb::ValueObjectSP
-    GetSP(Process::StopLocker &stop_locker, std::unique_lock<std::recursive_mutex> &lock, Error &error)
-    {
-        Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-        if (!m_valobj_sp)
-        {
-            error.SetErrorString("invalid value object");
-            return m_valobj_sp;
-        }
-
-        lldb::ValueObjectSP value_sp = m_valobj_sp;
+    lldb::ValueObjectSP value_sp = m_valobj_sp;
 
-        Target *target = value_sp->GetTargetSP().get();
-        if (!target)
-            return ValueObjectSP();
+    Target *target = value_sp->GetTargetSP().get();
+    if (!target)
+      return ValueObjectSP();
 
-        lock = std::unique_lock<std::recursive_mutex>(target->GetAPIMutex());
+    lock = std::unique_lock<std::recursive_mutex>(target->GetAPIMutex());
 
-        ProcessSP process_sp(value_sp->GetProcessSP());
-        if (process_sp && !stop_locker.TryLock (&process_sp->GetRunLock()))
-        {
-            // We don't allow people to play around with ValueObject if the process is running.
-            // If you want to look at values, pause the process, then look.
-            if (log)
-                log->Printf ("SBValue(%p)::GetSP() => error: process is running",
-                             static_cast<void*>(value_sp.get()));
-            error.SetErrorString ("process must be stopped.");
-            return ValueObjectSP();
-        }
+    ProcessSP process_sp(value_sp->GetProcessSP());
+    if (process_sp && !stop_locker.TryLock(&process_sp->GetRunLock())) {
+      // We don't allow people to play around with ValueObject if the process is
+      // running.
+      // If you want to look at values, pause the process, then look.
+      if (log)
+        log->Printf("SBValue(%p)::GetSP() => error: process is running",
+                    static_cast<void *>(value_sp.get()));
+      error.SetErrorString("process must be stopped.");
+      return ValueObjectSP();
+    }
 
-        if (m_use_dynamic != eNoDynamicValues)
-        {
-            ValueObjectSP dynamic_sp = value_sp->GetDynamicValue(m_use_dynamic);
-            if (dynamic_sp)
-                value_sp = dynamic_sp;
-        }
+    if (m_use_dynamic != eNoDynamicValues) {
+      ValueObjectSP dynamic_sp = value_sp->GetDynamicValue(m_use_dynamic);
+      if (dynamic_sp)
+        value_sp = dynamic_sp;
+    }
 
-        if (m_use_synthetic)
-        {
-            ValueObjectSP synthetic_sp = value_sp->GetSyntheticValue(m_use_synthetic);
-            if (synthetic_sp)
-                value_sp = synthetic_sp;
-        }
+    if (m_use_synthetic) {
+      ValueObjectSP synthetic_sp = value_sp->GetSyntheticValue(m_use_synthetic);
+      if (synthetic_sp)
+        value_sp = synthetic_sp;
+    }
 
-        if (!value_sp)
-            error.SetErrorString("invalid value object");
-        if (!m_name.IsEmpty())
-            value_sp->SetName(m_name);
+    if (!value_sp)
+      error.SetErrorString("invalid value object");
+    if (!m_name.IsEmpty())
+      value_sp->SetName(m_name);
 
-        return value_sp;
-    }
+    return value_sp;
+  }
 
-    void
-    SetUseDynamic (lldb::DynamicValueType use_dynamic)
-    {
-        m_use_dynamic = use_dynamic;
-    }
+  void SetUseDynamic(lldb::DynamicValueType use_dynamic) {
+    m_use_dynamic = use_dynamic;
+  }
 
-    void
-    SetUseSynthetic (bool use_synthetic)
-    {
-        m_use_synthetic = use_synthetic;
-    }
+  void SetUseSynthetic(bool use_synthetic) { m_use_synthetic = use_synthetic; }
 
-    lldb::DynamicValueType
-    GetUseDynamic ()
-    {
-        return m_use_dynamic;
-    }
+  lldb::DynamicValueType GetUseDynamic() { return m_use_dynamic; }
 
-    bool
-    GetUseSynthetic ()
-    {
-        return m_use_synthetic;
-    }
+  bool GetUseSynthetic() { return m_use_synthetic; }
 
-    // All the derived values that we would make from the m_valobj_sp will share
-    // the ExecutionContext with m_valobj_sp, so we don't need to do the calculations
-    // in GetSP to return the Target, Process, Thread or Frame.  It is convenient to
-    // provide simple accessors for these, which I do here.
-    TargetSP
-    GetTargetSP ()
-    {
-        if (m_valobj_sp)
-            return m_valobj_sp->GetTargetSP();
-        else
-            return TargetSP();
-    }
+  // All the derived values that we would make from the m_valobj_sp will share
+  // the ExecutionContext with m_valobj_sp, so we don't need to do the
+  // calculations
+  // in GetSP to return the Target, Process, Thread or Frame.  It is convenient
+  // to
+  // provide simple accessors for these, which I do here.
+  TargetSP GetTargetSP() {
+    if (m_valobj_sp)
+      return m_valobj_sp->GetTargetSP();
+    else
+      return TargetSP();
+  }
 
-    ProcessSP
-    GetProcessSP ()
-    {
-        if (m_valobj_sp)
-            return m_valobj_sp->GetProcessSP();
-        else
-            return ProcessSP();
-    }
+  ProcessSP GetProcessSP() {
+    if (m_valobj_sp)
+      return m_valobj_sp->GetProcessSP();
+    else
+      return ProcessSP();
+  }
 
-    ThreadSP
-    GetThreadSP ()
-    {
-        if (m_valobj_sp)
-            return m_valobj_sp->GetThreadSP();
-        else
-            return ThreadSP();
-    }
+  ThreadSP GetThreadSP() {
+    if (m_valobj_sp)
+      return m_valobj_sp->GetThreadSP();
+    else
+      return ThreadSP();
+  }
 
-    StackFrameSP
-    GetFrameSP ()
-    {
-        if (m_valobj_sp)
-            return m_valobj_sp->GetFrameSP();
-        else
-            return StackFrameSP();
-    }
+  StackFrameSP GetFrameSP() {
+    if (m_valobj_sp)
+      return m_valobj_sp->GetFrameSP();
+    else
+      return StackFrameSP();
+  }
 
 private:
-    lldb::ValueObjectSP m_valobj_sp;
-    lldb::DynamicValueType m_use_dynamic;
-    bool m_use_synthetic;
-    ConstString m_name;
+  lldb::ValueObjectSP m_valobj_sp;
+  lldb::DynamicValueType m_use_dynamic;
+  bool m_use_synthetic;
+  ConstString m_name;
 };
 
-class ValueLocker
-{
+class ValueLocker {
 public:
-    ValueLocker ()
-    {
-    }
+  ValueLocker() {}
 
-    ValueObjectSP
-    GetLockedSP(ValueImpl &in_value)
-    {
-        return in_value.GetSP(m_stop_locker, m_lock, m_lock_error);
-    }
+  ValueObjectSP GetLockedSP(ValueImpl &in_value) {
+    return in_value.GetSP(m_stop_locker, m_lock, m_lock_error);
+  }
+
+  Error &GetError() { return m_lock_error; }
 
-    Error &
-    GetError()
-    {
-        return m_lock_error;
-    }
-    
 private:
-    Process::StopLocker m_stop_locker;
-    std::unique_lock<std::recursive_mutex> m_lock;
-    Error m_lock_error;
+  Process::StopLocker m_stop_locker;
+  std::unique_lock<std::recursive_mutex> m_lock;
+  Error m_lock_error;
 };
 
-SBValue::SBValue () :
-m_opaque_sp ()
-{
-}
+SBValue::SBValue() : m_opaque_sp() {}
 
-SBValue::SBValue (const lldb::ValueObjectSP &value_sp)
-{
-    SetSP(value_sp);
-}
+SBValue::SBValue(const lldb::ValueObjectSP &value_sp) { SetSP(value_sp); }
+
+SBValue::SBValue(const SBValue &rhs) { SetSP(rhs.m_opaque_sp); }
 
-SBValue::SBValue(const SBValue &rhs)
-{
+SBValue &SBValue::operator=(const SBValue &rhs) {
+  if (this != &rhs) {
     SetSP(rhs.m_opaque_sp);
+  }
+  return *this;
 }
 
-SBValue &
-SBValue::operator = (const SBValue &rhs)
-{
-    if (this != &rhs)
-    {
-        SetSP(rhs.m_opaque_sp);
-    }
-    return *this;
-}
+SBValue::~SBValue() {}
 
-SBValue::~SBValue()
-{
+bool SBValue::IsValid() {
+  // If this function ever changes to anything that does more than just
+  // check if the opaque shared pointer is non NULL, then we need to update
+  // all "if (m_opaque_sp)" code in this file.
+  return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid() &&
+         m_opaque_sp->GetRootSP().get() != NULL;
 }
 
-bool
-SBValue::IsValid ()
-{
-    // If this function ever changes to anything that does more than just
-    // check if the opaque shared pointer is non NULL, then we need to update
-    // all "if (m_opaque_sp)" code in this file.
-    return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid() && m_opaque_sp->GetRootSP().get() != NULL;
-}
+void SBValue::Clear() { m_opaque_sp.reset(); }
 
-void
-SBValue::Clear()
-{
-    m_opaque_sp.reset();
-}
+SBError SBValue::GetError() {
+  SBError sb_error;
 
-SBError
-SBValue::GetError()
-{
-    SBError sb_error;
-    
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        sb_error.SetError(value_sp->GetError());
-    else
-        sb_error.SetErrorStringWithFormat ("error: %s", locker.GetError().AsCString());
-    
-    return sb_error;
-}
-
-user_id_t
-SBValue::GetID()
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        return value_sp->GetID();
-    return LLDB_INVALID_UID;
-}
-
-const char *
-SBValue::GetName()
-{
-    const char *name = NULL;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        name = value_sp->GetName().GetCString();
-
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-    {
-        if (name)
-            log->Printf ("SBValue(%p)::GetName () => \"%s\"",
-                         static_cast<void*>(value_sp.get()), name);
-        else
-            log->Printf ("SBValue(%p)::GetName () => NULL",
-                         static_cast<void*>(value_sp.get()));
-    }
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    sb_error.SetError(value_sp->GetError());
+  else
+    sb_error.SetErrorStringWithFormat("error: %s",
+                                      locker.GetError().AsCString());
 
-    return name;
+  return sb_error;
 }
 
-const char *
-SBValue::GetTypeName ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    const char *name = NULL;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        name = value_sp->GetQualifiedTypeName().GetCString();
-    }
-
-    if (log)
-    {
-        if (name)
-            log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"",
-                         static_cast<void*>(value_sp.get()), name);
-        else
-            log->Printf ("SBValue(%p)::GetTypeName () => NULL",
-                         static_cast<void*>(value_sp.get()));
-    }
-
-    return name;
-}
-
-const char *
-SBValue::GetDisplayTypeName ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    const char *name = NULL;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        name = value_sp->GetDisplayTypeName().GetCString();
-    }
-    
-    if (log)
-    {
-        if (name)
-            log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"",
-                         static_cast<void*>(value_sp.get()), name);
-        else
-            log->Printf ("SBValue(%p)::GetTypeName () => NULL",
-                         static_cast<void*>(value_sp.get()));
-    }
-    
-    return name;
+user_id_t SBValue::GetID() {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    return value_sp->GetID();
+  return LLDB_INVALID_UID;
 }
 
-size_t
-SBValue::GetByteSize ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    size_t result = 0;
-
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        result = value_sp->GetByteSize();
-    }
+const char *SBValue::GetName() {
+  const char *name = NULL;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    name = value_sp->GetName().GetCString();
 
-    if (log)
-        log->Printf ("SBValue(%p)::GetByteSize () => %" PRIu64,
-                     static_cast<void*>(value_sp.get()),
-                     static_cast<uint64_t>(result));
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log) {
+    if (name)
+      log->Printf("SBValue(%p)::GetName () => \"%s\"",
+                  static_cast<void *>(value_sp.get()), name);
+    else
+      log->Printf("SBValue(%p)::GetName () => NULL",
+                  static_cast<void *>(value_sp.get()));
+  }
+
+  return name;
+}
+
+const char *SBValue::GetTypeName() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  const char *name = NULL;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    name = value_sp->GetQualifiedTypeName().GetCString();
+  }
+
+  if (log) {
+    if (name)
+      log->Printf("SBValue(%p)::GetTypeName () => \"%s\"",
+                  static_cast<void *>(value_sp.get()), name);
+    else
+      log->Printf("SBValue(%p)::GetTypeName () => NULL",
+                  static_cast<void *>(value_sp.get()));
+  }
+
+  return name;
+}
+
+const char *SBValue::GetDisplayTypeName() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  const char *name = NULL;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    name = value_sp->GetDisplayTypeName().GetCString();
+  }
+
+  if (log) {
+    if (name)
+      log->Printf("SBValue(%p)::GetTypeName () => \"%s\"",
+                  static_cast<void *>(value_sp.get()), name);
+    else
+      log->Printf("SBValue(%p)::GetTypeName () => NULL",
+                  static_cast<void *>(value_sp.get()));
+  }
 
-    return result;
+  return name;
 }
 
-bool
-SBValue::IsInScope ()
-{
-    bool result = false;
+size_t SBValue::GetByteSize() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  size_t result = 0;
 
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        result = value_sp->IsInScope ();
-    }
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    result = value_sp->GetByteSize();
+  }
 
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf ("SBValue(%p)::IsInScope () => %i",
-                     static_cast<void*>(value_sp.get()), result);
+  if (log)
+    log->Printf("SBValue(%p)::GetByteSize () => %" PRIu64,
+                static_cast<void *>(value_sp.get()),
+                static_cast<uint64_t>(result));
 
-    return result;
+  return result;
 }
 
-const char *
-SBValue::GetValue ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+bool SBValue::IsInScope() {
+  bool result = false;
 
-    const char *cstr = NULL;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        cstr = value_sp->GetValueAsCString ();
-    }
-    if (log)
-    {
-        if (cstr)
-            log->Printf ("SBValue(%p)::GetValue() => \"%s\"",
-                         static_cast<void*>(value_sp.get()), cstr);
-        else
-            log->Printf ("SBValue(%p)::GetValue() => NULL",
-                         static_cast<void*>(value_sp.get()));
-    }
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    result = value_sp->IsInScope();
+  }
+
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBValue(%p)::IsInScope () => %i",
+                static_cast<void *>(value_sp.get()), result);
 
-    return cstr;
+  return result;
 }
 
-ValueType
-SBValue::GetValueType ()
-{
-    ValueType result = eValueTypeInvalid;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        result = value_sp->GetValueType();
+const char *SBValue::GetValue() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-    {
-        switch (result)
-        {
-            case eValueTypeInvalid:
-                log->Printf ("SBValue(%p)::GetValueType () => eValueTypeInvalid",
-                             static_cast<void*>(value_sp.get()));
-                break;
-            case eValueTypeVariableGlobal:
-                log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal",
-                             static_cast<void*>(value_sp.get()));
-                break;
-            case eValueTypeVariableStatic:
-                log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableStatic",
-                             static_cast<void*>(value_sp.get()));
-                break;
-            case eValueTypeVariableArgument:
-                log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableArgument",
-                             static_cast<void*>(value_sp.get()));
-                break;
-            case eValueTypeVariableLocal:
-                log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableLocal",
-                             static_cast<void*>(value_sp.get()));
-                break;
-            case eValueTypeRegister:
-                log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegister",
-                             static_cast<void*>(value_sp.get()));
-                break;
-            case eValueTypeRegisterSet:
-                log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegisterSet",
-                             static_cast<void*>(value_sp.get()));
-                break;
-            case eValueTypeConstResult:
-                log->Printf ("SBValue(%p)::GetValueType () => eValueTypeConstResult",
-                             static_cast<void*>(value_sp.get()));
-                break;
-            case eValueTypeVariableThreadLocal:
-                log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableThreadLocal",
-                            static_cast<void *>(value_sp.get()));
-                break;
-        }
-    }
-    return result;
-}
-
-const char *
-SBValue::GetObjectDescription ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    const char *cstr = NULL;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        cstr = value_sp->GetObjectDescription ();
-    }
-    if (log)
-    {
-        if (cstr)
-            log->Printf ("SBValue(%p)::GetObjectDescription() => \"%s\"",
-                         static_cast<void*>(value_sp.get()), cstr);
-        else
-            log->Printf ("SBValue(%p)::GetObjectDescription() => NULL",
-                         static_cast<void*>(value_sp.get()));
-    }
-    return cstr;
-}
-
-const char *
-SBValue::GetTypeValidatorResult ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    const char *cstr = NULL;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        const auto& validation(value_sp->GetValidationStatus());
-        if (TypeValidatorResult::Failure == validation.first)
-        {
-            if (validation.second.empty())
-                cstr = "unknown error";
-            else
-                cstr = validation.second.c_str();
-        }
-    }
-    if (log)
-    {
-        if (cstr)
-            log->Printf ("SBValue(%p)::GetTypeValidatorResult() => \"%s\"",
-                         static_cast<void*>(value_sp.get()), cstr);
-        else
-            log->Printf ("SBValue(%p)::GetTypeValidatorResult() => NULL",
-                         static_cast<void*>(value_sp.get()));
-    }
-    return cstr;
-}
-
-SBType
-SBValue::GetType()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    SBType sb_type;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    TypeImplSP type_sp;
-    if (value_sp)
-    {
-        type_sp.reset (new TypeImpl(value_sp->GetTypeImpl()));
-        sb_type.SetSP(type_sp);
-    }
-    if (log)
-    {
-        if (type_sp)
-            log->Printf ("SBValue(%p)::GetType => SBType(%p)",
-                         static_cast<void*>(value_sp.get()),
-                         static_cast<void*>(type_sp.get()));
-        else
-            log->Printf ("SBValue(%p)::GetType => NULL",
-                         static_cast<void*>(value_sp.get()));
-    }
-    return sb_type;
-}
-
-bool
-SBValue::GetValueDidChange ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    bool result = false;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        if (value_sp->UpdateValueIfNeeded(false))
-            result = value_sp->GetValueDidChange ();
-    }
-    if (log)
-        log->Printf ("SBValue(%p)::GetValueDidChange() => %i",
-                     static_cast<void*>(value_sp.get()), result);
-
-    return result;
-}
-
-const char *
-SBValue::GetSummary ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    const char *cstr = NULL;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        cstr = value_sp->GetSummaryAsCString();
-    }
-    if (log)
-    {
-        if (cstr)
-            log->Printf ("SBValue(%p)::GetSummary() => \"%s\"",
-                         static_cast<void*>(value_sp.get()), cstr);
-        else
-            log->Printf ("SBValue(%p)::GetSummary() => NULL",
-                         static_cast<void*>(value_sp.get()));
-    }
-    return cstr;
-}
-
-const char *
-SBValue::GetSummary (lldb::SBStream& stream,
-                     lldb::SBTypeSummaryOptions& options)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        std::string buffer;
-        if (value_sp->GetSummaryAsCString(buffer,options.ref()) && !buffer.empty())
-            stream.Printf("%s",buffer.c_str());
-    }
-    const char* cstr = stream.GetData();
-    if (log)
-    {
-        if (cstr)
-            log->Printf ("SBValue(%p)::GetSummary() => \"%s\"",
-                         static_cast<void*>(value_sp.get()), cstr);
-        else
-            log->Printf ("SBValue(%p)::GetSummary() => NULL",
-                         static_cast<void*>(value_sp.get()));
-    }
-    return cstr;
-}
-
-const char *
-SBValue::GetLocation ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    const char *cstr = NULL;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        cstr = value_sp->GetLocationAsCString();
-    }
-    if (log)
-    {
-        if (cstr)
-            log->Printf ("SBValue(%p)::GetLocation() => \"%s\"",
-                         static_cast<void*>(value_sp.get()), cstr);
-        else
-            log->Printf ("SBValue(%p)::GetLocation() => NULL",
-                         static_cast<void*>(value_sp.get()));
-    }
-    return cstr;
+  const char *cstr = NULL;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    cstr = value_sp->GetValueAsCString();
+  }
+  if (log) {
+    if (cstr)
+      log->Printf("SBValue(%p)::GetValue() => \"%s\"",
+                  static_cast<void *>(value_sp.get()), cstr);
+    else
+      log->Printf("SBValue(%p)::GetValue() => NULL",
+                  static_cast<void *>(value_sp.get()));
+  }
+
+  return cstr;
+}
+
+ValueType SBValue::GetValueType() {
+  ValueType result = eValueTypeInvalid;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    result = value_sp->GetValueType();
+
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log) {
+    switch (result) {
+    case eValueTypeInvalid:
+      log->Printf("SBValue(%p)::GetValueType () => eValueTypeInvalid",
+                  static_cast<void *>(value_sp.get()));
+      break;
+    case eValueTypeVariableGlobal:
+      log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal",
+                  static_cast<void *>(value_sp.get()));
+      break;
+    case eValueTypeVariableStatic:
+      log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableStatic",
+                  static_cast<void *>(value_sp.get()));
+      break;
+    case eValueTypeVariableArgument:
+      log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableArgument",
+                  static_cast<void *>(value_sp.get()));
+      break;
+    case eValueTypeVariableLocal:
+      log->Printf("SBValue(%p)::GetValueType () => eValueTypeVariableLocal",
+                  static_cast<void *>(value_sp.get()));
+      break;
+    case eValueTypeRegister:
+      log->Printf("SBValue(%p)::GetValueType () => eValueTypeRegister",
+                  static_cast<void *>(value_sp.get()));
+      break;
+    case eValueTypeRegisterSet:
+      log->Printf("SBValue(%p)::GetValueType () => eValueTypeRegisterSet",
+                  static_cast<void *>(value_sp.get()));
+      break;
+    case eValueTypeConstResult:
+      log->Printf("SBValue(%p)::GetValueType () => eValueTypeConstResult",
+                  static_cast<void *>(value_sp.get()));
+      break;
+    case eValueTypeVariableThreadLocal:
+      log->Printf(
+          "SBValue(%p)::GetValueType () => eValueTypeVariableThreadLocal",
+          static_cast<void *>(value_sp.get()));
+      break;
+    }
+  }
+  return result;
+}
+
+const char *SBValue::GetObjectDescription() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  const char *cstr = NULL;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    cstr = value_sp->GetObjectDescription();
+  }
+  if (log) {
+    if (cstr)
+      log->Printf("SBValue(%p)::GetObjectDescription() => \"%s\"",
+                  static_cast<void *>(value_sp.get()), cstr);
+    else
+      log->Printf("SBValue(%p)::GetObjectDescription() => NULL",
+                  static_cast<void *>(value_sp.get()));
+  }
+  return cstr;
+}
+
+const char *SBValue::GetTypeValidatorResult() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  const char *cstr = NULL;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    const auto &validation(value_sp->GetValidationStatus());
+    if (TypeValidatorResult::Failure == validation.first) {
+      if (validation.second.empty())
+        cstr = "unknown error";
+      else
+        cstr = validation.second.c_str();
+    }
+  }
+  if (log) {
+    if (cstr)
+      log->Printf("SBValue(%p)::GetTypeValidatorResult() => \"%s\"",
+                  static_cast<void *>(value_sp.get()), cstr);
+    else
+      log->Printf("SBValue(%p)::GetTypeValidatorResult() => NULL",
+                  static_cast<void *>(value_sp.get()));
+  }
+  return cstr;
+}
+
+SBType SBValue::GetType() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  SBType sb_type;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  TypeImplSP type_sp;
+  if (value_sp) {
+    type_sp.reset(new TypeImpl(value_sp->GetTypeImpl()));
+    sb_type.SetSP(type_sp);
+  }
+  if (log) {
+    if (type_sp)
+      log->Printf("SBValue(%p)::GetType => SBType(%p)",
+                  static_cast<void *>(value_sp.get()),
+                  static_cast<void *>(type_sp.get()));
+    else
+      log->Printf("SBValue(%p)::GetType => NULL",
+                  static_cast<void *>(value_sp.get()));
+  }
+  return sb_type;
+}
+
+bool SBValue::GetValueDidChange() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  bool result = false;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    if (value_sp->UpdateValueIfNeeded(false))
+      result = value_sp->GetValueDidChange();
+  }
+  if (log)
+    log->Printf("SBValue(%p)::GetValueDidChange() => %i",
+                static_cast<void *>(value_sp.get()), result);
+
+  return result;
+}
+
+const char *SBValue::GetSummary() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  const char *cstr = NULL;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    cstr = value_sp->GetSummaryAsCString();
+  }
+  if (log) {
+    if (cstr)
+      log->Printf("SBValue(%p)::GetSummary() => \"%s\"",
+                  static_cast<void *>(value_sp.get()), cstr);
+    else
+      log->Printf("SBValue(%p)::GetSummary() => NULL",
+                  static_cast<void *>(value_sp.get()));
+  }
+  return cstr;
+}
+
+const char *SBValue::GetSummary(lldb::SBStream &stream,
+                                lldb::SBTypeSummaryOptions &options) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    std::string buffer;
+    if (value_sp->GetSummaryAsCString(buffer, options.ref()) && !buffer.empty())
+      stream.Printf("%s", buffer.c_str());
+  }
+  const char *cstr = stream.GetData();
+  if (log) {
+    if (cstr)
+      log->Printf("SBValue(%p)::GetSummary() => \"%s\"",
+                  static_cast<void *>(value_sp.get()), cstr);
+    else
+      log->Printf("SBValue(%p)::GetSummary() => NULL",
+                  static_cast<void *>(value_sp.get()));
+  }
+  return cstr;
+}
+
+const char *SBValue::GetLocation() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  const char *cstr = NULL;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    cstr = value_sp->GetLocationAsCString();
+  }
+  if (log) {
+    if (cstr)
+      log->Printf("SBValue(%p)::GetLocation() => \"%s\"",
+                  static_cast<void *>(value_sp.get()), cstr);
+    else
+      log->Printf("SBValue(%p)::GetLocation() => NULL",
+                  static_cast<void *>(value_sp.get()));
+  }
+  return cstr;
 }
 
 // Deprecated - use the one that takes an lldb::SBError
-bool
-SBValue::SetValueFromCString (const char *value_str)
-{
-    lldb::SBError dummy;
-    return SetValueFromCString(value_str,dummy);
-}
-
-bool
-SBValue::SetValueFromCString (const char *value_str, lldb::SBError& error)
-{
-    bool success = false;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (value_sp)
-    {
-        success = value_sp->SetValueFromCString (value_str,error.ref());
-    }
-    else
-        error.SetErrorStringWithFormat ("Could not get value: %s", locker.GetError().AsCString());
-
-    if (log)
-        log->Printf ("SBValue(%p)::SetValueFromCString(\"%s\") => %i",
-                     static_cast<void*>(value_sp.get()), value_str, success);
-
-    return success;
-}
-
-lldb::SBTypeFormat
-SBValue::GetTypeFormat ()
-{
-    lldb::SBTypeFormat format;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        if (value_sp->UpdateValueIfNeeded(true))
-        {
-            lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat();
-            if (format_sp)
-                format.SetSP(format_sp);
-        }
-    }
-    return format;
-}
-
-lldb::SBTypeSummary
-SBValue::GetTypeSummary ()
-{
-    lldb::SBTypeSummary summary;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        if (value_sp->UpdateValueIfNeeded(true))
-        {
-            lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat();
-            if (summary_sp)
-                summary.SetSP(summary_sp);
-        }
-    }
-    return summary;
-}
-
-lldb::SBTypeFilter
-SBValue::GetTypeFilter ()
-{
-    lldb::SBTypeFilter filter;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        if (value_sp->UpdateValueIfNeeded(true))
-        {
-            lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren();
-            
-            if (synthetic_sp && !synthetic_sp->IsScripted())
-            {
-                TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(synthetic_sp);
-                filter.SetSP(filter_sp);
-            }
-        }
-    }
-    return filter;
+bool SBValue::SetValueFromCString(const char *value_str) {
+  lldb::SBError dummy;
+  return SetValueFromCString(value_str, dummy);
+}
+
+bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
+  bool success = false;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (value_sp) {
+    success = value_sp->SetValueFromCString(value_str, error.ref());
+  } else
+    error.SetErrorStringWithFormat("Could not get value: %s",
+                                   locker.GetError().AsCString());
+
+  if (log)
+    log->Printf("SBValue(%p)::SetValueFromCString(\"%s\") => %i",
+                static_cast<void *>(value_sp.get()), value_str, success);
+
+  return success;
+}
+
+lldb::SBTypeFormat SBValue::GetTypeFormat() {
+  lldb::SBTypeFormat format;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    if (value_sp->UpdateValueIfNeeded(true)) {
+      lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat();
+      if (format_sp)
+        format.SetSP(format_sp);
+    }
+  }
+  return format;
+}
+
+lldb::SBTypeSummary SBValue::GetTypeSummary() {
+  lldb::SBTypeSummary summary;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    if (value_sp->UpdateValueIfNeeded(true)) {
+      lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat();
+      if (summary_sp)
+        summary.SetSP(summary_sp);
+    }
+  }
+  return summary;
+}
+
+lldb::SBTypeFilter SBValue::GetTypeFilter() {
+  lldb::SBTypeFilter filter;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    if (value_sp->UpdateValueIfNeeded(true)) {
+      lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren();
+
+      if (synthetic_sp && !synthetic_sp->IsScripted()) {
+        TypeFilterImplSP filter_sp =
+            std::static_pointer_cast<TypeFilterImpl>(synthetic_sp);
+        filter.SetSP(filter_sp);
+      }
+    }
+  }
+  return filter;
 }
 
 #ifndef LLDB_DISABLE_PYTHON
-lldb::SBTypeSynthetic
-SBValue::GetTypeSynthetic ()
-{
-    lldb::SBTypeSynthetic synthetic;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        if (value_sp->UpdateValueIfNeeded(true))
-        {
-            lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren();
-            
-            if (children_sp && children_sp->IsScripted())
-            {
-                ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
-                synthetic.SetSP(synth_sp);
-            }
-        }
-    }
-    return synthetic;
+lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
+  lldb::SBTypeSynthetic synthetic;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    if (value_sp->UpdateValueIfNeeded(true)) {
+      lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren();
+
+      if (children_sp && children_sp->IsScripted()) {
+        ScriptedSyntheticChildrenSP synth_sp =
+            std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp);
+        synthetic.SetSP(synth_sp);
+      }
+    }
+  }
+  return synthetic;
 }
 #endif
 
-lldb::SBValue
-SBValue::CreateChildAtOffset (const char *name, uint32_t offset, SBType type)
-{
-    lldb::SBValue sb_value;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    lldb::ValueObjectSP new_value_sp;
-    if (value_sp)
-    {
-        TypeImplSP type_sp (type.GetSP());
-        if (type.IsValid())
-        {
-            sb_value.SetSP(value_sp->GetSyntheticChildAtOffset(offset, type_sp->GetCompilerType(false), true),GetPreferDynamicValue(),GetPreferSyntheticValue(), name);
-        }
-    }
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-    {
-        if (new_value_sp)
-            log->Printf ("SBValue(%p)::CreateChildAtOffset => \"%s\"",
-                         static_cast<void*>(value_sp.get()),
-                         new_value_sp->GetName().AsCString());
-        else
-            log->Printf ("SBValue(%p)::CreateChildAtOffset => NULL",
-                         static_cast<void*>(value_sp.get()));
-    }
-    return sb_value;
-}
-
-lldb::SBValue
-SBValue::Cast (SBType type)
-{
-    lldb::SBValue sb_value;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    TypeImplSP type_sp (type.GetSP());
-    if (value_sp && type_sp)
-        sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)),GetPreferDynamicValue(),GetPreferSyntheticValue());
-    return sb_value;
-}
-
-lldb::SBValue
-SBValue::CreateValueFromExpression (const char *name, const char* expression)
-{
-    SBExpressionOptions options;
-    options.ref().SetKeepInMemory(true);
-    return CreateValueFromExpression (name, expression, options);
-}
-
-lldb::SBValue
-SBValue::CreateValueFromExpression (const char *name, const char *expression, SBExpressionOptions &options)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    lldb::SBValue sb_value;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    lldb::ValueObjectSP new_value_sp;
-    if (value_sp)
-    {
-        ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
-        new_value_sp = ValueObject::CreateValueObjectFromExpression(name, expression, exe_ctx, options.ref());
-        if (new_value_sp)
-            new_value_sp->SetName(ConstString(name));
-    }
-    sb_value.SetSP(new_value_sp);
-    if (log)
-    {
-        if (new_value_sp)
-            log->Printf ("SBValue(%p)::CreateValueFromExpression(name=\"%s\", expression=\"%s\") => SBValue (%p)",
-                         static_cast<void*>(value_sp.get()), name, expression,
-                         static_cast<void*>(new_value_sp.get()));
-        else
-            log->Printf ("SBValue(%p)::CreateValueFromExpression(name=\"%s\", expression=\"%s\") => NULL",
-                         static_cast<void*>(value_sp.get()), name, expression);
-    }
-    return sb_value;
-}
-
-lldb::SBValue
-SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, SBType sb_type)
-{
-    lldb::SBValue sb_value;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    lldb::ValueObjectSP new_value_sp;
-    lldb::TypeImplSP type_impl_sp (sb_type.GetSP());
-    if (value_sp && type_impl_sp)
-    {
-        CompilerType ast_type(type_impl_sp->GetCompilerType(true));
-        ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
-        new_value_sp = ValueObject::CreateValueObjectFromAddress(name, address, exe_ctx, ast_type);
-    }
-    sb_value.SetSP(new_value_sp);
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-    {
-        if (new_value_sp)
-            log->Printf ("SBValue(%p)::CreateValueFromAddress => \"%s\"",
-                         static_cast<void*>(value_sp.get()),
-                         new_value_sp->GetName().AsCString());
-        else
-            log->Printf ("SBValue(%p)::CreateValueFromAddress => NULL",
-                         static_cast<void*>(value_sp.get()));
-    }
-    return sb_value;
-}
-
-lldb::SBValue
-SBValue::CreateValueFromData (const char* name, SBData data, SBType sb_type)
-{
-    lldb::SBValue sb_value;
-    lldb::ValueObjectSP new_value_sp;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    lldb::TypeImplSP type_impl_sp (sb_type.GetSP());
-    if (value_sp && type_impl_sp)
-    {
-        ExecutionContext exe_ctx (value_sp->GetExecutionContextRef());
-        new_value_sp = ValueObject::CreateValueObjectFromData(name, **data, exe_ctx, type_impl_sp->GetCompilerType(true));
-        new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad);
-    }
-    sb_value.SetSP(new_value_sp);
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-    {
-        if (new_value_sp)
-            log->Printf ("SBValue(%p)::CreateValueFromData => \"%s\"",
-                         static_cast<void*>(value_sp.get()),
-                         new_value_sp->GetName().AsCString());
-        else
-            log->Printf ("SBValue(%p)::CreateValueFromData => NULL",
-                         static_cast<void*>(value_sp.get()));
-    }
-    return sb_value;
-}
-
-SBValue
-SBValue::GetChildAtIndex (uint32_t idx)
-{
-    const bool can_create_synthetic = false;
-    lldb::DynamicValueType use_dynamic = eNoDynamicValues;
-    TargetSP target_sp;
-    if (m_opaque_sp)
-        target_sp = m_opaque_sp->GetTargetSP();
-    
-    if (target_sp)
-        use_dynamic = target_sp->GetPreferDynamicValue();
-    
-    return GetChildAtIndex (idx, use_dynamic, can_create_synthetic);
-}
-
-SBValue
-SBValue::GetChildAtIndex (uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic)
-{
-    lldb::ValueObjectSP child_sp;
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        const bool can_create = true;
-        child_sp = value_sp->GetChildAtIndex (idx, can_create);
-        if (can_create_synthetic && !child_sp)
-        {
-            child_sp = value_sp->GetSyntheticArrayMember(idx, can_create);
-        }
-    }
-
-    SBValue sb_value;
-    sb_value.SetSP (child_sp, use_dynamic, GetPreferSyntheticValue());
-    if (log)
-        log->Printf ("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)",
-                     static_cast<void*>(value_sp.get()), idx,
-                     static_cast<void*>(value_sp.get()));
-
-    return sb_value;
-}
-
-uint32_t
-SBValue::GetIndexOfChildWithName (const char *name)
-{
-    uint32_t idx = UINT32_MAX;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        idx = value_sp->GetIndexOfChildWithName (ConstString(name));
-    }
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-    {
-        if (idx == UINT32_MAX)
-            log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND",
-                         static_cast<void*>(value_sp.get()), name);
-        else
-            log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u",
-                         static_cast<void*>(value_sp.get()), name, idx);
-    }
-    return idx;
+lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
+                                           SBType type) {
+  lldb::SBValue sb_value;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  lldb::ValueObjectSP new_value_sp;
+  if (value_sp) {
+    TypeImplSP type_sp(type.GetSP());
+    if (type.IsValid()) {
+      sb_value.SetSP(value_sp->GetSyntheticChildAtOffset(
+                         offset, type_sp->GetCompilerType(false), true),
+                     GetPreferDynamicValue(), GetPreferSyntheticValue(), name);
+    }
+  }
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log) {
+    if (new_value_sp)
+      log->Printf("SBValue(%p)::CreateChildAtOffset => \"%s\"",
+                  static_cast<void *>(value_sp.get()),
+                  new_value_sp->GetName().AsCString());
+    else
+      log->Printf("SBValue(%p)::CreateChildAtOffset => NULL",
+                  static_cast<void *>(value_sp.get()));
+  }
+  return sb_value;
+}
+
+lldb::SBValue SBValue::Cast(SBType type) {
+  lldb::SBValue sb_value;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  TypeImplSP type_sp(type.GetSP());
+  if (value_sp && type_sp)
+    sb_value.SetSP(value_sp->Cast(type_sp->GetCompilerType(false)),
+                   GetPreferDynamicValue(), GetPreferSyntheticValue());
+  return sb_value;
+}
+
+lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
+                                                 const char *expression) {
+  SBExpressionOptions options;
+  options.ref().SetKeepInMemory(true);
+  return CreateValueFromExpression(name, expression, options);
+}
+
+lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
+                                                 const char *expression,
+                                                 SBExpressionOptions &options) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  lldb::SBValue sb_value;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  lldb::ValueObjectSP new_value_sp;
+  if (value_sp) {
+    ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
+    new_value_sp = ValueObject::CreateValueObjectFromExpression(
+        name, expression, exe_ctx, options.ref());
+    if (new_value_sp)
+      new_value_sp->SetName(ConstString(name));
+  }
+  sb_value.SetSP(new_value_sp);
+  if (log) {
+    if (new_value_sp)
+      log->Printf("SBValue(%p)::CreateValueFromExpression(name=\"%s\", "
+                  "expression=\"%s\") => SBValue (%p)",
+                  static_cast<void *>(value_sp.get()), name, expression,
+                  static_cast<void *>(new_value_sp.get()));
+    else
+      log->Printf("SBValue(%p)::CreateValueFromExpression(name=\"%s\", "
+                  "expression=\"%s\") => NULL",
+                  static_cast<void *>(value_sp.get()), name, expression);
+  }
+  return sb_value;
+}
+
+lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
+                                              lldb::addr_t address,
+                                              SBType sb_type) {
+  lldb::SBValue sb_value;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  lldb::ValueObjectSP new_value_sp;
+  lldb::TypeImplSP type_impl_sp(sb_type.GetSP());
+  if (value_sp && type_impl_sp) {
+    CompilerType ast_type(type_impl_sp->GetCompilerType(true));
+    ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
+    new_value_sp = ValueObject::CreateValueObjectFromAddress(name, address,
+                                                             exe_ctx, ast_type);
+  }
+  sb_value.SetSP(new_value_sp);
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log) {
+    if (new_value_sp)
+      log->Printf("SBValue(%p)::CreateValueFromAddress => \"%s\"",
+                  static_cast<void *>(value_sp.get()),
+                  new_value_sp->GetName().AsCString());
+    else
+      log->Printf("SBValue(%p)::CreateValueFromAddress => NULL",
+                  static_cast<void *>(value_sp.get()));
+  }
+  return sb_value;
+}
+
+lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
+                                           SBType sb_type) {
+  lldb::SBValue sb_value;
+  lldb::ValueObjectSP new_value_sp;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  lldb::TypeImplSP type_impl_sp(sb_type.GetSP());
+  if (value_sp && type_impl_sp) {
+    ExecutionContext exe_ctx(value_sp->GetExecutionContextRef());
+    new_value_sp = ValueObject::CreateValueObjectFromData(
+        name, **data, exe_ctx, type_impl_sp->GetCompilerType(true));
+    new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad);
+  }
+  sb_value.SetSP(new_value_sp);
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log) {
+    if (new_value_sp)
+      log->Printf("SBValue(%p)::CreateValueFromData => \"%s\"",
+                  static_cast<void *>(value_sp.get()),
+                  new_value_sp->GetName().AsCString());
+    else
+      log->Printf("SBValue(%p)::CreateValueFromData => NULL",
+                  static_cast<void *>(value_sp.get()));
+  }
+  return sb_value;
+}
+
+SBValue SBValue::GetChildAtIndex(uint32_t idx) {
+  const bool can_create_synthetic = false;
+  lldb::DynamicValueType use_dynamic = eNoDynamicValues;
+  TargetSP target_sp;
+  if (m_opaque_sp)
+    target_sp = m_opaque_sp->GetTargetSP();
+
+  if (target_sp)
+    use_dynamic = target_sp->GetPreferDynamicValue();
+
+  return GetChildAtIndex(idx, use_dynamic, can_create_synthetic);
+}
+
+SBValue SBValue::GetChildAtIndex(uint32_t idx,
+                                 lldb::DynamicValueType use_dynamic,
+                                 bool can_create_synthetic) {
+  lldb::ValueObjectSP child_sp;
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    const bool can_create = true;
+    child_sp = value_sp->GetChildAtIndex(idx, can_create);
+    if (can_create_synthetic && !child_sp) {
+      child_sp = value_sp->GetSyntheticArrayMember(idx, can_create);
+    }
+  }
+
+  SBValue sb_value;
+  sb_value.SetSP(child_sp, use_dynamic, GetPreferSyntheticValue());
+  if (log)
+    log->Printf("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)",
+                static_cast<void *>(value_sp.get()), idx,
+                static_cast<void *>(value_sp.get()));
+
+  return sb_value;
+}
+
+uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
+  uint32_t idx = UINT32_MAX;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    idx = value_sp->GetIndexOfChildWithName(ConstString(name));
+  }
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log) {
+    if (idx == UINT32_MAX)
+      log->Printf(
+          "SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND",
+          static_cast<void *>(value_sp.get()), name);
+    else
+      log->Printf("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u",
+                  static_cast<void *>(value_sp.get()), name, idx);
+  }
+  return idx;
 }
 
-SBValue
-SBValue::GetChildMemberWithName (const char *name)
-{
-    lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
-    TargetSP target_sp;
-    if (m_opaque_sp)
-        target_sp = m_opaque_sp->GetTargetSP();
+SBValue SBValue::GetChildMemberWithName(const char *name) {
+  lldb::DynamicValueType use_dynamic_value = eNoDynamicValues;
+  TargetSP target_sp;
+  if (m_opaque_sp)
+    target_sp = m_opaque_sp->GetTargetSP();
 
-    if (target_sp)
-        use_dynamic_value = target_sp->GetPreferDynamicValue();
-    return GetChildMemberWithName (name, use_dynamic_value);
+  if (target_sp)
+    use_dynamic_value = target_sp->GetPreferDynamicValue();
+  return GetChildMemberWithName(name, use_dynamic_value);
 }
 
 SBValue
-SBValue::GetChildMemberWithName (const char *name, lldb::DynamicValueType use_dynamic_value)
-{
-    lldb::ValueObjectSP child_sp;
-    const ConstString str_name (name);
-
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        child_sp = value_sp->GetChildMemberWithName (str_name, true);
-    }
-
-    SBValue sb_value;
-    sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue());
-
-    if (log)
-        log->Printf ("SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)",
-                     static_cast<void*>(value_sp.get()), name,
-                     static_cast<void*>(value_sp.get()));
+SBValue::GetChildMemberWithName(const char *name,
+                                lldb::DynamicValueType use_dynamic_value) {
+  lldb::ValueObjectSP child_sp;
+  const ConstString str_name(name);
 
-    return sb_value;
-}
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 
-lldb::SBValue
-SBValue::GetDynamicValue (lldb::DynamicValueType use_dynamic)
-{
-    SBValue value_sb;
-    if (IsValid())
-    {
-        ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),use_dynamic,m_opaque_sp->GetUseSynthetic()));
-        value_sb.SetSP(proxy_sp);
-    }
-    return value_sb;
-}
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    child_sp = value_sp->GetChildMemberWithName(str_name, true);
+  }
 
-lldb::SBValue
-SBValue::GetStaticValue ()
-{
-    SBValue value_sb;
-    if (IsValid())
-    {
-        ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),eNoDynamicValues,m_opaque_sp->GetUseSynthetic()));
-        value_sb.SetSP(proxy_sp);
-    }
-    return value_sb;
-}
+  SBValue sb_value;
+  sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue());
 
-lldb::SBValue
-SBValue::GetNonSyntheticValue ()
-{
-    SBValue value_sb;
-    if (IsValid())
-    {
-        ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),m_opaque_sp->GetUseDynamic(),false));
-        value_sb.SetSP(proxy_sp);
-    }
-    return value_sb;
-}
+  if (log)
+    log->Printf(
+        "SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)",
+        static_cast<void *>(value_sp.get()), name,
+        static_cast<void *>(value_sp.get()));
 
-lldb::DynamicValueType
-SBValue::GetPreferDynamicValue ()
-{
-    if (!IsValid())
-        return eNoDynamicValues;
-    return m_opaque_sp->GetUseDynamic();
+  return sb_value;
 }
 
-void
-SBValue::SetPreferDynamicValue (lldb::DynamicValueType use_dynamic)
-{
-    if (IsValid())
-        return m_opaque_sp->SetUseDynamic (use_dynamic);
+lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
+  SBValue value_sb;
+  if (IsValid()) {
+    ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(), use_dynamic,
+                                       m_opaque_sp->GetUseSynthetic()));
+    value_sb.SetSP(proxy_sp);
+  }
+  return value_sb;
 }
 
-bool
-SBValue::GetPreferSyntheticValue ()
-{
-    if (!IsValid())
-        return false;
-    return m_opaque_sp->GetUseSynthetic();
+lldb::SBValue SBValue::GetStaticValue() {
+  SBValue value_sb;
+  if (IsValid()) {
+    ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),
+                                       eNoDynamicValues,
+                                       m_opaque_sp->GetUseSynthetic()));
+    value_sb.SetSP(proxy_sp);
+  }
+  return value_sb;
 }
 
-void
-SBValue::SetPreferSyntheticValue (bool use_synthetic)
-{
-    if (IsValid())
-        return m_opaque_sp->SetUseSynthetic (use_synthetic);
+lldb::SBValue SBValue::GetNonSyntheticValue() {
+  SBValue value_sb;
+  if (IsValid()) {
+    ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),
+                                       m_opaque_sp->GetUseDynamic(), false));
+    value_sb.SetSP(proxy_sp);
+  }
+  return value_sb;
 }
 
-bool
-SBValue::IsDynamic()
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        return value_sp->IsDynamic();
-    return false;
+lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
+  if (!IsValid())
+    return eNoDynamicValues;
+  return m_opaque_sp->GetUseDynamic();
 }
 
-bool
-SBValue::IsSynthetic ()
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        return value_sp->IsSynthetic();
-    return false;
+void SBValue::SetPreferDynamicValue(lldb::DynamicValueType use_dynamic) {
+  if (IsValid())
+    return m_opaque_sp->SetUseDynamic(use_dynamic);
 }
 
-bool
-SBValue::IsSyntheticChildrenGenerated ()
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        return value_sp->IsSyntheticChildrenGenerated();
+bool SBValue::GetPreferSyntheticValue() {
+  if (!IsValid())
     return false;
-}
-
-void
-SBValue::SetSyntheticChildrenGenerated (bool is)
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        return value_sp->SetSyntheticChildrenGenerated(is);
-}
-
-lldb::SBValue
-SBValue::GetValueForExpressionPath(const char* expr_path)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    lldb::ValueObjectSP child_sp;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        // using default values for all the fancy options, just do it if you can
-        child_sp = value_sp->GetValueForExpressionPath(expr_path);
-    }
-
-    SBValue sb_value;
-    sb_value.SetSP(child_sp,GetPreferDynamicValue(),GetPreferSyntheticValue());
-
-    if (log)
-        log->Printf ("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => SBValue(%p)",
-                     static_cast<void*>(value_sp.get()), expr_path,
-                     static_cast<void*>(value_sp.get()));
-
-    return sb_value;
-}
-
-int64_t
-SBValue::GetValueAsSigned(SBError& error, int64_t fail_value)
-{
-    error.Clear();
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        bool success = true;
-        uint64_t ret_val = fail_value;
-        ret_val = value_sp->GetValueAsSigned(fail_value, &success);
-        if (!success)
-            error.SetErrorString("could not resolve value");
-        return ret_val;
-    }
-    else
-        error.SetErrorStringWithFormat ("could not get SBValue: %s", locker.GetError().AsCString());
-    
-    return fail_value;
-}
-
-uint64_t
-SBValue::GetValueAsUnsigned(SBError& error, uint64_t fail_value)
-{
-    error.Clear();
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        bool success = true;
-        uint64_t ret_val = fail_value;
-        ret_val = value_sp->GetValueAsUnsigned(fail_value, &success);
-        if (!success)
-            error.SetErrorString("could not resolve value");
-        return ret_val;
-    }
-    else
-        error.SetErrorStringWithFormat ("could not get SBValue: %s", locker.GetError().AsCString());
-    
-    return fail_value;
-}
-
-int64_t
-SBValue::GetValueAsSigned(int64_t fail_value)
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        return value_sp->GetValueAsSigned(fail_value);
-    }
-    return fail_value;
-}
-
-uint64_t
-SBValue::GetValueAsUnsigned(uint64_t fail_value)
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        return value_sp->GetValueAsUnsigned(fail_value);
-    }
-    return fail_value;
-}
-
-bool
-SBValue::MightHaveChildren ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    bool has_children = false;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        has_children = value_sp->MightHaveChildren();
-
-    if (log)
-        log->Printf ("SBValue(%p)::MightHaveChildren() => %i",
-                     static_cast<void*>(value_sp.get()), has_children);
-    return has_children;
-}
-
-bool
-SBValue::IsRuntimeSupportValue ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    bool is_support = false;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        is_support = value_sp->IsRuntimeSupportValue();
-    
-    if (log)
-        log->Printf ("SBValue(%p)::IsRuntimeSupportValue() => %i",
-                     static_cast<void*>(value_sp.get()), is_support);
-    return is_support;
-}
-
-uint32_t
-SBValue::GetNumChildren ()
-{
-    return GetNumChildren (UINT32_MAX);
-}
-
-uint32_t
-SBValue::GetNumChildren (uint32_t max)
-{
-    uint32_t num_children = 0;
-
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        num_children = value_sp->GetNumChildren(max);
-
-    if (log)
-        log->Printf ("SBValue(%p)::GetNumChildren (%u) => %u",
-                     static_cast<void*>(value_sp.get()), max, num_children);
-
-    return num_children;
-}
-
-SBValue
-SBValue::Dereference ()
-{
-    SBValue sb_value;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        Error error;
-        sb_value = value_sp->Dereference (error);
-    }
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf ("SBValue(%p)::Dereference () => SBValue(%p)",
-                     static_cast<void*>(value_sp.get()),
-                     static_cast<void*>(value_sp.get()));
-
-    return sb_value;
+  return m_opaque_sp->GetUseSynthetic();
+}
+
+void SBValue::SetPreferSyntheticValue(bool use_synthetic) {
+  if (IsValid())
+    return m_opaque_sp->SetUseSynthetic(use_synthetic);
+}
+
+bool SBValue::IsDynamic() {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    return value_sp->IsDynamic();
+  return false;
+}
+
+bool SBValue::IsSynthetic() {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    return value_sp->IsSynthetic();
+  return false;
+}
+
+bool SBValue::IsSyntheticChildrenGenerated() {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    return value_sp->IsSyntheticChildrenGenerated();
+  return false;
+}
+
+void SBValue::SetSyntheticChildrenGenerated(bool is) {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    return value_sp->SetSyntheticChildrenGenerated(is);
+}
+
+lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  lldb::ValueObjectSP child_sp;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    // using default values for all the fancy options, just do it if you can
+    child_sp = value_sp->GetValueForExpressionPath(expr_path);
+  }
+
+  SBValue sb_value;
+  sb_value.SetSP(child_sp, GetPreferDynamicValue(), GetPreferSyntheticValue());
+
+  if (log)
+    log->Printf("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => "
+                "SBValue(%p)",
+                static_cast<void *>(value_sp.get()), expr_path,
+                static_cast<void *>(value_sp.get()));
+
+  return sb_value;
+}
+
+int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
+  error.Clear();
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    bool success = true;
+    uint64_t ret_val = fail_value;
+    ret_val = value_sp->GetValueAsSigned(fail_value, &success);
+    if (!success)
+      error.SetErrorString("could not resolve value");
+    return ret_val;
+  } else
+    error.SetErrorStringWithFormat("could not get SBValue: %s",
+                                   locker.GetError().AsCString());
+
+  return fail_value;
+}
+
+uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
+  error.Clear();
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    bool success = true;
+    uint64_t ret_val = fail_value;
+    ret_val = value_sp->GetValueAsUnsigned(fail_value, &success);
+    if (!success)
+      error.SetErrorString("could not resolve value");
+    return ret_val;
+  } else
+    error.SetErrorStringWithFormat("could not get SBValue: %s",
+                                   locker.GetError().AsCString());
+
+  return fail_value;
+}
+
+int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    return value_sp->GetValueAsSigned(fail_value);
+  }
+  return fail_value;
+}
+
+uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    return value_sp->GetValueAsUnsigned(fail_value);
+  }
+  return fail_value;
+}
+
+bool SBValue::MightHaveChildren() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  bool has_children = false;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    has_children = value_sp->MightHaveChildren();
+
+  if (log)
+    log->Printf("SBValue(%p)::MightHaveChildren() => %i",
+                static_cast<void *>(value_sp.get()), has_children);
+  return has_children;
+}
+
+bool SBValue::IsRuntimeSupportValue() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  bool is_support = false;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    is_support = value_sp->IsRuntimeSupportValue();
+
+  if (log)
+    log->Printf("SBValue(%p)::IsRuntimeSupportValue() => %i",
+                static_cast<void *>(value_sp.get()), is_support);
+  return is_support;
+}
+
+uint32_t SBValue::GetNumChildren() { return GetNumChildren(UINT32_MAX); }
+
+uint32_t SBValue::GetNumChildren(uint32_t max) {
+  uint32_t num_children = 0;
+
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    num_children = value_sp->GetNumChildren(max);
+
+  if (log)
+    log->Printf("SBValue(%p)::GetNumChildren (%u) => %u",
+                static_cast<void *>(value_sp.get()), max, num_children);
+
+  return num_children;
+}
+
+SBValue SBValue::Dereference() {
+  SBValue sb_value;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    Error error;
+    sb_value = value_sp->Dereference(error);
+  }
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBValue(%p)::Dereference () => SBValue(%p)",
+                static_cast<void *>(value_sp.get()),
+                static_cast<void *>(value_sp.get()));
+
+  return sb_value;
 }
 
 // Deprecated - please use GetType().IsPointerType() instead.
-bool
-SBValue::TypeIsPointerType ()
-{
-    return GetType().IsPointerType();
-}
-
-void *
-SBValue::GetOpaqueType()
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        return value_sp->GetCompilerType().GetOpaqueQualType();
-    return NULL;
-}
-
-lldb::SBTarget
-SBValue::GetTarget()
-{
-    SBTarget sb_target;
-    TargetSP target_sp;
-    if (m_opaque_sp)
-    {
-        target_sp = m_opaque_sp->GetTargetSP();
-        sb_target.SetSP (target_sp);
-    }
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-    {
-        if (target_sp.get() == NULL)
-            log->Printf ("SBValue(%p)::GetTarget () => NULL",
-                         static_cast<void*>(m_opaque_sp.get()));
-        else
-            log->Printf ("SBValue(%p)::GetTarget () => %p",
-                         static_cast<void*>(m_opaque_sp.get()),
-                         static_cast<void*>(target_sp.get()));
-    }
-    return sb_target;
-}
-
-lldb::SBProcess
-SBValue::GetProcess()
-{
-    SBProcess sb_process;
-    ProcessSP process_sp;
-    if (m_opaque_sp)
-    {
-        process_sp = m_opaque_sp->GetProcessSP();
-        sb_process.SetSP (process_sp);
-    }
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-    {
-        if (process_sp.get() == NULL)
-            log->Printf ("SBValue(%p)::GetProcess () => NULL",
-                         static_cast<void*>(m_opaque_sp.get()));
-        else
-            log->Printf ("SBValue(%p)::GetProcess () => %p",
-                         static_cast<void*>(m_opaque_sp.get()),
-                         static_cast<void*>(process_sp.get()));
-    }
-    return sb_process;
-}
-
-lldb::SBThread
-SBValue::GetThread()
-{
-    SBThread sb_thread;
-    ThreadSP thread_sp;
-    if (m_opaque_sp)
-    {
-        thread_sp = m_opaque_sp->GetThreadSP();
-        sb_thread.SetThread(thread_sp);
-    }
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-    {
-        if (thread_sp.get() == NULL)
-            log->Printf ("SBValue(%p)::GetThread () => NULL",
-                         static_cast<void*>(m_opaque_sp.get()));
-        else
-            log->Printf ("SBValue(%p)::GetThread () => %p",
-                         static_cast<void*>(m_opaque_sp.get()),
-                         static_cast<void*>(thread_sp.get()));
-    }
-    return sb_thread;
-}
-
-lldb::SBFrame
-SBValue::GetFrame()
-{
-    SBFrame sb_frame;
-    StackFrameSP frame_sp;
-    if (m_opaque_sp)
-    {
-        frame_sp = m_opaque_sp->GetFrameSP();
-        sb_frame.SetFrameSP (frame_sp);
-    }
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-    {
-        if (frame_sp.get() == NULL)
-            log->Printf ("SBValue(%p)::GetFrame () => NULL",
-                         static_cast<void*>(m_opaque_sp.get()));
-        else
-            log->Printf ("SBValue(%p)::GetFrame () => %p",
-                         static_cast<void*>(m_opaque_sp.get()),
-                         static_cast<void*>(frame_sp.get()));
-    }
-    return sb_frame;
-}
-
-
-lldb::ValueObjectSP
-SBValue::GetSP (ValueLocker &locker) const
-{
-    if (!m_opaque_sp || !m_opaque_sp->IsValid())
-    {
-        locker.GetError().SetErrorString("No value");
-        return ValueObjectSP();
-    }
-    return locker.GetLockedSP(*m_opaque_sp.get());
-}
-
-lldb::ValueObjectSP
-SBValue::GetSP () const
-{
-    ValueLocker locker;
-    return GetSP(locker);
-}
-
-void
-SBValue::SetSP (ValueImplSP impl_sp)
-{
-    m_opaque_sp = impl_sp;
-}
-
-void
-SBValue::SetSP (const lldb::ValueObjectSP &sp)
-{
-    if (sp)
-    {
-        lldb::TargetSP target_sp(sp->GetTargetSP());
-        if (target_sp)
-        {
-            lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
-            bool use_synthetic = target_sp->TargetProperties::GetEnableSyntheticValue();
-            m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic));
-        }
-        else
-            m_opaque_sp = ValueImplSP(new ValueImpl(sp,eNoDynamicValues,true));
-    }
+bool SBValue::TypeIsPointerType() { return GetType().IsPointerType(); }
+
+void *SBValue::GetOpaqueType() {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    return value_sp->GetCompilerType().GetOpaqueQualType();
+  return NULL;
+}
+
+lldb::SBTarget SBValue::GetTarget() {
+  SBTarget sb_target;
+  TargetSP target_sp;
+  if (m_opaque_sp) {
+    target_sp = m_opaque_sp->GetTargetSP();
+    sb_target.SetSP(target_sp);
+  }
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log) {
+    if (target_sp.get() == NULL)
+      log->Printf("SBValue(%p)::GetTarget () => NULL",
+                  static_cast<void *>(m_opaque_sp.get()));
     else
-        m_opaque_sp = ValueImplSP(new ValueImpl(sp,eNoDynamicValues,false));
-}
-
-void
-SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic)
-{
-    if (sp)
-    {
-        lldb::TargetSP target_sp(sp->GetTargetSP());
-        if (target_sp)
-        {
-            bool use_synthetic = target_sp->TargetProperties::GetEnableSyntheticValue();
-            SetSP (sp, use_dynamic, use_synthetic);
-        }
-        else
-            SetSP (sp, use_dynamic, true);
-    }
+      log->Printf("SBValue(%p)::GetTarget () => %p",
+                  static_cast<void *>(m_opaque_sp.get()),
+                  static_cast<void *>(target_sp.get()));
+  }
+  return sb_target;
+}
+
+lldb::SBProcess SBValue::GetProcess() {
+  SBProcess sb_process;
+  ProcessSP process_sp;
+  if (m_opaque_sp) {
+    process_sp = m_opaque_sp->GetProcessSP();
+    sb_process.SetSP(process_sp);
+  }
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log) {
+    if (process_sp.get() == NULL)
+      log->Printf("SBValue(%p)::GetProcess () => NULL",
+                  static_cast<void *>(m_opaque_sp.get()));
     else
-        SetSP (sp, use_dynamic, false);
-}
-
-void
-SBValue::SetSP (const lldb::ValueObjectSP &sp, bool use_synthetic)
-{
-    if (sp)
-    {
-        lldb::TargetSP target_sp(sp->GetTargetSP());
-        if (target_sp)
-        {
-            lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
-            SetSP (sp, use_dynamic, use_synthetic);
-        }
-        else
-            SetSP (sp, eNoDynamicValues, use_synthetic);
-    }
+      log->Printf("SBValue(%p)::GetProcess () => %p",
+                  static_cast<void *>(m_opaque_sp.get()),
+                  static_cast<void *>(process_sp.get()));
+  }
+  return sb_process;
+}
+
+lldb::SBThread SBValue::GetThread() {
+  SBThread sb_thread;
+  ThreadSP thread_sp;
+  if (m_opaque_sp) {
+    thread_sp = m_opaque_sp->GetThreadSP();
+    sb_thread.SetThread(thread_sp);
+  }
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log) {
+    if (thread_sp.get() == NULL)
+      log->Printf("SBValue(%p)::GetThread () => NULL",
+                  static_cast<void *>(m_opaque_sp.get()));
     else
-        SetSP (sp, eNoDynamicValues, use_synthetic);
-}
-
-void
-SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic, bool use_synthetic)
-{
-    m_opaque_sp = ValueImplSP(new ValueImpl(sp,use_dynamic,use_synthetic));
-}
-
-void
-SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic, bool use_synthetic, const char *name)
-{
-    m_opaque_sp = ValueImplSP(new ValueImpl(sp,use_dynamic,use_synthetic, name));
-}
-
-bool
-SBValue::GetExpressionPath (SBStream &description)
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        value_sp->GetExpressionPath (description.ref(), false);
-        return true;
-    }
-    return false;
-}
-
-bool
-SBValue::GetExpressionPath (SBStream &description, bool qualify_cxx_base_classes)
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        value_sp->GetExpressionPath (description.ref(), qualify_cxx_base_classes);
-        return true;
-    }
-    return false;
-}
-
-bool
-SBValue::GetDescription (SBStream &description)
-{
-    Stream &strm = description.ref();
-    
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        value_sp->Dump(strm);
+      log->Printf("SBValue(%p)::GetThread () => %p",
+                  static_cast<void *>(m_opaque_sp.get()),
+                  static_cast<void *>(thread_sp.get()));
+  }
+  return sb_thread;
+}
+
+lldb::SBFrame SBValue::GetFrame() {
+  SBFrame sb_frame;
+  StackFrameSP frame_sp;
+  if (m_opaque_sp) {
+    frame_sp = m_opaque_sp->GetFrameSP();
+    sb_frame.SetFrameSP(frame_sp);
+  }
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log) {
+    if (frame_sp.get() == NULL)
+      log->Printf("SBValue(%p)::GetFrame () => NULL",
+                  static_cast<void *>(m_opaque_sp.get()));
     else
-        strm.PutCString ("No value");
-    
+      log->Printf("SBValue(%p)::GetFrame () => %p",
+                  static_cast<void *>(m_opaque_sp.get()),
+                  static_cast<void *>(frame_sp.get()));
+  }
+  return sb_frame;
+}
+
+lldb::ValueObjectSP SBValue::GetSP(ValueLocker &locker) const {
+  if (!m_opaque_sp || !m_opaque_sp->IsValid()) {
+    locker.GetError().SetErrorString("No value");
+    return ValueObjectSP();
+  }
+  return locker.GetLockedSP(*m_opaque_sp.get());
+}
+
+lldb::ValueObjectSP SBValue::GetSP() const {
+  ValueLocker locker;
+  return GetSP(locker);
+}
+
+void SBValue::SetSP(ValueImplSP impl_sp) { m_opaque_sp = impl_sp; }
+
+void SBValue::SetSP(const lldb::ValueObjectSP &sp) {
+  if (sp) {
+    lldb::TargetSP target_sp(sp->GetTargetSP());
+    if (target_sp) {
+      lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
+      bool use_synthetic =
+          target_sp->TargetProperties::GetEnableSyntheticValue();
+      m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic));
+    } else
+      m_opaque_sp = ValueImplSP(new ValueImpl(sp, eNoDynamicValues, true));
+  } else
+    m_opaque_sp = ValueImplSP(new ValueImpl(sp, eNoDynamicValues, false));
+}
+
+void SBValue::SetSP(const lldb::ValueObjectSP &sp,
+                    lldb::DynamicValueType use_dynamic) {
+  if (sp) {
+    lldb::TargetSP target_sp(sp->GetTargetSP());
+    if (target_sp) {
+      bool use_synthetic =
+          target_sp->TargetProperties::GetEnableSyntheticValue();
+      SetSP(sp, use_dynamic, use_synthetic);
+    } else
+      SetSP(sp, use_dynamic, true);
+  } else
+    SetSP(sp, use_dynamic, false);
+}
+
+void SBValue::SetSP(const lldb::ValueObjectSP &sp, bool use_synthetic) {
+  if (sp) {
+    lldb::TargetSP target_sp(sp->GetTargetSP());
+    if (target_sp) {
+      lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue();
+      SetSP(sp, use_dynamic, use_synthetic);
+    } else
+      SetSP(sp, eNoDynamicValues, use_synthetic);
+  } else
+    SetSP(sp, eNoDynamicValues, use_synthetic);
+}
+
+void SBValue::SetSP(const lldb::ValueObjectSP &sp,
+                    lldb::DynamicValueType use_dynamic, bool use_synthetic) {
+  m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic));
+}
+
+void SBValue::SetSP(const lldb::ValueObjectSP &sp,
+                    lldb::DynamicValueType use_dynamic, bool use_synthetic,
+                    const char *name) {
+  m_opaque_sp =
+      ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic, name));
+}
+
+bool SBValue::GetExpressionPath(SBStream &description) {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    value_sp->GetExpressionPath(description.ref(), false);
     return true;
+  }
+  return false;
 }
 
-lldb::Format
-SBValue::GetFormat ()
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        return value_sp->GetFormat();
-    return eFormatDefault;
-}
-
-void
-SBValue::SetFormat (lldb::Format format)
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-        value_sp->SetFormat(format);
-}
-
-lldb::SBValue
-SBValue::AddressOf()
-{
-    SBValue sb_value;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        Error error;
-        sb_value.SetSP(value_sp->AddressOf (error),GetPreferDynamicValue(), GetPreferSyntheticValue());
-    }
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf ("SBValue(%p)::AddressOf () => SBValue(%p)",
-                     static_cast<void*>(value_sp.get()),
-                     static_cast<void*>(value_sp.get()));
-
-    return sb_value;
-}
-
-lldb::addr_t
-SBValue::GetLoadAddress()
-{
-    lldb::addr_t value = LLDB_INVALID_ADDRESS;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        TargetSP target_sp (value_sp->GetTargetSP());
-        if (target_sp)
-        {
-            const bool scalar_is_load_address = true;
-            AddressType addr_type;
-            value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
-            if (addr_type == eAddressTypeFile)
-            {
-                ModuleSP module_sp (value_sp->GetModule());
-                if (!module_sp)
-                    value = LLDB_INVALID_ADDRESS;
-                else
-                {
-                    Address addr;
-                    module_sp->ResolveFileAddress(value, addr);
-                    value = addr.GetLoadAddress(target_sp.get());
-                }
-            }
-            else if (addr_type == eAddressTypeHost || addr_type == eAddressTypeInvalid)
-                value = LLDB_INVALID_ADDRESS;
+bool SBValue::GetExpressionPath(SBStream &description,
+                                bool qualify_cxx_base_classes) {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    value_sp->GetExpressionPath(description.ref(), qualify_cxx_base_classes);
+    return true;
+  }
+  return false;
+}
+
+bool SBValue::GetDescription(SBStream &description) {
+  Stream &strm = description.ref();
+
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    value_sp->Dump(strm);
+  else
+    strm.PutCString("No value");
+
+  return true;
+}
+
+lldb::Format SBValue::GetFormat() {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    return value_sp->GetFormat();
+  return eFormatDefault;
+}
+
+void SBValue::SetFormat(lldb::Format format) {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp)
+    value_sp->SetFormat(format);
+}
+
+lldb::SBValue SBValue::AddressOf() {
+  SBValue sb_value;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    Error error;
+    sb_value.SetSP(value_sp->AddressOf(error), GetPreferDynamicValue(),
+                   GetPreferSyntheticValue());
+  }
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBValue(%p)::AddressOf () => SBValue(%p)",
+                static_cast<void *>(value_sp.get()),
+                static_cast<void *>(value_sp.get()));
+
+  return sb_value;
+}
+
+lldb::addr_t SBValue::GetLoadAddress() {
+  lldb::addr_t value = LLDB_INVALID_ADDRESS;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    TargetSP target_sp(value_sp->GetTargetSP());
+    if (target_sp) {
+      const bool scalar_is_load_address = true;
+      AddressType addr_type;
+      value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
+      if (addr_type == eAddressTypeFile) {
+        ModuleSP module_sp(value_sp->GetModule());
+        if (!module_sp)
+          value = LLDB_INVALID_ADDRESS;
+        else {
+          Address addr;
+          module_sp->ResolveFileAddress(value, addr);
+          value = addr.GetLoadAddress(target_sp.get());
         }
-    }
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    if (log)
-        log->Printf ("SBValue(%p)::GetLoadAddress () => (%" PRIu64 ")",
-                     static_cast<void*>(value_sp.get()), value);
-
-    return value;
-}
-
-lldb::SBAddress
-SBValue::GetAddress()
-{
-    Address addr;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        TargetSP target_sp (value_sp->GetTargetSP());
-        if (target_sp)
-        {
-            lldb::addr_t value = LLDB_INVALID_ADDRESS;
-            const bool scalar_is_load_address = true;
-            AddressType addr_type;
-            value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
-            if (addr_type == eAddressTypeFile)
-            {
-                ModuleSP module_sp (value_sp->GetModule());
-                if (module_sp)
-                    module_sp->ResolveFileAddress(value, addr);
-            }
-            else if (addr_type == eAddressTypeLoad)
-            {
-                // no need to check the return value on this.. if it can actually do the resolve
-                // addr will be in the form (section,offset), otherwise it will simply be returned
-                // as (NULL, value)
-                addr.SetLoadAddress(value, target_sp.get());
-            }
+      } else if (addr_type == eAddressTypeHost ||
+                 addr_type == eAddressTypeInvalid)
+        value = LLDB_INVALID_ADDRESS;
+    }
+  }
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBValue(%p)::GetLoadAddress () => (%" PRIu64 ")",
+                static_cast<void *>(value_sp.get()), value);
+
+  return value;
+}
+
+lldb::SBAddress SBValue::GetAddress() {
+  Address addr;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    TargetSP target_sp(value_sp->GetTargetSP());
+    if (target_sp) {
+      lldb::addr_t value = LLDB_INVALID_ADDRESS;
+      const bool scalar_is_load_address = true;
+      AddressType addr_type;
+      value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type);
+      if (addr_type == eAddressTypeFile) {
+        ModuleSP module_sp(value_sp->GetModule());
+        if (module_sp)
+          module_sp->ResolveFileAddress(value, addr);
+      } else if (addr_type == eAddressTypeLoad) {
+        // no need to check the return value on this.. if it can actually do the
+        // resolve
+        // addr will be in the form (section,offset), otherwise it will simply
+        // be returned
+        // as (NULL, value)
+        addr.SetLoadAddress(value, target_sp.get());
+      }
+    }
+  }
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  if (log)
+    log->Printf("SBValue(%p)::GetAddress () => (%s,%" PRIu64 ")",
+                static_cast<void *>(value_sp.get()),
+                (addr.GetSection() ? addr.GetSection()->GetName().GetCString()
+                                   : "NULL"),
+                addr.GetOffset());
+  return SBAddress(new Address(addr));
+}
+
+lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  lldb::SBData sb_data;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    TargetSP target_sp(value_sp->GetTargetSP());
+    if (target_sp) {
+      DataExtractorSP data_sp(new DataExtractor());
+      value_sp->GetPointeeData(*data_sp, item_idx, item_count);
+      if (data_sp->GetByteSize() > 0)
+        *sb_data = data_sp;
+    }
+  }
+  if (log)
+    log->Printf("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)",
+                static_cast<void *>(value_sp.get()), item_idx, item_count,
+                static_cast<void *>(sb_data.get()));
+
+  return sb_data;
+}
+
+lldb::SBData SBValue::GetData() {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  lldb::SBData sb_data;
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    DataExtractorSP data_sp(new DataExtractor());
+    Error error;
+    value_sp->GetData(*data_sp, error);
+    if (error.Success())
+      *sb_data = data_sp;
+  }
+  if (log)
+    log->Printf("SBValue(%p)::GetData () => SBData(%p)",
+                static_cast<void *>(value_sp.get()),
+                static_cast<void *>(sb_data.get()));
+
+  return sb_data;
+}
+
+bool SBValue::SetData(lldb::SBData &data, SBError &error) {
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  bool ret = true;
+
+  if (value_sp) {
+    DataExtractor *data_extractor = data.get();
+
+    if (!data_extractor) {
+      if (log)
+        log->Printf("SBValue(%p)::SetData() => error: no data to set",
+                    static_cast<void *>(value_sp.get()));
+
+      error.SetErrorString("No data to set");
+      ret = false;
+    } else {
+      Error set_error;
+
+      value_sp->SetData(*data_extractor, set_error);
+
+      if (!set_error.Success()) {
+        error.SetErrorStringWithFormat("Couldn't set data: %s",
+                                       set_error.AsCString());
+        ret = false;
+      }
+    }
+  } else {
+    error.SetErrorStringWithFormat(
+        "Couldn't set data: could not get SBValue: %s",
+        locker.GetError().AsCString());
+    ret = false;
+  }
+
+  if (log)
+    log->Printf("SBValue(%p)::SetData (%p) => %s",
+                static_cast<void *>(value_sp.get()),
+                static_cast<void *>(data.get()), ret ? "true" : "false");
+  return ret;
+}
+
+lldb::SBDeclaration SBValue::GetDeclaration() {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  SBDeclaration decl_sb;
+  if (value_sp) {
+    Declaration decl;
+    if (value_sp->GetDeclaration(decl))
+      decl_sb.SetDeclaration(decl);
+  }
+  return decl_sb;
+}
+
+lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
+                                  SBError &error) {
+  SBWatchpoint sb_watchpoint;
+
+  // If the SBValue is not valid, there's no point in even trying to watch it.
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  TargetSP target_sp(GetTarget().GetSP());
+  if (value_sp && target_sp) {
+    // Read and Write cannot both be false.
+    if (!read && !write)
+      return sb_watchpoint;
+
+    // If the value is not in scope, don't try and watch and invalid value
+    if (!IsInScope())
+      return sb_watchpoint;
+
+    addr_t addr = GetLoadAddress();
+    if (addr == LLDB_INVALID_ADDRESS)
+      return sb_watchpoint;
+    size_t byte_size = GetByteSize();
+    if (byte_size == 0)
+      return sb_watchpoint;
+
+    uint32_t watch_type = 0;
+    if (read)
+      watch_type |= LLDB_WATCH_TYPE_READ;
+    if (write)
+      watch_type |= LLDB_WATCH_TYPE_WRITE;
+
+    Error rc;
+    CompilerType type(value_sp->GetCompilerType());
+    WatchpointSP watchpoint_sp =
+        target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc);
+    error.SetError(rc);
+
+    if (watchpoint_sp) {
+      sb_watchpoint.SetSP(watchpoint_sp);
+      Declaration decl;
+      if (value_sp->GetDeclaration(decl)) {
+        if (decl.GetFile()) {
+          StreamString ss;
+          // True to show fullpath for declaration file.
+          decl.DumpStopContext(&ss, true);
+          watchpoint_sp->SetDeclInfo(ss.GetString());
         }
+      }
     }
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+  } else if (target_sp) {
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
     if (log)
-        log->Printf ("SBValue(%p)::GetAddress () => (%s,%" PRIu64 ")",
-                     static_cast<void*>(value_sp.get()),
-                     (addr.GetSection()
-                        ? addr.GetSection()->GetName().GetCString()
-                        : "NULL"),
-                     addr.GetOffset());
-    return SBAddress(new Address(addr));
-}
-
-lldb::SBData
-SBValue::GetPointeeData (uint32_t item_idx,
-                         uint32_t item_count)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    lldb::SBData sb_data;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        TargetSP target_sp (value_sp->GetTargetSP());
-        if (target_sp)
-        {
-            DataExtractorSP data_sp(new DataExtractor());
-            value_sp->GetPointeeData(*data_sp, item_idx, item_count);
-            if (data_sp->GetByteSize() > 0)
-                *sb_data = data_sp;
-        }
-    }
+      log->Printf("SBValue(%p)::Watch() => error getting SBValue: %s",
+                  static_cast<void *>(value_sp.get()),
+                  locker.GetError().AsCString());
+
+    error.SetErrorStringWithFormat("could not get SBValue: %s",
+                                   locker.GetError().AsCString());
+  } else {
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
     if (log)
-        log->Printf ("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)",
-                     static_cast<void*>(value_sp.get()), item_idx, item_count,
-                     static_cast<void*>(sb_data.get()));
-
-    return sb_data;
-}
-
-lldb::SBData
-SBValue::GetData ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    lldb::SBData sb_data;
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    if (value_sp)
-    {
-        DataExtractorSP data_sp(new DataExtractor());
-        Error error;
-        value_sp->GetData(*data_sp, error);
-        if (error.Success())
-            *sb_data = data_sp;
-    }
-    if (log)
-        log->Printf ("SBValue(%p)::GetData () => SBData(%p)",
-                     static_cast<void*>(value_sp.get()),
-                     static_cast<void*>(sb_data.get()));
+      log->Printf("SBValue(%p)::Watch() => error getting SBValue: no target",
+                  static_cast<void *>(value_sp.get()));
+    error.SetErrorString("could not set watchpoint, a target is required");
+  }
 
-    return sb_data;
+  return sb_watchpoint;
 }
 
-bool
-SBValue::SetData (lldb::SBData &data, SBError &error)
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    bool ret = true;
-
-    if (value_sp)
-    {
-        DataExtractor *data_extractor = data.get();
-
-        if (!data_extractor)
-        {
-            if (log)
-                log->Printf ("SBValue(%p)::SetData() => error: no data to set",
-                             static_cast<void*>(value_sp.get()));
-
-            error.SetErrorString("No data to set");
-            ret = false;
-        }
-        else
-        {
-            Error set_error;
-
-            value_sp->SetData(*data_extractor, set_error);
-
-            if (!set_error.Success())
-            {
-                error.SetErrorStringWithFormat("Couldn't set data: %s", set_error.AsCString());
-                ret = false;
-            }
-        }
-    }
-    else
-    {
-        error.SetErrorStringWithFormat ("Couldn't set data: could not get SBValue: %s", locker.GetError().AsCString());
-        ret = false;
-    }
-
-    if (log)
-        log->Printf ("SBValue(%p)::SetData (%p) => %s",
-                     static_cast<void*>(value_sp.get()),
-                     static_cast<void*>(data.get()), ret ? "true" : "false");
-    return ret;
-}
-
-lldb::SBDeclaration
-SBValue::GetDeclaration ()
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    SBDeclaration decl_sb;
-    if (value_sp)
-    {
-        Declaration decl;
-        if (value_sp->GetDeclaration(decl))
-            decl_sb.SetDeclaration(decl);
-    }
-    return decl_sb;
-}
-
-lldb::SBWatchpoint
-SBValue::Watch (bool resolve_location, bool read, bool write, SBError &error)
-{
-    SBWatchpoint sb_watchpoint;
-
-    // If the SBValue is not valid, there's no point in even trying to watch it.
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    TargetSP target_sp (GetTarget().GetSP());
-    if (value_sp && target_sp)
-    {
-        // Read and Write cannot both be false.
-        if (!read && !write)
-            return sb_watchpoint;
-
-        // If the value is not in scope, don't try and watch and invalid value
-        if (!IsInScope())
-            return sb_watchpoint;
-
-        addr_t addr = GetLoadAddress();
-        if (addr == LLDB_INVALID_ADDRESS)
-            return sb_watchpoint;
-        size_t byte_size = GetByteSize();
-        if (byte_size == 0)
-            return sb_watchpoint;
-
-        uint32_t watch_type = 0;
-        if (read)
-            watch_type |= LLDB_WATCH_TYPE_READ;
-        if (write)
-            watch_type |= LLDB_WATCH_TYPE_WRITE;
-
-        Error rc;
-        CompilerType type (value_sp->GetCompilerType());
-        WatchpointSP watchpoint_sp = target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc);
-        error.SetError(rc);
-
-        if (watchpoint_sp)
-        {
-            sb_watchpoint.SetSP (watchpoint_sp);
-            Declaration decl;
-            if (value_sp->GetDeclaration (decl))
-            {
-                if (decl.GetFile())
-                {
-                    StreamString ss;
-                    // True to show fullpath for declaration file.
-                    decl.DumpStopContext(&ss, true);
-                    watchpoint_sp->SetDeclInfo(ss.GetString());
-                }
-            }
-        }
-    }
-    else if (target_sp)
-    {
-        Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-        if (log)
-            log->Printf ("SBValue(%p)::Watch() => error getting SBValue: %s",
-                         static_cast<void*>(value_sp.get()),
-                         locker.GetError().AsCString());
-
-        error.SetErrorStringWithFormat("could not get SBValue: %s", locker.GetError().AsCString());
-    }
-    else
-    {
-        Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-        if (log)
-            log->Printf ("SBValue(%p)::Watch() => error getting SBValue: no target",
-                         static_cast<void*>(value_sp.get()));
-        error.SetErrorString("could not set watchpoint, a target is required");
-    }
-
-    return sb_watchpoint;
-}
-
-// FIXME: Remove this method impl (as well as the decl in .h) once it is no longer needed.
+// FIXME: Remove this method impl (as well as the decl in .h) once it is no
+// longer needed.
 // Backward compatibility fix in the interim.
-lldb::SBWatchpoint
-SBValue::Watch (bool resolve_location, bool read, bool write)
-{
-    SBError error;
-    return Watch(resolve_location, read, write, error);
-}
-
-lldb::SBWatchpoint
-SBValue::WatchPointee (bool resolve_location, bool read, bool write, SBError &error)
-{
-    SBWatchpoint sb_watchpoint;
-    if (IsInScope() && GetType().IsPointerType())
-        sb_watchpoint = Dereference().Watch (resolve_location, read, write, error);
-    return sb_watchpoint;
-}
-
-lldb::SBValue
-SBValue::Persist ()
-{
-    ValueLocker locker;
-    lldb::ValueObjectSP value_sp(GetSP(locker));
-    SBValue persisted_sb;
-    if (value_sp)
-    {
-        persisted_sb.SetSP(value_sp->Persist());
-    }
-    return persisted_sb;
+lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read,
+                                  bool write) {
+  SBError error;
+  return Watch(resolve_location, read, write, error);
+}
+
+lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read,
+                                         bool write, SBError &error) {
+  SBWatchpoint sb_watchpoint;
+  if (IsInScope() && GetType().IsPointerType())
+    sb_watchpoint = Dereference().Watch(resolve_location, read, write, error);
+  return sb_watchpoint;
+}
+
+lldb::SBValue SBValue::Persist() {
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  SBValue persisted_sb;
+  if (value_sp) {
+    persisted_sb.SetSP(value_sp->Persist());
+  }
+  return persisted_sb;
 }